diff options
Diffstat (limited to 'src/stdlib')
49 files changed, 3023 insertions, 3198 deletions
diff --git a/src/stdlib/bools.c b/src/stdlib/bools.c index 76de49e0..0231e21b 100644 --- a/src/stdlib/bools.c +++ b/src/stdlib/bools.c @@ -11,18 +11,14 @@ #include "text.h" #include "util.h" -PUREFUNC public Text_t Bool$as_text(const void *b, bool colorize, const TypeInfo_t *info) -{ +PUREFUNC public Text_t Bool$as_text(const void *b, bool colorize, const TypeInfo_t *info) { (void)info; if (!b) return Text("Bool"); - if (colorize) - return *(Bool_t*)b ? Text("\x1b[35myes\x1b[m") : Text("\x1b[35mno\x1b[m"); - else - return *(Bool_t*)b ? Text("yes") : Text("no"); + if (colorize) return *(Bool_t *)b ? Text("\x1b[35myes\x1b[m") : Text("\x1b[35mno\x1b[m"); + else return *(Bool_t *)b ? Text("yes") : Text("no"); } -static bool try_parse(Text_t text, Text_t target, bool target_value, Text_t *remainder, bool *result) -{ +static bool try_parse(Text_t text, Text_t target, bool target_value, Text_t *remainder, bool *result) { static const Text_t lang = Text("C"); if (text.length < target.length) return false; Text_t prefix = Text$to(text, Int$from_int64(target.length)); @@ -36,35 +32,33 @@ static bool try_parse(Text_t text, Text_t target, bool target_value, Text_t *rem } } -PUREFUNC public OptionalBool_t Bool$parse(Text_t text, Text_t *remainder) -{ +PUREFUNC public OptionalBool_t Bool$parse(Text_t text, Text_t *remainder) { bool result; if (try_parse(text, Text("yes"), true, remainder, &result) || try_parse(text, Text("true"), true, remainder, &result) - || try_parse(text, Text("on"), true, remainder, &result) - || try_parse(text, Text("1"), true, remainder, &result) + || try_parse(text, Text("on"), true, remainder, &result) || try_parse(text, Text("1"), true, remainder, &result) || try_parse(text, Text("no"), false, remainder, &result) || try_parse(text, Text("false"), false, remainder, &result) || try_parse(text, Text("off"), false, remainder, &result) || try_parse(text, Text("0"), false, remainder, &result)) return result; - else - return NONE_BOOL; + else return NONE_BOOL; } -static bool Bool$is_none(const void *b, const TypeInfo_t *info) -{ +static bool Bool$is_none(const void *b, const TypeInfo_t *info) { (void)info; - return *(OptionalBool_t*)b == NONE_BOOL; + return *(OptionalBool_t *)b == NONE_BOOL; } -public const TypeInfo_t Bool$info = { - .size=sizeof(bool), - .align=__alignof__(bool), - .metamethods={ - .as_text=Bool$as_text, - .is_none=Bool$is_none, - }, +public +const TypeInfo_t Bool$info = { + .size = sizeof(bool), + .align = __alignof__(bool), + .metamethods = + { + .as_text = Bool$as_text, + .is_none = Bool$is_none, + }, }; // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/bools.h b/src/stdlib/bools.h index bdf80879..3eac0f0d 100644 --- a/src/stdlib/bools.h +++ b/src/stdlib/bools.h @@ -8,8 +8,8 @@ #include "types.h" #include "util.h" -#define yes (Bool_t)true -#define no (Bool_t)false +#define yes (Bool_t) true +#define no (Bool_t) false PUREFUNC Text_t Bool$as_text(const void *b, bool colorize, const TypeInfo_t *type); OptionalBool_t Bool$parse(Text_t text, Text_t *remainder); diff --git a/src/stdlib/bytes.c b/src/stdlib/bytes.c index 5a581e7e..d4bd5ef6 100644 --- a/src/stdlib/bytes.c +++ b/src/stdlib/bytes.c @@ -8,15 +8,18 @@ #include "text.h" #include "util.h" -public const Byte_t Byte$min = 0; -public const Byte_t Byte$max = UINT8_MAX; +public +const Byte_t Byte$min = 0; +public +const Byte_t Byte$max = UINT8_MAX; -PUREFUNC public Text_t Byte$as_text(const void *b, bool colorize, const TypeInfo_t *info) -{ +PUREFUNC public Text_t Byte$as_text(const void *b, bool colorize, const TypeInfo_t *info) { (void)info; if (!b) return Text("Byte"); - Byte_t byte = *(Byte_t*)b; - char digits[] = {'0', 'x', + Byte_t byte = *(Byte_t *)b; + char digits[] = { + '0', + 'x', (byte / 16) <= 9 ? '0' + (byte / 16) : 'a' + (byte / 16) - 10, (byte & 15) <= 9 ? '0' + (byte & 15) : 'a' + (byte & 15) - 10, '\0', @@ -26,52 +29,54 @@ PUREFUNC public Text_t Byte$as_text(const void *b, bool colorize, const TypeInfo return text; } -public CONSTFUNC bool Byte$is_between(const Byte_t x, const Byte_t low, const Byte_t high) { - return low <= x && x <= high; -} +public +CONSTFUNC bool Byte$is_between(const Byte_t x, const Byte_t low, const Byte_t high) { return low <= x && x <= high; } -public OptionalByte_t Byte$parse(Text_t text, Text_t *remainder) -{ +public +OptionalByte_t Byte$parse(Text_t text, Text_t *remainder) { OptionalInt_t full_int = Int$parse(text, remainder); - if (full_int.small != 0L - && Int$compare_value(full_int, I(0)) >= 0 - && Int$compare_value(full_int, I(255)) <= 0) { - return (OptionalByte_t){.value=Byte$from_int(full_int, true)}; + if (full_int.small != 0L && Int$compare_value(full_int, I(0)) >= 0 && Int$compare_value(full_int, I(255)) <= 0) { + return (OptionalByte_t){.value = Byte$from_int(full_int, true)}; } else { return NONE_BYTE; } } -public Text_t Byte$hex(Byte_t byte, bool uppercase, bool prefix) { - struct Text_s text = {.tag=TEXT_ASCII}; +public +Text_t Byte$hex(Byte_t byte, bool uppercase, bool prefix) { + struct Text_s text = {.tag = TEXT_ASCII}; text.ascii = GC_MALLOC_ATOMIC(8); - char *p = (char*)text.ascii; + char *p = (char *)text.ascii; if (prefix) { *(p++) = '0'; *(p++) = 'x'; } if (uppercase) { - *(p++) = (byte/16) > 9 ? 'A' + (byte/16) - 10 : '0' + (byte/16); + *(p++) = (byte / 16) > 9 ? 'A' + (byte / 16) - 10 : '0' + (byte / 16); *(p++) = (byte & 15) > 9 ? 'A' + (byte & 15) - 10 : '0' + (byte & 15); } else { - *(p++) = (byte/16) > 9 ? 'a' + (byte/16) - 10 : '0' + (byte/16); + *(p++) = (byte / 16) > 9 ? 'a' + (byte / 16) - 10 : '0' + (byte / 16); *(p++) = (byte & 15) > 9 ? 'a' + (byte & 15) - 10 : '0' + (byte & 15); } text.length = (int64_t)(p - text.ascii); return text; } -public bool Byte$get_bit(Byte_t x, Int_t bit_index) { - if (Int$compare_value(bit_index, I(1)) < 0) - fail("Invalid bit index (expected 1 or higher): ", bit_index); +public +bool Byte$get_bit(Byte_t x, Int_t bit_index) { + if (Int$compare_value(bit_index, I(1)) < 0) fail("Invalid bit index (expected 1 or higher): ", bit_index); if (Int$compare_value(bit_index, I(8)) > 0) fail("Bit index is too large! There are only 8 bits in a byte, but index is: ", bit_index); - return ((x & (Byte_t)(1L << (Int64$from_int(bit_index, true)-1L))) != 0); + return ((x & (Byte_t)(1L << (Int64$from_int(bit_index, true) - 1L))) != 0); } #ifdef __TINYC__ -#define __builtin_add_overflow(x, y, result) ({ *(result) = (x) + (y); false; }) +#define __builtin_add_overflow(x, y, result) \ + ({ \ + *(result) = (x) + (y); \ + false; \ + }) #endif typedef struct { @@ -82,52 +87,59 @@ typedef struct { static OptionalByte_t _next_Byte(ByteRange_t *info) { OptionalByte_t i = info->current; if (!i.is_none) { - Byte_t next; bool overflow = __builtin_add_overflow(i.value, info->step, &next); + Byte_t next; + bool overflow = __builtin_add_overflow(i.value, info->step, &next); if (overflow || (!info->last.is_none && (info->step >= 0 ? next > info->last.value : next < info->last.value))) - info->current = (OptionalByte_t){.is_none=true}; - else - info->current = (OptionalByte_t){.value=next}; + info->current = (OptionalByte_t){.is_none = true}; + else info->current = (OptionalByte_t){.value = next}; } return i; } -public CONSTFUNC Closure_t Byte$to(Byte_t first, Byte_t last, OptionalInt8_t step) { +public +CONSTFUNC Closure_t Byte$to(Byte_t first, Byte_t last, OptionalInt8_t step) { ByteRange_t *range = GC_MALLOC(sizeof(ByteRange_t)); - range->current = (OptionalByte_t){.value=first}; - range->last = (OptionalByte_t){.value=last}; + range->current = (OptionalByte_t){.value = first}; + range->last = (OptionalByte_t){.value = last}; range->step = step.is_none ? (last >= first ? 1 : -1) : step.value; - return (Closure_t){.fn=_next_Byte, .userdata=range}; + return (Closure_t){.fn = _next_Byte, .userdata = range}; } -public PUREFUNC Byte_t Byte$from_int(Int_t i, bool truncate) { +public +PUREFUNC Byte_t Byte$from_int(Int_t i, bool truncate) { if unlikely (!truncate && Int$compare_value(i, I_small(0xFF)) > 0) fail("This value is too large to convert to a byte without truncation: ", i); else if unlikely (!truncate && Int$compare_value(i, I_small(0)) < 0) fail("Negative values can't be converted to bytes: ", i); return (Byte_t)(i.small >> 2); } -public PUREFUNC Byte_t Byte$from_int64(Int64_t i, bool truncate) { +public +PUREFUNC Byte_t Byte$from_int64(Int64_t i, bool truncate) { if unlikely (!truncate && i != (Int64_t)(Byte_t)i) fail("This value can't be converted to a byte without truncation: ", i); return (Byte_t)i; } -public PUREFUNC Byte_t Byte$from_int32(Int32_t i, bool truncate) { +public +PUREFUNC Byte_t Byte$from_int32(Int32_t i, bool truncate) { if unlikely (!truncate && i != (Int32_t)(Byte_t)i) fail("This value can't be converted to a byte without truncation: ", i); return (Byte_t)i; } -public PUREFUNC Byte_t Byte$from_int16(Int16_t i, bool truncate) { +public +PUREFUNC Byte_t Byte$from_int16(Int16_t i, bool truncate) { if unlikely (!truncate && i != (Int16_t)(Byte_t)i) fail("This value can't be converted to a byte without truncation: ", i); return (Byte_t)i; } -public const TypeInfo_t Byte$info = { - .size=sizeof(Byte_t), - .align=__alignof__(Byte_t), - .metamethods={ - .as_text=Byte$as_text, - }, +public +const TypeInfo_t Byte$info = { + .size = sizeof(Byte_t), + .align = __alignof__(Byte_t), + .metamethods = + { + .as_text = Byte$as_text, + }, }; // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/c_strings.c b/src/stdlib/c_strings.c index c2b8efbe..b965f04b 100644 --- a/src/stdlib/c_strings.c +++ b/src/stdlib/c_strings.c @@ -12,46 +12,40 @@ #include "text.h" #include "util.h" -public Text_t CString$as_text(const void *c_string, bool colorize, const TypeInfo_t *info) -{ +public +Text_t CString$as_text(const void *c_string, bool colorize, const TypeInfo_t *info) { (void)info; if (!c_string) return Text("CString"); - Text_t text = Text$from_str(*(const char**)c_string); - return Text$concat(colorize ? Text("\x1b[34mCString\x1b[m(") : Text("CString("), Text$quoted(text, colorize, Text("\"")), Text(")")); + Text_t text = Text$from_str(*(const char **)c_string); + return Text$concat(colorize ? Text("\x1b[34mCString\x1b[m(") : Text("CString("), + Text$quoted(text, colorize, Text("\"")), Text(")")); } -PUREFUNC public int32_t CString$compare(const void *x, const void *y, const TypeInfo_t *info) -{ +PUREFUNC public int32_t CString$compare(const void *x, const void *y, const TypeInfo_t *info) { (void)info; - if (x == y) - return 0; + if (x == y) return 0; - if (!*(const char**)x != !*(const char**)y) - return (!*(const char**)y) - (!*(const char**)x); + if (!*(const char **)x != !*(const char **)y) return (!*(const char **)y) - (!*(const char **)x); - return strcmp(*(const char**)x, *(const char**)y); + return strcmp(*(const char **)x, *(const char **)y); } -PUREFUNC public bool CString$equal(const void *x, const void *y, const TypeInfo_t *type) -{ +PUREFUNC public bool CString$equal(const void *x, const void *y, const TypeInfo_t *type) { return CString$compare(x, y, type) == 0; } -PUREFUNC public uint64_t CString$hash(const void *c_str, const TypeInfo_t *info) -{ +PUREFUNC public uint64_t CString$hash(const void *c_str, const TypeInfo_t *info) { (void)info; - if (!*(const char**)c_str) return 0; - return siphash24(*(void**)c_str, strlen(*(const char**)c_str)); + if (!*(const char **)c_str) return 0; + return siphash24(*(void **)c_str, strlen(*(const char **)c_str)); } -PUREFUNC public bool CString$is_none(const void *c_str, const TypeInfo_t *info) -{ +PUREFUNC public bool CString$is_none(const void *c_str, const TypeInfo_t *info) { (void)info; - return *(const char**)c_str == NULL; + return *(const char **)c_str == NULL; } -static void CString$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *info) -{ +static void CString$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *info) { (void)info; const char *str = *(const char **)obj; int64_t len = (int64_t)strlen(str); @@ -59,30 +53,30 @@ static void CString$serialize(const void *obj, FILE *out, Table_t *pointers, con fwrite(str, sizeof(char), (size_t)len, out); } -static void CString$deserialize(FILE *in, void *out, List_t *pointers, const TypeInfo_t *info) -{ +static void CString$deserialize(FILE *in, void *out, List_t *pointers, const TypeInfo_t *info) { (void)info; int64_t len = -1; Int64$deserialize(in, &len, pointers, &Int64$info); - char *str = GC_MALLOC_ATOMIC((size_t)len+1); - if (fread(str, sizeof(char), (size_t)len, in) != (size_t)len) - fail("Not enough data in stream to deserialize"); - str[len+1] = '\0'; - *(const char**)out = str; + char *str = GC_MALLOC_ATOMIC((size_t)len + 1); + if (fread(str, sizeof(char), (size_t)len, in) != (size_t)len) fail("Not enough data in stream to deserialize"); + str[len + 1] = '\0'; + *(const char **)out = str; } -public const TypeInfo_t CString$info = { - .size=sizeof(const char*), - .align=__alignof__(const char*), - .metamethods={ - .hash=CString$hash, - .compare=CString$compare, - .equal=CString$equal, - .as_text=CString$as_text, - .is_none=CString$is_none, - .serialize=CString$serialize, - .deserialize=CString$deserialize, - }, +public +const TypeInfo_t CString$info = { + .size = sizeof(const char *), + .align = __alignof__(const char *), + .metamethods = + { + .hash = CString$hash, + .compare = CString$compare, + .equal = CString$equal, + .as_text = CString$as_text, + .is_none = CString$is_none, + .serialize = CString$serialize, + .deserialize = CString$deserialize, + }, }; // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/datatypes.h b/src/stdlib/datatypes.h index e473956e..5d016246 100644 --- a/src/stdlib/datatypes.h +++ b/src/stdlib/datatypes.h @@ -12,9 +12,9 @@ #define LIST_REFCOUNT_BITS 3 #define LIST_STRIDE_BITS 12 -#define MAX_FOR_N_BITS(N) ((1L<<(N))-1L) -#define LIST_MAX_STRIDE MAX_FOR_N_BITS(LIST_STRIDE_BITS-1) -#define LIST_MIN_STRIDE (~MAX_FOR_N_BITS(LIST_STRIDE_BITS-1)) +#define MAX_FOR_N_BITS(N) ((1L << (N)) - 1L) +#define LIST_MAX_STRIDE MAX_FOR_N_BITS(LIST_STRIDE_BITS - 1) +#define LIST_MIN_STRIDE (~MAX_FOR_N_BITS(LIST_STRIDE_BITS - 1)) #define LIST_MAX_DATA_REFCOUNT MAX_FOR_N_BITS(LIST_REFCOUNT_BITS) #define LIST_MAX_FREE_ENTRIES MAX_FOR_N_BITS(LIST_FREE_BITS) @@ -41,15 +41,15 @@ typedef struct { // structs can be passed in two 64-bit registers. C will handle doing the // bit arithmetic to extract the necessary values, which is cheaper than // spilling onto the stack and needing to retrieve data from the stack. - int64_t length:LIST_LENGTH_BITS; - uint64_t free:LIST_FREE_BITS; - bool atomic:LIST_ATOMIC_BITS; - uint8_t data_refcount:LIST_REFCOUNT_BITS; - int16_t stride:LIST_STRIDE_BITS; + int64_t length : LIST_LENGTH_BITS; + uint64_t free : LIST_FREE_BITS; + bool atomic : LIST_ATOMIC_BITS; + uint8_t data_refcount : LIST_REFCOUNT_BITS; + int16_t stride : LIST_STRIDE_BITS; } List_t; typedef struct { - uint32_t occupied:1, index:31; + uint32_t occupied : 1, index : 31; uint32_t next_bucket; } bucket_t; @@ -57,8 +57,8 @@ typedef struct { #define TABLE_MAX_DATA_REFCOUNT 3 typedef struct { - uint32_t count:31, last_free:31; - uint8_t data_refcount:2; + uint32_t count : 31, last_free : 31; + uint8_t data_refcount : 2; bucket_t buckets[]; } bucket_info_t; @@ -76,9 +76,9 @@ typedef struct { enum text_type { TEXT_ASCII, TEXT_GRAPHEMES, TEXT_CONCAT, TEXT_BLOB }; typedef struct Text_s { - int64_t length:54; // Number of grapheme clusters - uint8_t tag:2; - uint8_t depth:8; + int64_t length : 54; // Number of grapheme clusters + uint8_t tag : 2; + uint8_t depth : 8; union { struct { const char *ascii; @@ -117,10 +117,9 @@ typedef struct { typedef struct { Byte_t value; - bool is_none:1; + bool is_none : 1; } OptionalByte_t; -#define NONE_BYTE ((OptionalByte_t){.is_none=true}) - +#define NONE_BYTE ((OptionalByte_t){.is_none = true}) // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/enums.c b/src/stdlib/enums.c index ae0c976d..7f7c4284 100644 --- a/src/stdlib/enums.c +++ b/src/stdlib/enums.c @@ -11,34 +11,30 @@ CONSTFUNC static ptrdiff_t value_offset(const TypeInfo_t *type) { ptrdiff_t offset = sizeof(int32_t); for (int i = 0; i < type->EnumInfo.num_tags; i++) { - if (type->EnumInfo.tags[i].type) - offset = MAX(offset, type->EnumInfo.tags[i].type->align); + if (type->EnumInfo.tags[i].type) offset = MAX(offset, type->EnumInfo.tags[i].type->align); } return offset; } -PUREFUNC public uint64_t Enum$hash(const void *obj, const TypeInfo_t *type) -{ - int32_t tag = *(int32_t*)obj; +PUREFUNC public uint64_t Enum$hash(const void *obj, const TypeInfo_t *type) { + int32_t tag = *(int32_t *)obj; uint32_t components[2] = {(uint32_t)tag, 0}; - const TypeInfo_t *value = type->EnumInfo.tags[tag-1].type; + const TypeInfo_t *value = type->EnumInfo.tags[tag - 1].type; if (value && value->size > 0) { components[1] = generic_hash(obj + value_offset(type), value); } - return siphash24((void*)components, sizeof(components)); + return siphash24((void *)components, sizeof(components)); } -PUREFUNC public int32_t Enum$compare(const void *x, const void *y, const TypeInfo_t *type) -{ +PUREFUNC public int32_t Enum$compare(const void *x, const void *y, const TypeInfo_t *type) { if (x == y) return 0; - int32_t x_tag = *(int32_t*)x; - int32_t y_tag = *(int32_t*)y; - if (x_tag != y_tag) - return x_tag > y_tag ? 1 : -1; + int32_t x_tag = *(int32_t *)x; + int32_t y_tag = *(int32_t *)y; + if (x_tag != y_tag) return x_tag > y_tag ? 1 : -1; - const TypeInfo_t *value = type->EnumInfo.tags[x_tag-1].type; + const TypeInfo_t *value = type->EnumInfo.tags[x_tag - 1].type; if (value && value->size > 0) { ptrdiff_t byte_offset = value_offset(type); return generic_compare(x + byte_offset, y + byte_offset, value); @@ -46,16 +42,14 @@ PUREFUNC public int32_t Enum$compare(const void *x, const void *y, const TypeInf return 0; } -PUREFUNC public bool Enum$equal(const void *x, const void *y, const TypeInfo_t *type) -{ +PUREFUNC public bool Enum$equal(const void *x, const void *y, const TypeInfo_t *type) { if (x == y) return true; - int32_t x_tag = *(int32_t*)x; - int32_t y_tag = *(int32_t*)y; - if (x_tag != y_tag) - return false; + int32_t x_tag = *(int32_t *)x; + int32_t y_tag = *(int32_t *)y; + if (x_tag != y_tag) return false; - const TypeInfo_t *value = type->EnumInfo.tags[x_tag-1].type; + const TypeInfo_t *value = type->EnumInfo.tags[x_tag - 1].type; if (value && value->size > 0) { ptrdiff_t byte_offset = value_offset(type); return generic_equal(x + byte_offset, y + byte_offset, value); @@ -63,12 +57,12 @@ PUREFUNC public bool Enum$equal(const void *x, const void *y, const TypeInfo_t * return true; } -public Text_t Enum$as_text(const void *obj, bool colorize, const TypeInfo_t *type) -{ +public +Text_t Enum$as_text(const void *obj, bool colorize, const TypeInfo_t *type) { if (!obj) return Text$from_str(type->EnumInfo.name); - int32_t tag = *(int32_t*)obj; - NamedType_t value = type->EnumInfo.tags[tag-1]; + int32_t tag = *(int32_t *)obj; + NamedType_t value = type->EnumInfo.tags[tag - 1]; if (!value.type || value.type->size == 0) { Text_t text = Text$from_str(value.name); return colorize ? Texts(Text("\x1b[1m"), text, Text("\x1b[m")) : text; @@ -77,30 +71,29 @@ public Text_t Enum$as_text(const void *obj, bool colorize, const TypeInfo_t *typ return generic_as_text(obj + value_offset(type), colorize, value.type); } -PUREFUNC public bool Enum$is_none(const void *x, const TypeInfo_t *info) -{ +PUREFUNC public bool Enum$is_none(const void *x, const TypeInfo_t *info) { (void)info; - return *(int32_t*)x == 0; + return *(int32_t *)x == 0; } -public void Enum$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) -{ - int32_t tag = *(int32_t*)obj; +public +void Enum$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) { + int32_t tag = *(int32_t *)obj; Int32$serialize(&tag, out, pointers, &Int32$info); - NamedType_t value = type->EnumInfo.tags[tag-1]; + NamedType_t value = type->EnumInfo.tags[tag - 1]; if (value.type && value.type->size > 0) { _serialize(obj + value_offset(type), out, pointers, value.type); } } -public void Enum$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *type) -{ +public +void Enum$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *type) { int32_t tag = 0; Int32$deserialize(in, &tag, pointers, &Int32$info); - *(int32_t*)outval = tag; + *(int32_t *)outval = tag; - NamedType_t value = type->EnumInfo.tags[tag-1]; + NamedType_t value = type->EnumInfo.tags[tag - 1]; if (value.type && value.type->size > 0) { _deserialize(in, outval + value_offset(type), pointers, value.type); } diff --git a/src/stdlib/enums.h b/src/stdlib/enums.h index 8345c527..99a0f615 100644 --- a/src/stdlib/enums.h +++ b/src/stdlib/enums.h @@ -15,24 +15,26 @@ PUREFUNC bool Enum$is_none(const void *obj, const TypeInfo_t *type); void Enum$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type); void Enum$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *type); -#define Enum$metamethods { \ - .as_text=Enum$as_text, \ - .compare=Enum$compare, \ - .equal=Enum$equal, \ - .hash=Enum$hash, \ - .is_none=Enum$is_none, \ - .serialize=Enum$serialize, \ - .deserialize=Enum$deserialize, \ -} +#define Enum$metamethods \ + { \ + .as_text = Enum$as_text, \ + .compare = Enum$compare, \ + .equal = Enum$equal, \ + .hash = Enum$hash, \ + .is_none = Enum$is_none, \ + .serialize = Enum$serialize, \ + .deserialize = Enum$deserialize, \ + } -#define PackedDataEnum$metamethods { \ - .hash=PackedData$hash, \ - .compare=Enum$compare, \ - .equal=PackedData$equal, \ - .as_text=Enum$as_text, \ - .is_none=Enum$is_none, \ - .serialize=Enum$serialize, \ - .deserialize=Enum$deserialize, \ -} +#define PackedDataEnum$metamethods \ + { \ + .hash = PackedData$hash, \ + .compare = Enum$compare, \ + .equal = PackedData$equal, \ + .as_text = Enum$as_text, \ + .is_none = Enum$is_none, \ + .serialize = Enum$serialize, \ + .deserialize = Enum$deserialize, \ + } // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/files.c b/src/stdlib/files.c index 87b0205c..08023e0e 100644 --- a/src/stdlib/files.c +++ b/src/stdlib/files.c @@ -20,8 +20,8 @@ static const int tabstop = 4; -public char *resolve_path(const char *path, const char *relative_to, const char *system_path) -{ +public +char *resolve_path(const char *path, const char *relative_to, const char *system_path) { if (!relative_to || streq(relative_to, "/dev/stdin")) relative_to = "."; if (!path || strlen(path) == 0) return NULL; @@ -29,7 +29,7 @@ public char *resolve_path(const char *path, const char *relative_to, const char // it was found in: char buf[PATH_MAX] = {0}; if (streq(path, "~") || starts_with(path, "~/")) { - char *resolved = realpath(String(getenv("HOME"), path+1), buf); + char *resolved = realpath(String(getenv("HOME"), path + 1), buf); if (resolved) return GC_strdup(resolved); } else if (streq(path, ".") || starts_with(path, "./") || starts_with(path, "../")) { char *relative_dir = dirname(GC_strdup(relative_to)); @@ -49,12 +49,13 @@ public char *resolve_path(const char *path, const char *relative_to, const char char *resolved = realpath(String(dir, "/", path), buf); if (resolved) return GC_strdup(resolved); } else if (dir[0] == '~' && (dir[1] == '\0' || dir[1] == '/')) { - char *resolved = realpath(String(getenv("HOME"), dir+1, "/", path), buf); + char *resolved = realpath(String(getenv("HOME"), dir + 1, "/", path), buf); if (resolved) return GC_strdup(resolved); } else if (streq(dir, ".") || strncmp(dir, "./", 2) == 0) { char *resolved = realpath(String(relative_dir, "/", path), buf); if (resolved) return GC_strdup(resolved); - } else if (streq(dir, ".") || streq(dir, "..") || strncmp(dir, "./", 2) == 0 || strncmp(dir, "../", 3) == 0) { + } else if (streq(dir, ".") || streq(dir, "..") || strncmp(dir, "./", 2) == 0 + || strncmp(dir, "../", 3) == 0) { char *resolved = realpath(String(relative_dir, "/", dir, "/", path), buf); if (resolved) return GC_strdup(resolved); } else { @@ -66,24 +67,23 @@ public char *resolve_path(const char *path, const char *relative_to, const char return NULL; } -public char *file_base_name(const char *path) -{ +public +char *file_base_name(const char *path) { const char *slash = strrchr(path, '/'); if (slash) path = slash + 1; assert(!isdigit(*path)); const char *end = path + strcspn(path, "."); size_t len = (size_t)(end - path); - char *buf = GC_MALLOC_ATOMIC(len+1); + char *buf = GC_MALLOC_ATOMIC(len + 1); strncpy(buf, path, len); buf[len] = '\0'; return buf; } -static file_t *_load_file(const char* filename, FILE *file) -{ +static file_t *_load_file(const char *filename, FILE *file) { if (!file) return NULL; - file_t *ret = new(file_t, .filename=filename); + file_t *ret = new (file_t, .filename = filename); size_t file_size = 0, line_cap = 0; char *file_buf = NULL, *line_buf = NULL; @@ -98,7 +98,7 @@ static file_t *_load_file(const char* filename, FILE *file) } fclose(file); - char *copy = GC_MALLOC_ATOMIC(file_size+1); + char *copy = GC_MALLOC_ATOMIC(file_size + 1); memcpy(copy, file_buf, file_size); copy[file_size] = '\0'; ret->text = copy; @@ -114,7 +114,7 @@ static file_t *_load_file(const char* filename, FILE *file) char *cwd = getcwd(buf, sizeof(buf)); size_t cwd_len = strlen(cwd); if (strncmp(cwd, filename, cwd_len) == 0 && filename[cwd_len] == '/') - ret->relative_filename = &filename[cwd_len+1]; + ret->relative_filename = &filename[cwd_len + 1]; } return ret; } @@ -122,8 +122,8 @@ static file_t *_load_file(const char* filename, FILE *file) // // Read an entire file into memory. // -public file_t *load_file(const char* filename) -{ +public +file_t *load_file(const char *filename) { FILE *file = filename[0] ? fopen(filename, "r") : stdin; return _load_file(filename, file); } @@ -131,30 +131,27 @@ public file_t *load_file(const char* filename) // // Create a virtual file from a string. // -public file_t *spoof_file(const char* filename, const char *text) -{ - FILE *file = fmemopen((char*)text, strlen(text)+1, "r"); +public +file_t *spoof_file(const char *filename, const char *text) { + FILE *file = fmemopen((char *)text, strlen(text) + 1, "r"); return _load_file(filename, file); } // // Given a pointer, determine which line number it points to (1-indexed) // -public int64_t get_line_number(file_t *f, const char *p) -{ +public +int64_t get_line_number(file_t *f, const char *p) { // Binary search: - int64_t lo = 0, hi = (int64_t)f->num_lines-1; + int64_t lo = 0, hi = (int64_t)f->num_lines - 1; if (p < f->text) return 0; int64_t offset = (int64_t)(p - f->text); while (lo <= hi) { int64_t mid = (lo + hi) / 2; int64_t line_offset = f->line_offsets[mid]; - if (line_offset == offset) - return mid + 1; - else if (line_offset < offset) - lo = mid + 1; - else if (line_offset > offset) - hi = mid - 1; + if (line_offset == offset) return mid + 1; + else if (line_offset < offset) lo = mid + 1; + else if (line_offset > offset) hi = mid - 1; } return lo; // Return the line number whose line starts closest before p } @@ -162,33 +159,32 @@ public int64_t get_line_number(file_t *f, const char *p) // // Given a pointer, determine which line column it points to. // -public int64_t get_line_column(file_t *f, const char *p) -{ +public +int64_t get_line_column(file_t *f, const char *p) { int64_t line_no = get_line_number(f, p); - int64_t line_offset = f->line_offsets[line_no-1]; + int64_t line_offset = f->line_offsets[line_no - 1]; return 1 + (int64_t)(p - (f->text + line_offset)); } // // Return a pointer to the line with the specified line number (1-indexed) // -public const char *get_line(file_t *f, int64_t line_number) -{ +public +const char *get_line(file_t *f, int64_t line_number) { if (line_number == 0 || line_number > (int64_t)f->num_lines) return NULL; - int64_t line_offset = f->line_offsets[line_number-1]; + int64_t line_offset = f->line_offsets[line_number - 1]; return f->text + line_offset; } // // Return a value like /foo:line.col // -public const char *get_file_pos(file_t *f, const char *p) -{ +public +const char *get_file_pos(file_t *f, const char *p) { return String(f->filename, ":", get_line_number(f, p), ".", get_line_column(f, p)); } -static int fputc_column(FILE *out, char c, char print_char, int *column) -{ +static int fputc_column(FILE *out, char c, char print_char, int *column) { int printed = 0; if (print_char == '\t') print_char = ' '; if (c == '\t') { @@ -206,18 +202,16 @@ static int fputc_column(FILE *out, char c, char print_char, int *column) // // Print a span from a file // -public int highlight_error(file_t *file, const char *start, const char *end, const char *hl_color, int64_t context_lines, bool use_color) -{ +public +int highlight_error(file_t *file, const char *start, const char *end, const char *hl_color, int64_t context_lines, + bool use_color) { if (!file) return 0; // Handle spans that come from multiple files: - if (start < file->text || start > file->text + file->len) - start = end; - if (end < file->text || end > file->text + file->len) - end = start; + if (start < file->text || start > file->text + file->len) start = end; + if (end < file->text || end > file->text + file->len) end = start; // Just in case neither end of the span came from this file: - if (end < file->text || end > file->text + file->len) - start = end = file->text; + if (end < file->text || end > file->text + file->len) start = end = file->text; const char *lineno_prefix, *lineno_suffix, *normal_color, *empty_marker; bool print_carets = false; @@ -238,27 +232,25 @@ public int highlight_error(file_t *file, const char *start, const char *end, con printed += fprint(stderr, file->relative_filename); } - if (context_lines == 0) - return fprint(stderr, hl_color, string_slice(start, (size_t)(end - start)), normal_color); + if (context_lines == 0) return fprint(stderr, hl_color, string_slice(start, (size_t)(end - start)), normal_color); - int64_t start_line = get_line_number(file, start), - end_line = get_line_number(file, end); + int64_t start_line = get_line_number(file, start), end_line = get_line_number(file, end); - int64_t first_line = start_line - (context_lines - 1), - last_line = end_line + (context_lines - 1); + int64_t first_line = start_line - (context_lines - 1), last_line = end_line + (context_lines - 1); if (first_line < 1) first_line = 1; if (last_line > file->num_lines) last_line = file->num_lines; int digits = 1; - for (int64_t i = last_line; i > 0; i /= 10) ++digits; + for (int64_t i = last_line; i > 0; i /= 10) + ++digits; for (int64_t line_no = first_line; line_no <= last_line; ++line_no) { if (line_no > first_line + 5 && line_no < last_line - 5) { if (use_color) - printed += fprint(stderr, "\x1b[0;2;3;4m ... ", (last_line - first_line) - 11, " lines omitted ... \x1b[m"); - else - printed += fprint(stderr, " ... ", (last_line - first_line) - 11, " lines omitted ..."); + printed += fprint(stderr, "\x1b[0;2;3;4m ... ", (last_line - first_line) - 11, + " lines omitted ... \x1b[m"); + else printed += fprint(stderr, " ... ", (last_line - first_line) - 11, " lines omitted ..."); line_no = last_line - 6; continue; } @@ -305,14 +297,10 @@ public int highlight_error(file_t *file, const char *start, const char *end, con int col = 0; for (const char *sp = line; *sp && *sp != '\n'; ++sp) { char print_char; - if (sp < start) - print_char = ' '; - else if (sp == start && sp == end) - print_char = '^'; - else if (sp >= start && sp < end) - print_char = '-'; - else - print_char = ' '; + if (sp < start) print_char = ' '; + else if (sp == start && sp == end) print_char = '^'; + else if (sp >= start && sp < end) print_char = '-'; + else print_char = ' '; printed += fputc_column(stderr, *sp, print_char, &col); } printed += fputs("\n", stderr); diff --git a/src/stdlib/files.h b/src/stdlib/files.h index f650f78e..d3e5ebe8 100644 --- a/src/stdlib/files.h +++ b/src/stdlib/files.h @@ -16,20 +16,14 @@ typedef struct { } file_t; char *resolve_path(const char *path, const char *relative_to, const char *system_path); -__attribute__((pure, nonnull)) -char *file_base_name(const char *path); -__attribute__((nonnull)) -file_t *load_file(const char *filename); -__attribute__((nonnull, returns_nonnull)) -file_t *spoof_file(const char *filename, const char *text); -__attribute__((pure, nonnull)) -int64_t get_line_number(file_t *f, const char *p); -__attribute__((pure, nonnull)) -int64_t get_line_column(file_t *f, const char *p); -__attribute__((pure, nonnull)) -const char *get_line(file_t *f, int64_t line_number); -__attribute__((pure, nonnull)) -const char *get_file_pos(file_t *f, const char *p); -int highlight_error(file_t *file, const char *start, const char *end, const char *hl_color, int64_t context_lines, bool use_color); +__attribute__((pure, nonnull)) char *file_base_name(const char *path); +__attribute__((nonnull)) file_t *load_file(const char *filename); +__attribute__((nonnull, returns_nonnull)) file_t *spoof_file(const char *filename, const char *text); +__attribute__((pure, nonnull)) int64_t get_line_number(file_t *f, const char *p); +__attribute__((pure, nonnull)) int64_t get_line_column(file_t *f, const char *p); +__attribute__((pure, nonnull)) const char *get_line(file_t *f, int64_t line_number); +__attribute__((pure, nonnull)) const char *get_file_pos(file_t *f, const char *p); +int highlight_error(file_t *file, const char *start, const char *end, const char *hl_color, int64_t context_lines, + bool use_color); // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/fpconv.c b/src/stdlib/fpconv.c index 97699784..8b994cfa 100644 --- a/src/stdlib/fpconv.c +++ b/src/stdlib/fpconv.c @@ -6,37 +6,46 @@ #include "fpconv.h" #include "powers.h" -#define fracmask 0x000FFFFFFFFFFFFFU -#define expmask 0x7FF0000000000000U +#define fracmask 0x000FFFFFFFFFFFFFU +#define expmask 0x7FF0000000000000U #define hiddenbit 0x0010000000000000U -#define signmask 0x8000000000000000U -#define expbias (1023 + 52) +#define signmask 0x8000000000000000U +#define expbias (1023 + 52) #define absv(n) ((n) < 0 ? -(n) : (n)) #define minv(a, b) ((a) < (b) ? (a) : (b)) -static uint64_t tens[] = { - 10000000000000000000U, 1000000000000000000U, 100000000000000000U, - 10000000000000000U, 1000000000000000U, 100000000000000U, - 10000000000000U, 1000000000000U, 100000000000U, - 10000000000U, 1000000000U, 100000000U, - 10000000U, 1000000U, 100000U, - 10000U, 1000U, 100U, - 10U, 1U -}; - -static inline uint64_t get_dbits(double d) -{ +static uint64_t tens[] = {10000000000000000000U, + 1000000000000000000U, + 100000000000000000U, + 10000000000000000U, + 1000000000000000U, + 100000000000000U, + 10000000000000U, + 1000000000000U, + 100000000000U, + 10000000000U, + 1000000000U, + 100000000U, + 10000000U, + 1000000U, + 100000U, + 10000U, + 1000U, + 100U, + 10U, + 1U}; + +static inline uint64_t get_dbits(double d) { union { - double dbl; + double dbl; uint64_t i; - } dbl_bits = { d }; + } dbl_bits = {d}; return dbl_bits.i; } -static Fp build_fp(double d) -{ +static Fp build_fp(double d) { uint64_t bits = get_dbits(d); Fp fp; @@ -54,8 +63,7 @@ static Fp build_fp(double d) return fp; } -static void normalize(Fp* fp) -{ +static void normalize(Fp *fp) { while ((fp->frac & hiddenbit) == 0) { fp->frac <<= 1; fp->exp--; @@ -66,10 +74,9 @@ static void normalize(Fp* fp) fp->exp -= shift; } -static void get_normalized_boundaries(Fp* fp, Fp* lower, Fp* upper) -{ +static void get_normalized_boundaries(Fp *fp, Fp *lower, Fp *upper) { upper->frac = (fp->frac << 1) + 1; - upper->exp = fp->exp - 1; + upper->exp = fp->exp - 1; while ((upper->frac & (hiddenbit << 1)) == 0) { upper->frac <<= 1; @@ -81,64 +88,55 @@ static void get_normalized_boundaries(Fp* fp, Fp* lower, Fp* upper) upper->frac <<= u_shift; upper->exp = upper->exp - u_shift; - int l_shift = fp->frac == hiddenbit ? 2 : 1; lower->frac = (fp->frac << l_shift) - 1; lower->exp = fp->exp - l_shift; - lower->frac <<= lower->exp - upper->exp; lower->exp = upper->exp; } -static Fp multiply(Fp* a, Fp* b) -{ +static Fp multiply(Fp *a, Fp *b) { const uint64_t lomask = 0x00000000FFFFFFFF; - uint64_t ah_bl = (a->frac >> 32) * (b->frac & lomask); + uint64_t ah_bl = (a->frac >> 32) * (b->frac & lomask); uint64_t al_bh = (a->frac & lomask) * (b->frac >> 32); uint64_t al_bl = (a->frac & lomask) * (b->frac & lomask); - uint64_t ah_bh = (a->frac >> 32) * (b->frac >> 32); + uint64_t ah_bh = (a->frac >> 32) * (b->frac >> 32); uint64_t tmp = (ah_bl & lomask) + (al_bh & lomask) + (al_bl >> 32); /* round up */ tmp += 1U << 31; - Fp fp = { - ah_bh + (ah_bl >> 32) + (al_bh >> 32) + (tmp >> 32), - a->exp + b->exp + 64 - }; + Fp fp = {ah_bh + (ah_bl >> 32) + (al_bh >> 32) + (tmp >> 32), a->exp + b->exp + 64}; return fp; } -static void round_digit(char* digits, int ndigits, uint64_t delta, uint64_t rem, uint64_t kappa, uint64_t frac) -{ - while (rem < frac && delta - rem >= kappa && - (rem + kappa < frac || frac - rem > rem + kappa - frac)) { +static void round_digit(char *digits, int ndigits, uint64_t delta, uint64_t rem, uint64_t kappa, uint64_t frac) { + while (rem < frac && delta - rem >= kappa && (rem + kappa < frac || frac - rem > rem + kappa - frac)) { digits[ndigits - 1]--; rem += kappa; } } -static int generate_digits(Fp* fp, Fp* upper, Fp* lower, char* digits, int* K) -{ +static int generate_digits(Fp *fp, Fp *upper, Fp *lower, char *digits, int *K) { uint64_t wfrac = upper->frac - fp->frac; uint64_t delta = upper->frac - lower->frac; Fp one; one.frac = 1ULL << -upper->exp; - one.exp = upper->exp; + one.exp = upper->exp; uint64_t part1 = upper->frac >> -one.exp; uint64_t part2 = upper->frac & (one.frac - 1); int idx = 0, kappa = 10; - uint64_t* divp; + uint64_t *divp; /* 1000000000 */ - for(divp = tens + 10; kappa > 0; divp++) { + for (divp = tens + 10; kappa > 0; divp++) { uint64_t div = *divp; unsigned digit = part1 / div; @@ -150,7 +148,7 @@ static int generate_digits(Fp* fp, Fp* upper, Fp* lower, char* digits, int* K) part1 -= digit * div; kappa--; - uint64_t tmp = (part1 <<-one.exp) + part2; + uint64_t tmp = (part1 << -one.exp) + part2; if (tmp <= delta) { *K += kappa; round_digit(digits, idx, delta, tmp, div << -one.exp, wfrac); @@ -160,7 +158,7 @@ static int generate_digits(Fp* fp, Fp* upper, Fp* lower, char* digits, int* K) } /* 10 */ - uint64_t* unit = tens + 18; + uint64_t *unit = tens + 18; while (true) { part2 *= 10; @@ -184,8 +182,7 @@ static int generate_digits(Fp* fp, Fp* upper, Fp* lower, char* digits, int* K) } } -static int grisu2(double d, char* digits, int* K) -{ +static int grisu2(double d, char *digits, int *K) { Fp w = build_fp(d); Fp lower, upper; @@ -196,7 +193,7 @@ static int grisu2(double d, char* digits, int* K) int k; Fp cp = find_cachedpow10(upper.exp, &k); - w = multiply(&w, &cp); + w = multiply(&w, &cp); upper = multiply(&upper, &cp); lower = multiply(&lower, &cp); @@ -208,8 +205,7 @@ static int grisu2(double d, char* digits, int* K) return generate_digits(&w, &upper, &lower, digits, K); } -static int emit_digits(char* digits, int ndigits, char* dest, int K, bool neg) -{ +static int emit_digits(char *digits, int ndigits, char *dest, int K, bool neg) { int exp = absv(K + ndigits - 1); int max_trailing_zeros = 7; @@ -240,7 +236,7 @@ static int emit_digits(char* digits, int ndigits, char* dest, int K, bool neg) return ndigits + 2 + offset; - /* fp > 1.0 */ + /* fp > 1.0 */ } else { memcpy(dest, digits, (size_t)offset); dest[offset] = '.'; @@ -288,8 +284,7 @@ static int emit_digits(char* digits, int ndigits, char* dest, int K, bool neg) return idx; } -static int filter_special(double fp, char* dest) -{ +static int filter_special(double fp, char *dest) { if (fp == 0.0) { dest[0] = '0'; return 1; @@ -304,17 +299,20 @@ static int filter_special(double fp, char* dest) } if (bits & fracmask) { - dest[0] = 'n'; dest[1] = 'a'; dest[2] = 'n'; + dest[0] = 'n'; + dest[1] = 'a'; + dest[2] = 'n'; } else { - dest[0] = 'i'; dest[1] = 'n'; dest[2] = 'f'; + dest[0] = 'i'; + dest[1] = 'n'; + dest[2] = 'f'; } return 3; } -int fpconv_dtoa(double d, char dest[24]) -{ +int fpconv_dtoa(double d, char dest[24]) { char digits[18]; int str_len = 0; diff --git a/src/stdlib/functiontype.c b/src/stdlib/functiontype.c index 6d692c6d..a6e12798 100644 --- a/src/stdlib/functiontype.c +++ b/src/stdlib/functiontype.c @@ -9,18 +9,17 @@ #include "types.h" #include "util.h" -public Text_t Func$as_text(const void *fn, bool colorize, const TypeInfo_t *type) -{ +public +Text_t Func$as_text(const void *fn, bool colorize, const TypeInfo_t *type) { Text_t text = Text$from_str(type->FunctionInfo.type_str); - if (fn && colorize) - text = Text$concat(Text("\x1b[32;1m"), text, Text("\x1b[m")); + if (fn && colorize) text = Text$concat(Text("\x1b[32;1m"), text, Text("\x1b[m")); return text; } -public PUREFUNC bool Func$is_none(const void *obj, const TypeInfo_t *info) -{ +public +PUREFUNC bool Func$is_none(const void *obj, const TypeInfo_t *info) { (void)info; - return *(void**)obj == NULL; + return *(void **)obj == NULL; } // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/functiontype.h b/src/stdlib/functiontype.h index 095d630e..3169cfc9 100644 --- a/src/stdlib/functiontype.h +++ b/src/stdlib/functiontype.h @@ -13,20 +13,27 @@ OptionalText_t get_function_name(void *fn); OptionalText_t get_function_filename(void *fn); int64_t get_function_line_num(void *fn); Text_t Func$as_text(const void *fn, bool colorize, const TypeInfo_t *type); -PUREFUNC bool Func$is_none(const void *obj, const TypeInfo_t*); +PUREFUNC bool Func$is_none(const void *obj, const TypeInfo_t *); -#define Func$metamethods { \ - .as_text=Func$as_text, \ - .is_none=Func$is_none, \ - .serialize=cannot_serialize, \ - .deserialize=cannot_deserialize, \ -} +#define Func$metamethods \ + { \ + .as_text = Func$as_text, \ + .is_none = Func$is_none, \ + .serialize = cannot_serialize, \ + .deserialize = cannot_deserialize, \ + } -#define Function$info(typestr) &((TypeInfo_t){.size=sizeof(void*), .align=__alignof__(void*), \ - .tag=FunctionInfo, .FunctionInfo.type_str=typestr, \ - .metamethods=Func$metamethods}) -#define Closure$info(typestr) &((TypeInfo_t){.size=sizeof(void*[2]), .align=__alignof__(void*), \ - .tag=FunctionInfo, .FunctionInfo.type_str=typestr, \ - .metamethods=Func$metamethods}) +#define Function$info(typestr) \ + &((TypeInfo_t){.size = sizeof(void *), \ + .align = __alignof__(void *), \ + .tag = FunctionInfo, \ + .FunctionInfo.type_str = typestr, \ + .metamethods = Func$metamethods}) +#define Closure$info(typestr) \ + &((TypeInfo_t){.size = sizeof(void *[2]), \ + .align = __alignof__(void *), \ + .tag = FunctionInfo, \ + .FunctionInfo.type_str = typestr, \ + .metamethods = Func$metamethods}) // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/integers.c b/src/stdlib/integers.c index e24d984d..93095a70 100644 --- a/src/stdlib/integers.c +++ b/src/stdlib/integers.c @@ -17,20 +17,19 @@ #include "text.h" #include "types.h" -public int Int$print(FILE *f, Int_t i) { +public +int Int$print(FILE *f, Int_t i) { if (likely(i.small & 1L)) { - return _print_int(f, (int64_t)((i.small)>>2L)); + return _print_int(f, (int64_t)((i.small) >> 2L)); } else { return gmp_fprintf(f, "%Zd", *i.big); } } -static inline Text_t _int64_to_text(int64_t n) -{ - if (n == INT64_MIN) - return Text("-9223372036854775808"); +static inline Text_t _int64_to_text(int64_t n) { + if (n == INT64_MIN) return Text("-9223372036854775808"); - char buf[21] = {[20]=0}; // Big enough for INT64_MIN + '\0' + char buf[21] = {[20] = 0}; // Big enough for INT64_MIN + '\0' char *p = &buf[19]; bool negative = n < 0; if (negative) n = -n; // Safe to do because we checked for INT64_MIN earlier @@ -40,13 +39,13 @@ static inline Text_t _int64_to_text(int64_t n) n /= 10; } while (n > 0); - if (negative) - *(p--) = '-'; + if (negative) *(p--) = '-'; return Text$from_strn(p + 1, (size_t)(&buf[19] - p)); } -public Text_t Int$value_as_text(Int_t i) { +public +Text_t Int$value_as_text(Int_t i) { if (likely(i.small & 1L)) { return _int64_to_text(i.small >> 2L); } else { @@ -55,74 +54,76 @@ public Text_t Int$value_as_text(Int_t i) { } } -public Text_t Int$as_text(const void *i, bool colorize, const TypeInfo_t *info) { +public +Text_t Int$as_text(const void *i, bool colorize, const TypeInfo_t *info) { (void)info; if (!i) return Text("Int"); - Text_t text = Int$value_as_text(*(Int_t*)i); + Text_t text = Int$value_as_text(*(Int_t *)i); if (colorize) text = Text$concat(Text("\x1b[35m"), text, Text("\x1b[m")); return text; } -static bool Int$is_none(const void *i, const TypeInfo_t *info) -{ +static bool Int$is_none(const void *i, const TypeInfo_t *info) { (void)info; - return ((Int_t*)i)->small == 0L; + return ((Int_t *)i)->small == 0L; } -public PUREFUNC int32_t Int$compare_value(const Int_t x, const Int_t y) { - if (likely(x.small & y.small & 1L)) - return (x.small > y.small) - (x.small < y.small); - else if (x.small & 1) - return -mpz_cmp_si(*y.big, x.small); - else if (y.small & 1) - return mpz_cmp_si(*x.big, y.small); - else - return x.big == y.big ? 0 : mpz_cmp(*x.big, *y.big); +public +PUREFUNC int32_t Int$compare_value(const Int_t x, const Int_t y) { + if (likely(x.small & y.small & 1L)) return (x.small > y.small) - (x.small < y.small); + else if (x.small & 1) return -mpz_cmp_si(*y.big, x.small); + else if (y.small & 1) return mpz_cmp_si(*x.big, y.small); + else return x.big == y.big ? 0 : mpz_cmp(*x.big, *y.big); } -public PUREFUNC int32_t Int$compare(const void *x, const void *y, const TypeInfo_t *info) { +public +PUREFUNC int32_t Int$compare(const void *x, const void *y, const TypeInfo_t *info) { (void)info; - return Int$compare_value(*(Int_t*)x, *(Int_t*)y); + return Int$compare_value(*(Int_t *)x, *(Int_t *)y); } -public PUREFUNC bool Int$equal_value(const Int_t x, const Int_t y) { - if (likely((x.small | y.small) & 1L)) - return x.small == y.small; - else - return x.big == y.big ? 0 : (mpz_cmp(*x.big, *y.big) == 0); +public +PUREFUNC bool Int$equal_value(const Int_t x, const Int_t y) { + if (likely((x.small | y.small) & 1L)) return x.small == y.small; + else return x.big == y.big ? 0 : (mpz_cmp(*x.big, *y.big) == 0); } -public PUREFUNC bool Int$equal(const void *x, const void *y, const TypeInfo_t *info) { +public +PUREFUNC bool Int$equal(const void *x, const void *y, const TypeInfo_t *info) { (void)info; - return Int$equal_value(*(Int_t*)x, *(Int_t*)y); + return Int$equal_value(*(Int_t *)x, *(Int_t *)y); } -public CONSTFUNC Int_t Int$clamped(Int_t x, Int_t low, Int_t high) { +public +CONSTFUNC Int_t Int$clamped(Int_t x, Int_t low, Int_t high) { return (Int$compare(&x, &low, &Int$info) <= 0) ? low : (Int$compare(&x, &high, &Int$info) >= 0 ? high : x); } -public CONSTFUNC bool Int$is_between(const Int_t x, const Int_t low, const Int_t high) { +public +CONSTFUNC bool Int$is_between(const Int_t x, const Int_t low, const Int_t high) { return Int$compare_value(low, x) <= 0 && Int$compare_value(x, high) <= 0; } -public PUREFUNC uint64_t Int$hash(const void *vx, const TypeInfo_t *info) { +public +PUREFUNC uint64_t Int$hash(const void *vx, const TypeInfo_t *info) { (void)info; - Int_t *x = (Int_t*)vx; + Int_t *x = (Int_t *)vx; if (likely(x->small & 1L)) { - return siphash24((void*)x, sizeof(Int_t)); + return siphash24((void *)x, sizeof(Int_t)); } else { char *str = mpz_get_str(NULL, 16, *x->big); - return siphash24((void*)str, strlen(str)); + return siphash24((void *)str, strlen(str)); } } -public Text_t Int$hex(Int_t i, Int_t digits_int, bool uppercase, bool prefix) { - if (Int$is_negative(i)) - return Text$concat(Text("-"), Int$hex(Int$negative(i), digits_int, uppercase, prefix)); +public +Text_t Int$hex(Int_t i, Int_t digits_int, bool uppercase, bool prefix) { + if (Int$is_negative(i)) return Text$concat(Text("-"), Int$hex(Int$negative(i), digits_int, uppercase, prefix)); if (likely(i.small & 1L)) { uint64_t u64 = (uint64_t)(i.small >> 2); - return Text$from_str(String(hex(u64, .no_prefix=!prefix, .digits=Int32$from_int(digits_int, false), .uppercase=uppercase))); + return Text$from_str(String( + hex(u64, .no_prefix = !prefix, .digits = Int32$from_int(digits_int, false), .uppercase = uppercase))); } else { char *str = mpz_get_str(NULL, 16, *i.big); if (uppercase) { @@ -131,97 +132,88 @@ public Text_t Int$hex(Int_t i, Int_t digits_int, bool uppercase, bool prefix) { } int64_t digits = Int64$from_int(digits_int, false); int64_t needed_zeroes = digits - (int64_t)strlen(str); - if (needed_zeroes <= 0) - return prefix ? Text$concat(Text("0x"), Text$from_str(str)) : Text$from_str(str); + if (needed_zeroes <= 0) return prefix ? Text$concat(Text("0x"), Text$from_str(str)) : Text$from_str(str); char *zeroes = GC_MALLOC_ATOMIC((size_t)(needed_zeroes)); memset(zeroes, '0', (size_t)(needed_zeroes)); - if (prefix) - return Text$concat(Text("0x"), Text$from_str(zeroes), Text$from_str(str)); - else - return Text$concat(Text$from_str(zeroes), Text$from_str(str)); + if (prefix) return Text$concat(Text("0x"), Text$from_str(zeroes), Text$from_str(str)); + else return Text$concat(Text$from_str(zeroes), Text$from_str(str)); } } -public Text_t Int$octal(Int_t i, Int_t digits_int, bool prefix) { - if (Int$is_negative(i)) - return Text$concat(Text("-"), Int$octal(Int$negative(i), digits_int, prefix)); +public +Text_t Int$octal(Int_t i, Int_t digits_int, bool prefix) { + if (Int$is_negative(i)) return Text$concat(Text("-"), Int$octal(Int$negative(i), digits_int, prefix)); if (likely(i.small & 1L)) { uint64_t u64 = (uint64_t)(i.small >> 2); - return Text$from_str(String(oct(u64, .no_prefix=!prefix, .digits=Int32$from_int(digits_int, false)))); + return Text$from_str(String(oct(u64, .no_prefix = !prefix, .digits = Int32$from_int(digits_int, false)))); } else { int64_t digits = Int64$from_int(digits_int, false); char *str = mpz_get_str(NULL, 8, *i.big); int64_t needed_zeroes = digits - (int64_t)strlen(str); - if (needed_zeroes <= 0) - return prefix ? Text$concat(Text("0o"), Text$from_str(str)) : Text$from_str(str); + if (needed_zeroes <= 0) return prefix ? Text$concat(Text("0o"), Text$from_str(str)) : Text$from_str(str); char *zeroes = GC_MALLOC_ATOMIC((size_t)(needed_zeroes)); memset(zeroes, '0', (size_t)(needed_zeroes)); - if (prefix) - return Text$concat(Text("0o"), Text$from_str(zeroes), Text$from_str(str)); - else - return Text$concat(Text$from_str(zeroes), Text$from_str(str)); + if (prefix) return Text$concat(Text("0o"), Text$from_str(zeroes), Text$from_str(str)); + else return Text$concat(Text$from_str(zeroes), Text$from_str(str)); } } -public Int_t Int$slow_plus(Int_t x, Int_t y) { +public +Int_t Int$slow_plus(Int_t x, Int_t y) { mpz_t result; mpz_init_set_int(result, x); if (y.small & 1L) { - if (y.small < 0L) - mpz_sub_ui(result, result, (uint64_t)(-(y.small >> 2L))); - else - mpz_add_ui(result, result, (uint64_t)(y.small >> 2L)); + if (y.small < 0L) mpz_sub_ui(result, result, (uint64_t)(-(y.small >> 2L))); + else mpz_add_ui(result, result, (uint64_t)(y.small >> 2L)); } else { mpz_add(result, result, *y.big); } return Int$from_mpz(result); } -public Int_t Int$slow_minus(Int_t x, Int_t y) { +public +Int_t Int$slow_minus(Int_t x, Int_t y) { mpz_t result; mpz_init_set_int(result, x); if (y.small & 1L) { - if (y.small < 0L) - mpz_add_ui(result, result, (uint64_t)(-(y.small >> 2L))); - else - mpz_sub_ui(result, result, (uint64_t)(y.small >> 2L)); + if (y.small < 0L) mpz_add_ui(result, result, (uint64_t)(-(y.small >> 2L))); + else mpz_sub_ui(result, result, (uint64_t)(y.small >> 2L)); } else { mpz_sub(result, result, *y.big); } return Int$from_mpz(result); } -public Int_t Int$slow_times(Int_t x, Int_t y) { +public +Int_t Int$slow_times(Int_t x, Int_t y) { mpz_t result; mpz_init_set_int(result, x); - if (y.small & 1L) - mpz_mul_si(result, result, y.small >> 2L); - else - mpz_mul(result, result, *y.big); + if (y.small & 1L) mpz_mul_si(result, result, y.small >> 2L); + else mpz_mul(result, result, *y.big); return Int$from_mpz(result); } -public Int_t Int$slow_divided_by(Int_t dividend, Int_t divisor) { - // Euclidean division, see: https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf +public +Int_t Int$slow_divided_by(Int_t dividend, Int_t divisor) { + // Euclidean division, see: + // https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf mpz_t quotient, remainder; mpz_init_set_int(quotient, dividend); mpz_init_set_int(remainder, divisor); mpz_tdiv_qr(quotient, remainder, quotient, remainder); if (mpz_sgn(remainder) < 0) { bool d_positive = likely(divisor.small & 1L) ? divisor.small > 0x1L : mpz_sgn(*divisor.big) > 0; - if (d_positive) - mpz_sub_ui(quotient, quotient, 1); - else - mpz_add_ui(quotient, quotient, 1); + if (d_positive) mpz_sub_ui(quotient, quotient, 1); + else mpz_add_ui(quotient, quotient, 1); } return Int$from_mpz(quotient); } -public Int_t Int$slow_modulo(Int_t x, Int_t modulus) -{ +public +Int_t Int$slow_modulo(Int_t x, Int_t modulus) { mpz_t result; mpz_init_set_int(result, x); mpz_t divisor; @@ -230,8 +222,8 @@ public Int_t Int$slow_modulo(Int_t x, Int_t modulus) return Int$from_mpz(result); } -public Int_t Int$slow_modulo1(Int_t x, Int_t modulus) -{ +public +Int_t Int$slow_modulo1(Int_t x, Int_t modulus) { mpz_t result; mpz_init_set_int(result, x); mpz_sub_ui(result, result, 1); @@ -242,8 +234,8 @@ public Int_t Int$slow_modulo1(Int_t x, Int_t modulus) return Int$from_mpz(result); } -public Int_t Int$slow_left_shifted(Int_t x, Int_t y) -{ +public +Int_t Int$slow_left_shifted(Int_t x, Int_t y) { mp_bitcnt_t bits = (mp_bitcnt_t)Int64$from_int(y, false); mpz_t result; mpz_init_set_int(result, x); @@ -251,8 +243,8 @@ public Int_t Int$slow_left_shifted(Int_t x, Int_t y) return Int$from_mpz(result); } -public Int_t Int$slow_right_shifted(Int_t x, Int_t y) -{ +public +Int_t Int$slow_right_shifted(Int_t x, Int_t y) { mp_bitcnt_t bits = (mp_bitcnt_t)Int64$from_int(y, false); mpz_t result; mpz_init_set_int(result, x); @@ -260,8 +252,8 @@ public Int_t Int$slow_right_shifted(Int_t x, Int_t y) return Int$from_mpz(result); } -public Int_t Int$slow_bit_and(Int_t x, Int_t y) -{ +public +Int_t Int$slow_bit_and(Int_t x, Int_t y) { mpz_t result; mpz_init_set_int(result, x); mpz_t y_mpz; @@ -270,8 +262,8 @@ public Int_t Int$slow_bit_and(Int_t x, Int_t y) return Int$from_mpz(result); } -public Int_t Int$slow_bit_or(Int_t x, Int_t y) -{ +public +Int_t Int$slow_bit_or(Int_t x, Int_t y) { mpz_t result; mpz_init_set_int(result, x); mpz_t y_mpz; @@ -280,8 +272,8 @@ public Int_t Int$slow_bit_or(Int_t x, Int_t y) return Int$from_mpz(result); } -public Int_t Int$slow_bit_xor(Int_t x, Int_t y) -{ +public +Int_t Int$slow_bit_xor(Int_t x, Int_t y) { mpz_t result; mpz_init_set_int(result, x); mpz_t y_mpz; @@ -290,8 +282,8 @@ public Int_t Int$slow_bit_xor(Int_t x, Int_t y) return Int$from_mpz(result); } -public Int_t Int$slow_negated(Int_t x) -{ +public +Int_t Int$slow_negated(Int_t x) { mpz_t result; mpz_init_set_int(result, x); mpz_neg(result, result); @@ -299,10 +291,9 @@ public Int_t Int$slow_negated(Int_t x) return Int$from_mpz(result); } -public Int_t Int$slow_negative(Int_t x) -{ - if (likely(x.small & 1L)) - return (Int_t){.small=4L*-((x.small)>>2L) + 1L}; +public +Int_t Int$slow_negative(Int_t x) { + if (likely(x.small & 1L)) return (Int_t){.small = 4L * -((x.small) >> 2L) + 1L}; mpz_t result; mpz_init_set_int(result, x); @@ -310,10 +301,9 @@ public Int_t Int$slow_negative(Int_t x) return Int$from_mpz(result); } -public Int_t Int$abs(Int_t x) -{ - if (likely(x.small & 1L)) - return (Int_t){.small=4L*labs((x.small)>>2L) + 1L}; +public +Int_t Int$abs(Int_t x) { + if (likely(x.small & 1L)) return (Int_t){.small = 4L * labs((x.small) >> 2L) + 1L}; mpz_t result; mpz_init_set_int(result, x); @@ -321,53 +311,45 @@ public Int_t Int$abs(Int_t x) return Int$from_mpz(result); } -public Int_t Int$power(Int_t base, Int_t exponent) -{ +public +Int_t Int$power(Int_t base, Int_t exponent) { int64_t exp = Int64$from_int(exponent, false); - if (unlikely(exp < 0)) - fail("Cannot take a negative power of an integer!"); + if (unlikely(exp < 0)) fail("Cannot take a negative power of an integer!"); mpz_t result; mpz_init_set_int(result, base); mpz_pow_ui(result, result, (uint64_t)exp); return Int$from_mpz(result); } -public Int_t Int$gcd(Int_t x, Int_t y) -{ - if (likely(x.small & y.small & 0x1L)) - return I_small(Int32$gcd(x.small >> 2L, y.small >> 2L)); +public +Int_t Int$gcd(Int_t x, Int_t y) { + if (likely(x.small & y.small & 0x1L)) return I_small(Int32$gcd(x.small >> 2L, y.small >> 2L)); mpz_t result; mpz_init(result); - if (x.small & 0x1L) - mpz_gcd_ui(result, *y.big, (uint64_t)labs(x.small>>2L)); - else if (y.small & 0x1L) - mpz_gcd_ui(result, *x.big, (uint64_t)labs(y.small>>2L)); - else - mpz_gcd(result, *x.big, *y.big); + if (x.small & 0x1L) mpz_gcd_ui(result, *y.big, (uint64_t)labs(x.small >> 2L)); + else if (y.small & 0x1L) mpz_gcd_ui(result, *x.big, (uint64_t)labs(y.small >> 2L)); + else mpz_gcd(result, *x.big, *y.big); return Int$from_mpz(result); } -public OptionalInt_t Int$sqrt(Int_t i) -{ - if (Int$compare_value(i, I(0)) < 0) - return NONE_INT; +public +OptionalInt_t Int$sqrt(Int_t i) { + if (Int$compare_value(i, I(0)) < 0) return NONE_INT; mpz_t result; mpz_init_set_int(result, i); mpz_sqrt(result, result); return Int$from_mpz(result); } -public bool Int$get_bit(Int_t x, Int_t bit_index) -{ +public +bool Int$get_bit(Int_t x, Int_t bit_index) { mpz_t i; mpz_init_set_int(i, x); - if (Int$compare_value(bit_index, I(1)) < 0) - fail("Invalid bit index (expected 1 or higher): ", bit_index); - if (Int$compare_value(bit_index, Int$from_int64(INT64_MAX)) > 0) - fail("Bit index is too large! ", bit_index); + if (Int$compare_value(bit_index, I(1)) < 0) fail("Invalid bit index (expected 1 or higher): ", bit_index); + if (Int$compare_value(bit_index, Int$from_int64(INT64_MAX)) > 0) fail("Bit index is too large! ", bit_index); - int is_bit_set = mpz_tstbit(i, (mp_bitcnt_t)(Int64$from_int(bit_index, true)-1)); + int is_bit_set = mpz_tstbit(i, (mp_bitcnt_t)(Int64$from_int(bit_index, true) - 1)); return (bool)is_bit_set; } @@ -376,37 +358,41 @@ typedef struct { Int_t step; } IntRange_t; -static OptionalInt_t _next_int(IntRange_t *info) -{ +static OptionalInt_t _next_int(IntRange_t *info) { OptionalInt_t i = info->current; if (!Int$is_none(&i, &Int$info)) { Int_t next = Int$plus(i, info->step); - if (!Int$is_none(&info->last, &Int$info) && Int$compare_value(next, info->last) == Int$compare_value(info->step, I(0))) + if (!Int$is_none(&info->last, &Int$info) + && Int$compare_value(next, info->last) == Int$compare_value(info->step, I(0))) next = NONE_INT; info->current = next; } return i; } -public PUREFUNC Closure_t Int$to(Int_t first, Int_t last, OptionalInt_t step) { +public +PUREFUNC Closure_t Int$to(Int_t first, Int_t last, OptionalInt_t step) { IntRange_t *range = GC_MALLOC(sizeof(IntRange_t)); range->current = first; range->last = last; - range->step = Int$is_none(&step, &Int$info) ? - Int$compare_value(last, first) >= 0 ? (Int_t){.small=(1L<<2L)|1L} : (Int_t){.small=(-1L>>2L)|1L} - : step; - return (Closure_t){.fn=_next_int, .userdata=range}; + range->step = Int$is_none(&step, &Int$info) ? Int$compare_value(last, first) >= 0 + ? (Int_t){.small = (1L << 2L) | 1L} + : (Int_t){.small = (-1L >> 2L) | 1L} + : step; + return (Closure_t){.fn = _next_int, .userdata = range}; } -public PUREFUNC Closure_t Int$onward(Int_t first, Int_t step) { +public +PUREFUNC Closure_t Int$onward(Int_t first, Int_t step) { IntRange_t *range = GC_MALLOC(sizeof(IntRange_t)); range->current = first; range->last = NONE_INT; range->step = step; - return (Closure_t){.fn=_next_int, .userdata=range}; + return (Closure_t){.fn = _next_int, .userdata = range}; } -public Int_t Int$from_str(const char *str) { +public +Int_t Int$from_str(const char *str) { mpz_t i; int result; if (strncmp(str, "0x", 2) == 0) { @@ -418,12 +404,12 @@ public Int_t Int$from_str(const char *str) { } else { result = mpz_init_set_str(i, str, 10); } - if (result != 0) - return NONE_INT; + if (result != 0) return NONE_INT; return Int$from_mpz(i); } -public OptionalInt_t Int$parse(Text_t text, Text_t *remainder) { +public +OptionalInt_t Int$parse(Text_t text, Text_t *remainder) { const char *str = Text$as_c_string(text); mpz_t i; int result; @@ -455,8 +441,8 @@ public OptionalInt_t Int$parse(Text_t text, Text_t *remainder) { return Int$from_mpz(i); } -public bool Int$is_prime(Int_t x, Int_t reps) -{ +public +bool Int$is_prime(Int_t x, Int_t reps) { mpz_t p; mpz_init_set_int(p, x); if (unlikely(Int$compare_value(reps, I(9999)) > 0)) @@ -465,8 +451,8 @@ public bool Int$is_prime(Int_t x, Int_t reps) return (mpz_probab_prime_p(p, reps_int) != 0); } -public Int_t Int$next_prime(Int_t x) -{ +public +Int_t Int$next_prime(Int_t x) { mpz_t p; mpz_init_set_int(p, x); mpz_nextprime(p, p); @@ -475,28 +461,25 @@ public Int_t Int$next_prime(Int_t x) #if __GNU_MP_VERSION >= 6 #if __GNU_MP_VERSION_MINOR >= 3 -public OptionalInt_t Int$prev_prime(Int_t x) -{ +public +OptionalInt_t Int$prev_prime(Int_t x) { mpz_t p; mpz_init_set_int(p, x); - if (unlikely(mpz_prevprime(p, p) == 0)) - return NONE_INT; + if (unlikely(mpz_prevprime(p, p) == 0)) return NONE_INT; return Int$from_mpz(p); } #endif #endif -public Int_t Int$choose(Int_t n, Int_t k) -{ - if unlikely (Int$compare_value(n, I_small(0)) < 0) - fail("Negative inputs are not supported for choose()"); +public +Int_t Int$choose(Int_t n, Int_t k) { + if unlikely (Int$compare_value(n, I_small(0)) < 0) fail("Negative inputs are not supported for choose()"); mpz_t ret; mpz_init(ret); int64_t k_i64 = Int64$from_int(k, false); - if unlikely (k_i64 < 0) - fail("Negative inputs are not supported for choose()"); + if unlikely (k_i64 < 0) fail("Negative inputs are not supported for choose()"); if likely (n.small & 1L) { mpz_bin_uiui(ret, (unsigned long)(n.small >> 2L), (unsigned long)k_i64); @@ -508,21 +491,19 @@ public Int_t Int$choose(Int_t n, Int_t k) return Int$from_mpz(ret); } -public Int_t Int$factorial(Int_t n) -{ +public +Int_t Int$factorial(Int_t n) { mpz_t ret; mpz_init(ret); int64_t n_i64 = Int64$from_int(n, false); - if unlikely (n_i64 < 0) - fail("Factorials are not defined for negative numbers"); + if unlikely (n_i64 < 0) fail("Factorials are not defined for negative numbers"); mpz_fac_ui(ret, (unsigned long)n_i64); return Int$from_mpz(ret); } -static void Int$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *info) -{ +static void Int$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *info) { (void)info; - Int_t i = *(Int_t*)obj; + Int_t i = *(Int_t *)obj; if (likely(i.small & 1L)) { fputc(0, out); int64_t i64 = i.small >> 2L; @@ -530,44 +511,45 @@ static void Int$serialize(const void *obj, FILE *out, Table_t *pointers, const T } else { fputc(1, out); mpz_t n; - mpz_init_set_int(n, *(Int_t*)obj); + mpz_init_set_int(n, *(Int_t *)obj); mpz_out_raw(out, n); } } -static void Int$deserialize(FILE *in, void *obj, List_t *pointers, const TypeInfo_t *info) -{ +static void Int$deserialize(FILE *in, void *obj, List_t *pointers, const TypeInfo_t *info) { (void)info; if (fgetc(in) == 0) { int64_t i = 0; Int64$deserialize(in, &i, pointers, &Int64$info); - *(Int_t*)obj = (Int_t){.small=(i<<2L) | 1L}; + *(Int_t *)obj = (Int_t){.small = (i << 2L) | 1L}; } else { mpz_t n; mpz_init(n); mpz_inp_raw(n, in); - *(Int_t*)obj = Int$from_mpz(n); + *(Int_t *)obj = Int$from_mpz(n); } } -public const TypeInfo_t Int$info = { - .size=sizeof(Int_t), - .align=__alignof__(Int_t), - .metamethods={ - .compare=Int$compare, - .equal=Int$equal, - .hash=Int$hash, - .as_text=Int$as_text, - .is_none=Int$is_none, - .serialize=Int$serialize, - .deserialize=Int$deserialize, - }, +public +const TypeInfo_t Int$info = { + .size = sizeof(Int_t), + .align = __alignof__(Int_t), + .metamethods = + { + .compare = Int$compare, + .equal = Int$equal, + .hash = Int$hash, + .as_text = Int$as_text, + .is_none = Int$is_none, + .serialize = Int$serialize, + .deserialize = Int$deserialize, + }, }; -public void Int64$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *info) -{ +public +void Int64$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *info) { (void)info, (void)pointers; - int64_t i = *(int64_t*)obj; + int64_t i = *(int64_t *)obj; uint64_t z = (uint64_t)((i << 1L) ^ (i >> 63L)); // Zigzag encode while (z >= 0x80L) { fputc((uint8_t)(z | 0x80L), out); @@ -576,22 +558,22 @@ public void Int64$serialize(const void *obj, FILE *out, Table_t *pointers, const fputc((uint8_t)z, out); } -public void Int64$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *info) -{ +public +void Int64$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *info) { (void)info, (void)pointers; uint64_t z = 0; - for(size_t shift = 0; ; shift += 7) { + for (size_t shift = 0;; shift += 7) { uint8_t byte = (uint8_t)fgetc(in); z |= ((uint64_t)(byte & 0x7F)) << shift; if ((byte & 0x80) == 0) break; } - *(int64_t*)outval = (int64_t)((z >> 1L) ^ -(z & 1L)); // Zigzag decode + *(int64_t *)outval = (int64_t)((z >> 1L) ^ -(z & 1L)); // Zigzag decode } -public void Int32$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *info) -{ +public +void Int32$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *info) { (void)info, (void)pointers; - int32_t i = *(int32_t*)obj; + int32_t i = *(int32_t *)obj; uint32_t z = (uint32_t)((i << 1) ^ (i >> 31)); // Zigzag encode while (z >= 0x80) { fputc((uint8_t)(z | 0x80), out); @@ -600,16 +582,16 @@ public void Int32$serialize(const void *obj, FILE *out, Table_t *pointers, const fputc((uint8_t)z, out); } -public void Int32$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *info) -{ +public +void Int32$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *info) { (void)info, (void)pointers; uint32_t z = 0; - for(size_t shift = 0; ; shift += 7) { + for (size_t shift = 0;; shift += 7) { uint8_t byte = (uint8_t)fgetc(in); z |= ((uint32_t)(byte & 0x7F)) << shift; if ((byte & 0x80) == 0) break; } - *(int32_t*)outval = (int32_t)((z >> 1L) ^ -(z & 1L)); // Zigzag decode + *(int32_t *)outval = (int32_t)((z >> 1L) ^ -(z & 1L)); // Zigzag decode } // The space savings for smaller ints are not worth having: @@ -619,122 +601,146 @@ public void Int32$deserialize(FILE *in, void *outval, List_t *pointers, const Ty #define Int8$deserialize NULL #ifdef __TINYC__ -#define __builtin_add_overflow(x, y, result) ({ *(result) = (x) + (y); false; }) +#define __builtin_add_overflow(x, y, result) \ + ({ \ + *(result) = (x) + (y); \ + false; \ + }) #endif -#define DEFINE_INT_TYPE(c_type, KindOfInt, min_val, max_val, to_attr)\ - public Text_t KindOfInt ## $as_text(const void *i, bool colorize, const TypeInfo_t *info) { \ - (void)info; \ - if (!i) return Text(#KindOfInt); \ - Text_t text = _int64_to_text((int64_t)(*(c_type*)i)); \ - return colorize ? Texts(Text("\033[35m"), text, Text("\033[m")) : text; \ - } \ - public PUREFUNC int32_t KindOfInt ## $compare(const void *x, const void *y, const TypeInfo_t *info) { \ - (void)info; \ - return (*(c_type*)x > *(c_type*)y) - (*(c_type*)x < *(c_type*)y); \ - } \ - public PUREFUNC bool KindOfInt ## $equal(const void *x, const void *y, const TypeInfo_t *info) { \ - (void)info; \ - return *(c_type*)x == *(c_type*)y; \ - } \ - public CONSTFUNC bool KindOfInt ## $is_between(const c_type x, const c_type low, const c_type high) { \ - return low <= x && x <= high; \ - } \ - public CONSTFUNC c_type KindOfInt ## $clamped(c_type x, c_type min, c_type max) { \ - return x < min ? min : (x > max ? max : x); \ - } \ - public Text_t KindOfInt ## $hex(c_type i, Int_t digits_int, bool uppercase, bool prefix) { \ - Int_t as_int = Int$from_int64((int64_t)i); \ - return Int$hex(as_int, digits_int, uppercase, prefix); \ - } \ - public Text_t KindOfInt ## $octal(c_type i, Int_t digits_int, bool prefix) { \ - Int_t as_int = Int$from_int64((int64_t)i); \ - return Int$octal(as_int, digits_int, prefix); \ - } \ - public List_t KindOfInt ## $bits(c_type x) { \ - List_t bit_list = (List_t){.data=GC_MALLOC_ATOMIC(sizeof(bool[8*sizeof(c_type)])), .atomic=1, .stride=sizeof(bool), .length=8*sizeof(c_type)}; \ - bool *bits = bit_list.data + sizeof(c_type)*8; \ - for (size_t i = 0; i < 8*sizeof(c_type); i++) { \ - *(bits--) = x & 1; \ - x >>= 1; \ - } \ - return bit_list; \ - } \ - public bool KindOfInt ## $get_bit(c_type x, Int_t bit_index) { \ - if (Int$compare_value(bit_index, I(1)) < 0) \ - fail("Invalid bit index (expected 1 or higher): ", bit_index); \ - if (Int$compare_value(bit_index, Int$from_int64(sizeof(c_type)*8)) > 0) \ - fail("Bit index is too large! There are only ", (uint64_t)sizeof(c_type)*8, " bits, but index is: ", bit_index); \ - return ((x & (c_type)(1L << (Int64$from_int(bit_index, true)-1L))) != 0); \ - } \ - typedef struct { \ - Optional##KindOfInt##_t current, last; \ - KindOfInt##_t step; \ - } KindOfInt##Range_t; \ - static Optional##KindOfInt##_t _next_##KindOfInt(KindOfInt##Range_t *info) \ - { \ - Optional##KindOfInt##_t i = info->current; \ - if (!i.is_none) { \ - KindOfInt##_t next; bool overflow = __builtin_add_overflow(i.value, info->step, &next); \ - if (overflow || (!info->last.is_none && (info->step >= 0 ? next > info->last.value : next < info->last.value))) \ - info->current = (Optional##KindOfInt##_t){.is_none=true}; \ - else \ - info->current = (Optional##KindOfInt##_t){.value=next}; \ - } \ - return i; \ - } \ - public to_attr Closure_t KindOfInt ## $to(c_type first, c_type last, Optional ## KindOfInt ## _t step) { \ - KindOfInt##Range_t *range = GC_MALLOC(sizeof(KindOfInt##Range_t)); \ - range->current = (Optional##KindOfInt##_t){.value=first}; \ - range->last = (Optional##KindOfInt##_t){.value=last}; \ - range->step = step.is_none ? (last >= first ? 1 : -1) : step.value; \ - return (Closure_t){.fn=_next_##KindOfInt, .userdata=range}; \ - } \ - public to_attr Closure_t KindOfInt ## $onward(c_type first, c_type step) { \ - KindOfInt##Range_t *range = GC_MALLOC(sizeof(KindOfInt##Range_t)); \ - range->current = (Optional##KindOfInt##_t){.value=first}; \ - range->last = (Optional##KindOfInt##_t){.is_none=true}; \ - range->step = step; \ - return (Closure_t){.fn=_next_##KindOfInt, .userdata=range}; \ - } \ - public PUREFUNC Optional ## KindOfInt ## _t KindOfInt ## $parse(Text_t text, Text_t *remainder) { \ - OptionalInt_t full_int = Int$parse(text, remainder); \ - if (full_int.small == 0L) return (Optional ## KindOfInt ## _t){.is_none=true}; \ - if (Int$compare_value(full_int, I(min_val)) < 0) { \ - return (Optional ## KindOfInt ## _t){.is_none=true}; \ - } \ - if (Int$compare_value(full_int, I(max_val)) > 0) { \ - return (Optional ## KindOfInt ## _t){.is_none=true}; \ - } \ - return (Optional ## KindOfInt ## _t){.value=KindOfInt##$from_int(full_int, true)}; \ - } \ - public CONSTFUNC c_type KindOfInt ## $gcd(c_type x, c_type y) { \ - if (x == 0 || y == 0) return 0; \ - x = KindOfInt##$abs(x); \ - y = KindOfInt##$abs(y); \ - while (x != y) { \ - if (x > y) x -= y; \ - else y -= x; \ - } \ - return x; \ - } \ - public const c_type KindOfInt##$min = min_val; \ - public const c_type KindOfInt##$max = max_val; \ - public const TypeInfo_t KindOfInt##$info = { \ - .size=sizeof(c_type), \ - .align=__alignof__(c_type), \ - .metamethods={ \ - .compare=KindOfInt##$compare, \ - .as_text=KindOfInt##$as_text, \ - .serialize=KindOfInt##$serialize, \ - .deserialize=KindOfInt##$deserialize, \ - }, \ +#define DEFINE_INT_TYPE(c_type, KindOfInt, min_val, max_val, to_attr) \ + public \ + Text_t KindOfInt##$as_text(const void *i, bool colorize, const TypeInfo_t *info) { \ + (void)info; \ + if (!i) return Text(#KindOfInt); \ + Text_t text = _int64_to_text((int64_t)(*(c_type *)i)); \ + return colorize ? Texts(Text("\033[35m"), text, Text("\033[m")) : text; \ + } \ + public \ + PUREFUNC int32_t KindOfInt##$compare(const void *x, const void *y, const TypeInfo_t *info) { \ + (void)info; \ + return (*(c_type *)x > *(c_type *)y) - (*(c_type *)x < *(c_type *)y); \ + } \ + public \ + PUREFUNC bool KindOfInt##$equal(const void *x, const void *y, const TypeInfo_t *info) { \ + (void)info; \ + return *(c_type *)x == *(c_type *)y; \ + } \ + public \ + CONSTFUNC bool KindOfInt##$is_between(const c_type x, const c_type low, const c_type high) { \ + return low <= x && x <= high; \ + } \ + public \ + CONSTFUNC c_type KindOfInt##$clamped(c_type x, c_type min, c_type max) { \ + return x < min ? min : (x > max ? max : x); \ + } \ + public \ + Text_t KindOfInt##$hex(c_type i, Int_t digits_int, bool uppercase, bool prefix) { \ + Int_t as_int = Int$from_int64((int64_t)i); \ + return Int$hex(as_int, digits_int, uppercase, prefix); \ + } \ + public \ + Text_t KindOfInt##$octal(c_type i, Int_t digits_int, bool prefix) { \ + Int_t as_int = Int$from_int64((int64_t)i); \ + return Int$octal(as_int, digits_int, prefix); \ + } \ + public \ + List_t KindOfInt##$bits(c_type x) { \ + List_t bit_list = (List_t){.data = GC_MALLOC_ATOMIC(sizeof(bool[8 * sizeof(c_type)])), \ + .atomic = 1, \ + .stride = sizeof(bool), \ + .length = 8 * sizeof(c_type)}; \ + bool *bits = bit_list.data + sizeof(c_type) * 8; \ + for (size_t i = 0; i < 8 * sizeof(c_type); i++) { \ + *(bits--) = x & 1; \ + x >>= 1; \ + } \ + return bit_list; \ + } \ + public \ + bool KindOfInt##$get_bit(c_type x, Int_t bit_index) { \ + if (Int$compare_value(bit_index, I(1)) < 0) fail("Invalid bit index (expected 1 or higher): ", bit_index); \ + if (Int$compare_value(bit_index, Int$from_int64(sizeof(c_type) * 8)) > 0) \ + fail("Bit index is too large! There are only ", (uint64_t)sizeof(c_type) * 8, \ + " bits, but index is: ", bit_index); \ + return ((x & (c_type)(1L << (Int64$from_int(bit_index, true) - 1L))) != 0); \ + } \ + typedef struct { \ + Optional##KindOfInt##_t current, last; \ + KindOfInt##_t step; \ + } KindOfInt##Range_t; \ + static Optional##KindOfInt##_t _next_##KindOfInt(KindOfInt##Range_t *info) { \ + Optional##KindOfInt##_t i = info->current; \ + if (!i.is_none) { \ + KindOfInt##_t next; \ + bool overflow = __builtin_add_overflow(i.value, info->step, &next); \ + if (overflow \ + || (!info->last.is_none && (info->step >= 0 ? next > info->last.value : next < info->last.value))) \ + info->current = (Optional##KindOfInt##_t){.is_none = true}; \ + else info->current = (Optional##KindOfInt##_t){.value = next}; \ + } \ + return i; \ + } \ + public \ + to_attr Closure_t KindOfInt##$to(c_type first, c_type last, Optional##KindOfInt##_t step) { \ + KindOfInt##Range_t *range = GC_MALLOC(sizeof(KindOfInt##Range_t)); \ + range->current = (Optional##KindOfInt##_t){.value = first}; \ + range->last = (Optional##KindOfInt##_t){.value = last}; \ + range->step = step.is_none ? (last >= first ? 1 : -1) : step.value; \ + return (Closure_t){.fn = _next_##KindOfInt, .userdata = range}; \ + } \ + public \ + to_attr Closure_t KindOfInt##$onward(c_type first, c_type step) { \ + KindOfInt##Range_t *range = GC_MALLOC(sizeof(KindOfInt##Range_t)); \ + range->current = (Optional##KindOfInt##_t){.value = first}; \ + range->last = (Optional##KindOfInt##_t){.is_none = true}; \ + range->step = step; \ + return (Closure_t){.fn = _next_##KindOfInt, .userdata = range}; \ + } \ + public \ + PUREFUNC Optional##KindOfInt##_t KindOfInt##$parse(Text_t text, Text_t *remainder) { \ + OptionalInt_t full_int = Int$parse(text, remainder); \ + if (full_int.small == 0L) return (Optional##KindOfInt##_t){.is_none = true}; \ + if (Int$compare_value(full_int, I(min_val)) < 0) { \ + return (Optional##KindOfInt##_t){.is_none = true}; \ + } \ + if (Int$compare_value(full_int, I(max_val)) > 0) { \ + return (Optional##KindOfInt##_t){.is_none = true}; \ + } \ + return (Optional##KindOfInt##_t){.value = KindOfInt##$from_int(full_int, true)}; \ + } \ + public \ + CONSTFUNC c_type KindOfInt##$gcd(c_type x, c_type y) { \ + if (x == 0 || y == 0) return 0; \ + x = KindOfInt##$abs(x); \ + y = KindOfInt##$abs(y); \ + while (x != y) { \ + if (x > y) x -= y; \ + else y -= x; \ + } \ + return x; \ + } \ + public \ + const c_type KindOfInt##$min = min_val; \ + public \ + const c_type KindOfInt##$max = max_val; \ + public \ + const TypeInfo_t KindOfInt##$info = { \ + .size = sizeof(c_type), \ + .align = __alignof__(c_type), \ + .metamethods = \ + { \ + .compare = KindOfInt##$compare, \ + .as_text = KindOfInt##$as_text, \ + .serialize = KindOfInt##$serialize, \ + .deserialize = KindOfInt##$deserialize, \ + }, \ }; -DEFINE_INT_TYPE(int64_t, Int64, INT64_MIN, INT64_MAX, __attribute__(())) -DEFINE_INT_TYPE(int32_t, Int32, INT32_MIN, INT32_MAX, CONSTFUNC) -DEFINE_INT_TYPE(int16_t, Int16, INT16_MIN, INT16_MAX, CONSTFUNC) -DEFINE_INT_TYPE(int8_t, Int8, INT8_MIN, INT8_MAX, CONSTFUNC) +DEFINE_INT_TYPE(int64_t, Int64, INT64_MIN, INT64_MAX, __attribute__(())) +DEFINE_INT_TYPE(int32_t, Int32, INT32_MIN, INT32_MAX, CONSTFUNC) +DEFINE_INT_TYPE(int16_t, Int16, INT16_MIN, INT16_MAX, CONSTFUNC) +DEFINE_INT_TYPE(int8_t, Int8, INT8_MIN, INT8_MAX, CONSTFUNC) #undef DEFINE_INT_TYPE // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/integers.h b/src/stdlib/integers.h index 744992dd..a7249495 100644 --- a/src/stdlib/integers.h +++ b/src/stdlib/integers.h @@ -2,9 +2,9 @@ // Integer type infos and methods +#include <gmp.h> #include <stdbool.h> #include <stdint.h> -#include <gmp.h> #include "datatypes.h" #include "stdlib.h" @@ -16,74 +16,72 @@ #define I16(x) ((int16_t)x) #define I8(x) ((int8_t)x) -#define DEFINE_INT_TYPE(c_type, type_name) \ - typedef struct { \ - c_type value; \ - bool is_none:1; \ - } Optional ## type_name ## _t; \ - Text_t type_name ## $as_text(const void *i, bool colorize, const TypeInfo_t *type); \ - PUREFUNC int32_t type_name ## $compare(const void *x, const void *y, const TypeInfo_t *type); \ - PUREFUNC bool type_name ## $equal(const void *x, const void *y, const TypeInfo_t *type); \ - Text_t type_name ## $hex(c_type i, Int_t digits, bool uppercase, bool prefix); \ - Text_t type_name ## $octal(c_type i, Int_t digits, bool prefix); \ - List_t type_name ## $bits(c_type x); \ - bool type_name ## $get_bit(c_type x, Int_t bit_index); \ - Closure_t type_name ## $to(c_type first, c_type last, Optional ## type_name ## _t step); \ - Closure_t type_name ## $onward(c_type first, c_type step); \ - PUREFUNC Optional ## type_name ## _t type_name ## $parse(Text_t text, Text_t *remainder); \ - CONSTFUNC bool type_name ## $is_between(const c_type x, const c_type low, const c_type high); \ - CONSTFUNC c_type type_name ## $clamped(c_type x, c_type min, c_type max); \ - MACROLIKE CONSTFUNC c_type type_name ## $from_byte(Byte_t b) { return (c_type)b; } \ - MACROLIKE CONSTFUNC c_type type_name ## $from_bool(Bool_t b) { return (c_type)b; } \ - CONSTFUNC c_type type_name ## $gcd(c_type x, c_type y); \ - extern const c_type type_name ## $min, type_name##$max; \ - extern const TypeInfo_t type_name ## $info; \ - MACROLIKE c_type type_name ## $divided_by(c_type D, c_type d) { \ - c_type q = D/d, r = D%d; \ - q -= (r < 0) * (2*(d > 0) - 1); \ - return q; \ - } \ - MACROLIKE c_type type_name ## $modulo(c_type D, c_type d) { \ - c_type r = D%d; \ - r -= (r < 0) * (2*(d < 0) - 1) * d; \ - return r; \ - } \ - MACROLIKE c_type type_name ## $modulo1(c_type D, c_type d) { \ - return type_name ## $modulo(D-1, d) + 1; \ - } \ - MACROLIKE PUREFUNC c_type type_name ## $wrapping_plus(c_type x, c_type y) { \ - return (c_type)((u##c_type)x + (u##c_type)y); \ - } \ - MACROLIKE PUREFUNC c_type type_name ## $wrapping_minus(c_type x, c_type y) { \ - return (c_type)((u##c_type)x + (u##c_type)y); \ - } \ - MACROLIKE PUREFUNC c_type type_name ## $unsigned_left_shifted(c_type x, c_type y) { \ - return (c_type)((u##c_type)x << y); \ - } \ - MACROLIKE PUREFUNC c_type type_name ## $unsigned_right_shifted(c_type x, c_type y) { \ - return (c_type)((u##c_type)x >> y); \ +#define DEFINE_INT_TYPE(c_type, type_name) \ + typedef struct { \ + c_type value; \ + bool is_none : 1; \ + } Optional##type_name##_t; \ + Text_t type_name##$as_text(const void *i, bool colorize, const TypeInfo_t *type); \ + PUREFUNC int32_t type_name##$compare(const void *x, const void *y, const TypeInfo_t *type); \ + PUREFUNC bool type_name##$equal(const void *x, const void *y, const TypeInfo_t *type); \ + Text_t type_name##$hex(c_type i, Int_t digits, bool uppercase, bool prefix); \ + Text_t type_name##$octal(c_type i, Int_t digits, bool prefix); \ + List_t type_name##$bits(c_type x); \ + bool type_name##$get_bit(c_type x, Int_t bit_index); \ + Closure_t type_name##$to(c_type first, c_type last, Optional##type_name##_t step); \ + Closure_t type_name##$onward(c_type first, c_type step); \ + PUREFUNC Optional##type_name##_t type_name##$parse(Text_t text, Text_t *remainder); \ + CONSTFUNC bool type_name##$is_between(const c_type x, const c_type low, const c_type high); \ + CONSTFUNC c_type type_name##$clamped(c_type x, c_type min, c_type max); \ + MACROLIKE CONSTFUNC c_type type_name##$from_byte(Byte_t b) { return (c_type)b; } \ + MACROLIKE CONSTFUNC c_type type_name##$from_bool(Bool_t b) { return (c_type)b; } \ + CONSTFUNC c_type type_name##$gcd(c_type x, c_type y); \ + extern const c_type type_name##$min, type_name##$max; \ + extern const TypeInfo_t type_name##$info; \ + MACROLIKE c_type type_name##$divided_by(c_type D, c_type d) { \ + c_type q = D / d, r = D % d; \ + q -= (r < 0) * (2 * (d > 0) - 1); \ + return q; \ + } \ + MACROLIKE c_type type_name##$modulo(c_type D, c_type d) { \ + c_type r = D % d; \ + r -= (r < 0) * (2 * (d < 0) - 1) * d; \ + return r; \ + } \ + MACROLIKE c_type type_name##$modulo1(c_type D, c_type d) { return type_name##$modulo(D - 1, d) + 1; } \ + MACROLIKE PUREFUNC c_type type_name##$wrapping_plus(c_type x, c_type y) { \ + return (c_type)((u##c_type)x + (u##c_type)y); \ + } \ + MACROLIKE PUREFUNC c_type type_name##$wrapping_minus(c_type x, c_type y) { \ + return (c_type)((u##c_type)x + (u##c_type)y); \ + } \ + MACROLIKE PUREFUNC c_type type_name##$unsigned_left_shifted(c_type x, c_type y) { \ + return (c_type)((u##c_type)x << y); \ + } \ + MACROLIKE PUREFUNC c_type type_name##$unsigned_right_shifted(c_type x, c_type y) { \ + return (c_type)((u##c_type)x >> y); \ } DEFINE_INT_TYPE(int64_t, Int64) DEFINE_INT_TYPE(int32_t, Int32) DEFINE_INT_TYPE(int16_t, Int16) -DEFINE_INT_TYPE(int8_t, Int8) +DEFINE_INT_TYPE(int8_t, Int8) #undef DEFINE_INT_TYPE -#define NONE_INT64 ((OptionalInt64_t){.is_none=true}) -#define NONE_INT32 ((OptionalInt32_t){.is_none=true}) -#define NONE_INT16 ((OptionalInt16_t){.is_none=true}) -#define NONE_INT8 ((OptionalInt8_t){.is_none=true}) +#define NONE_INT64 ((OptionalInt64_t){.is_none = true}) +#define NONE_INT32 ((OptionalInt32_t){.is_none = true}) +#define NONE_INT16 ((OptionalInt16_t){.is_none = true}) +#define NONE_INT8 ((OptionalInt8_t){.is_none = true}) #define Int64$abs(...) I64(labs(__VA_ARGS__)) #define Int32$abs(...) I32(abs(__VA_ARGS__)) #define Int16$abs(...) I16(abs(__VA_ARGS__)) #define Int8$abs(...) I8(abs(__VA_ARGS__)) -void Int64$serialize(const void *obj, FILE *out, Table_t*, const TypeInfo_t*); -void Int64$deserialize(FILE *in, void *outval, List_t*, const TypeInfo_t*); -void Int32$serialize(const void *obj, FILE *out, Table_t*, const TypeInfo_t*); -void Int32$deserialize(FILE *in, void *outval, List_t*, const TypeInfo_t*); +void Int64$serialize(const void *obj, FILE *out, Table_t *, const TypeInfo_t *); +void Int64$deserialize(FILE *in, void *outval, List_t *, const TypeInfo_t *); +void Int32$serialize(const void *obj, FILE *out, Table_t *, const TypeInfo_t *); +void Int32$deserialize(FILE *in, void *outval, List_t *, const TypeInfo_t *); Text_t Int$as_text(const void *i, bool colorize, const TypeInfo_t *type); Text_t Int$value_as_text(Int_t i); @@ -109,19 +107,17 @@ bool Int$get_bit(Int_t x, Int_t bit_index); #define BIGGEST_SMALL_INT 0x3fffffff #define SMALLEST_SMALL_INT -0x40000000 -#define Int$from_mpz(mpz) (\ - mpz_cmpabs_ui(mpz, BIGGEST_SMALL_INT) <= 0 ? ( \ - (Int_t){.small=(mpz_get_si(mpz)<<2L)|1L} \ - ) : ( \ - (Int_t){.big=memcpy(new(mpz_t), &mpz, sizeof(mpz_t))} \ - )) +#define Int$from_mpz(mpz) \ + (mpz_cmpabs_ui(mpz, BIGGEST_SMALL_INT) <= 0 ? ((Int_t){.small = (mpz_get_si(mpz) << 2L) | 1L}) \ + : ((Int_t){.big = memcpy(new (mpz_t), &mpz, sizeof(mpz_t))})) -#define mpz_init_set_int(mpz, i) do { \ - if likely ((i).small & 1L) mpz_init_set_si(mpz, (i).small >> 2L); \ - else mpz_init_set(mpz, *(i).big); \ -} while (0) +#define mpz_init_set_int(mpz, i) \ + do { \ + if likely ((i).small & 1L) mpz_init_set_si(mpz, (i).small >> 2L); \ + else mpz_init_set(mpz, *(i).big); \ + } while (0) -#define I_small(i) ((Int_t){.small=(int64_t)((uint64_t)(i)<<2L)|1L}) +#define I_small(i) ((Int_t){.small = (int64_t)((uint64_t)(i) << 2L) | 1L}) #define I(i) _Generic(i, int8_t: I_small(i), int16_t: I_small(i), default: Int$from_int64(i)) #define I_is_zero(i) ((i).small == 1L) @@ -155,116 +151,107 @@ extern const TypeInfo_t Int$info; MACROLIKE Int_t Int$plus(Int_t x, Int_t y) { const int64_t z = (int64_t)((uint64_t)x.small + (uint64_t)y.small); - if likely ((z|2L) == (int32_t)z) - return (Int_t){.small=(z-1L)}; + if likely ((z | 2L) == (int32_t)z) return (Int_t){.small = (z - 1L)}; return Int$slow_plus(x, y); } MACROLIKE Int_t Int$minus(Int_t x, Int_t y) { const int64_t z = (int64_t)(((uint64_t)x.small ^ 3L) - (uint64_t)y.small); - if likely ((z & ~2L) == (int32_t)z) - return (Int_t){.small=z}; + if likely ((z & ~2L) == (int32_t)z) return (Int_t){.small = z}; return Int$slow_minus(x, y); } MACROLIKE Int_t Int$times(Int_t x, Int_t y) { if likely ((x.small & y.small) & 1L) { - const int64_t z = (x.small>>1L) * (y.small>>1L); - if likely (z == (int32_t)z) - return (Int_t){.small=z+1L}; + const int64_t z = (x.small >> 1L) * (y.small >> 1L); + if likely (z == (int32_t)z) return (Int_t){.small = z + 1L}; } return Int$slow_times(x, y); } MACROLIKE Int_t Int$divided_by(Int_t x, Int_t y) { if likely (x.small & y.small & 1L) { - // Euclidean division, see: https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf - const int64_t D = (x.small>>2L); - const int64_t d = (y.small>>2L); - int64_t q = D/d, r = D%d; - q -= (r < 0L) * (2L*(d > 0L) - 1L); - if likely (q == (int32_t)q) - return (Int_t){.small=(q<<2L)|1L}; + // Euclidean division, see: + // https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf + const int64_t D = (x.small >> 2L); + const int64_t d = (y.small >> 2L); + int64_t q = D / d, r = D % d; + q -= (r < 0L) * (2L * (d > 0L) - 1L); + if likely (q == (int32_t)q) return (Int_t){.small = (q << 2L) | 1L}; } return Int$slow_divided_by(x, y); } MACROLIKE Int_t Int$modulo(Int_t x, Int_t y) { if likely (x.small & y.small & 1L) { - // Euclidean modulus, see: https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf - const int64_t D = (x.small>>2L); - const int64_t d = (y.small>>2L); - int64_t r = D%d; - r -= (r < 0L) * (2L*(d < 0L) - 1L) * d; - return (Int_t){.small=(r<<2L)|1L}; + // Euclidean modulus, see: + // https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf + const int64_t D = (x.small >> 2L); + const int64_t d = (y.small >> 2L); + int64_t r = D % d; + r -= (r < 0L) * (2L * (d < 0L) - 1L) * d; + return (Int_t){.small = (r << 2L) | 1L}; } return Int$slow_modulo(x, y); } MACROLIKE Int_t Int$modulo1(Int_t x, Int_t y) { if likely (x.small & y.small & 1L) { - // Euclidean modulus, see: https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf - const int64_t D = (x.small>>2L)-1L; - const int64_t d = (y.small>>2L); - int64_t r = D%d; - r -= (r < 0L) * (2L*(d < 0L) - 1L) * d; - return (Int_t){.small=((r+1L)<<2L)|1L}; + // Euclidean modulus, see: + // https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf + const int64_t D = (x.small >> 2L) - 1L; + const int64_t d = (y.small >> 2L); + int64_t r = D % d; + r -= (r < 0L) * (2L * (d < 0L) - 1L) * d; + return (Int_t){.small = ((r + 1L) << 2L) | 1L}; } return Int$slow_modulo1(x, y); } MACROLIKE Int_t Int$left_shifted(Int_t x, Int_t y) { if likely (x.small & y.small & 1L) { - const int64_t z = ((x.small>>2L) << (y.small>>2L))<<2L; - if likely (z == (int32_t)z) - return (Int_t){.small=z+1L}; + const int64_t z = ((x.small >> 2L) << (y.small >> 2L)) << 2L; + if likely (z == (int32_t)z) return (Int_t){.small = z + 1L}; } return Int$slow_left_shifted(x, y); } MACROLIKE Int_t Int$right_shifted(Int_t x, Int_t y) { if likely (x.small & y.small & 1L) { - const int64_t z = ((x.small>>2L) >> (y.small>>2L))<<2L; - if likely (z == (int32_t)z) - return (Int_t){.small=z+1L}; + const int64_t z = ((x.small >> 2L) >> (y.small >> 2L)) << 2L; + if likely (z == (int32_t)z) return (Int_t){.small = z + 1L}; } return Int$slow_right_shifted(x, y); } MACROLIKE Int_t Int$bit_and(Int_t x, Int_t y) { const int64_t z = x.small & y.small; - if likely (z & 1L) - return (Int_t){.small=z}; + if likely (z & 1L) return (Int_t){.small = z}; return Int$slow_bit_and(x, y); } MACROLIKE Int_t Int$bit_or(Int_t x, Int_t y) { - if likely (x.small & y.small & 1L) - return (Int_t){.small=(x.small | y.small)}; + if likely (x.small & y.small & 1L) return (Int_t){.small = (x.small | y.small)}; return Int$slow_bit_or(x, y); } MACROLIKE Int_t Int$bit_xor(Int_t x, Int_t y) { - if likely (x.small & y.small & 1L) - return (Int_t){.small=(x.small ^ y.small) | 1L}; + if likely (x.small & y.small & 1L) return (Int_t){.small = (x.small ^ y.small) | 1L}; return Int$slow_bit_xor(x, y); } MACROLIKE Int_t Int$negated(Int_t x) { - if likely (x.small & 1L) - return (Int_t){.small=(~x.small) ^ 3L}; + if likely (x.small & 1L) return (Int_t){.small = (~x.small) ^ 3L}; return Int$slow_negated(x); } MACROLIKE Int_t Int$negative(Int_t x) { - if likely (x.small & 1L) - return (Int_t){.small=((-((x.small)>>2L))<<2L) | 1L}; + if likely (x.small & 1L) return (Int_t){.small = ((-((x.small) >> 2L)) << 2L) | 1L}; return Int$slow_negative(x); } MACROLIKE PUREFUNC bool Int$is_negative(Int_t x) { - if likely (x.small & 1L) - return x.small < 0L; + if likely (x.small & 1L) return x.small < 0L; return Int$compare_value(x, I_small(0)) < 0L; } @@ -278,42 +265,36 @@ MACROLIKE PUREFUNC bool Int$is_negative(Int_t x) { MACROLIKE PUREFUNC Int_t Int$from_num(double n, bool truncate) { mpz_t result; mpz_init_set_d(result, n); - if (!truncate && unlikely(mpz_get_d(result) != n)) - fail("Could not convert to an integer without truncation: ", n); + if (!truncate && unlikely(mpz_get_d(result) != n)) fail("Could not convert to an integer without truncation: ", n); return Int$from_mpz(result); } MACROLIKE PUREFUNC Int_t Int$from_num32(float n, bool truncate) { return Int$from_num((double)n, truncate); } MACROLIKE Int_t Int$from_int64(int64_t i) { - if likely (i >= SMALLEST_SMALL_INT && i <= BIGGEST_SMALL_INT) - return (Int_t){.small=(i<<2L)|1L}; + if likely (i >= SMALLEST_SMALL_INT && i <= BIGGEST_SMALL_INT) return (Int_t){.small = (i << 2L) | 1L}; mpz_t result; mpz_init_set_si(result, i); return Int$from_mpz(result); } MACROLIKE CONSTFUNC Int_t Int$from_int32(Int32_t i) { return Int$from_int64((Int32_t)i); } MACROLIKE CONSTFUNC Int_t Int$from_int16(Int16_t i) { return I_small(i); } -MACROLIKE CONSTFUNC Int_t Int$from_int8(Int8_t i) { return I_small(i); } +MACROLIKE CONSTFUNC Int_t Int$from_int8(Int8_t i) { return I_small(i); } MACROLIKE CONSTFUNC Int_t Int$from_byte(Byte_t b) { return I_small(b); } MACROLIKE CONSTFUNC Int_t Int$from_bool(Bool_t b) { return I_small(b); } // Int64 constructors MACROLIKE PUREFUNC Int64_t Int64$from_num(Num_t n, bool truncate) { int64_t i64 = (int64_t)n; - if (!truncate && unlikely((Num_t)i64 != n)) - fail("Could not convert Num to Int64 without truncation: ", n); + if (!truncate && unlikely((Num_t)i64 != n)) fail("Could not convert Num to Int64 without truncation: ", n); return i64; } MACROLIKE PUREFUNC Int64_t Int64$from_num32(Num32_t n, bool truncate) { int64_t i64 = (int64_t)n; - if (!truncate && unlikely((Num32_t)i64 != n)) - fail("Could not convert Num32 to Int64 without truncation: ", n); + if (!truncate && unlikely((Num32_t)i64 != n)) fail("Could not convert Num32 to Int64 without truncation: ", n); return i64; } MACROLIKE PUREFUNC Int64_t Int64$from_int(Int_t i, bool truncate) { - if likely (i.small & 1L) - return (int64_t)(i.small >> 2L); - if (!truncate && unlikely(!mpz_fits_slong_p(*i.big))) - fail("Integer is too big to fit in a 64-bit integer: ", i); + if likely (i.small & 1L) return (int64_t)(i.small >> 2L); + if (!truncate && unlikely(!mpz_fits_slong_p(*i.big))) fail("Integer is too big to fit in a 64-bit integer: ", i); return mpz_get_si(*i.big); } MACROLIKE CONSTFUNC Int64_t Int64$from_int32(Int32_t i) { return (Int64_t)i; } @@ -323,27 +304,23 @@ MACROLIKE CONSTFUNC Int64_t Int64$from_int8(Int8_t i) { return (Int64_t)i; } // Int32 constructors MACROLIKE PUREFUNC Int32_t Int32$from_num(Num_t n, bool truncate) { int32_t i32 = (int32_t)n; - if (!truncate && unlikely((Num_t)i32 != n)) - fail("Could not convert Num to Int32 without truncation: ", n); + if (!truncate && unlikely((Num_t)i32 != n)) fail("Could not convert Num to Int32 without truncation: ", n); return i32; } MACROLIKE PUREFUNC Int32_t Int32$from_num32(Num32_t n, bool truncate) { int32_t i32 = (int32_t)n; - if (!truncate && unlikely((Num32_t)i32 != n)) - fail("Could not convert Num32 to Int32 without truncation: ", n); + if (!truncate && unlikely((Num32_t)i32 != n)) fail("Could not convert Num32 to Int32 without truncation: ", n); return i32; } MACROLIKE PUREFUNC Int32_t Int32$from_int(Int_t i, bool truncate) { int64_t i64 = Int64$from_int(i, truncate); int32_t i32 = (int32_t)i64; - if (!truncate && unlikely((int64_t)i32 != i64)) - fail("Integer is too big to fit in a 32-bit integer: ", i); + if (!truncate && unlikely((int64_t)i32 != i64)) fail("Integer is too big to fit in a 32-bit integer: ", i); return i32; } MACROLIKE PUREFUNC Int32_t Int32$from_int64(Int64_t i64, bool truncate) { int32_t i32 = (int32_t)i64; - if (!truncate && unlikely((int64_t)i32 != i64)) - fail("Integer is too big to fit in a 32-bit integer: ", i64); + if (!truncate && unlikely((int64_t)i32 != i64)) fail("Integer is too big to fit in a 32-bit integer: ", i64); return i32; } MACROLIKE CONSTFUNC Int32_t Int32$from_int16(Int16_t i) { return (Int32_t)i; } @@ -352,8 +329,7 @@ MACROLIKE CONSTFUNC Int32_t Int32$from_int8(Int8_t i) { return (Int32_t)i; } // Int16 constructors MACROLIKE PUREFUNC Int16_t Int16$from_num(Num_t n, bool truncate) { int16_t i16 = (int16_t)n; - if (!truncate && unlikely((Num_t)i16 != n)) - fail("Could not convert Num to Int16 without truncation: ", n); + if (!truncate && unlikely((Num_t)i16 != n)) fail("Could not convert Num to Int16 without truncation: ", n); return i16; } MACROLIKE PUREFUNC Int16_t Int16$from_num32(Num32_t n, bool truncate) { @@ -365,20 +341,17 @@ MACROLIKE PUREFUNC Int16_t Int16$from_num32(Num32_t n, bool truncate) { MACROLIKE PUREFUNC Int16_t Int16$from_int(Int_t i, bool truncate) { int64_t i64 = Int64$from_int(i, truncate); int16_t i16 = (int16_t)i64; - if (!truncate && unlikely((int64_t)i16 != i64)) - fail("Integer is too big to fit in a 16-bit integer!"); + if (!truncate && unlikely((int64_t)i16 != i64)) fail("Integer is too big to fit in a 16-bit integer!"); return i16; } MACROLIKE PUREFUNC Int16_t Int16$from_int64(Int64_t i64, bool truncate) { int16_t i16 = (int16_t)i64; - if (!truncate && unlikely((int64_t)i16 != i64)) - fail("Integer is too big to fit in a 16-bit integer: ", i64); + if (!truncate && unlikely((int64_t)i16 != i64)) fail("Integer is too big to fit in a 16-bit integer: ", i64); return i16; } MACROLIKE PUREFUNC Int16_t Int16$from_int32(Int32_t i32, bool truncate) { int16_t i16 = (int16_t)i32; - if (!truncate && unlikely((int32_t)i16 != i32)) - fail("Integer is too big to fit in a 16-bit integer: ", i32); + if (!truncate && unlikely((int32_t)i16 != i32)) fail("Integer is too big to fit in a 16-bit integer: ", i32); return i16; } MACROLIKE CONSTFUNC Int16_t Int16$from_int8(Int8_t i) { return (Int16_t)i; } @@ -386,39 +359,33 @@ MACROLIKE CONSTFUNC Int16_t Int16$from_int8(Int8_t i) { return (Int16_t)i; } // Int8 constructors MACROLIKE PUREFUNC Int8_t Int8$from_num(Num_t n, bool truncate) { int8_t i8 = (int8_t)n; - if (!truncate && unlikely((Num_t)i8 != n)) - fail("Could not convert Num to Int8 without truncation: ", n); + if (!truncate && unlikely((Num_t)i8 != n)) fail("Could not convert Num to Int8 without truncation: ", n); return i8; } MACROLIKE PUREFUNC Int8_t Int8$from_num32(Num32_t n, bool truncate) { int8_t i8 = (int8_t)n; - if (!truncate && unlikely((Num32_t)i8 != n)) - fail("Could not convert Num32 to Int8 without truncation: ", n); + if (!truncate && unlikely((Num32_t)i8 != n)) fail("Could not convert Num32 to Int8 without truncation: ", n); return i8; } MACROLIKE PUREFUNC Int8_t Int8$from_int(Int_t i, bool truncate) { int64_t i64 = Int64$from_int(i, truncate); int8_t i8 = (int8_t)i64; - if (!truncate && unlikely((int64_t)i8 != i64)) - fail("Integer is too big to fit in an 8-bit integer!"); + if (!truncate && unlikely((int64_t)i8 != i64)) fail("Integer is too big to fit in an 8-bit integer!"); return i8; } MACROLIKE PUREFUNC Int8_t Int8$from_int64(Int64_t i64, bool truncate) { int8_t i8 = (int8_t)i64; - if (!truncate && unlikely((int64_t)i8 != i64)) - fail("Integer is too big to fit in a 8-bit integer: ", i64); + if (!truncate && unlikely((int64_t)i8 != i64)) fail("Integer is too big to fit in a 8-bit integer: ", i64); return i8; } MACROLIKE PUREFUNC Int8_t Int8$from_int32(Int32_t i32, bool truncate) { int8_t i8 = (int8_t)i32; - if (!truncate && unlikely((int32_t)i8 != i32)) - fail("Integer is too big to fit in a 8-bit integer: ", i32); + if (!truncate && unlikely((int32_t)i8 != i32)) fail("Integer is too big to fit in a 8-bit integer: ", i32); return i8; } MACROLIKE PUREFUNC Int8_t Int8$from_int16(Int16_t i16, bool truncate) { int8_t i8 = (int8_t)i16; - if (!truncate && unlikely((int16_t)i8 != i16)) - fail("Integer is too big to fit in a 8-bit integer: ", i16); + if (!truncate && unlikely((int16_t)i8 != i16)) fail("Integer is too big to fit in a 8-bit integer: ", i16); return i8; } #ifdef __GNUC__ diff --git a/src/stdlib/lists.c b/src/stdlib/lists.c index ce27f822..415e28a5 100644 --- a/src/stdlib/lists.c +++ b/src/stdlib/lists.c @@ -6,8 +6,8 @@ #include <stdint.h> #include <sys/param.h> -#include "lists.h" #include "integers.h" +#include "lists.h" #include "math.h" #include "metamethods.h" #include "optionals.h" @@ -18,39 +18,37 @@ // Use inline version of siphash code: #include "siphash-internals.h" -PUREFUNC static INLINE int64_t get_padded_item_size(const TypeInfo_t *info) -{ +PUREFUNC static INLINE int64_t get_padded_item_size(const TypeInfo_t *info) { int64_t size = info->ListInfo.item->size; - if (info->ListInfo.item->align > 1 && size % info->ListInfo.item->align) - errx(1, "Item size is not padded!"); + if (info->ListInfo.item->align > 1 && size % info->ListInfo.item->align) errx(1, "Item size is not padded!"); return size; } // Replace the list's .data pointer with a new pointer to a copy of the // data that is compacted and has a stride of exactly `padded_item_size` -public void List$compact(List_t *list, int64_t padded_item_size) -{ +public +void List$compact(List_t *list, int64_t padded_item_size) { void *copy = NULL; if (list->length > 0) { copy = list->atomic ? GC_MALLOC_ATOMIC((size_t)list->length * (size_t)padded_item_size) - : GC_MALLOC((size_t)list->length * (size_t)padded_item_size); + : GC_MALLOC((size_t)list->length * (size_t)padded_item_size); if ((int64_t)list->stride == padded_item_size) { memcpy(copy, list->data, (size_t)list->length * (size_t)padded_item_size); } else { for (int64_t i = 0; i < list->length; i++) - memcpy(copy + i*padded_item_size, list->data + list->stride*i, (size_t)padded_item_size); + memcpy(copy + i * padded_item_size, list->data + list->stride * i, (size_t)padded_item_size); } } *list = (List_t){ - .data=copy, - .length=list->length, - .stride=padded_item_size, - .atomic=list->atomic, + .data = copy, + .length = list->length, + .stride = padded_item_size, + .atomic = list->atomic, }; } -public void List$insert(List_t *list, const void *item, Int_t int_index, int64_t padded_item_size) -{ +public +void List$insert(List_t *list, const void *item, Int_t int_index, int64_t padded_item_size) { int64_t index = Int64$from_int(int_index, false); if (index <= 0) index = list->length + index + 1; @@ -61,42 +59,38 @@ public void List$insert(List_t *list, const void *item, Int_t int_index, int64_t if (!list->data) { list->free = 4; list->data = list->atomic ? GC_MALLOC_ATOMIC((size_t)list->free * (size_t)padded_item_size) - : GC_MALLOC((size_t)list->free * (size_t)padded_item_size); + : GC_MALLOC((size_t)list->free * (size_t)padded_item_size); list->stride = padded_item_size; } else if (list->free < 1 || list->data_refcount != 0 || (int64_t)list->stride != padded_item_size) { // Resize policy: +50% growth (clamped between 8 and LIST_MAX_FREE_ENTRIES) - list->free = MIN(LIST_MAX_FREE_ENTRIES, MAX(8, list->length)/2); + list->free = MIN(LIST_MAX_FREE_ENTRIES, MAX(8, list->length) / 2); void *copy = list->atomic ? GC_MALLOC_ATOMIC((size_t)(list->length + list->free) * (size_t)padded_item_size) - : GC_MALLOC((size_t)(list->length + list->free) * (size_t)padded_item_size); - for (int64_t i = 0; i < index-1; i++) - memcpy(copy + i*padded_item_size, list->data + list->stride*i, (size_t)padded_item_size); - for (int64_t i = index-1; i < (int64_t)list->length; i++) - memcpy(copy + (i+1)*padded_item_size, list->data + list->stride*i, (size_t)padded_item_size); + : GC_MALLOC((size_t)(list->length + list->free) * (size_t)padded_item_size); + for (int64_t i = 0; i < index - 1; i++) + memcpy(copy + i * padded_item_size, list->data + list->stride * i, (size_t)padded_item_size); + for (int64_t i = index - 1; i < (int64_t)list->length; i++) + memcpy(copy + (i + 1) * padded_item_size, list->data + list->stride * i, (size_t)padded_item_size); list->data = copy; list->data_refcount = 0; list->stride = padded_item_size; } else { - if (index != list->length+1) { + if (index != list->length + 1) { assert(list->length >= index); - size_t size = (size_t)((list->length - index + 1)*padded_item_size); + size_t size = (size_t)((list->length - index + 1) * padded_item_size); assert(size < SIZE_MAX); - memmove( - list->data + index*padded_item_size, - list->data + (index-1)*padded_item_size, - size); + memmove(list->data + index * padded_item_size, list->data + (index - 1) * padded_item_size, size); } } assert(list->free > 0); --list->free; ++list->length; - memcpy((void*)list->data + (index-1)*padded_item_size, item, (size_t)padded_item_size); + memcpy((void *)list->data + (index - 1) * padded_item_size, item, (size_t)padded_item_size); } -public void List$insert_all(List_t *list, List_t to_insert, Int_t int_index, int64_t padded_item_size) -{ +public +void List$insert_all(List_t *list, List_t to_insert, Int_t int_index, int64_t padded_item_size) { int64_t index = Int64$from_int(int_index, false); - if (to_insert.length == 0) - return; + if (to_insert.length == 0) return; if (!list->data) { *list = to_insert; @@ -111,34 +105,33 @@ public void List$insert_all(List_t *list, List_t to_insert, Int_t int_index, int fail("Invalid insertion index ", index, " for a list with length ", (int64_t)list->length); if ((int64_t)list->free >= (int64_t)to_insert.length // Adequate free space - && list->data_refcount == 0 // Not aliased memory - && (int64_t)list->stride == padded_item_size) { // Contiguous list + && list->data_refcount == 0 // Not aliased memory + && (int64_t)list->stride == padded_item_size) { // Contiguous list // If we can fit this within the list's preallocated free space, do that: list->free -= to_insert.length; list->length += to_insert.length; - if (index != list->length+1) - memmove((void*)list->data + index*padded_item_size, - list->data + (index-1)*padded_item_size, - (size_t)((list->length - index + to_insert.length-1)*padded_item_size)); + if (index != list->length + 1) + memmove((void *)list->data + index * padded_item_size, list->data + (index - 1) * padded_item_size, + (size_t)((list->length - index + to_insert.length - 1) * padded_item_size)); for (int64_t i = 0; i < to_insert.length; i++) - memcpy((void*)list->data + (index-1 + i)*padded_item_size, - to_insert.data + i*to_insert.stride, (size_t)padded_item_size); + memcpy((void *)list->data + (index - 1 + i) * padded_item_size, to_insert.data + i * to_insert.stride, + (size_t)padded_item_size); } else { // Otherwise, allocate a new chunk of memory for the list and populate it: int64_t new_len = list->length + to_insert.length; - list->free = MIN(LIST_MAX_FREE_ENTRIES, MAX(8, new_len/4)); + list->free = MIN(LIST_MAX_FREE_ENTRIES, MAX(8, new_len / 4)); void *data = list->atomic ? GC_MALLOC_ATOMIC((size_t)((new_len + list->free) * padded_item_size)) - : GC_MALLOC((size_t)((new_len + list->free) * padded_item_size)); + : GC_MALLOC((size_t)((new_len + list->free) * padded_item_size)); void *p = data; // Copy first chunk of `list` if needed: if (index > 1) { if (list->stride == padded_item_size) { - memcpy(p, list->data, (size_t)((index-1)*padded_item_size)); - p += (index-1)*padded_item_size; + memcpy(p, list->data, (size_t)((index - 1) * padded_item_size)); + p += (index - 1) * padded_item_size; } else { - for (int64_t i = 0; i < index-1; i++) { - memcpy(p, list->data + list->stride*i, (size_t)padded_item_size); + for (int64_t i = 0; i < index - 1; i++) { + memcpy(p, list->data + list->stride * i, (size_t)padded_item_size); p += padded_item_size; } } @@ -146,11 +139,11 @@ public void List$insert_all(List_t *list, List_t to_insert, Int_t int_index, int // Copy `to_insert` if (to_insert.stride == padded_item_size) { - memcpy(p, to_insert.data, (size_t)(to_insert.length*padded_item_size)); - p += to_insert.length*padded_item_size; + memcpy(p, to_insert.data, (size_t)(to_insert.length * padded_item_size)); + p += to_insert.length * padded_item_size; } else { - for (int64_t i = 0; i < index-1; i++) { - memcpy(p, to_insert.data + to_insert.stride*i, (size_t)padded_item_size); + for (int64_t i = 0; i < index - 1; i++) { + memcpy(p, to_insert.data + to_insert.stride * i, (size_t)padded_item_size); p += padded_item_size; } } @@ -158,11 +151,12 @@ public void List$insert_all(List_t *list, List_t to_insert, Int_t int_index, int // Copy last chunk of `list` if needed: if (index < list->length + 1) { if (list->stride == padded_item_size) { - memcpy(p, list->data + padded_item_size*(index-1), (size_t)((list->length - index + 1)*padded_item_size)); - p += (list->length - index + 1)*padded_item_size; + memcpy(p, list->data + padded_item_size * (index - 1), + (size_t)((list->length - index + 1) * padded_item_size)); + p += (list->length - index + 1) * padded_item_size; } else { - for (int64_t i = index-1; i < list->length-1; i++) { - memcpy(p, list->data + list->stride*i, (size_t)padded_item_size); + for (int64_t i = index - 1; i < list->length - 1; i++) { + memcpy(p, list->data + list->stride * i, (size_t)padded_item_size); p += padded_item_size; } } @@ -174,27 +168,27 @@ public void List$insert_all(List_t *list, List_t to_insert, Int_t int_index, int } } -public void List$remove_at(List_t *list, Int_t int_index, Int_t int_count, int64_t padded_item_size) -{ +public +void List$remove_at(List_t *list, Int_t int_index, Int_t int_count, int64_t padded_item_size) { int64_t index = Int64$from_int(int_index, false); if (index < 1) index = list->length + index + 1; int64_t count = Int64$from_int(int_count, false); if (index < 1 || index > (int64_t)list->length || count < 1) return; - if (count > list->length - index + 1) - count = (list->length - index) + 1; + if (count > list->length - index + 1) count = (list->length - index) + 1; if (index == 1) { list->data += list->stride * count; } else if (index + count > list->length) { list->free += count; } else if (list->data_refcount != 0 || (int64_t)list->stride != padded_item_size) { - void *copy = list->atomic ? GC_MALLOC_ATOMIC((size_t)((list->length-1) * padded_item_size)) - : GC_MALLOC((size_t)((list->length-1) * padded_item_size)); + void *copy = list->atomic ? GC_MALLOC_ATOMIC((size_t)((list->length - 1) * padded_item_size)) + : GC_MALLOC((size_t)((list->length - 1) * padded_item_size)); for (int64_t src = 1, dest = 1; src <= (int64_t)list->length; src++) { if (src < index || src >= index + count) { - memcpy(copy + (dest - 1)*padded_item_size, list->data + list->stride*(src - 1), (size_t)padded_item_size); + memcpy(copy + (dest - 1) * padded_item_size, list->data + list->stride * (src - 1), + (size_t)padded_item_size); ++dest; } } @@ -202,26 +196,27 @@ public void List$remove_at(List_t *list, Int_t int_index, Int_t int_count, int64 list->free = 0; list->data_refcount = 0; } else { - memmove((void*)list->data + (index-1)*padded_item_size, list->data + (index-1 + count)*padded_item_size, - (size_t)((list->length - index + count - 1)*padded_item_size)); + memmove((void *)list->data + (index - 1) * padded_item_size, + list->data + (index - 1 + count) * padded_item_size, + (size_t)((list->length - index + count - 1) * padded_item_size)); list->free += count; } list->length -= count; if (list->length == 0) list->data = NULL; } -public void List$remove_item(List_t *list, void *item, Int_t max_removals, const TypeInfo_t *type) -{ +public +void List$remove_item(List_t *list, void *item, Int_t max_removals, const TypeInfo_t *type) { int64_t padded_item_size = get_padded_item_size(type); - const Int_t ZERO = (Int_t){.small=(0<<2)|1}; - const Int_t ONE = (Int_t){.small=(1<<2)|1}; + const Int_t ZERO = (Int_t){.small = (0 << 2) | 1}; + const Int_t ONE = (Int_t){.small = (1 << 2) | 1}; const TypeInfo_t *item_type = type->ListInfo.item; - for (int64_t i = 0; i < list->length; ) { + for (int64_t i = 0; i < list->length;) { if (max_removals.small == ZERO.small) // zero break; - if (generic_equal(item, list->data + i*list->stride, item_type)) { - List$remove_at(list, I(i+1), ONE, padded_item_size); + if (generic_equal(item, list->data + i * list->stride, item_type)) { + List$remove_at(list, I(i + 1), ONE, padded_item_size); max_removals = Int$minus(max_removals, ONE); } else { i++; @@ -229,45 +224,41 @@ public void List$remove_item(List_t *list, void *item, Int_t max_removals, const } } -public OptionalInt_t List$find(List_t list, void *item, const TypeInfo_t *type) -{ +public +OptionalInt_t List$find(List_t list, void *item, const TypeInfo_t *type) { const TypeInfo_t *item_type = type->ListInfo.item; for (int64_t i = 0; i < list.length; i++) { - if (generic_equal(item, list.data + i*list.stride, item_type)) - return I(i+1); + if (generic_equal(item, list.data + i * list.stride, item_type)) return I(i + 1); } return NONE_INT; } -public OptionalInt_t List$first(List_t list, Closure_t predicate) -{ - bool (*is_good)(void*, void*) = (void*)predicate.fn; +public +OptionalInt_t List$first(List_t list, Closure_t predicate) { + bool (*is_good)(void *, void *) = (void *)predicate.fn; for (int64_t i = 0; i < list.length; i++) { - if (is_good(list.data + i*list.stride, predicate.userdata)) - return I(i+1); + if (is_good(list.data + i * list.stride, predicate.userdata)) return I(i + 1); } return NONE_INT; } -static Closure_t _sort_comparison = {.fn=NULL}; +static Closure_t _sort_comparison = {.fn = NULL}; -int _compare_closure(const void *a, const void *b) -{ - typedef int (*comparison_t)(const void*, const void*, void*); +int _compare_closure(const void *a, const void *b) { + typedef int (*comparison_t)(const void *, const void *, void *); return ((comparison_t)_sort_comparison.fn)(a, b, _sort_comparison.userdata); } -public void List$sort(List_t *list, Closure_t comparison, int64_t padded_item_size) -{ - if (list->data_refcount != 0 || (int64_t)list->stride != padded_item_size) - List$compact(list, padded_item_size); +public +void List$sort(List_t *list, Closure_t comparison, int64_t padded_item_size) { + if (list->data_refcount != 0 || (int64_t)list->stride != padded_item_size) List$compact(list, padded_item_size); _sort_comparison = comparison; qsort(list->data, (size_t)list->length, (size_t)padded_item_size, _compare_closure); } -public List_t List$sorted(List_t list, Closure_t comparison, int64_t padded_item_size) -{ +public +List_t List$sorted(List_t list, Closure_t comparison, int64_t padded_item_size) { List$compact(&list, padded_item_size); _sort_comparison = comparison; qsort(list.data, (size_t)list.length, (size_t)padded_item_size, _compare_closure); @@ -283,13 +274,12 @@ static ssize_t getrandom(void *buf, size_t buflen, unsigned int flags) { } #elif defined(__linux__) // Use getrandom() -# include <sys/random.h> +#include <sys/random.h> #else - #error "Unsupported platform for secure random number generation" +#error "Unsupported platform for secure random number generation" #endif -static int64_t _default_random_int64(int64_t min, int64_t max, void *userdata) -{ +static int64_t _default_random_int64(int64_t min, int64_t max, void *userdata) { (void)userdata; if (min > max) fail("Random minimum value (", min, ") is larger than the maximum value (", max, ")"); if (min == max) return min; @@ -303,50 +293,49 @@ static int64_t _default_random_int64(int64_t min, int64_t max, void *userdata) return (int64_t)((uint64_t)min + (r % range)); } -public void List$shuffle(List_t *list, OptionalClosure_t random_int64, int64_t padded_item_size) -{ - if (list->data_refcount != 0 || (int64_t)list->stride != padded_item_size) - List$compact(list, padded_item_size); +public +void List$shuffle(List_t *list, OptionalClosure_t random_int64, int64_t padded_item_size) { + if (list->data_refcount != 0 || (int64_t)list->stride != padded_item_size) List$compact(list, padded_item_size); - typedef int64_t (*rng_fn_t)(int64_t, int64_t, void*); + typedef int64_t (*rng_fn_t)(int64_t, int64_t, void *); rng_fn_t rng_fn = random_int64.fn ? (rng_fn_t)random_int64.fn : _default_random_int64; char tmp[padded_item_size]; - for (int64_t i = list->length-1; i > 1; i--) { + for (int64_t i = list->length - 1; i > 1; i--) { int64_t j = rng_fn(0, i, random_int64.userdata); - if unlikely (j < 0 || j > list->length-1) + if unlikely (j < 0 || j > list->length - 1) fail("The provided random number function returned an invalid value: ", j, " (not between 0 and ", i, ")"); - memcpy(tmp, list->data + i*padded_item_size, (size_t)padded_item_size); - memcpy((void*)list->data + i*padded_item_size, list->data + j*padded_item_size, (size_t)padded_item_size); - memcpy((void*)list->data + j*padded_item_size, tmp, (size_t)padded_item_size); + memcpy(tmp, list->data + i * padded_item_size, (size_t)padded_item_size); + memcpy((void *)list->data + i * padded_item_size, list->data + j * padded_item_size, (size_t)padded_item_size); + memcpy((void *)list->data + j * padded_item_size, tmp, (size_t)padded_item_size); } } -public List_t List$shuffled(List_t list, Closure_t random_int64, int64_t padded_item_size) -{ +public +List_t List$shuffled(List_t list, Closure_t random_int64, int64_t padded_item_size) { List$compact(&list, padded_item_size); List$shuffle(&list, random_int64, padded_item_size); return list; } -public void *List$random(List_t list, OptionalClosure_t random_int64) -{ - if (list.length == 0) - return NULL; // fail("Cannot get a random item from an empty list!"); +public +void *List$random(List_t list, OptionalClosure_t random_int64) { + if (list.length == 0) return NULL; // fail("Cannot get a random item from an empty list!"); - typedef int64_t (*rng_fn_t)(int64_t, int64_t, void*); + typedef int64_t (*rng_fn_t)(int64_t, int64_t, void *); rng_fn_t rng_fn = random_int64.fn ? (rng_fn_t)random_int64.fn : _default_random_int64; - int64_t index = rng_fn(0, list.length-1, random_int64.userdata); - if unlikely (index < 0 || index > list.length-1) - fail("The provided random number function returned an invalid value: ", index, " (not between 0 and ", (int64_t)list.length, ")"); - return list.data + list.stride*index; + int64_t index = rng_fn(0, list.length - 1, random_int64.userdata); + if unlikely (index < 0 || index > list.length - 1) + fail("The provided random number function returned an invalid value: ", index, " (not between 0 and ", + (int64_t)list.length, ")"); + return list.data + list.stride * index; } -public Table_t List$counts(List_t list, const TypeInfo_t *type) -{ +public +Table_t List$counts(List_t list, const TypeInfo_t *type) { Table_t counts = {}; const TypeInfo_t count_type = *Table$info(type->ListInfo.item, &Int$info); for (int64_t i = 0; i < list.length; i++) { - void *key = list.data + i*list.stride; + void *key = list.data + i * list.stride; int64_t *count = Table$get(counts, key, &count_type); int64_t val = count ? *count + 1 : 1; Table$set(&counts, key, &val, &count_type); @@ -354,14 +343,13 @@ public Table_t List$counts(List_t list, const TypeInfo_t *type) return counts; } -static double _default_random_num(void *userdata) -{ +static double _default_random_num(void *userdata) { (void)userdata; union { Num_t num; uint64_t bits; - } r = {.bits=0}, one = {.num=1.0}; - assert(getrandom((uint8_t*)&r, sizeof(r), 0) == sizeof(r)); + } r = {.bits = 0}, one = {.num = 1.0}; + assert(getrandom((uint8_t *)&r, sizeof(r), 0) == sizeof(r)); // Set r.num to 1.<random-bits> r.bits &= ~(0xFFFULL << 52); @@ -369,39 +357,30 @@ static double _default_random_num(void *userdata) return r.num - 1.0; } -public List_t List$sample(List_t list, Int_t int_n, List_t weights, OptionalClosure_t random_num, int64_t padded_item_size) -{ +public +List_t List$sample(List_t list, Int_t int_n, List_t weights, OptionalClosure_t random_num, int64_t padded_item_size) { int64_t n = Int64$from_int(int_n, false); - if (n < 0) - fail("Cannot select a negative number of values"); + if (n < 0) fail("Cannot select a negative number of values"); - if (n == 0) - return (List_t){}; + if (n == 0) return (List_t){}; - if (list.length == 0) - fail("There are no elements in this list!"); + if (list.length == 0) fail("There are no elements in this list!"); if (weights.length != list.length) fail("List has ", (int64_t)list.length, " elements, but there are ", (int64_t)weights.length, " weights given"); double total = 0.0; for (int64_t i = 0; i < weights.length && i < list.length; i++) { - double weight = *(double*)(weights.data + weights.stride*i); - if (isinf(weight)) - fail("Infinite weight!"); - else if (isnan(weight)) - fail("NaN weight!"); - else if (weight < 0.0) - fail("Negative weight!"); - else - total += weight; + double weight = *(double *)(weights.data + weights.stride * i); + if (isinf(weight)) fail("Infinite weight!"); + else if (isnan(weight)) fail("NaN weight!"); + else if (weight < 0.0) fail("Negative weight!"); + else total += weight; } - if (isinf(total)) - fail("Sample weights have overflowed to infinity"); + if (isinf(total)) fail("Sample weights have overflowed to infinity"); - if (total == 0.0) - fail("None of the given weights are nonzero"); + if (total == 0.0) fail("None of the given weights are nonzero"); double inverse_average = (double)list.length / total; @@ -411,7 +390,7 @@ public List_t List$sample(List_t list, Int_t int_n, List_t weights, OptionalClos } aliases[list.length]; for (int64_t i = 0; i < list.length; i++) { - double weight = i >= weights.length ? 0.0 : *(double*)(weights.data + weights.stride*i); + double weight = i >= weights.length ? 0.0 : *(double *)(weights.data + weights.stride * i); aliases[i].odds = weight * inverse_average; aliases[i].alias = -1; } @@ -435,16 +414,16 @@ public List_t List$sample(List_t list, Int_t int_n, List_t weights, OptionalClos } for (int64_t i = small; i < list.length; i++) - if (aliases[i].alias == -1) - aliases[i].alias = i; + if (aliases[i].alias == -1) aliases[i].alias = i; - typedef double (*rng_fn_t)(void*); + typedef double (*rng_fn_t)(void *); rng_fn_t rng_fn = random_num.fn ? (rng_fn_t)random_num.fn : _default_random_num; - List_t selected = { - .data=list.atomic ? GC_MALLOC_ATOMIC((size_t)(n * padded_item_size)) : GC_MALLOC((size_t)(n * padded_item_size)), - .length=n, - .stride=padded_item_size, .atomic=list.atomic}; + List_t selected = {.data = list.atomic ? GC_MALLOC_ATOMIC((size_t)(n * padded_item_size)) + : GC_MALLOC((size_t)(n * padded_item_size)), + .length = n, + .stride = padded_item_size, + .atomic = list.atomic}; for (int64_t i = 0; i < n; i++) { double r = rng_fn(random_num.userdata); if unlikely (r < 0.0 || r >= 1.0) @@ -452,85 +431,77 @@ public List_t List$sample(List_t list, Int_t int_n, List_t weights, OptionalClos r *= (double)list.length; int64_t index = (int64_t)r; assert(index >= 0 && index < list.length); - if ((r - (double)index) > aliases[index].odds) - index = aliases[index].alias; - memcpy(selected.data + i*selected.stride, list.data + index*list.stride, (size_t)padded_item_size); + if ((r - (double)index) > aliases[index].odds) index = aliases[index].alias; + memcpy(selected.data + i * selected.stride, list.data + index * list.stride, (size_t)padded_item_size); } return selected; } -public List_t List$from(List_t list, Int_t first) -{ - return List$slice(list, first, I_small(-1)); -} +public +List_t List$from(List_t list, Int_t first) { return List$slice(list, first, I_small(-1)); } -public List_t List$to(List_t list, Int_t last) -{ - return List$slice(list, I_small(1), last); -} +public +List_t List$to(List_t list, Int_t last) { return List$slice(list, I_small(1), last); } -public List_t List$by(List_t list, Int_t int_stride, int64_t padded_item_size) -{ +public +List_t List$by(List_t list, Int_t int_stride, int64_t padded_item_size) { int64_t stride = Int64$from_int(int_stride, false); // In the unlikely event that the stride value would be too large to fit in // a 15-bit integer, fall back to creating a copy of the list: - if (unlikely(list.stride*stride < LIST_MIN_STRIDE || list.stride*stride > LIST_MAX_STRIDE)) { + if (unlikely(list.stride * stride < LIST_MIN_STRIDE || list.stride * stride > LIST_MAX_STRIDE)) { void *copy = NULL; int64_t len = (stride < 0 ? list.length / -stride : list.length / stride) + ((list.length % stride) != 0); if (len > 0) { - copy = list.atomic ? GC_MALLOC_ATOMIC((size_t)(len * padded_item_size)) : GC_MALLOC((size_t)(len * padded_item_size)); + copy = list.atomic ? GC_MALLOC_ATOMIC((size_t)(len * padded_item_size)) + : GC_MALLOC((size_t)(len * padded_item_size)); void *start = (stride < 0 ? list.data + (list.stride * (list.length - 1)) : list.data); for (int64_t i = 0; i < len; i++) - memcpy(copy + i*padded_item_size, start + list.stride*stride*i, (size_t)padded_item_size); + memcpy(copy + i * padded_item_size, start + list.stride * stride * i, (size_t)padded_item_size); } return (List_t){ - .data=copy, - .length=len, - .stride=padded_item_size, - .atomic=list.atomic, + .data = copy, + .length = len, + .stride = padded_item_size, + .atomic = list.atomic, }; } - if (stride == 0) - return (List_t){.atomic=list.atomic}; + if (stride == 0) return (List_t){.atomic = list.atomic}; return (List_t){ - .atomic=list.atomic, - .data=(stride < 0 ? list.data + (list.stride * (list.length - 1)) : list.data), - .length=(stride < 0 ? list.length / -stride : list.length / stride) + ((list.length % stride) != 0), - .stride=list.stride * stride, - .data_refcount=list.data_refcount, + .atomic = list.atomic, + .data = (stride < 0 ? list.data + (list.stride * (list.length - 1)) : list.data), + .length = (stride < 0 ? list.length / -stride : list.length / stride) + ((list.length % stride) != 0), + .stride = list.stride * stride, + .data_refcount = list.data_refcount, }; } -public List_t List$slice(List_t list, Int_t int_first, Int_t int_last) +public +List_t List$slice(List_t list, Int_t int_first, Int_t int_last) { int64_t first = Int64$from_int(int_first, false); - if (first < 0) - first = list.length + first + 1; + if (first < 0) first = list.length + first + 1; int64_t last = Int64$from_int(int_last, false); - if (last < 0) - last = list.length + last + 1; + if (last < 0) last = list.length + last + 1; - if (last > list.length) - last = list.length; + if (last > list.length) last = list.length; - if (first < 1 || first > list.length || last == 0) - return (List_t){.atomic=list.atomic}; + if (first < 1 || first > list.length || last == 0) return (List_t){.atomic = list.atomic}; return (List_t){ - .atomic=list.atomic, - .data=list.data + list.stride*(first-1), - .length=last - first + 1, - .stride=list.stride, - .data_refcount=list.data_refcount, + .atomic = list.atomic, + .data = list.data + list.stride * (first - 1), + .length = last - first + 1, + .stride = list.stride, + .data_refcount = list.data_refcount, }; } -public List_t List$reversed(List_t list, int64_t padded_item_size) -{ +public +List_t List$reversed(List_t list, int64_t padded_item_size) { // Just in case negating the stride gives a value that doesn't fit into a // 15-bit integer, fall back to List$by()'s more general method of copying // the list. This should only happen if list.stride is MIN_STRIDE to @@ -540,58 +511,54 @@ public List_t List$reversed(List_t list, int64_t padded_item_size) List_t reversed = list; reversed.stride = -list.stride; - reversed.data = list.data + (list.length-1)*list.stride; + reversed.data = list.data + (list.length - 1) * list.stride; return reversed; } -public List_t List$concat(List_t x, List_t y, int64_t padded_item_size) -{ - void *data = x.atomic ? GC_MALLOC_ATOMIC((size_t)(padded_item_size*(x.length + y.length))) - : GC_MALLOC((size_t)(padded_item_size*(x.length + y.length))); +public +List_t List$concat(List_t x, List_t y, int64_t padded_item_size) { + void *data = x.atomic ? GC_MALLOC_ATOMIC((size_t)(padded_item_size * (x.length + y.length))) + : GC_MALLOC((size_t)(padded_item_size * (x.length + y.length))); if (x.stride == padded_item_size) { - memcpy(data, x.data, (size_t)(padded_item_size*x.length)); + memcpy(data, x.data, (size_t)(padded_item_size * x.length)); } else { for (int64_t i = 0; i < x.length; i++) - memcpy(data + i*padded_item_size, x.data + i*padded_item_size, (size_t)padded_item_size); + memcpy(data + i * padded_item_size, x.data + i * padded_item_size, (size_t)padded_item_size); } - void *dest = data + padded_item_size*x.length; + void *dest = data + padded_item_size * x.length; if (y.stride == padded_item_size) { - memcpy(dest, y.data, (size_t)(padded_item_size*y.length)); + memcpy(dest, y.data, (size_t)(padded_item_size * y.length)); } else { for (int64_t i = 0; i < y.length; i++) - memcpy(dest + i*padded_item_size, y.data + i*y.stride, (size_t)padded_item_size); + memcpy(dest + i * padded_item_size, y.data + i * y.stride, (size_t)padded_item_size); } return (List_t){ - .data=data, - .length=x.length + y.length, - .stride=padded_item_size, - .atomic=x.atomic, + .data = data, + .length = x.length + y.length, + .stride = padded_item_size, + .atomic = x.atomic, }; } -public bool List$has(List_t list, void *item, const TypeInfo_t *type) -{ +public +bool List$has(List_t list, void *item, const TypeInfo_t *type) { const TypeInfo_t *item_type = type->ListInfo.item; for (int64_t i = 0; i < list.length; i++) { - if (generic_equal(list.data + i*list.stride, item, item_type)) - return true; + if (generic_equal(list.data + i * list.stride, item, item_type)) return true; } return false; } -public void List$clear(List_t *list) -{ - *list = (List_t){.data=0, .length=0}; -} +public +void List$clear(List_t *list) { *list = (List_t){.data = 0, .length = 0}; } -public int32_t List$compare(const void *vx, const void *vy, const TypeInfo_t *type) -{ - const List_t *x = (List_t*)vx, *y = (List_t*)vy; +public +int32_t List$compare(const void *vx, const void *vy, const TypeInfo_t *type) { + const List_t *x = (List_t *)vx, *y = (List_t *)vy; // Early out for lists with the same data, e.g. two copies of the same list: - if (x->data == y->data && x->stride == y->stride) - return (x->length > y->length) - (x->length < y->length); + if (x->data == y->data && x->stride == y->stride) return (x->length > y->length) - (x->length < y->length); const TypeInfo_t *item = type->ListInfo.item; if (item->tag == PointerInfo || !item->metamethods.compare) { // data comparison @@ -599,128 +566,120 @@ public int32_t List$compare(const void *vx, const void *vy, const TypeInfo_t *ty if (type->ListInfo.item->align > 1 && item_padded_size % type->ListInfo.item->align) errx(1, "Item size is not padded!"); - if ((int64_t)x->stride == item_padded_size && (int64_t)y->stride == item_padded_size && item->size == item_padded_size) { - int32_t cmp = (int32_t)memcmp(x->data, y->data, (size_t)(MIN(x->length, y->length)*item_padded_size)); + if ((int64_t)x->stride == item_padded_size && (int64_t)y->stride == item_padded_size + && item->size == item_padded_size) { + int32_t cmp = (int32_t)memcmp(x->data, y->data, (size_t)(MIN(x->length, y->length) * item_padded_size)); if (cmp != 0) return cmp; } else { for (int32_t i = 0, len = MIN(x->length, y->length); i < len; i++) { - int32_t cmp = (int32_t)memcmp(x->data+ x->stride*i, y->data + y->stride*i, (size_t)(item->size)); + int32_t cmp = (int32_t)memcmp(x->data + x->stride * i, y->data + y->stride * i, (size_t)(item->size)); if (cmp != 0) return cmp; } } } else { for (int32_t i = 0, len = MIN(x->length, y->length); i < len; i++) { - int32_t cmp = generic_compare(x->data + x->stride*i, y->data + y->stride*i, item); + int32_t cmp = generic_compare(x->data + x->stride * i, y->data + y->stride * i, item); if (cmp != 0) return cmp; } } return (x->length > y->length) - (x->length < y->length); } -public bool List$equal(const void *x, const void *y, const TypeInfo_t *type) -{ - return x == y || (((List_t*)x)->length == ((List_t*)y)->length && List$compare(x, y, type) == 0); +public +bool List$equal(const void *x, const void *y, const TypeInfo_t *type) { + return x == y || (((List_t *)x)->length == ((List_t *)y)->length && List$compare(x, y, type) == 0); } -public Text_t List$as_text(const void *obj, bool colorize, const TypeInfo_t *type) -{ - List_t *list = (List_t*)obj; - if (!list) - return Text$concat(Text("["), generic_as_text(NULL, false, type->ListInfo.item), Text("]")); +public +Text_t List$as_text(const void *obj, bool colorize, const TypeInfo_t *type) { + List_t *list = (List_t *)obj; + if (!list) return Text$concat(Text("["), generic_as_text(NULL, false, type->ListInfo.item), Text("]")); const TypeInfo_t *item_type = type->ListInfo.item; Text_t text = Text("["); for (int64_t i = 0; i < list->length; i++) { - if (i > 0) - text = Text$concat(text, Text(", ")); - Text_t item_text = generic_as_text(list->data + i*list->stride, colorize, item_type); + if (i > 0) text = Text$concat(text, Text(", ")); + Text_t item_text = generic_as_text(list->data + i * list->stride, colorize, item_type); text = Text$concat(text, item_text); } text = Text$concat(text, Text("]")); return text; } -public uint64_t List$hash(const void *obj, const TypeInfo_t *type) -{ - const List_t *list = (List_t*)obj; +public +uint64_t List$hash(const void *obj, const TypeInfo_t *type) { + const List_t *list = (List_t *)obj; const TypeInfo_t *item = type->ListInfo.item; siphash sh; siphashinit(&sh, sizeof(uint64_t[list->length])); - if (item->tag == PointerInfo || (!item->metamethods.hash && item->size == sizeof(void*))) { // Raw data hash + if (item->tag == PointerInfo || (!item->metamethods.hash && item->size == sizeof(void *))) { // Raw data hash for (int64_t i = 0; i < list->length; i++) - siphashadd64bits(&sh, (uint64_t)(list->data + i*list->stride)); + siphashadd64bits(&sh, (uint64_t)(list->data + i * list->stride)); } else { for (int64_t i = 0; i < list->length; i++) { - uint64_t item_hash = generic_hash(list->data + i*list->stride, item); + uint64_t item_hash = generic_hash(list->data + i * list->stride, item); siphashadd64bits(&sh, item_hash); } } return siphashfinish_last_part(&sh, 0); } -static void siftdown(List_t *heap, int64_t startpos, int64_t pos, Closure_t comparison, int64_t padded_item_size) -{ +static void siftdown(List_t *heap, int64_t startpos, int64_t pos, Closure_t comparison, int64_t padded_item_size) { assert(pos > 0 && pos < heap->length); char newitem[padded_item_size]; - memcpy(newitem, heap->data + heap->stride*pos, (size_t)(padded_item_size)); + memcpy(newitem, heap->data + heap->stride * pos, (size_t)(padded_item_size)); while (pos > startpos) { int64_t parentpos = (pos - 1) >> 1; - typedef int32_t (*cmp_fn_t)(void*, void*, void*); - int32_t cmp = ((cmp_fn_t)comparison.fn)(newitem, heap->data + heap->stride*parentpos, comparison.userdata); - if (cmp >= 0) - break; + typedef int32_t (*cmp_fn_t)(void *, void *, void *); + int32_t cmp = ((cmp_fn_t)comparison.fn)(newitem, heap->data + heap->stride * parentpos, comparison.userdata); + if (cmp >= 0) break; - memcpy(heap->data + heap->stride*pos, heap->data + heap->stride*parentpos, (size_t)(padded_item_size)); + memcpy(heap->data + heap->stride * pos, heap->data + heap->stride * parentpos, (size_t)(padded_item_size)); pos = parentpos; } - memcpy(heap->data + heap->stride*pos, newitem, (size_t)(padded_item_size)); + memcpy(heap->data + heap->stride * pos, newitem, (size_t)(padded_item_size)); } -static void siftup(List_t *heap, int64_t pos, Closure_t comparison, int64_t padded_item_size) -{ +static void siftup(List_t *heap, int64_t pos, Closure_t comparison, int64_t padded_item_size) { int64_t endpos = heap->length; int64_t startpos = pos; assert(pos < endpos); char old_top[padded_item_size]; - memcpy(old_top, heap->data + heap->stride*pos, (size_t)(padded_item_size)); + memcpy(old_top, heap->data + heap->stride * pos, (size_t)(padded_item_size)); // Bubble up the smallest leaf node int64_t limit = endpos >> 1; while (pos < limit) { - int64_t childpos = 2*pos + 1; // Smaller of the two child nodes + int64_t childpos = 2 * pos + 1; // Smaller of the two child nodes if (childpos + 1 < endpos) { - typedef int32_t (*cmp_fn_t)(void*, void*, void*); - int32_t cmp = ((cmp_fn_t)comparison.fn)( - heap->data + heap->stride*childpos, - heap->data + heap->stride*(childpos + 1), - comparison.userdata); + typedef int32_t (*cmp_fn_t)(void *, void *, void *); + int32_t cmp = ((cmp_fn_t)comparison.fn)(heap->data + heap->stride * childpos, + heap->data + heap->stride * (childpos + 1), comparison.userdata); childpos += (cmp >= 0); } // Move the child node up: - memcpy(heap->data + heap->stride*pos, heap->data + heap->stride*childpos, (size_t)(padded_item_size)); + memcpy(heap->data + heap->stride * pos, heap->data + heap->stride * childpos, (size_t)(padded_item_size)); pos = childpos; } - memcpy(heap->data + heap->stride*pos, old_top, (size_t)(padded_item_size)); + memcpy(heap->data + heap->stride * pos, old_top, (size_t)(padded_item_size)); // Shift the node's parents down: siftdown(heap, startpos, pos, comparison, padded_item_size); } -public void List$heap_push(List_t *heap, const void *item, Closure_t comparison, int64_t padded_item_size) -{ +public +void List$heap_push(List_t *heap, const void *item, Closure_t comparison, int64_t padded_item_size) { List$insert(heap, item, I(0), padded_item_size); if (heap->length > 1) { - if (heap->data_refcount != 0) - List$compact(heap, padded_item_size); - siftdown(heap, 0, heap->length-1, comparison, padded_item_size); + if (heap->data_refcount != 0) List$compact(heap, padded_item_size); + siftdown(heap, 0, heap->length - 1, comparison, padded_item_size); } } -public void List$heap_pop(List_t *heap, Closure_t comparison, int64_t padded_item_size) -{ - if (heap->length == 0) - fail("Attempt to pop from an empty list"); +public +void List$heap_pop(List_t *heap, Closure_t comparison, int64_t padded_item_size) { + if (heap->length == 0) fail("Attempt to pop from an empty list"); if (heap->length == 1) { *heap = (List_t){}; @@ -728,96 +687,90 @@ public void List$heap_pop(List_t *heap, Closure_t comparison, int64_t padded_ite heap->data += heap->stride; --heap->length; } else { - if (heap->data_refcount != 0) - List$compact(heap, padded_item_size); - memcpy(heap->data, heap->data + heap->stride*(heap->length-1), (size_t)(padded_item_size)); + if (heap->data_refcount != 0) List$compact(heap, padded_item_size); + memcpy(heap->data, heap->data + heap->stride * (heap->length - 1), (size_t)(padded_item_size)); --heap->length; siftup(heap, 0, comparison, padded_item_size); } } -public void List$heapify(List_t *heap, Closure_t comparison, int64_t padded_item_size) -{ - if (heap->data_refcount != 0) - List$compact(heap, padded_item_size); +public +void List$heapify(List_t *heap, Closure_t comparison, int64_t padded_item_size) { + if (heap->data_refcount != 0) List$compact(heap, padded_item_size); // It's necessary to bump the refcount because the user's comparison // function could do stuff that modifies the heap's data. LIST_INCREF(*heap); int64_t i, n = heap->length; - for (i = (n >> 1) - 1 ; i >= 0 ; i--) + for (i = (n >> 1) - 1; i >= 0; i--) siftup(heap, i, comparison, padded_item_size); LIST_DECREF(*heap); } -public Int_t List$binary_search(List_t list, void *target, Closure_t comparison) -{ - typedef int32_t (*cmp_fn_t)(void*, void*, void*); - int64_t lo = 0, hi = list.length-1; +public +Int_t List$binary_search(List_t list, void *target, Closure_t comparison) { + typedef int32_t (*cmp_fn_t)(void *, void *, void *); + int64_t lo = 0, hi = list.length - 1; while (lo <= hi) { int64_t mid = (lo + hi) / 2; - int32_t cmp = ((cmp_fn_t)comparison.fn)( - list.data + list.stride*mid, target, comparison.userdata); - if (cmp == 0) - return I(mid+1); - else if (cmp < 0) - lo = mid + 1; - else if (cmp > 0) - hi = mid - 1; + int32_t cmp = ((cmp_fn_t)comparison.fn)(list.data + list.stride * mid, target, comparison.userdata); + if (cmp == 0) return I(mid + 1); + else if (cmp < 0) lo = mid + 1; + else if (cmp > 0) hi = mid - 1; } - return I(lo+1); // Return the index where the target would be inserted + return I(lo + 1); // Return the index where the target would be inserted } -public PUREFUNC bool List$is_none(const void *obj, const TypeInfo_t *info) -{ +public +PUREFUNC bool List$is_none(const void *obj, const TypeInfo_t *info) { (void)info; - return ((List_t*)obj)->length < 0; + return ((List_t *)obj)->length < 0; } -public void List$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) -{ - List_t list = *(List_t*)obj; +public +void List$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) { + List_t list = *(List_t *)obj; int64_t len = list.length; Int64$serialize(&len, out, pointers, &Int64$info); serialize_fn_t item_serialize = type->ListInfo.item->metamethods.serialize; if (item_serialize) { for (int64_t i = 0; i < len; i++) - item_serialize(list.data + i*list.stride, out, pointers, type->ListInfo.item); + item_serialize(list.data + i * list.stride, out, pointers, type->ListInfo.item); } else if (list.stride == type->ListInfo.item->size) { fwrite(list.data, (size_t)type->ListInfo.item->size, (size_t)len, out); } else { for (int64_t i = 0; i < len; i++) - fwrite(list.data + i*list.stride, (size_t)type->ListInfo.item->size, 1, out); + fwrite(list.data + i * list.stride, (size_t)type->ListInfo.item->size, 1, out); } } -public void List$deserialize(FILE *in, void *obj, List_t *pointers, const TypeInfo_t *type) -{ +public +void List$deserialize(FILE *in, void *obj, List_t *pointers, const TypeInfo_t *type) { int64_t len = -1; Int64$deserialize(in, &len, pointers, &Int64$info); int64_t padded_size = type->ListInfo.item->size; if (type->ListInfo.item->align > 0 && padded_size % type->ListInfo.item->align > 0) padded_size += type->ListInfo.item->align - (padded_size % type->ListInfo.item->align); List_t list = { - .length=len, - .data=GC_MALLOC((size_t)(len*padded_size)), - .stride=padded_size, + .length = len, + .data = GC_MALLOC((size_t)(len * padded_size)), + .stride = padded_size, }; deserialize_fn_t item_deserialize = type->ListInfo.item->metamethods.deserialize; if (item_deserialize) { for (int64_t i = 0; i < len; i++) - item_deserialize(in, list.data + i*list.stride, pointers, type->ListInfo.item); + item_deserialize(in, list.data + i * list.stride, pointers, type->ListInfo.item); } else if (list.stride == type->ListInfo.item->size) { if (fread(list.data, (size_t)type->ListInfo.item->size, (size_t)len, in) != (size_t)len) fail("Not enough data in stream to deserialize"); } else { size_t item_size = (size_t)type->ListInfo.item->size; for (int64_t i = 0; i < len; i++) { - if (fread(list.data + i*list.stride, item_size, 1, in) != 1) + if (fread(list.data + i * list.stride, item_size, 1, in) != 1) fail("Not enough data in stream to deserialize"); } } - *(List_t*)obj = list; + *(List_t *)obj = list; } // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/lists.h b/src/stdlib/lists.h index a2853e48..afda3d74 100644 --- a/src/stdlib/lists.h +++ b/src/stdlib/lists.h @@ -10,88 +10,141 @@ #include "util.h" // Convert negative indices to back-indexed without branching: index0 = index + (index < 0)*(len+1)) - 1 -#define List_get(item_type, arr_expr, index_expr, start, end) *({ \ - const List_t list = arr_expr; int64_t index = index_expr; \ - int64_t off = index + (index < 0) * (list.length + 1) - 1; \ - if (unlikely(off < 0 || off >= list.length)) \ - fail_source(__SOURCE_FILE__, start, end, "Invalid list index: ", index, " (list has length ", (int64_t)list.length, ")\n"); \ - (item_type*)(list.data + list.stride * off);}) -#define List_get_unchecked(type, x, i) *({ const List_t list = x; int64_t index = i; \ - int64_t off = index + (index < 0) * (list.length + 1) - 1; \ - (type*)(list.data + list.stride * off);}) -#define List_lvalue(item_type, arr_expr, index_expr, start, end) *({ \ - List_t *list = arr_expr; int64_t index = index_expr; \ - int64_t off = index + (index < 0) * (list->length + 1) - 1; \ - if (unlikely(off < 0 || off >= list->length)) \ - fail_source(__SOURCE_FILE__, start, end, "Invalid list index: ", index, " (list has length ", (int64_t)list->length, ")\n"); \ - if (list->data_refcount > 0) \ - List$compact(list, sizeof(item_type)); \ - (item_type*)(list->data + list->stride * off); }) -#define List_lvalue_unchecked(item_type, arr_expr, index_expr) *({ \ - List_t *list = arr_expr; int64_t index = index_expr; \ - int64_t off = index + (index < 0) * (list->length + 1) - 1; \ - if (list->data_refcount > 0) \ - List$compact(list, sizeof(item_type)); \ - (item_type*)(list->data + list->stride * off); }) -#define List_set(item_type, list, index, value, start, end) \ - List_lvalue(item_type, arr_expr, index, start, end) = value -#define is_atomic(x) _Generic(x, bool: true, int8_t: true, int16_t: true, int32_t: true, int64_t: true, float: true, double: true, default: false) -#define TypedList(t, ...) ({ t items[] = {__VA_ARGS__}; \ - (List_t){.length=sizeof(items)/sizeof(items[0]), \ - .stride=(int64_t)&items[1] - (int64_t)&items[0], \ - .data=memcpy(GC_MALLOC(sizeof(items)), items, sizeof(items)), \ - .atomic=0, \ - .data_refcount=0}; }) -#define TypedListN(t, N, ...) ({ t items[N] = {__VA_ARGS__}; \ - (List_t){.length=N, \ - .stride=(int64_t)&items[1] - (int64_t)&items[0], \ - .data=memcpy(GC_MALLOC(sizeof(items)), items, sizeof(items)), \ - .atomic=0, \ - .data_refcount=0}; }) -#define List(x, ...) ({ __typeof(x) items[] = {x, __VA_ARGS__}; \ - (List_t){.length=sizeof(items)/sizeof(items[0]), \ - .stride=(int64_t)&items[1] - (int64_t)&items[0], \ - .data=memcpy(is_atomic(x) ? GC_MALLOC_ATOMIC(sizeof(items)) : GC_MALLOC(sizeof(items)), items, sizeof(items)), \ - .atomic=is_atomic(x), \ - .data_refcount=0}; }) +#define List_get(item_type, arr_expr, index_expr, start, end) \ + *({ \ + const List_t list = arr_expr; \ + int64_t index = index_expr; \ + int64_t off = index + (index < 0) * (list.length + 1) - 1; \ + if (unlikely(off < 0 || off >= list.length)) \ + fail_source(__SOURCE_FILE__, start, end, "Invalid list index: ", index, " (list has length ", \ + (int64_t)list.length, ")\n"); \ + (item_type *)(list.data + list.stride * off); \ + }) +#define List_get_unchecked(type, x, i) \ + *({ \ + const List_t list = x; \ + int64_t index = i; \ + int64_t off = index + (index < 0) * (list.length + 1) - 1; \ + (type *)(list.data + list.stride * off); \ + }) +#define List_lvalue(item_type, arr_expr, index_expr, start, end) \ + *({ \ + List_t *list = arr_expr; \ + int64_t index = index_expr; \ + int64_t off = index + (index < 0) * (list->length + 1) - 1; \ + if (unlikely(off < 0 || off >= list->length)) \ + fail_source(__SOURCE_FILE__, start, end, "Invalid list index: ", index, " (list has length ", \ + (int64_t)list->length, ")\n"); \ + if (list->data_refcount > 0) List$compact(list, sizeof(item_type)); \ + (item_type *)(list->data + list->stride * off); \ + }) +#define List_lvalue_unchecked(item_type, arr_expr, index_expr) \ + *({ \ + List_t *list = arr_expr; \ + int64_t index = index_expr; \ + int64_t off = index + (index < 0) * (list->length + 1) - 1; \ + if (list->data_refcount > 0) List$compact(list, sizeof(item_type)); \ + (item_type *)(list->data + list->stride * off); \ + }) +#define List_set(item_type, list, index, value, start, end) List_lvalue(item_type, arr_expr, index, start, end) = value +#define is_atomic(x) \ + _Generic(x, \ + bool: true, \ + int8_t: true, \ + int16_t: true, \ + int32_t: true, \ + int64_t: true, \ + float: true, \ + double: true, \ + default: false) +#define TypedList(t, ...) \ + ({ \ + t items[] = {__VA_ARGS__}; \ + (List_t){.length = sizeof(items) / sizeof(items[0]), \ + .stride = (int64_t)&items[1] - (int64_t)&items[0], \ + .data = memcpy(GC_MALLOC(sizeof(items)), items, sizeof(items)), \ + .atomic = 0, \ + .data_refcount = 0}; \ + }) +#define TypedListN(t, N, ...) \ + ({ \ + t items[N] = {__VA_ARGS__}; \ + (List_t){.length = N, \ + .stride = (int64_t)&items[1] - (int64_t)&items[0], \ + .data = memcpy(GC_MALLOC(sizeof(items)), items, sizeof(items)), \ + .atomic = 0, \ + .data_refcount = 0}; \ + }) +#define List(x, ...) \ + ({ \ + __typeof(x) items[] = {x, __VA_ARGS__}; \ + (List_t){.length = sizeof(items) / sizeof(items[0]), \ + .stride = (int64_t)&items[1] - (int64_t)&items[0], \ + .data = memcpy(is_atomic(x) ? GC_MALLOC_ATOMIC(sizeof(items)) : GC_MALLOC(sizeof(items)), items, \ + sizeof(items)), \ + .atomic = is_atomic(x), \ + .data_refcount = 0}; \ + }) // List refcounts use a saturating add, where once it's at the max value, it stays there. #define LIST_INCREF(list) (list).data_refcount += ((list).data_refcount < LIST_MAX_DATA_REFCOUNT) #define LIST_DECREF(list) (list).data_refcount -= ((list).data_refcount < LIST_MAX_DATA_REFCOUNT) -#define LIST_COPY(list) ({ LIST_INCREF(list); list; }) +#define LIST_COPY(list) \ + ({ \ + LIST_INCREF(list); \ + list; \ + }) -#define List$insert_value(list, item_expr, index, padded_item_size) List$insert(list, (__typeof(item_expr)[1]){item_expr}, index, padded_item_size) +#define List$insert_value(list, item_expr, index, padded_item_size) \ + List$insert(list, (__typeof(item_expr)[1]){item_expr}, index, padded_item_size) void List$insert(List_t *list, const void *item, Int_t index, int64_t padded_item_size); void List$insert_all(List_t *list, List_t to_insert, Int_t index, int64_t padded_item_size); void List$remove_at(List_t *list, Int_t index, Int_t count, int64_t padded_item_size); void List$remove_item(List_t *list, void *item, Int_t max_removals, const TypeInfo_t *type); -#define List$remove_item_value(list, item_expr, max, type) List$remove_item(list, (__typeof(item_expr)[1]){item_expr}, max, type) +#define List$remove_item_value(list, item_expr, max, type) \ + List$remove_item(list, (__typeof(item_expr)[1]){item_expr}, max, type) -#define List$pop(arr_expr, index_expr, item_type, nonnone_var, nonnone_expr, none_expr) ({ \ - List_t *list = arr_expr; \ - Int_t index = index_expr; \ - int64_t index64 = Int64$from_int(index, false); \ - int64_t off = index64 + (index64 < 0) * (list->length + 1) - 1; \ - (off >= 0 && off < list->length) ? ({ \ - item_type nonnone_var = *(item_type*)(list->data + off*list->stride); \ - List$remove_at(list, index, I_small(1), sizeof(item_type)); \ - nonnone_expr; \ - }) : none_expr; }) +#define List$pop(arr_expr, index_expr, item_type, nonnone_var, nonnone_expr, none_expr) \ + ({ \ + List_t *list = arr_expr; \ + Int_t index = index_expr; \ + int64_t index64 = Int64$from_int(index, false); \ + int64_t off = index64 + (index64 < 0) * (list->length + 1) - 1; \ + (off >= 0 && off < list->length) ? ({ \ + item_type nonnone_var = *(item_type *)(list->data + off * list->stride); \ + List$remove_at(list, index, I_small(1), sizeof(item_type)); \ + nonnone_expr; \ + }) \ + : none_expr; \ + }) OptionalInt_t List$find(List_t list, void *item, const TypeInfo_t *type); -#define List$find_value(list, item_expr, type) ({ __typeof(item_expr) item = item_expr; List$find(list, &item, type); }) +#define List$find_value(list, item_expr, type) \ + ({ \ + __typeof(item_expr) item = item_expr; \ + List$find(list, &item, type); \ + }) OptionalInt_t List$first(List_t list, Closure_t predicate); void List$sort(List_t *list, Closure_t comparison, int64_t padded_item_size); List_t List$sorted(List_t list, Closure_t comparison, int64_t padded_item_size); void List$shuffle(List_t *list, OptionalClosure_t random_int64, int64_t padded_item_size); List_t List$shuffled(List_t list, OptionalClosure_t random_int64, int64_t padded_item_size); void *List$random(List_t list, OptionalClosure_t random_int64); -#define List$random_value(list, random_int64, t) ({ List_t _arr = list; if (_arr.length == 0) fail("Cannot get a random value from an empty list!"); *(t*)List$random(_arr, random_int64); }) +#define List$random_value(list, random_int64, t) \ + ({ \ + List_t _arr = list; \ + if (_arr.length == 0) fail("Cannot get a random value from an empty list!"); \ + *(t *)List$random(_arr, random_int64); \ + }) List_t List$sample(List_t list, Int_t n, List_t weights, Closure_t random_num, int64_t padded_item_size); Table_t List$counts(List_t list, const TypeInfo_t *type); void List$clear(List_t *list); void List$compact(List_t *list, int64_t padded_item_size); PUREFUNC bool List$has(List_t list, void *item, const TypeInfo_t *type); -#define List$has_value(list, item_expr, type) ({ __typeof(item_expr) item = item_expr; List$has(list, &item, type); }) +#define List$has_value(list, item_expr, type) \ + ({ \ + __typeof(item_expr) item = item_expr; \ + List$has(list, &item, type); \ + }) PUREFUNC List_t List$from(List_t list, Int_t first); PUREFUNC List_t List$to(List_t list, Int_t last); PUREFUNC List_t List$by(List_t list, Int_t stride, int64_t padded_item_size); @@ -101,37 +154,51 @@ List_t List$concat(List_t x, List_t y, int64_t padded_item_size); PUREFUNC uint64_t List$hash(const void *list, const TypeInfo_t *type); PUREFUNC int32_t List$compare(const void *x, const void *y, const TypeInfo_t *type); PUREFUNC bool List$equal(const void *x, const void *y, const TypeInfo_t *type); -PUREFUNC bool List$is_none(const void *obj, const TypeInfo_t*); +PUREFUNC bool List$is_none(const void *obj, const TypeInfo_t *); Text_t List$as_text(const void *list, bool colorize, const TypeInfo_t *type); void List$heapify(List_t *heap, Closure_t comparison, int64_t padded_item_size); void List$heap_push(List_t *heap, const void *item, Closure_t comparison, int64_t padded_item_size); -#define List$heap_push_value(heap, _value, comparison, padded_item_size) ({ __typeof(_value) value = _value; List$heap_push(heap, &value, comparison, padded_item_size); }) +#define List$heap_push_value(heap, _value, comparison, padded_item_size) \ + ({ \ + __typeof(_value) value = _value; \ + List$heap_push(heap, &value, comparison, padded_item_size); \ + }) void List$heap_pop(List_t *heap, Closure_t comparison, int64_t padded_item_size); -#define List$heap_pop_value(heap, comparison, type, nonnone_var, nonnone_expr, none_expr) \ - ({ List_t *_heap = heap; \ - (_heap->length > 0) ? ({ \ - type nonnone_var = *(type*)_heap->data; \ - List$heap_pop(_heap, comparison, sizeof(type)); \ - nonnone_expr; \ - }) : none_expr; }) +#define List$heap_pop_value(heap, comparison, type, nonnone_var, nonnone_expr, none_expr) \ + ({ \ + List_t *_heap = heap; \ + (_heap->length > 0) ? ({ \ + type nonnone_var = *(type *)_heap->data; \ + List$heap_pop(_heap, comparison, sizeof(type)); \ + nonnone_expr; \ + }) \ + : none_expr; \ + }) Int_t List$binary_search(List_t list, void *target, Closure_t comparison); -#define List$binary_search_value(list, target, comparison) \ - ({ __typeof(target) _target = target; List$binary_search(list, &_target, comparison); }) +#define List$binary_search_value(list, target, comparison) \ + ({ \ + __typeof(target) _target = target; \ + List$binary_search(list, &_target, comparison); \ + }) void List$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type); void List$deserialize(FILE *in, void *obj, List_t *pointers, const TypeInfo_t *type); -#define List$metamethods { \ - .as_text=List$as_text, \ - .compare=List$compare, \ - .equal=List$equal, \ - .hash=List$hash, \ - .is_none=List$is_none, \ - .serialize=List$serialize, \ - .deserialize=List$deserialize, \ -} +#define List$metamethods \ + { \ + .as_text = List$as_text, \ + .compare = List$compare, \ + .equal = List$equal, \ + .hash = List$hash, \ + .is_none = List$is_none, \ + .serialize = List$serialize, \ + .deserialize = List$deserialize, \ + } -#define List$info(item_info) &((TypeInfo_t){.size=sizeof(List_t), .align=__alignof__(List_t), \ - .tag=ListInfo, .ListInfo.item=item_info, \ - .metamethods=List$metamethods}) +#define List$info(item_info) \ + &((TypeInfo_t){.size = sizeof(List_t), \ + .align = __alignof__(List_t), \ + .tag = ListInfo, \ + .ListInfo.item = item_info, \ + .metamethods = List$metamethods}) // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/mapmacro.h b/src/stdlib/mapmacro.h index 5ed7a4b7..68834f8f 100644 --- a/src/stdlib/mapmacro.h +++ b/src/stdlib/mapmacro.h @@ -9,7 +9,7 @@ #define EVAL2(...) EVAL1(EVAL1(EVAL1(__VA_ARGS__))) #define EVAL3(...) EVAL2(EVAL2(EVAL2(__VA_ARGS__))) #define EVAL4(...) EVAL3(EVAL3(EVAL3(__VA_ARGS__))) -#define EVAL(...) EVAL4(EVAL4(EVAL4(__VA_ARGS__))) +#define EVAL(...) EVAL4(EVAL4(EVAL4(__VA_ARGS__))) #define MAP_END(...) #define MAP_OUT @@ -21,7 +21,7 @@ #define MAP_NEXT0(test, next, ...) next MAP_OUT #define MAP_LIST_NEXT1(test, next) MAP_NEXT0(test, MAP_COMMA next, 0) -#define MAP_LIST_NEXT(test, next) MAP_LIST_NEXT1(MAP_GET_END test, next) +#define MAP_LIST_NEXT(test, next) MAP_LIST_NEXT1(MAP_GET_END test, next) #define MAP_LIST0(f, x, peek, ...) f(x) MAP_LIST_NEXT(peek, MAP_LIST1)(f, peek, __VA_ARGS__) #define MAP_LIST1(f, x, peek, ...) f(x) MAP_LIST_NEXT(peek, MAP_LIST0)(f, peek, __VA_ARGS__) diff --git a/src/stdlib/memory.c b/src/stdlib/memory.c index a28b0069..90e14261 100644 --- a/src/stdlib/memory.c +++ b/src/stdlib/memory.c @@ -1,9 +1,9 @@ // Type info and methods for "Memory" opaque type +#include <err.h> #include <gc.h> #include <stdbool.h> #include <stdint.h> #include <sys/param.h> -#include <err.h> #include "memory.h" #include "metamethods.h" @@ -12,21 +12,24 @@ #include "types.h" #include "util.h" -public Text_t Memory$as_text(const void *p, bool colorize, const TypeInfo_t *info) { +public +Text_t Memory$as_text(const void *p, bool colorize, const TypeInfo_t *info) { (void)info; if (!p) return Text("Memory"); - Text_t text = Text$from_str(String("Memory<", *(void**)p, ">")); + Text_t text = Text$from_str(String("Memory<", *(void **)p, ">")); return colorize ? Texts(Text("\x1b[0;34;1m"), text, Text("\x1b[m")) : text; } -public const TypeInfo_t Memory$info = { - .size=0, - .align=0, - .metamethods={ - .as_text=Memory$as_text, - .serialize=cannot_serialize, - .deserialize=cannot_deserialize, - }, +public +const TypeInfo_t Memory$info = { + .size = 0, + .align = 0, + .metamethods = + { + .as_text = Memory$as_text, + .serialize = cannot_serialize, + .deserialize = cannot_deserialize, + }, }; // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/metamethods.c b/src/stdlib/metamethods.c index 8c755c59..ea06d20b 100644 --- a/src/stdlib/metamethods.c +++ b/src/stdlib/metamethods.c @@ -9,52 +9,44 @@ #include "types.h" #include "util.h" -PUREFUNC public uint64_t generic_hash(const void *obj, const TypeInfo_t *type) -{ - if (type->metamethods.hash) - return type->metamethods.hash(obj, type); +PUREFUNC public uint64_t generic_hash(const void *obj, const TypeInfo_t *type) { + if (type->metamethods.hash) return type->metamethods.hash(obj, type); - return siphash24((void*)obj, (size_t)(type->size)); + return siphash24((void *)obj, (size_t)(type->size)); } -PUREFUNC public int32_t generic_compare(const void *x, const void *y, const TypeInfo_t *type) -{ +PUREFUNC public int32_t generic_compare(const void *x, const void *y, const TypeInfo_t *type) { if (x == y) return 0; - if (type->metamethods.compare) - return type->metamethods.compare(x, y, type); + if (type->metamethods.compare) return type->metamethods.compare(x, y, type); - return (int32_t)memcmp((void*)x, (void*)y, (size_t)(type->size)); + return (int32_t)memcmp((void *)x, (void *)y, (size_t)(type->size)); } -PUREFUNC public bool generic_equal(const void *x, const void *y, const TypeInfo_t *type) -{ +PUREFUNC public bool generic_equal(const void *x, const void *y, const TypeInfo_t *type) { if (x == y) return true; - if (type->metamethods.equal) - return type->metamethods.equal(x, y, type); + if (type->metamethods.equal) return type->metamethods.equal(x, y, type); return (generic_compare(x, y, type) == 0); } -public Text_t generic_as_text(const void *obj, bool colorize, const TypeInfo_t *type) -{ - if (!type->metamethods.as_text) - fail("No text metamethod provided for type!"); +public +Text_t generic_as_text(const void *obj, bool colorize, const TypeInfo_t *type) { + if (!type->metamethods.as_text) fail("No text metamethod provided for type!"); return type->metamethods.as_text(obj, colorize, type); } -public void _serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) -{ - if (type->metamethods.serialize) - return type->metamethods.serialize(obj, out, pointers, type); +public +void _serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) { + if (type->metamethods.serialize) return type->metamethods.serialize(obj, out, pointers, type); fwrite(obj, (size_t)type->size, 1, out); } -public List_t generic_serialize(const void *x, const TypeInfo_t *type) -{ +public +List_t generic_serialize(const void *x, const TypeInfo_t *type) { char *buf = NULL; size_t size = 0; FILE *stream = open_memstream(&buf, &size); @@ -62,31 +54,29 @@ public List_t generic_serialize(const void *x, const TypeInfo_t *type) _serialize(x, stream, &pointers, type); fclose(stream); List_t bytes = { - .data=GC_MALLOC_ATOMIC(size), - .length=(int64_t)size, - .stride=1, - .atomic=1, + .data = GC_MALLOC_ATOMIC(size), + .length = (int64_t)size, + .stride = 1, + .atomic = 1, }; memcpy(bytes.data, buf, size); free(buf); return bytes; } -public void _deserialize(FILE *input, void *outval, List_t *pointers, const TypeInfo_t *type) -{ +public +void _deserialize(FILE *input, void *outval, List_t *pointers, const TypeInfo_t *type) { if (type->metamethods.deserialize) { type->metamethods.deserialize(input, outval, pointers, type); return; } - if (fread(outval, (size_t)type->size, 1, input) != 1) - fail("Not enough data in stream to deserialize"); + if (fread(outval, (size_t)type->size, 1, input) != 1) fail("Not enough data in stream to deserialize"); } -public void generic_deserialize(List_t bytes, void *outval, const TypeInfo_t *type) -{ - if (bytes.stride != 1) - List$compact(&bytes, 1); +public +void generic_deserialize(List_t bytes, void *outval, const TypeInfo_t *type) { + if (bytes.stride != 1) List$compact(&bytes, 1); FILE *input = fmemopen(bytes.data, (size_t)bytes.length, "r"); List_t pointers = {}; @@ -94,23 +84,21 @@ public void generic_deserialize(List_t bytes, void *outval, const TypeInfo_t *ty fclose(input); } -public int generic_print(const void *obj, bool colorize, const TypeInfo_t *type) -{ +public +int generic_print(const void *obj, bool colorize, const TypeInfo_t *type) { Text_t text = generic_as_text(obj, colorize, type); return Text$print(stdout, text) + fputc('\n', stdout); } -__attribute__((noreturn)) -public void cannot_serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) -{ +__attribute__((noreturn)) public +void cannot_serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) { (void)obj, (void)out, (void)pointers; Text_t typestr = generic_as_text(NULL, false, type); fail("Values of type ", typestr, " cannot be serialized or deserialized!"); } -__attribute__((noreturn)) -public void cannot_deserialize(FILE *in, void *obj, List_t *pointers, const TypeInfo_t *type) -{ +__attribute__((noreturn)) public +void cannot_deserialize(FILE *in, void *obj, List_t *pointers, const TypeInfo_t *type) { (void)obj, (void)in, (void)pointers; Text_t typestr = generic_as_text(NULL, false, type); fail("Values of type ", typestr, " cannot be serialized or deserialized!"); diff --git a/src/stdlib/metamethods.h b/src/stdlib/metamethods.h index ca0a1e7e..eda2230e 100644 --- a/src/stdlib/metamethods.h +++ b/src/stdlib/metamethods.h @@ -16,7 +16,7 @@ List_t generic_serialize(const void *x, const TypeInfo_t *type); void _deserialize(FILE *input, void *outval, List_t *pointers, const TypeInfo_t *type); void generic_deserialize(List_t bytes, void *outval, const TypeInfo_t *type); int generic_print(const void *obj, bool colorize, const TypeInfo_t *type); -void cannot_serialize(const void*, FILE*, Table_t*, const TypeInfo_t *type); -void cannot_deserialize(FILE*, void*, List_t*, const TypeInfo_t *type); +void cannot_serialize(const void *, FILE *, Table_t *, const TypeInfo_t *type); +void cannot_deserialize(FILE *, void *, List_t *, const TypeInfo_t *type); // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/nums.c b/src/stdlib/nums.c index 83166659..05ed14a8 100644 --- a/src/stdlib/nums.c +++ b/src/stdlib/nums.c @@ -13,20 +13,21 @@ #include "text.h" #include "types.h" -public PUREFUNC Text_t Num$as_text(const void *f, bool colorize, const TypeInfo_t *info) { +public +PUREFUNC Text_t Num$as_text(const void *f, bool colorize, const TypeInfo_t *info) { (void)info; if (!f) return Text("Num"); char *str = GC_MALLOC_ATOMIC(24); - int len = fpconv_dtoa(*(double*)f, str); + int len = fpconv_dtoa(*(double *)f, str); static const Text_t color_prefix = Text("\x1b[35m"), color_suffix = Text("\x1b[m"); Text_t text = Text$from_strn(str, (size_t)len); return colorize ? Texts(color_prefix, text, color_suffix) : text; -} +} -public PUREFUNC int32_t Num$compare(const void *x, const void *y, const TypeInfo_t *info) { +public +PUREFUNC int32_t Num$compare(const void *x, const void *y, const TypeInfo_t *info) { (void)info; - int64_t rx = *(int64_t*)x, - ry = *(int64_t*)y; + int64_t rx = *(int64_t *)x, ry = *(int64_t *)y; if (rx == ry) return 0; @@ -34,14 +35,16 @@ public PUREFUNC int32_t Num$compare(const void *x, const void *y, const TypeInfo if (ry < 0) ry ^= INT64_MAX; return (rx > ry) - (rx < ry); -} +} -public PUREFUNC bool Num$equal(const void *x, const void *y, const TypeInfo_t *info) { +public +PUREFUNC bool Num$equal(const void *x, const void *y, const TypeInfo_t *info) { (void)info; - return *(double*)x == *(double*)y; -} + return *(double *)x == *(double *)y; +} -public CONSTFUNC bool Num$near(double a, double b, double ratio, double absolute) { +public +CONSTFUNC bool Num$near(double a, double b, double ratio, double absolute) { if (ratio < 0) ratio = 0; else if (ratio > 1) ratio = 1; @@ -56,17 +59,19 @@ public CONSTFUNC bool Num$near(double a, double b, double ratio, double absolute return (diff < epsilon); } -public Text_t Num$percent(double f, double precision) { +public +Text_t Num$percent(double f, double precision) { double d = 100. * f; d = Num$with_precision(d, precision); return Texts(Num$as_text(&d, false, &Num$info), Text("%")); } -public CONSTFUNC double Num$with_precision(double num, double precision) { +public +CONSTFUNC double Num$with_precision(double num, double precision) { if (precision == 0.0) return num; // Precision will be, e.g. 0.01 or 100. if (precision < 1.) { - double inv = round(1./precision); // Necessary to make the math work + double inv = round(1. / precision); // Necessary to make the math work double k = num * inv; return round(k) / inv; } else { @@ -75,37 +80,34 @@ public CONSTFUNC double Num$with_precision(double num, double precision) { } } -public CONSTFUNC double Num$mod(double num, double modulus) { - // Euclidean division, see: https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf +public +CONSTFUNC double Num$mod(double num, double modulus) { + // Euclidean division, see: + // https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf double r = remainder(num, modulus); - r -= (r < 0) * (2*(modulus < 0) - 1) * modulus; + r -= (r < 0) * (2 * (modulus < 0) - 1) * modulus; return r; } -public CONSTFUNC double Num$mod1(double num, double modulus) { - return 1.0 + Num$mod(num-1, modulus); -} +public +CONSTFUNC double Num$mod1(double num, double modulus) { return 1.0 + Num$mod(num - 1, modulus); } -public CONSTFUNC double Num$mix(double amount, double x, double y) { - return (1.0-amount)*x + amount*y; -} +public +CONSTFUNC double Num$mix(double amount, double x, double y) { return (1.0 - amount) * x + amount * y; } -public CONSTFUNC bool Num$is_between(const double x, const double low, const double high) { - return low <= x && x <= high; -} -public CONSTFUNC double Num$clamped(double x, double low, double high) { - return (x <= low) ? low : (x >= high ? high : x); -} +public +CONSTFUNC bool Num$is_between(const double x, const double low, const double high) { return low <= x && x <= high; } +public +CONSTFUNC double Num$clamped(double x, double low, double high) { return (x <= low) ? low : (x >= high ? high : x); } -public OptionalNum_t Num$parse(Text_t text, Text_t *remainder) { +public +OptionalNum_t Num$parse(Text_t text, Text_t *remainder) { const char *str = Text$as_c_string(text); char *end = NULL; double d = strtod(str, &end); if (end > str) { - if (remainder) - *remainder = Text$from_str(end); - else if (*end != '\0') - return nan("none"); + if (remainder) *remainder = Text$from_str(end); + else if (*end != '\0') return nan("none"); return d; } else { if (remainder) *remainder = text; @@ -113,45 +115,54 @@ public OptionalNum_t Num$parse(Text_t text, Text_t *remainder) { } } -public CONSTFUNC bool Num$is_none(const void *n, const TypeInfo_t *info) -{ +public +CONSTFUNC bool Num$is_none(const void *n, const TypeInfo_t *info) { (void)info; - return isnan(*(Num_t*)n); -} - -public CONSTFUNC bool Num$isinf(double n) { return (fpclassify(n) == FP_INFINITE); } -public CONSTFUNC bool Num$finite(double n) { return (fpclassify(n) != FP_INFINITE); } -public CONSTFUNC bool Num$isnan(double n) { return (fpclassify(n) == FP_NAN); } - -public const TypeInfo_t Num$info = { - .size=sizeof(double), - .align=__alignof__(double), - .metamethods={ - .compare=Num$compare, - .equal=Num$equal, - .as_text=Num$as_text, - .is_none=Num$is_none, - }, + return isnan(*(Num_t *)n); +} + +public +CONSTFUNC bool Num$isinf(double n) { return (fpclassify(n) == FP_INFINITE); } +public +CONSTFUNC bool Num$finite(double n) { return (fpclassify(n) != FP_INFINITE); } +public +CONSTFUNC bool Num$isnan(double n) { return (fpclassify(n) == FP_NAN); } + +public +const TypeInfo_t Num$info = { + .size = sizeof(double), + .align = __alignof__(double), + .metamethods = + { + .compare = Num$compare, + .equal = Num$equal, + .as_text = Num$as_text, + .is_none = Num$is_none, + }, }; -public PUREFUNC Text_t Num32$as_text(const void *f, bool colorize, const TypeInfo_t *info) { +public +PUREFUNC Text_t Num32$as_text(const void *f, bool colorize, const TypeInfo_t *info) { (void)info; if (!f) return Text("Num32"); - double d = (double)(*(float*)f); + double d = (double)(*(float *)f); return Num$as_text(&d, colorize, &Num$info); } -public PUREFUNC int32_t Num32$compare(const void *x, const void *y, const TypeInfo_t *info) { +public +PUREFUNC int32_t Num32$compare(const void *x, const void *y, const TypeInfo_t *info) { (void)info; - return (*(float*)x > *(float*)y) - (*(float*)x < *(float*)y); -} + return (*(float *)x > *(float *)y) - (*(float *)x < *(float *)y); +} -public PUREFUNC bool Num32$equal(const void *x, const void *y, const TypeInfo_t *info) { +public +PUREFUNC bool Num32$equal(const void *x, const void *y, const TypeInfo_t *info) { (void)info; - return *(float*)x == *(float*)y; + return *(float *)x == *(float *)y; } -public CONSTFUNC bool Num32$near(float a, float b, float ratio, float absolute) { +public +CONSTFUNC bool Num32$near(float a, float b, float ratio, float absolute) { if (ratio < 0) ratio = 0; else if (ratio > 1) ratio = 1; @@ -166,17 +177,19 @@ public CONSTFUNC bool Num32$near(float a, float b, float ratio, float absolute) return (diff < epsilon); } -public Text_t Num32$percent(float f, float precision) { +public +Text_t Num32$percent(float f, float precision) { double d = 100. * (double)f; d = Num$with_precision(d, (double)precision); return Texts(Num$as_text(&d, false, &Num$info), Text("%")); } -public CONSTFUNC float Num32$with_precision(float num, float precision) { +public +CONSTFUNC float Num32$with_precision(float num, float precision) { if (precision == 0.0f) return num; // Precision will be, e.g. 0.01 or 100. if (precision < 1.f) { - float inv = roundf(1.f/precision); // Necessary to make the math work + float inv = roundf(1.f / precision); // Necessary to make the math work float k = num * inv; return roundf(k) / inv; } else { @@ -185,37 +198,35 @@ public CONSTFUNC float Num32$with_precision(float num, float precision) { } } -public CONSTFUNC float Num32$mod(float num, float modulus) { - // Euclidean division, see: https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf +public +CONSTFUNC float Num32$mod(float num, float modulus) { + // Euclidean division, see: + // https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf float r = remainderf(num, modulus); - r -= (r < 0) * (2*(modulus < 0) - 1) * modulus; + r -= (r < 0) * (2 * (modulus < 0) - 1) * modulus; return r; } -public CONSTFUNC float Num32$mod1(float num, float modulus) { - return 1.0f + Num32$mod(num-1, modulus); -} +public +CONSTFUNC float Num32$mod1(float num, float modulus) { return 1.0f + Num32$mod(num - 1, modulus); } -public CONSTFUNC float Num32$mix(float amount, float x, float y) { - return (1.0f-amount)*x + amount*y; -} +public +CONSTFUNC float Num32$mix(float amount, float x, float y) { return (1.0f - amount) * x + amount * y; } -public CONSTFUNC bool Num32$is_between(const float x, const float low, const float high) { - return low <= x && x <= high; -} +public +CONSTFUNC bool Num32$is_between(const float x, const float low, const float high) { return low <= x && x <= high; } -public CONSTFUNC float Num32$clamped(float x, float low, float high) { - return (x <= low) ? low : (x >= high ? high : x); -} +public +CONSTFUNC float Num32$clamped(float x, float low, float high) { return (x <= low) ? low : (x >= high ? high : x); } -public OptionalNum32_t Num32$parse(Text_t text, Text_t *remainder) { +public +OptionalNum32_t Num32$parse(Text_t text, Text_t *remainder) { const char *str = Text$as_c_string(text); char *end = NULL; double d = strtod(str, &end); if (end > str && end[0] == '\0') { if (remainder) *remainder = Text$from_str(end); - else if (*end != '\0') - return nan("none"); + else if (*end != '\0') return nan("none"); return d; } else { if (remainder) *remainder = text; @@ -223,25 +234,30 @@ public OptionalNum32_t Num32$parse(Text_t text, Text_t *remainder) { } } -public CONSTFUNC bool Num32$is_none(const void *n, const TypeInfo_t *info) -{ +public +CONSTFUNC bool Num32$is_none(const void *n, const TypeInfo_t *info) { (void)info; - return isnan(*(Num32_t*)n); -} - -public CONSTFUNC bool Num32$isinf(float n) { return (fpclassify(n) == FP_INFINITE); } -public CONSTFUNC bool Num32$finite(float n) { return (fpclassify(n) != FP_INFINITE); } -public CONSTFUNC bool Num32$isnan(float n) { return (fpclassify(n) == FP_NAN); } - -public const TypeInfo_t Num32$info = { - .size=sizeof(float), - .align=__alignof__(float), - .metamethods={ - .compare=Num32$compare, - .equal=Num32$equal, - .as_text=Num32$as_text, - .is_none=Num32$is_none, - }, + return isnan(*(Num32_t *)n); +} + +public +CONSTFUNC bool Num32$isinf(float n) { return (fpclassify(n) == FP_INFINITE); } +public +CONSTFUNC bool Num32$finite(float n) { return (fpclassify(n) != FP_INFINITE); } +public +CONSTFUNC bool Num32$isnan(float n) { return (fpclassify(n) == FP_NAN); } + +public +const TypeInfo_t Num32$info = { + .size = sizeof(float), + .align = __alignof__(float), + .metamethods = + { + .compare = Num32$compare, + .equal = Num32$equal, + .as_text = Num32$as_text, + .is_none = Num32$is_none, + }, }; // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/optionals.c b/src/stdlib/optionals.c index 36683241..a6f943ae 100644 --- a/src/stdlib/optionals.c +++ b/src/stdlib/optionals.c @@ -9,22 +9,19 @@ #include "text.h" #include "util.h" -public PUREFUNC bool is_none(const void *obj, const TypeInfo_t *non_optional_type) -{ - if (non_optional_type->metamethods.is_none) - return non_optional_type->metamethods.is_none(obj, non_optional_type); +public +PUREFUNC bool is_none(const void *obj, const TypeInfo_t *non_optional_type) { + if (non_optional_type->metamethods.is_none) return non_optional_type->metamethods.is_none(obj, non_optional_type); const void *dest = (obj + non_optional_type->size); - return *(bool*)dest; + return *(bool *)dest; } -PUREFUNC public uint64_t Optional$hash(const void *obj, const TypeInfo_t *type) -{ +PUREFUNC public uint64_t Optional$hash(const void *obj, const TypeInfo_t *type) { return is_none(obj, type->OptionalInfo.type) ? 0 : generic_hash(obj, type->OptionalInfo.type); } -PUREFUNC public int32_t Optional$compare(const void *x, const void *y, const TypeInfo_t *type) -{ +PUREFUNC public int32_t Optional$compare(const void *x, const void *y, const TypeInfo_t *type) { if (x == y) return 0; bool x_is_null = is_none(x, type->OptionalInfo.type); bool y_is_null = is_none(y, type->OptionalInfo.type); @@ -33,8 +30,7 @@ PUREFUNC public int32_t Optional$compare(const void *x, const void *y, const Typ else return generic_compare(x, y, type->OptionalInfo.type); } -PUREFUNC public bool Optional$equal(const void *x, const void *y, const TypeInfo_t *type) -{ +PUREFUNC public bool Optional$equal(const void *x, const void *y, const TypeInfo_t *type) { if (x == y) return true; bool x_is_null = is_none(x, type->OptionalInfo.type); @@ -44,46 +40,37 @@ PUREFUNC public bool Optional$equal(const void *x, const void *y, const TypeInfo else return generic_equal(x, y, type->OptionalInfo.type); } -public Text_t Optional$as_text(const void *obj, bool colorize, const TypeInfo_t *type) -{ - if (!obj) - return Text$concat(generic_as_text(obj, colorize, type->OptionalInfo.type), Text("?")); +public +Text_t Optional$as_text(const void *obj, bool colorize, const TypeInfo_t *type) { + if (!obj) return Text$concat(generic_as_text(obj, colorize, type->OptionalInfo.type), Text("?")); - if (is_none(obj, type->OptionalInfo.type)) - return colorize ? Text("\x1b[31mnone\x1b[m") : Text("none"); + if (is_none(obj, type->OptionalInfo.type)) return colorize ? Text("\x1b[31mnone\x1b[m") : Text("none"); return generic_as_text(obj, colorize, type->OptionalInfo.type); } -public void Optional$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) -{ +public +void Optional$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) { bool has_value = !is_none(obj, type->OptionalInfo.type); assert(fputc((int)has_value, out) != EOF); - if (has_value) - _serialize(obj, out, pointers, type->OptionalInfo.type); + if (has_value) _serialize(obj, out, pointers, type->OptionalInfo.type); } -public void Optional$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *type) -{ +public +void Optional$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *type) { bool has_value = (bool)fgetc(in); const TypeInfo_t *nonnull = type->OptionalInfo.type; if (has_value) { memset(outval, 0, (size_t)type->size); _deserialize(in, outval, pointers, nonnull); } else { - if (nonnull->tag == TextInfo) - *(Text_t*)outval = NONE_TEXT; - else if (nonnull->tag == ListInfo) - *(List_t*)outval = (List_t){.length=-1}; - else if (nonnull->tag == TableInfo) - *(Table_t*)outval = (Table_t){.entries={.length=-1}}; - else if (nonnull == &Num$info) - *(double*)outval = (double)NAN; - else if (nonnull == &Num32$info) - *(float*)outval = (float)NAN; + if (nonnull->tag == TextInfo) *(Text_t *)outval = NONE_TEXT; + else if (nonnull->tag == ListInfo) *(List_t *)outval = (List_t){.length = -1}; + else if (nonnull->tag == TableInfo) *(Table_t *)outval = (Table_t){.entries = {.length = -1}}; + else if (nonnull == &Num$info) *(double *)outval = (double)NAN; + else if (nonnull == &Num32$info) *(float *)outval = (float)NAN; else if (nonnull->tag == StructInfo || (nonnull->tag == OpaqueInfo && type->size > nonnull->size)) memset(outval + type->size, -1, (size_t)(type->size - nonnull->size)); - else - memset(outval, 0, (size_t)type->size); + else memset(outval, 0, (size_t)type->size); } } diff --git a/src/stdlib/optionals.h b/src/stdlib/optionals.h index bd1f63b3..77ce6db4 100644 --- a/src/stdlib/optionals.h +++ b/src/stdlib/optionals.h @@ -9,13 +9,13 @@ #include "types.h" #include "util.h" -#define NONE_LIST ((List_t){.length=-1}) +#define NONE_LIST ((List_t){.length = -1}) #define NONE_BOOL ((OptionalBool_t)2) -#define NONE_INT ((OptionalInt_t){.small=0}) -#define NONE_TABLE ((OptionalTable_t){.entries.length=-1}) -#define NONE_CLOSURE ((OptionalClosure_t){.fn=NULL}) -#define NONE_TEXT ((OptionalText_t){.length=-1}) -#define NONE_PATH ((Path_t){.type=PATH_NONE}) +#define NONE_INT ((OptionalInt_t){.small = 0}) +#define NONE_TABLE ((OptionalTable_t){.entries.length = -1}) +#define NONE_CLOSURE ((OptionalClosure_t){.fn = NULL}) +#define NONE_TEXT ((OptionalText_t){.length = -1}) +#define NONE_PATH ((Path_t){.type = PATH_NONE}) PUREFUNC bool is_none(const void *obj, const TypeInfo_t *non_optional_type); PUREFUNC uint64_t Optional$hash(const void *obj, const TypeInfo_t *type); @@ -25,17 +25,21 @@ Text_t Optional$as_text(const void *obj, bool colorize, const TypeInfo_t *type); void Optional$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type); void Optional$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *type); -#define Optional$metamethods { \ - .hash=Optional$hash, \ - .compare=Optional$compare, \ - .equal=Optional$equal, \ - .as_text=Optional$as_text, \ - .serialize=Optional$serialize, \ - .deserialize=Optional$deserialize, \ -} - -#define Optional$info(_size, _align, t) &((TypeInfo_t){.size=_size, .align=_align, \ - .tag=OptionalInfo, .OptionalInfo.type=t, \ - .metamethods=Optional$metamethods}) +#define Optional$metamethods \ + { \ + .hash = Optional$hash, \ + .compare = Optional$compare, \ + .equal = Optional$equal, \ + .as_text = Optional$as_text, \ + .serialize = Optional$serialize, \ + .deserialize = Optional$deserialize, \ + } + +#define Optional$info(_size, _align, t) \ + &((TypeInfo_t){.size = _size, \ + .align = _align, \ + .tag = OptionalInfo, \ + .OptionalInfo.type = t, \ + .metamethods = Optional$metamethods}) // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/paths.c b/src/stdlib/paths.c index a14b32c2..efe9f7ad 100644 --- a/src/stdlib/paths.c +++ b/src/stdlib/paths.c @@ -17,32 +17,30 @@ #include <unistd.h> #include <unistr.h> -#include "lists.h" #include "enums.h" #include "integers.h" +#include "lists.h" #include "optionals.h" #include "paths.h" +#include "print.h" #include "structs.h" #include "text.h" #include "types.h" #include "util.h" -#include "print.h" // Use inline version of the siphash code for performance: #include "siphash-internals.h" -static const Path_t HOME_PATH = {.type.$tag=PATH_HOME}, - ROOT_PATH = {.type.$tag=PATH_ABSOLUTE}, - CURDIR_PATH = {.type.$tag=PATH_RELATIVE}; +static const Path_t HOME_PATH = {.type.$tag = PATH_HOME}, ROOT_PATH = {.type.$tag = PATH_ABSOLUTE}, + CURDIR_PATH = {.type.$tag = PATH_RELATIVE}; -static void clean_components(List_t *components) -{ - for (int64_t i = 0; i < components->length; ) { - Text_t *component = (Text_t*)(components->data + i*components->stride); +static void clean_components(List_t *components) { + for (int64_t i = 0; i < components->length;) { + Text_t *component = (Text_t *)(components->data + i * components->stride); if (component->length == 0 || Text$equal_values(*component, Text("."))) { - List$remove_at(components, I(i+1), I(1), sizeof(Text_t)); + List$remove_at(components, I(i + 1), I(1), sizeof(Text_t)); } else if (i > 0 && Text$equal_values(*component, Text(".."))) { - Text_t *prev = (Text_t*)(components->data + (i-1)*components->stride); + Text_t *prev = (Text_t *)(components->data + (i - 1) * components->stride); if (!Text$equal_values(*prev, Text(".."))) { List$remove_at(components, I(i), I(2), sizeof(Text_t)); i -= 1; @@ -55,16 +53,15 @@ static void clean_components(List_t *components) } } -public Path_t Path$from_str(const char *str) -{ +public +Path_t Path$from_str(const char *str) { if (!str || str[0] == '\0' || streq(str, "/")) return ROOT_PATH; else if (streq(str, "~")) return HOME_PATH; else if (streq(str, ".")) return CURDIR_PATH; - if (strchr(str, ';') != NULL) - fail("Path has illegal character (semicolon): ", str); + if (strchr(str, ';') != NULL) fail("Path has illegal character (semicolon): ", str); - Path_t result = {.components={}}; + Path_t result = {.components = {}}; if (str[0] == '/') { result.type.$tag = PATH_ABSOLUTE; str += 1; @@ -83,12 +80,13 @@ public Path_t Path$from_str(const char *str) if (component_len > 0) { if (component_len == 1 && str[0] == '.') { // ignore /./ - } else if (component_len == 2 && strncmp(str, "..", 2) == 0 - && result.components.length > 1 - && !Text$equal_values(Text(".."), *(Text_t*)(result.components.data + result.components.stride*(result.components.length-1)))) { + } else if (component_len == 2 && strncmp(str, "..", 2) == 0 && result.components.length > 1 + && !Text$equal_values( + Text(".."), *(Text_t *)(result.components.data + + result.components.stride * (result.components.length - 1)))) { // Pop off /foo/baz/.. -> /foo List$remove_at(&result.components, I(result.components.length), I(1), sizeof(Text_t)); - } else { + } else { Text_t component = Text$from_strn(str, component_len); List$insert_value(&result.components, component, I(0), sizeof(Text_t)); } @@ -99,25 +97,23 @@ public Path_t Path$from_str(const char *str) return result; } -public Path_t Path$from_text(Text_t text) -{ - return Path$from_str(Text$as_c_string(text)); -} +public +Path_t Path$from_text(Text_t text) { return Path$from_str(Text$as_c_string(text)); } -public Path_t Path$expand_home(Path_t path) -{ +public +Path_t Path$expand_home(Path_t path) { if (path.type.$tag == PATH_HOME) { Path_t pwd = Path$from_str(getenv("HOME")); List_t components = List$concat(pwd.components, path.components, sizeof(Text_t)); assert(components.length == path.components.length + pwd.components.length); clean_components(&components); - path = (Path_t){.type.$tag=PATH_ABSOLUTE, .components=components}; + path = (Path_t){.type.$tag = PATH_ABSOLUTE, .components = components}; } return path; } -public Path_t Path$_concat(int n, Path_t items[n]) -{ +public +Path_t Path$_concat(int n, Path_t items[n]) { assert(n > 0); Path_t result = items[0]; LIST_INCREF(result.components); @@ -130,10 +126,11 @@ public Path_t Path$_concat(int n, Path_t items[n]) return result; } -public Path_t Path$resolved(Path_t path, Path_t relative_to) -{ - if (path.type.$tag == PATH_RELATIVE && !(relative_to.type.$tag == PATH_RELATIVE && relative_to.components.length == 0)) { - Path_t result = {.type.$tag=relative_to.type.$tag}; +public +Path_t Path$resolved(Path_t path, Path_t relative_to) { + if (path.type.$tag == PATH_RELATIVE + && !(relative_to.type.$tag == PATH_RELATIVE && relative_to.components.length == 0)) { + Path_t result = {.type.$tag = relative_to.type.$tag}; result.components = relative_to.components; LIST_INCREF(result.components); List$insert_all(&result.components, path.components, I(0), sizeof(Text_t)); @@ -143,87 +140,86 @@ public Path_t Path$resolved(Path_t path, Path_t relative_to) return path; } -public Path_t Path$relative_to(Path_t path, Path_t relative_to) -{ +public +Path_t Path$relative_to(Path_t path, Path_t relative_to) { if (path.type.$tag != relative_to.type.$tag) - fail("Cannot create a path relative to a different path with a mismatching type: (", path, ") relative to (", relative_to, ")"); + fail("Cannot create a path relative to a different path with a mismatching type: (", path, ") relative to (", + relative_to, ")"); - Path_t result = {.type.$tag=PATH_RELATIVE}; + Path_t result = {.type.$tag = PATH_RELATIVE}; int64_t shared = 0; for (; shared < path.components.length && shared < relative_to.components.length; shared++) { - Text_t *p = (Text_t*)(path.components.data + shared*path.components.stride); - Text_t *r = (Text_t*)(relative_to.components.data + shared*relative_to.components.stride); - if (!Text$equal_values(*p, *r)) - break; + Text_t *p = (Text_t *)(path.components.data + shared * path.components.stride); + Text_t *r = (Text_t *)(relative_to.components.data + shared * relative_to.components.stride); + if (!Text$equal_values(*p, *r)) break; } for (int64_t i = shared; i < relative_to.components.length; i++) List$insert_value(&result.components, Text(".."), I(1), sizeof(Text_t)); for (int64_t i = shared; i < path.components.length; i++) { - Text_t *p = (Text_t*)(path.components.data + i*path.components.stride); + Text_t *p = (Text_t *)(path.components.data + i * path.components.stride); List$insert(&result.components, p, I(0), sizeof(Text_t)); } - //clean_components(&result.components); + // clean_components(&result.components); return result; } -public bool Path$exists(Path_t path) -{ +public +bool Path$exists(Path_t path) { path = Path$expand_home(path); struct stat sb; return (stat(Path$as_c_string(path), &sb) == 0); } -static INLINE int path_stat(Path_t path, bool follow_symlinks, struct stat *sb) -{ +static INLINE int path_stat(Path_t path, bool follow_symlinks, struct stat *sb) { path = Path$expand_home(path); const char *path_str = Path$as_c_string(path); return follow_symlinks ? stat(path_str, sb) : lstat(path_str, sb); } -public bool Path$is_file(Path_t path, bool follow_symlinks) -{ +public +bool Path$is_file(Path_t path, bool follow_symlinks) { struct stat sb; int status = path_stat(path, follow_symlinks, &sb); if (status != 0) return false; return (sb.st_mode & S_IFMT) == S_IFREG; } -public bool Path$is_directory(Path_t path, bool follow_symlinks) -{ +public +bool Path$is_directory(Path_t path, bool follow_symlinks) { struct stat sb; int status = path_stat(path, follow_symlinks, &sb); if (status != 0) return false; return (sb.st_mode & S_IFMT) == S_IFDIR; } -public bool Path$is_pipe(Path_t path, bool follow_symlinks) -{ +public +bool Path$is_pipe(Path_t path, bool follow_symlinks) { struct stat sb; int status = path_stat(path, follow_symlinks, &sb); if (status != 0) return false; return (sb.st_mode & S_IFMT) == S_IFIFO; } -public bool Path$is_socket(Path_t path, bool follow_symlinks) -{ +public +bool Path$is_socket(Path_t path, bool follow_symlinks) { struct stat sb; int status = path_stat(path, follow_symlinks, &sb); if (status != 0) return false; return (sb.st_mode & S_IFMT) == S_IFSOCK; } -public bool Path$is_symlink(Path_t path) -{ +public +bool Path$is_symlink(Path_t path) { struct stat sb; int status = path_stat(path, false, &sb); if (status != 0) return false; return (sb.st_mode & S_IFMT) == S_IFLNK; } -public bool Path$can_read(Path_t path) -{ +public +bool Path$can_read(Path_t path) { path = Path$expand_home(path); const char *path_str = Path$as_c_string(path); #ifdef _GNU_SOURCE @@ -233,8 +229,8 @@ public bool Path$can_read(Path_t path) #endif } -public bool Path$can_write(Path_t path) -{ +public +bool Path$can_write(Path_t path) { path = Path$expand_home(path); const char *path_str = Path$as_c_string(path); #ifdef _GNU_SOURCE @@ -244,8 +240,8 @@ public bool Path$can_write(Path_t path) #endif } -public bool Path$can_execute(Path_t path) -{ +public +bool Path$can_execute(Path_t path) { path = Path$expand_home(path); const char *path_str = Path$as_c_string(path); #ifdef _GNU_SOURCE @@ -255,93 +251,86 @@ public bool Path$can_execute(Path_t path) #endif } -public OptionalInt64_t Path$modified(Path_t path, bool follow_symlinks) -{ +public +OptionalInt64_t Path$modified(Path_t path, bool follow_symlinks) { struct stat sb; int status = path_stat(path, follow_symlinks, &sb); if (status != 0) return NONE_INT64; - return (OptionalInt64_t){.value=(int64_t)sb.st_mtime}; + return (OptionalInt64_t){.value = (int64_t)sb.st_mtime}; } -public OptionalInt64_t Path$accessed(Path_t path, bool follow_symlinks) -{ +public +OptionalInt64_t Path$accessed(Path_t path, bool follow_symlinks) { struct stat sb; int status = path_stat(path, follow_symlinks, &sb); if (status != 0) return NONE_INT64; - return (OptionalInt64_t){.value=(int64_t)sb.st_atime}; + return (OptionalInt64_t){.value = (int64_t)sb.st_atime}; } -public OptionalInt64_t Path$changed(Path_t path, bool follow_symlinks) -{ +public +OptionalInt64_t Path$changed(Path_t path, bool follow_symlinks) { struct stat sb; int status = path_stat(path, follow_symlinks, &sb); if (status != 0) return NONE_INT64; - return (OptionalInt64_t){.value=(int64_t)sb.st_ctime}; + return (OptionalInt64_t){.value = (int64_t)sb.st_ctime}; } -static void _write(Path_t path, List_t bytes, int mode, int permissions) -{ +static void _write(Path_t path, List_t bytes, int mode, int permissions) { path = Path$expand_home(path); const char *path_str = Path$as_c_string(path); int fd = open(path_str, mode, permissions); - if (fd == -1) - fail("Could not write to file: ", path_str, "\n", strerror(errno)); + if (fd == -1) fail("Could not write to file: ", path_str, "\n", strerror(errno)); - if (bytes.stride != 1) - List$compact(&bytes, 1); + if (bytes.stride != 1) List$compact(&bytes, 1); ssize_t written = write(fd, bytes.data, (size_t)bytes.length); - if (written != (ssize_t)bytes.length) - fail("Could not write to file: ", path_str, "\n", strerror(errno)); + if (written != (ssize_t)bytes.length) fail("Could not write to file: ", path_str, "\n", strerror(errno)); close(fd); } -public void Path$write(Path_t path, Text_t text, int permissions) -{ +public +void Path$write(Path_t path, Text_t text, int permissions) { List_t bytes = Text$utf8_bytes(text); _write(path, bytes, O_WRONLY | O_CREAT | O_TRUNC, permissions); } -public void Path$write_bytes(Path_t path, List_t bytes, int permissions) -{ +public +void Path$write_bytes(Path_t path, List_t bytes, int permissions) { _write(path, bytes, O_WRONLY | O_CREAT | O_TRUNC, permissions); } -public void Path$append(Path_t path, Text_t text, int permissions) -{ +public +void Path$append(Path_t path, Text_t text, int permissions) { List_t bytes = Text$utf8_bytes(text); _write(path, bytes, O_WRONLY | O_APPEND | O_CREAT, permissions); } -public void Path$append_bytes(Path_t path, List_t bytes, int permissions) -{ +public +void Path$append_bytes(Path_t path, List_t bytes, int permissions) { _write(path, bytes, O_WRONLY | O_APPEND | O_CREAT, permissions); } -public OptionalList_t Path$read_bytes(Path_t path, OptionalInt_t count) -{ +public +OptionalList_t Path$read_bytes(Path_t path, OptionalInt_t count) { path = Path$expand_home(path); int fd = open(Path$as_c_string(path), O_RDONLY); - if (fd == -1) - return NONE_LIST; + if (fd == -1) return NONE_LIST; struct stat sb; - if (fstat(fd, &sb) != 0) - return NONE_LIST; + if (fstat(fd, &sb) != 0) return NONE_LIST; int64_t const target_count = count.small ? Int64$from_int(count, false) : INT64_MAX; - if (target_count < 0) - fail("Cannot read a negative number of bytes!"); + if (target_count < 0) fail("Cannot read a negative number of bytes!"); if ((sb.st_mode & S_IFMT) == S_IFREG) { // Use memory mapping if it's a real file: const char *mem = mmap(NULL, (size_t)sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0); - char *content = GC_MALLOC_ATOMIC((size_t)sb.st_size+1); + char *content = GC_MALLOC_ATOMIC((size_t)sb.st_size + 1); memcpy(content, mem, (size_t)sb.st_size); content[sb.st_size] = '\0'; close(fd); if (count.small && (int64_t)sb.st_size < target_count) fail("Could not read ", target_count, " bytes from ", path, " (only got ", (uint64_t)sb.st_size, ")"); int64_t len = count.small ? target_count : (int64_t)sb.st_size; - return (List_t){.data=content, .atomic=1, .stride=1, .length=len}; + return (List_t){.data = content, .atomic = 1, .stride = 1, .length = len}; } else { size_t capacity = 256, len = 0; char *content = GC_MALLOC_ATOMIC(capacity); @@ -354,8 +343,7 @@ public OptionalList_t Path$read_bytes(Path_t path, OptionalInt_t count) close(fd); return NONE_LIST; } else if (just_read == 0) { - if (errno == EAGAIN || errno == EINTR) - continue; + if (errno == EAGAIN || errno == EINTR) continue; break; } count_remaining -= (int64_t)just_read; @@ -370,19 +358,19 @@ public OptionalList_t Path$read_bytes(Path_t path, OptionalInt_t count) close(fd); if (count.small != 0 && (int64_t)len < target_count) fail("Could not read ", target_count, " bytes from ", path, " (only got ", (uint64_t)len, ")"); - return (List_t){.data=content, .atomic=1, .stride=1, .length=(int64_t)len}; + return (List_t){.data = content, .atomic = 1, .stride = 1, .length = (int64_t)len}; } } -public OptionalText_t Path$read(Path_t path) -{ +public +OptionalText_t Path$read(Path_t path) { List_t bytes = Path$read_bytes(path, NONE_INT); if (bytes.length < 0) return NONE_TEXT; return Text$from_bytes(bytes); } -public OptionalText_t Path$owner(Path_t path, bool follow_symlinks) -{ +public +OptionalText_t Path$owner(Path_t path, bool follow_symlinks) { struct stat sb; int status = path_stat(path, follow_symlinks, &sb); if (status != 0) return NONE_TEXT; @@ -390,8 +378,8 @@ public OptionalText_t Path$owner(Path_t path, bool follow_symlinks) return pw ? Text$from_str(pw->pw_name) : NONE_TEXT; } -public OptionalText_t Path$group(Path_t path, bool follow_symlinks) -{ +public +OptionalText_t Path$group(Path_t path, bool follow_symlinks) { struct stat sb; int status = path_stat(path, follow_symlinks, &sb); if (status != 0) return NONE_TEXT; @@ -399,8 +387,8 @@ public OptionalText_t Path$group(Path_t path, bool follow_symlinks) return gr ? Text$from_str(gr->gr_name) : NONE_TEXT; } -public void Path$set_owner(Path_t path, OptionalText_t owner, OptionalText_t group, bool follow_symlinks) -{ +public +void Path$set_owner(Path_t path, OptionalText_t owner, OptionalText_t group, bool follow_symlinks) { uid_t owner_id = (uid_t)-1; if (owner.length >= 0) { struct passwd *pwd = getpwnam(Text$as_c_string(owner)); @@ -416,38 +404,34 @@ public void Path$set_owner(Path_t path, OptionalText_t owner, OptionalText_t gro } const char *path_str = Path$as_c_string(path); int result = follow_symlinks ? chown(path_str, owner_id, group_id) : lchown(path_str, owner_id, group_id); - if (result < 0) - fail("Could not set owner!"); + if (result < 0) fail("Could not set owner!"); } -static int _remove_files(const char *path, const struct stat *sbuf, int type, struct FTW *ftwb) -{ +static int _remove_files(const char *path, const struct stat *sbuf, int type, struct FTW *ftwb) { (void)sbuf, (void)ftwb; switch (type) { - case FTW_F: case FTW_SL: case FTW_SLN: + case FTW_F: + case FTW_SL: + case FTW_SLN: if (remove(path) < 0) { fail("Could not remove file: ", path, " (", strerror(errno), ")"); return -1; } return 0; case FTW_DP: - if (rmdir(path) != 0) - fail("Could not remove directory: ", path, " (", strerror(errno), ")"); + if (rmdir(path) != 0) fail("Could not remove directory: ", path, " (", strerror(errno), ")"); return 0; - default: - fail("Could not remove path: ", path, " (not a file or directory)"); - return -1; + default: fail("Could not remove path: ", path, " (not a file or directory)"); return -1; } } -public void Path$remove(Path_t path, bool ignore_missing) -{ +public +void Path$remove(Path_t path, bool ignore_missing) { path = Path$expand_home(path); const char *path_str = Path$as_c_string(path); struct stat sb; if (lstat(path_str, &sb) != 0) { - if (!ignore_missing) - fail("Could not remove file: ", path_str, " (", strerror(errno), ")"); + if (!ignore_missing) fail("Could not remove file: ", path_str, " (", strerror(errno), ")"); return; } @@ -456,48 +440,40 @@ public void Path$remove(Path_t path, bool ignore_missing) fail("Could not remove file: ", path_str, " (", strerror(errno), ")"); } else if ((sb.st_mode & S_IFMT) == S_IFDIR) { const int num_open_fd = 10; - if (nftw(path_str, _remove_files, num_open_fd, FTW_DEPTH|FTW_MOUNT|FTW_PHYS) < 0) + if (nftw(path_str, _remove_files, num_open_fd, FTW_DEPTH | FTW_MOUNT | FTW_PHYS) < 0) fail("Could not remove directory: %s (%s)", path_str, strerror(errno)); } else { fail("Could not remove path: ", path_str, " (not a file or directory)"); } } -public void Path$create_directory(Path_t path, int permissions) -{ +public +void Path$create_directory(Path_t path, int permissions) { path = Path$expand_home(path); const char *c_path = Path$as_c_string(path); int status = mkdir(c_path, (mode_t)permissions); - if (status != 0 && errno != EEXIST) - fail("Could not create directory: ", c_path, " (", strerror(errno), ")"); + if (status != 0 && errno != EEXIST) fail("Could not create directory: ", c_path, " (", strerror(errno), ")"); } -static List_t _filtered_children(Path_t path, bool include_hidden, mode_t filter) -{ +static List_t _filtered_children(Path_t path, bool include_hidden, mode_t filter) { path = Path$expand_home(path); struct dirent *dir; List_t children = {}; const char *path_str = Path$as_c_string(path); size_t path_len = strlen(path_str); DIR *d = opendir(path_str); - if (!d) - fail("Could not open directory: ", path, " (", strerror(errno), ")"); + if (!d) fail("Could not open directory: ", path, " (", strerror(errno), ")"); - if (path_str[path_len-1] == '/') - --path_len; + if (path_str[path_len - 1] == '/') --path_len; while ((dir = readdir(d)) != NULL) { - if (!include_hidden && dir->d_name[0] == '.') - continue; - if (streq(dir->d_name, ".") || streq(dir->d_name, "..")) - continue; + if (!include_hidden && dir->d_name[0] == '.') continue; + if (streq(dir->d_name, ".") || streq(dir->d_name, "..")) continue; const char *child_str = String(string_slice(path_str, path_len), "/", dir->d_name); struct stat sb; - if (stat(child_str, &sb) != 0) - continue; - if (!((sb.st_mode & S_IFMT) & filter)) - continue; + if (stat(child_str, &sb) != 0) continue; + if (!((sb.st_mode & S_IFMT) & filter)) continue; Path_t child = Path$from_str(child_str); List$insert(&children, &child, I(0), sizeof(Path_t)); @@ -506,23 +482,19 @@ static List_t _filtered_children(Path_t path, bool include_hidden, mode_t filter return children; } -public List_t Path$children(Path_t path, bool include_hidden) -{ - return _filtered_children(path, include_hidden, (mode_t)-1); -} +public +List_t Path$children(Path_t path, bool include_hidden) { return _filtered_children(path, include_hidden, (mode_t)-1); } -public List_t Path$files(Path_t path, bool include_hidden) -{ - return _filtered_children(path, include_hidden, S_IFREG); -} +public +List_t Path$files(Path_t path, bool include_hidden) { return _filtered_children(path, include_hidden, S_IFREG); } -public List_t Path$subdirectories(Path_t path, bool include_hidden) -{ +public +List_t Path$subdirectories(Path_t path, bool include_hidden) { return _filtered_children(path, include_hidden, S_IFDIR); } -public Path_t Path$unique_directory(Path_t path) -{ +public +Path_t Path$unique_directory(Path_t path) { path = Path$expand_home(path); const char *path_str = Path$as_c_string(path); size_t len = strlen(path_str); @@ -530,15 +502,14 @@ public Path_t Path$unique_directory(Path_t path) char buf[PATH_MAX] = {}; memcpy(buf, path_str, len); buf[len] = '\0'; - if (buf[len-1] == '/') - buf[--len] = '\0'; + if (buf[len - 1] == '/') buf[--len] = '\0'; char *created = mkdtemp(buf); if (!created) fail("Failed to create temporary directory: ", path_str, " (", strerror(errno), ")"); return Path$from_str(created); } -public Path_t Path$write_unique_bytes(Path_t path, List_t bytes) -{ +public +Path_t Path$write_unique_bytes(Path_t path, List_t bytes) { path = Path$expand_home(path); const char *path_str = Path$as_c_string(path); size_t len = strlen(path_str); @@ -554,82 +525,73 @@ public Path_t Path$write_unique_bytes(Path_t path, List_t bytes) ++suffixlen; int fd = mkstemps(buf, suffixlen); - if (fd == -1) - fail("Could not write to unique file: ", buf, "\n", strerror(errno)); + if (fd == -1) fail("Could not write to unique file: ", buf, "\n", strerror(errno)); - if (bytes.stride != 1) - List$compact(&bytes, 1); + if (bytes.stride != 1) List$compact(&bytes, 1); ssize_t written = write(fd, bytes.data, (size_t)bytes.length); - if (written != (ssize_t)bytes.length) - fail("Could not write to file: ", buf, "\n", strerror(errno)); + if (written != (ssize_t)bytes.length) fail("Could not write to file: ", buf, "\n", strerror(errno)); close(fd); return Path$from_str(buf); } -public Path_t Path$write_unique(Path_t path, Text_t text) -{ - return Path$write_unique_bytes(path, Text$utf8_bytes(text)); -} +public +Path_t Path$write_unique(Path_t path, Text_t text) { return Path$write_unique_bytes(path, Text$utf8_bytes(text)); } -public Path_t Path$parent(Path_t path) -{ +public +Path_t Path$parent(Path_t path) { if (path.type.$tag == PATH_ABSOLUTE && path.components.length == 0) { return path; - } else if (path.components.length > 0 && !Text$equal_values(*(Text_t*)(path.components.data + path.components.stride*(path.components.length-1)), - Text(".."))) { - return (Path_t){.type.$tag=path.type.$tag, .components=List$slice(path.components, I(1), I(-2))}; + } else if (path.components.length > 0 + && !Text$equal_values( + *(Text_t *)(path.components.data + path.components.stride * (path.components.length - 1)), + Text(".."))) { + return (Path_t){.type.$tag = path.type.$tag, .components = List$slice(path.components, I(1), I(-2))}; } else { - Path_t result = {.type.$tag=path.type.$tag, .components=path.components}; + Path_t result = {.type.$tag = path.type.$tag, .components = path.components}; LIST_INCREF(result.components); List$insert_value(&result.components, Text(".."), I(0), sizeof(Text_t)); return result; } } -public PUREFUNC Text_t Path$base_name(Path_t path) -{ +public +PUREFUNC Text_t Path$base_name(Path_t path) { if (path.components.length >= 1) - return *(Text_t*)(path.components.data + path.components.stride*(path.components.length-1)); - else if (path.type.$tag == PATH_HOME) - return Text("~"); - else if (path.type.$tag == PATH_RELATIVE) - return Text("."); - else - return EMPTY_TEXT; + return *(Text_t *)(path.components.data + path.components.stride * (path.components.length - 1)); + else if (path.type.$tag == PATH_HOME) return Text("~"); + else if (path.type.$tag == PATH_RELATIVE) return Text("."); + else return EMPTY_TEXT; } -public Text_t Path$extension(Path_t path, bool full) -{ +public +Text_t Path$extension(Path_t path, bool full) { const char *base = Text$as_c_string(Path$base_name(path)); const char *dot = full ? strchr(base + 1, '.') : strrchr(base + 1, '.'); const char *extension = dot ? dot + 1 : ""; return Text$from_str(extension); } -public bool Path$has_extension(Path_t path, Text_t extension) -{ - if (path.components.length < 2) - return extension.length == 0; +public +bool Path$has_extension(Path_t path, Text_t extension) { + if (path.components.length < 2) return extension.length == 0; - Text_t last = *(Text_t*)(path.components.data + path.components.stride*(path.components.length-1)); + Text_t last = *(Text_t *)(path.components.data + path.components.stride * (path.components.length - 1)); if (extension.length == 0) return !Text$has(Text$from(last, I(2)), Text(".")) || Text$equal_values(last, Text("..")); - if (!Text$starts_with(extension, Text("."), NULL)) - extension = Texts(Text("."), extension); + if (!Text$starts_with(extension, Text("."), NULL)) extension = Texts(Text("."), extension); return Text$ends_with(Text$from(last, I(2)), extension, NULL); } -public Path_t Path$child(Path_t path, Text_t name) -{ - if (Text$has(name, Text("/")) || Text$has(name, Text(";"))) - fail("Path name has invalid characters: ", name); +public +Path_t Path$child(Path_t path, Text_t name) { + if (Text$has(name, Text("/")) || Text$has(name, Text(";"))) fail("Path name has invalid characters: ", name); Path_t result = { - .type.$tag=path.type.$tag, - .components=path.components, + .type.$tag = path.type.$tag, + .components = path.components, }; LIST_INCREF(result.components); List$insert(&result.components, &name, I(0), sizeof(Text_t)); @@ -637,31 +599,27 @@ public Path_t Path$child(Path_t path, Text_t name) return result; } -public Path_t Path$sibling(Path_t path, Text_t name) -{ - return Path$child(Path$parent(path), name); -} +public +Path_t Path$sibling(Path_t path, Text_t name) { return Path$child(Path$parent(path), name); } -public Path_t Path$with_extension(Path_t path, Text_t extension, bool replace) -{ - if (path.components.length == 0) - fail("A path with no components can't have an extension!"); +public +Path_t Path$with_extension(Path_t path, Text_t extension, bool replace) { + if (path.components.length == 0) fail("A path with no components can't have an extension!"); if (Text$has(extension, Text("/")) || Text$has(extension, Text(";"))) fail("Path extension has invalid characters: ", extension); Path_t result = { - .type.$tag=path.type.$tag, - .components=path.components, + .type.$tag = path.type.$tag, + .components = path.components, }; LIST_INCREF(result.components); - Text_t last = *(Text_t*)(path.components.data + path.components.stride*(path.components.length-1)); + Text_t last = *(Text_t *)(path.components.data + path.components.stride * (path.components.length - 1)); List$remove_at(&result.components, I(-1), I(1), sizeof(Text_t)); if (replace) { const char *base = Text$as_c_string(last); const char *dot = strchr(base + 1, '.'); - if (dot) - last = Text$from_strn(base, (size_t)(dot - base)); + if (dot) last = Text$from_strn(base, (size_t)(dot - base)); } last = Text$concat(last, extension); @@ -669,16 +627,14 @@ public Path_t Path$with_extension(Path_t path, Text_t extension, bool replace) return result; } -static void _line_reader_cleanup(FILE **f) -{ +static void _line_reader_cleanup(FILE **f) { if (f && *f) { fclose(*f); *f = NULL; } } -static Text_t _next_line(FILE **f) -{ +static Text_t _next_line(FILE **f) { if (!f || !*f) return NONE_TEXT; char *line = NULL; @@ -689,43 +645,41 @@ static Text_t _next_line(FILE **f) return NONE_TEXT; } - while (len > 0 && (line[len-1] == '\r' || line[len-1] == '\n')) + while (len > 0 && (line[len - 1] == '\r' || line[len - 1] == '\n')) --len; - if (u8_check((uint8_t*)line, (size_t)len) != NULL) - fail("Invalid UTF8!"); + if (u8_check((uint8_t *)line, (size_t)len) != NULL) fail("Invalid UTF8!"); Text_t line_text = Text$from_strn(line, (size_t)len); free(line); return line_text; } -public OptionalClosure_t Path$by_line(Path_t path) -{ +public +OptionalClosure_t Path$by_line(Path_t path) { path = Path$expand_home(path); FILE *f = fopen(Path$as_c_string(path), "r"); - if (f == NULL) - return NONE_CLOSURE; + if (f == NULL) return NONE_CLOSURE; - FILE **wrapper = GC_MALLOC(sizeof(FILE*)); + FILE **wrapper = GC_MALLOC(sizeof(FILE *)); *wrapper = f; - GC_register_finalizer(wrapper, (void*)_line_reader_cleanup, NULL, NULL, NULL); - return (Closure_t){.fn=(void*)_next_line, .userdata=wrapper}; + GC_register_finalizer(wrapper, (void *)_line_reader_cleanup, NULL, NULL, NULL); + return (Closure_t){.fn = (void *)_next_line, .userdata = wrapper}; } -public List_t Path$glob(Path_t path) -{ +public +List_t Path$glob(Path_t path) { glob_t glob_result; int status = glob(Path$as_c_string(path), GLOB_BRACE | GLOB_TILDE, NULL, &glob_result); - if (status != 0 && status != GLOB_NOMATCH) - fail("Failed to perform globbing"); + if (status != 0 && status != GLOB_NOMATCH) fail("Failed to perform globbing"); List_t glob_files = {}; for (size_t i = 0; i < glob_result.gl_pathc; i++) { size_t len = strlen(glob_result.gl_pathv[i]); - if ((len >= 2 && glob_result.gl_pathv[i][len-1] == '.' && glob_result.gl_pathv[i][len-2] == '/') - || (len >= 2 && glob_result.gl_pathv[i][len-1] == '.' && glob_result.gl_pathv[i][len-2] == '.' && glob_result.gl_pathv[i][len-3] == '/')) + if ((len >= 2 && glob_result.gl_pathv[i][len - 1] == '.' && glob_result.gl_pathv[i][len - 2] == '/') + || (len >= 2 && glob_result.gl_pathv[i][len - 1] == '.' && glob_result.gl_pathv[i][len - 2] == '.' + && glob_result.gl_pathv[i][len - 3] == '/')) continue; Path_t p = Path$from_str(glob_result.gl_pathv[i]); List$insert(&glob_files, &p, I(0), sizeof(Path_t)); @@ -733,52 +687,51 @@ public List_t Path$glob(Path_t path) return glob_files; } -public Path_t Path$current_dir(void) -{ +public +Path_t Path$current_dir(void) { char cwd[PATH_MAX]; - if (getcwd(cwd, sizeof(cwd)) == NULL) - fail("Could not get current working directory"); + if (getcwd(cwd, sizeof(cwd)) == NULL) fail("Could not get current working directory"); return Path$from_str(cwd); } -public PUREFUNC uint64_t Path$hash(const void *obj, const TypeInfo_t *type) -{ +public +PUREFUNC uint64_t Path$hash(const void *obj, const TypeInfo_t *type) { (void)type; - Path_t *path = (Path_t*)obj; + Path_t *path = (Path_t *)obj; siphash sh; siphashinit(&sh, (uint64_t)path->type.$tag); for (int64_t i = 0; i < path->components.length; i++) { - uint64_t item_hash = Text$hash(path->components.data + i*path->components.stride, &Text$info); + uint64_t item_hash = Text$hash(path->components.data + i * path->components.stride, &Text$info); siphashadd64bits(&sh, item_hash); } return siphashfinish_last_part(&sh, (uint64_t)path->components.length); } -public PUREFUNC int32_t Path$compare(const void *va, const void *vb, const TypeInfo_t *type) -{ +public +PUREFUNC int32_t Path$compare(const void *va, const void *vb, const TypeInfo_t *type) { (void)type; - Path_t *a = (Path_t*)va, *b = (Path_t*)vb; + Path_t *a = (Path_t *)va, *b = (Path_t *)vb; int diff = ((int)a->type.$tag - (int)b->type.$tag); if (diff != 0) return diff; return List$compare(&a->components, &b->components, List$info(&Text$info)); } -public PUREFUNC bool Path$equal(const void *va, const void *vb, const TypeInfo_t *type) -{ +public +PUREFUNC bool Path$equal(const void *va, const void *vb, const TypeInfo_t *type) { (void)type; - Path_t *a = (Path_t*)va, *b = (Path_t*)vb; + Path_t *a = (Path_t *)va, *b = (Path_t *)vb; if (a->type.$tag != b->type.$tag) return false; return List$equal(&a->components, &b->components, List$info(&Text$info)); } -public PUREFUNC bool Path$equal_values(Path_t a, Path_t b) -{ +public +PUREFUNC bool Path$equal_values(Path_t a, Path_t b) { if (a.type.$tag != b.type.$tag) return false; return List$equal(&a.components, &b.components, List$info(&Text$info)); } -public int Path$print(FILE *f, Path_t path) -{ +public +int Path$print(FILE *f, Path_t path) { if (path.components.length == 0) { if (path.type.$tag == PATH_ABSOLUTE) return fputs("/", f); else if (path.type.$tag == PATH_RELATIVE) return fputs(".", f); @@ -791,91 +744,86 @@ public int Path$print(FILE *f, Path_t path) } else if (path.type.$tag == PATH_HOME) { n += fputs("~/", f); } else if (path.type.$tag == PATH_RELATIVE) { - if (!Text$equal_values(*(Text_t*)path.components.data, Text(".."))) - n += fputs("./", f); + if (!Text$equal_values(*(Text_t *)path.components.data, Text(".."))) n += fputs("./", f); } for (int64_t i = 0; i < path.components.length; i++) { - Text_t *comp = (Text_t*)(path.components.data + i*path.components.stride); + Text_t *comp = (Text_t *)(path.components.data + i * path.components.stride); n += Text$print(f, *comp); - if (i + 1 < path.components.length) - n += fputc('/', f); + if (i + 1 < path.components.length) n += fputc('/', f); } return n; } -public const char *Path$as_c_string(Path_t path) -{ - return String(path); -} +public +const char *Path$as_c_string(Path_t path) { return String(path); } -public Text_t Path$as_text(const void *obj, bool color, const TypeInfo_t *type) -{ +public +Text_t Path$as_text(const void *obj, bool color, const TypeInfo_t *type) { (void)type; if (!obj) return Text("Path"); - Path_t *path = (Path_t*)obj; + Path_t *path = (Path_t *)obj; Text_t text = Text$join(Text("/"), path->components); - if (path->type.$tag == PATH_HOME) - text = Text$concat(path->components.length > 0 ? Text("~/") : Text("~"), text); - else if (path->type.$tag == PATH_ABSOLUTE) - text = Text$concat(Text("/"), text); - else if (path->type.$tag == PATH_RELATIVE && (path->components.length == 0 || !Text$equal_values(*(Text_t*)(path->components.data), Text("..")))) + if (path->type.$tag == PATH_HOME) text = Text$concat(path->components.length > 0 ? Text("~/") : Text("~"), text); + else if (path->type.$tag == PATH_ABSOLUTE) text = Text$concat(Text("/"), text); + else if (path->type.$tag == PATH_RELATIVE + && (path->components.length == 0 || !Text$equal_values(*(Text_t *)(path->components.data), Text("..")))) text = Text$concat(path->components.length > 0 ? Text("./") : Text("."), text); - if (color) - text = Texts(Text("\033[32;1m"), text, Text("\033[m")); + if (color) text = Texts(Text("\033[32;1m"), text, Text("\033[m")); return text; } -public CONSTFUNC bool Path$is_none(const void *obj, const TypeInfo_t *type) -{ +public +CONSTFUNC bool Path$is_none(const void *obj, const TypeInfo_t *type) { (void)type; - return ((Path_t*)obj)->type.$tag == PATH_NONE; + return ((Path_t *)obj)->type.$tag == PATH_NONE; } -public void Path$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) -{ +public +void Path$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) { (void)type; - Path_t *path = (Path_t*)obj; + Path_t *path = (Path_t *)obj; fputc((int)path->type.$tag, out); List$serialize(&path->components, out, pointers, List$info(&Text$info)); } -public void Path$deserialize(FILE *in, void *obj, List_t *pointers, const TypeInfo_t *type) -{ +public +void Path$deserialize(FILE *in, void *obj, List_t *pointers, const TypeInfo_t *type) { (void)type; Path_t path = {}; path.type.$tag = fgetc(in); List$deserialize(in, &path.components, pointers, List$info(&Text$info)); - *(Path_t*)obj = path; -} - -public const TypeInfo_t Path$info = { - .size=sizeof(Path_t), - .align=__alignof__(Path_t), - .tag=OpaqueInfo, - .metamethods={ - .as_text=Path$as_text, - .hash=Path$hash, - .compare=Path$compare, - .equal=Path$equal, - .is_none=Path$is_none, - .serialize=Path$serialize, - .deserialize=Path$deserialize, - } -}; - -public const TypeInfo_t PathType$info = { - .size=sizeof(PathType_t), - .align=__alignof__(PathType_t), - .metamethods=PackedDataEnum$metamethods, - .tag=EnumInfo, - .EnumInfo={ - .name="PathType", - .num_tags=3, - .tags=((NamedType_t[3]){{.name="Relative"}, {.name="Absolute"}, {.name="Home"}}), - }, + *(Path_t *)obj = path; +} + +public +const TypeInfo_t Path$info = {.size = sizeof(Path_t), + .align = __alignof__(Path_t), + .tag = OpaqueInfo, + .metamethods = { + .as_text = Path$as_text, + .hash = Path$hash, + .compare = Path$compare, + .equal = Path$equal, + .is_none = Path$is_none, + .serialize = Path$serialize, + .deserialize = Path$deserialize, + }}; + +public +const TypeInfo_t PathType$info = { + .size = sizeof(PathType_t), + .align = __alignof__(PathType_t), + .metamethods = PackedDataEnum$metamethods, + .tag = EnumInfo, + .EnumInfo = + { + .name = "PathType", + .num_tags = 3, + .tags = ((NamedType_t[3]){{.name = "Relative"}, {.name = "Absolute"}, {.name = "Home"}}), + }, }; // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/paths.h b/src/stdlib/paths.h index 6284e55b..7f0d8830 100644 --- a/src/stdlib/paths.h +++ b/src/stdlib/paths.h @@ -15,7 +15,7 @@ Path_t Path$from_text(Text_t text); const char *Path$as_c_string(Path_t path); #define Path(str) Path$from_str(str) Path_t Path$_concat(int n, Path_t items[n]); -#define Path$concat(...) Path$_concat((int)sizeof((Path_t[]){__VA_ARGS__})/sizeof(Path_t), ((Path_t[]){__VA_ARGS__})) +#define Path$concat(...) Path$_concat((int)sizeof((Path_t[]){__VA_ARGS__}) / sizeof(Path_t), ((Path_t[]){__VA_ARGS__})) Path_t Path$resolved(Path_t path, Path_t relative_to); Path_t Path$relative_to(Path_t path, Path_t relative_to); Path_t Path$expand_home(Path_t path); @@ -59,7 +59,7 @@ Path_t Path$current_dir(void); Closure_t Path$by_line(Path_t path); List_t Path$glob(Path_t path); -uint64_t Path$hash(const void *obj, const TypeInfo_t*); +uint64_t Path$hash(const void *obj, const TypeInfo_t *); int32_t Path$compare(const void *a, const void *b, const TypeInfo_t *type); bool Path$equal(const void *a, const void *b, const TypeInfo_t *type); bool Path$equal_values(Path_t a, Path_t b); @@ -72,4 +72,3 @@ extern const TypeInfo_t Path$info; extern const TypeInfo_t PathType$info; // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 - diff --git a/src/stdlib/pointers.c b/src/stdlib/pointers.c index 3708da62..e94ede6d 100644 --- a/src/stdlib/pointers.c +++ b/src/stdlib/pointers.c @@ -13,22 +13,19 @@ #include "types.h" #include "util.h" -public Text_t Pointer$as_text(const void *x, bool colorize, const TypeInfo_t *type) { +public +Text_t Pointer$as_text(const void *x, bool colorize, const TypeInfo_t *type) { __typeof(type->PointerInfo) ptr_info = type->PointerInfo; if (!x) { Text_t typename = generic_as_text(NULL, false, ptr_info.pointed); - if (colorize) - return Text$concat(Text("\x1b[34;1m"), Text$from_str(ptr_info.sigil), typename, Text("\x1b[m")); - else - return Text$concat(Text$from_str(ptr_info.sigil), typename); + if (colorize) return Text$concat(Text("\x1b[34;1m"), Text$from_str(ptr_info.sigil), typename, Text("\x1b[m")); + else return Text$concat(Text$from_str(ptr_info.sigil), typename); } - const void *ptr = *(const void**)x; + const void *ptr = *(const void **)x; if (!ptr) { Text_t typename = generic_as_text(NULL, false, ptr_info.pointed); - if (colorize) - return Text$concat(Text("\x1b[34;1m!"), typename, Text("\x1b[m")); - else - return Text$concat(Text("!"), typename); + if (colorize) return Text$concat(Text("\x1b[34;1m!"), typename, Text("\x1b[m")); + else return Text$concat(Text("!"), typename); } static const void *root = NULL; @@ -61,38 +58,38 @@ public Text_t Pointer$as_text(const void *x, bool colorize, const TypeInfo_t *ty } Text_t text; - if (colorize) - text = Text$concat(Text("\x1b[34;1m"), Text$from_str(ptr_info.sigil), Text("\x1b[m"), pointed); - else - text = Text$concat(Text$from_str(ptr_info.sigil), pointed); + if (colorize) text = Text$concat(Text("\x1b[34;1m"), Text$from_str(ptr_info.sigil), Text("\x1b[m"), pointed); + else text = Text$concat(Text$from_str(ptr_info.sigil), pointed); return text; } PUREFUNC public int32_t Pointer$compare(const void *x, const void *y, const TypeInfo_t *info) { (void)info; - const void *xp = *(const void**)x, *yp = *(const void**)y; + const void *xp = *(const void **)x, *yp = *(const void **)y; return (xp > yp) - (xp < yp); } PUREFUNC public bool Pointer$equal(const void *x, const void *y, const TypeInfo_t *info) { (void)info; - const void *xp = *(const void**)x, *yp = *(const void**)y; + const void *xp = *(const void **)x, *yp = *(const void **)y; return xp == yp; } -PUREFUNC public bool Pointer$is_none(const void *x, const TypeInfo_t *info) -{ +PUREFUNC public bool Pointer$is_none(const void *x, const TypeInfo_t *info) { (void)info; - return *(void**)x == NULL; + return *(void **)x == NULL; } -public void Pointer$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) -{ - void *ptr = *(void**)obj; +public +void Pointer$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) { + void *ptr = *(void **)obj; assert(ptr != NULL); - const TypeInfo_t ptr_to_int_table = {.size=sizeof(Table_t), .align=__alignof__(Table_t), - .tag=TableInfo, .TableInfo.key=type, .TableInfo.value=&Int64$info}; + const TypeInfo_t ptr_to_int_table = {.size = sizeof(Table_t), + .align = __alignof__(Table_t), + .tag = TableInfo, + .TableInfo.key = type, + .TableInfo.value = &Int64$info}; int64_t *id_ptr = Table$get(*pointers, &ptr, &ptr_to_int_table); int64_t id; @@ -105,23 +102,22 @@ public void Pointer$serialize(const void *obj, FILE *out, Table_t *pointers, con Int64$serialize(&id, out, pointers, &Int64$info); - if (!id_ptr) - _serialize(ptr, out, pointers, type->PointerInfo.pointed); + if (!id_ptr) _serialize(ptr, out, pointers, type->PointerInfo.pointed); } -public void Pointer$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *type) -{ +public +void Pointer$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *type) { int64_t id = 0; Int64$deserialize(in, &id, pointers, &Int64$info); assert(id != 0); if (id > pointers->length) { void *obj = GC_MALLOC((size_t)type->PointerInfo.pointed->size); - List$insert(pointers, &obj, I(0), sizeof(void*)); + List$insert(pointers, &obj, I(0), sizeof(void *)); _deserialize(in, obj, pointers, type->PointerInfo.pointed); - *(void**)outval = obj; + *(void **)outval = obj; } else { - *(void**)outval = *(void**)(pointers->data + (id-1)*pointers->stride); + *(void **)outval = *(void **)(pointers->data + (id - 1) * pointers->stride); } } diff --git a/src/stdlib/pointers.h b/src/stdlib/pointers.h index 001dc5ce..522a97be 100644 --- a/src/stdlib/pointers.h +++ b/src/stdlib/pointers.h @@ -12,25 +12,33 @@ Text_t Pointer$as_text(const void *x, bool colorize, const TypeInfo_t *type); PUREFUNC int32_t Pointer$compare(const void *x, const void *y, const TypeInfo_t *type); PUREFUNC bool Pointer$equal(const void *x, const void *y, const TypeInfo_t *type); -PUREFUNC bool Pointer$is_none(const void *x, const TypeInfo_t*); +PUREFUNC bool Pointer$is_none(const void *x, const TypeInfo_t *); void Pointer$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type); void Pointer$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *type); -#define Null(t) (t*)NULL -#define POINTER_TYPE(_sigil, _pointed) (&(TypeInfo_t){\ - .size=sizeof(void*), .align=__alignof__(void*), .tag=PointerInfo, .PointerInfo.sigil=_sigil, .PointerInfo.pointed=_pointed}) - -#define Pointer$metamethods { \ - .as_text=Pointer$as_text, \ - .compare=Pointer$compare, \ - .equal=Pointer$equal, \ - .is_none=Pointer$is_none, \ - .serialize=Pointer$serialize, \ - .deserialize=Pointer$deserialize, \ -} - -#define Pointer$info(sigil_expr, pointed_info) &((TypeInfo_t){.size=sizeof(void*), .align=__alignof__(void*), \ - .tag=PointerInfo, .PointerInfo={.sigil=sigil_expr, .pointed=pointed_info}, \ - .metamethods=Pointer$metamethods}) +#define Null(t) (t *)NULL +#define POINTER_TYPE(_sigil, _pointed) \ + (&(TypeInfo_t){.size = sizeof(void *), \ + .align = __alignof__(void *), \ + .tag = PointerInfo, \ + .PointerInfo.sigil = _sigil, \ + .PointerInfo.pointed = _pointed}) + +#define Pointer$metamethods \ + { \ + .as_text = Pointer$as_text, \ + .compare = Pointer$compare, \ + .equal = Pointer$equal, \ + .is_none = Pointer$is_none, \ + .serialize = Pointer$serialize, \ + .deserialize = Pointer$deserialize, \ + } + +#define Pointer$info(sigil_expr, pointed_info) \ + &((TypeInfo_t){.size = sizeof(void *), \ + .align = __alignof__(void *), \ + .tag = PointerInfo, \ + .PointerInfo = {.sigil = sigil_expr, .pointed = pointed_info}, \ + .metamethods = Pointer$metamethods}) // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/powers.h b/src/stdlib/powers.h index d1829b60..e9b6a74e 100644 --- a/src/stdlib/powers.h +++ b/src/stdlib/powers.h @@ -4,13 +4,12 @@ #include <stdint.h> -#define npowers 87 -#define steppowers 8 +#define npowers 87 +#define steppowers 8 #define firstpower -348 /* 10 ^ -348 */ -#define expmax -32 -#define expmin -60 - +#define expmax -32 +#define expmin -60 typedef struct Fp { uint64_t frac; @@ -18,54 +17,37 @@ typedef struct Fp { } Fp; static const Fp powers_ten[] = { - { 18054884314459144840U, -1220 }, { 13451937075301367670U, -1193 }, - { 10022474136428063862U, -1166 }, { 14934650266808366570U, -1140 }, - { 11127181549972568877U, -1113 }, { 16580792590934885855U, -1087 }, - { 12353653155963782858U, -1060 }, { 18408377700990114895U, -1034 }, - { 13715310171984221708U, -1007 }, { 10218702384817765436U, -980 }, - { 15227053142812498563U, -954 }, { 11345038669416679861U, -927 }, - { 16905424996341287883U, -901 }, { 12595523146049147757U, -874 }, - { 9384396036005875287U, -847 }, { 13983839803942852151U, -821 }, - { 10418772551374772303U, -794 }, { 15525180923007089351U, -768 }, - { 11567161174868858868U, -741 }, { 17236413322193710309U, -715 }, - { 12842128665889583758U, -688 }, { 9568131466127621947U, -661 }, - { 14257626930069360058U, -635 }, { 10622759856335341974U, -608 }, - { 15829145694278690180U, -582 }, { 11793632577567316726U, -555 }, - { 17573882009934360870U, -529 }, { 13093562431584567480U, -502 }, - { 9755464219737475723U, -475 }, { 14536774485912137811U, -449 }, - { 10830740992659433045U, -422 }, { 16139061738043178685U, -396 }, - { 12024538023802026127U, -369 }, { 17917957937422433684U, -343 }, - { 13349918974505688015U, -316 }, { 9946464728195732843U, -289 }, - { 14821387422376473014U, -263 }, { 11042794154864902060U, -236 }, - { 16455045573212060422U, -210 }, { 12259964326927110867U, -183 }, - { 18268770466636286478U, -157 }, { 13611294676837538539U, -130 }, - { 10141204801825835212U, -103 }, { 15111572745182864684U, -77 }, - { 11258999068426240000U, -50 }, { 16777216000000000000U, -24 }, - { 12500000000000000000U, 3 }, { 9313225746154785156U, 30 }, - { 13877787807814456755U, 56 }, { 10339757656912845936U, 83 }, - { 15407439555097886824U, 109 }, { 11479437019748901445U, 136 }, - { 17105694144590052135U, 162 }, { 12744735289059618216U, 189 }, - { 9495567745759798747U, 216 }, { 14149498560666738074U, 242 }, - { 10542197943230523224U, 269 }, { 15709099088952724970U, 295 }, - { 11704190886730495818U, 322 }, { 17440603504673385349U, 348 }, - { 12994262207056124023U, 375 }, { 9681479787123295682U, 402 }, - { 14426529090290212157U, 428 }, { 10748601772107342003U, 455 }, - { 16016664761464807395U, 481 }, { 11933345169920330789U, 508 }, - { 17782069995880619868U, 534 }, { 13248674568444952270U, 561 }, - { 9871031767461413346U, 588 }, { 14708983551653345445U, 614 }, - { 10959046745042015199U, 641 }, { 16330252207878254650U, 667 }, - { 12166986024289022870U, 694 }, { 18130221999122236476U, 720 }, - { 13508068024458167312U, 747 }, { 10064294952495520794U, 774 }, - { 14996968138956309548U, 800 }, { 11173611982879273257U, 827 }, - { 16649979327439178909U, 853 }, { 12405201291620119593U, 880 }, - { 9242595204427927429U, 907 }, { 13772540099066387757U, 933 }, - { 10261342003245940623U, 960 }, { 15290591125556738113U, 986 }, - { 11392378155556871081U, 1013 }, { 16975966327722178521U, 1039 }, - { 12648080533535911531U, 1066 } -}; + {18054884314459144840U, -1220}, {13451937075301367670U, -1193}, {10022474136428063862U, -1166}, + {14934650266808366570U, -1140}, {11127181549972568877U, -1113}, {16580792590934885855U, -1087}, + {12353653155963782858U, -1060}, {18408377700990114895U, -1034}, {13715310171984221708U, -1007}, + {10218702384817765436U, -980}, {15227053142812498563U, -954}, {11345038669416679861U, -927}, + {16905424996341287883U, -901}, {12595523146049147757U, -874}, {9384396036005875287U, -847}, + {13983839803942852151U, -821}, {10418772551374772303U, -794}, {15525180923007089351U, -768}, + {11567161174868858868U, -741}, {17236413322193710309U, -715}, {12842128665889583758U, -688}, + {9568131466127621947U, -661}, {14257626930069360058U, -635}, {10622759856335341974U, -608}, + {15829145694278690180U, -582}, {11793632577567316726U, -555}, {17573882009934360870U, -529}, + {13093562431584567480U, -502}, {9755464219737475723U, -475}, {14536774485912137811U, -449}, + {10830740992659433045U, -422}, {16139061738043178685U, -396}, {12024538023802026127U, -369}, + {17917957937422433684U, -343}, {13349918974505688015U, -316}, {9946464728195732843U, -289}, + {14821387422376473014U, -263}, {11042794154864902060U, -236}, {16455045573212060422U, -210}, + {12259964326927110867U, -183}, {18268770466636286478U, -157}, {13611294676837538539U, -130}, + {10141204801825835212U, -103}, {15111572745182864684U, -77}, {11258999068426240000U, -50}, + {16777216000000000000U, -24}, {12500000000000000000U, 3}, {9313225746154785156U, 30}, + {13877787807814456755U, 56}, {10339757656912845936U, 83}, {15407439555097886824U, 109}, + {11479437019748901445U, 136}, {17105694144590052135U, 162}, {12744735289059618216U, 189}, + {9495567745759798747U, 216}, {14149498560666738074U, 242}, {10542197943230523224U, 269}, + {15709099088952724970U, 295}, {11704190886730495818U, 322}, {17440603504673385349U, 348}, + {12994262207056124023U, 375}, {9681479787123295682U, 402}, {14426529090290212157U, 428}, + {10748601772107342003U, 455}, {16016664761464807395U, 481}, {11933345169920330789U, 508}, + {17782069995880619868U, 534}, {13248674568444952270U, 561}, {9871031767461413346U, 588}, + {14708983551653345445U, 614}, {10959046745042015199U, 641}, {16330252207878254650U, 667}, + {12166986024289022870U, 694}, {18130221999122236476U, 720}, {13508068024458167312U, 747}, + {10064294952495520794U, 774}, {14996968138956309548U, 800}, {11173611982879273257U, 827}, + {16649979327439178909U, 853}, {12405201291620119593U, 880}, {9242595204427927429U, 907}, + {13772540099066387757U, 933}, {10261342003245940623U, 960}, {15290591125556738113U, 986}, + {11392378155556871081U, 1013}, {16975966327722178521U, 1039}, {12648080533535911531U, 1066}}; -static Fp find_cachedpow10(int exp, int* k) -{ +static Fp find_cachedpow10(int exp, int *k) { const double one_log_ten = 0.30102999566398114; int approx = -(exp + npowers) * one_log_ten; diff --git a/src/stdlib/print.c b/src/stdlib/print.c index 8e2dd862..d246c9c3 100644 --- a/src/stdlib/print.c +++ b/src/stdlib/print.c @@ -8,9 +8,9 @@ #include "print.h" #include "util.h" -public int _print_int(FILE *f, int64_t n) -{ - char buf[21] = {[20]=0}; // Big enough for INT64_MIN + '\0' +public +int _print_int(FILE *f, int64_t n) { + char buf[21] = {[20] = 0}; // Big enough for INT64_MIN + '\0' char *p = &buf[19]; bool negative = n < 0; @@ -19,15 +19,14 @@ public int _print_int(FILE *f, int64_t n) n /= 10; } while (n > 0); - if (negative) - *(p--) = '-'; + if (negative) *(p--) = '-'; return fwrite(p + 1, sizeof(char), (size_t)(&buf[19] - p), f); } -public int _print_uint(FILE *f, uint64_t n) -{ - char buf[21] = {[20]=0}; // Big enough for UINT64_MAX + '\0' +public +int _print_uint(FILE *f, uint64_t n) { + char buf[21] = {[20] = 0}; // Big enough for UINT64_MAX + '\0' char *p = &buf[19]; do { @@ -38,8 +37,8 @@ public int _print_uint(FILE *f, uint64_t n) return fwrite(p + 1, sizeof(char), (size_t)(&buf[19] - p), f); } -public int _print_hex(FILE *f, hex_format_t hex) -{ +public +int _print_hex(FILE *f, hex_format_t hex) { int printed = 0; if (!hex.no_prefix) printed += fputs("0x", f); if (hex.digits > 0) { @@ -50,24 +49,21 @@ public int _print_hex(FILE *f, hex_format_t hex) printed += fputc('0', f); } } - char buf[9] = {[8]='\0'}; // Enough space for FFFFFFFF + '\0' + char buf[9] = {[8] = '\0'}; // Enough space for FFFFFFFF + '\0' char *p = &buf[7]; do { uint8_t digit = hex.n % 16; - if (digit <= 9) - *(p--) = '0' + digit; - else if (hex.uppercase) - *(p--) = 'A' + digit - 10; - else - *(p--) = 'a' + digit - 10; + if (digit <= 9) *(p--) = '0' + digit; + else if (hex.uppercase) *(p--) = 'A' + digit - 10; + else *(p--) = 'a' + digit - 10; hex.n /= 16; } while (hex.n > 0); printed += (int)fwrite(p + 1, sizeof(char), (size_t)(&buf[7] - p), f); return printed; } -public int _print_oct(FILE *f, oct_format_t oct) -{ +public +int _print_oct(FILE *f, oct_format_t oct) { int printed = 0; if (!oct.no_prefix) printed += fputs("0o", f); if (oct.digits > 0) { @@ -76,7 +72,7 @@ public int _print_oct(FILE *f, oct_format_t oct) for (; oct.digits > 0; oct.digits -= 1) printed += fputc('0', f); } - char buf[12] = {[11]='\0'}; // Enough space for octal UINT64_MAX + '\0' + char buf[12] = {[11] = '\0'}; // Enough space for octal UINT64_MAX + '\0' char *p = &buf[10]; do { *(p--) = '0' + (oct.n % 8); @@ -86,25 +82,24 @@ public int _print_oct(FILE *f, oct_format_t oct) return printed; } -public int _print_double(FILE *f, double n) -{ +public +int _print_double(FILE *f, double n) { static char buf[24]; int len = fpconv_dtoa(n, buf); return (int)fwrite(buf, sizeof(char), (size_t)len, f); } -public int _print_hex_double(FILE *f, hex_double_t hex) -{ - if (hex.d != hex.d) - return fputs("NAN", f); - else if (hex.d == 1.0/0.0) - return fputs("INF", f); - else if (hex.d == -1.0/0.0) - return fputs("-INF", f); - else if (hex.d == 0.0) - return fputs("0.0", f); +public +int _print_hex_double(FILE *f, hex_double_t hex) { + if (hex.d != hex.d) return fputs("NAN", f); + else if (hex.d == 1.0 / 0.0) return fputs("INF", f); + else if (hex.d == -1.0 / 0.0) return fputs("-INF", f); + else if (hex.d == 0.0) return fputs("0.0", f); - union { double d; uint64_t u; } bits = { .d = hex.d }; + union { + double d; + uint64_t u; + } bits = {.d = hex.d}; int sign = (bits.u >> 63) & 1ull; int exp = (int)((bits.u >> 52) & 0x7FF) - 1023ull; @@ -161,30 +156,27 @@ public int _print_hex_double(FILE *f, hex_double_t hex) return fwrite(buf, sizeof(char), (size_t)(p - buf), f); } -public int _print_char(FILE *f, char c) -{ +public +int _print_char(FILE *f, char c) { #define ESC(e) "'\\" e "'" - const char *named[256] = {['\'']=ESC("'"), ['\\']=ESC("\\"), - ['\n']=ESC("n"), ['\t']=ESC("t"), ['\r']=ESC("r"), - ['\033']=ESC("e"), ['\v']=ESC("v"), ['\a']=ESC("a"), ['\b']=ESC("b")}; + const char *named[256] = { + ['\''] = ESC("'"), ['\\'] = ESC("\\"), ['\n'] = ESC("n"), ['\t'] = ESC("t"), ['\r'] = ESC("r"), + ['\033'] = ESC("e"), ['\v'] = ESC("v"), ['\a'] = ESC("a"), ['\b'] = ESC("b")}; const char *name = named[(uint8_t)c]; - if (name != NULL) - return fputs(name, f); - else if (isprint(c)) - - return fputc('\'', f) + fputc(c, f) + fputc('\'', f); + if (name != NULL) return fputs(name, f); + else if (isprint(c)) return fputc('\'', f) + fputc(c, f) + fputc('\'', f); else - return (fputs("'\\x", f) + _print_hex(f, hex((uint64_t)c, .digits=2, .no_prefix=true, .uppercase=true)) + return (fputs("'\\x", f) + _print_hex(f, hex((uint64_t)c, .digits = 2, .no_prefix = true, .uppercase = true)) + fputs("'", f)); #undef ESC } -public int _print_quoted(FILE *f, quoted_t quoted) -{ +public +int _print_quoted(FILE *f, quoted_t quoted) { #define ESC(e) "\\" e - const char *named[256] = {['"']=ESC("\""), ['\\']=ESC("\\"), - ['\n']=ESC("n"), ['\t']=ESC("t"), ['\r']=ESC("r"), - ['\033']=ESC("e"), ['\v']=ESC("v"), ['\a']=ESC("a"), ['\b']=ESC("b")}; + const char *named[256] = { + ['"'] = ESC("\""), ['\\'] = ESC("\\"), ['\n'] = ESC("n"), ['\t'] = ESC("t"), ['\r'] = ESC("r"), + ['\033'] = ESC("e"), ['\v'] = ESC("v"), ['\a'] = ESC("a"), ['\b'] = ESC("b")}; int printed = fputc('"', f); for (const char *p = quoted.str; *p; p++) { const char *name = named[(uint8_t)*p]; @@ -193,7 +185,8 @@ public int _print_quoted(FILE *f, quoted_t quoted) } else if (isprint(*p) || (uint8_t)*p > 0x7F) { printed += fputc(*p, f); } else { - printed += fputs("\\x", f) + _print_hex(f, hex((uint64_t)*p, .digits=2, .no_prefix=true, .uppercase=true)); + printed += + fputs("\\x", f) + _print_hex(f, hex((uint64_t)*p, .digits = 2, .no_prefix = true, .uppercase = true)); } } printed += fputc('"', f); @@ -202,52 +195,56 @@ public int _print_quoted(FILE *f, quoted_t quoted) } #if defined(__GLIBC__) && defined(_GNU_SOURCE) - // GLIBC has fopencookie() - static ssize_t _gc_stream_write(void *cookie, const char *buf, size_t size) { - gc_stream_t *stream = (gc_stream_t *)cookie; - if (stream->position + size + 1 > *stream->size) - *stream->buffer = GC_REALLOC(*stream->buffer, (*stream->size += MAX(MAX(16UL, *stream->size/2UL), size + 1UL))); - memcpy(&(*stream->buffer)[stream->position], buf, size); - stream->position += size; - (*stream->buffer)[stream->position] = '\0'; - return (ssize_t)size; - } +// GLIBC has fopencookie() +static ssize_t _gc_stream_write(void *cookie, const char *buf, size_t size) { + gc_stream_t *stream = (gc_stream_t *)cookie; + if (stream->position + size + 1 > *stream->size) + *stream->buffer = + GC_REALLOC(*stream->buffer, (*stream->size += MAX(MAX(16UL, *stream->size / 2UL), size + 1UL))); + memcpy(&(*stream->buffer)[stream->position], buf, size); + stream->position += size; + (*stream->buffer)[stream->position] = '\0'; + return (ssize_t)size; +} - public FILE *gc_memory_stream(char **buf, size_t *size) { - gc_stream_t *stream = GC_MALLOC(sizeof(gc_stream_t)); - stream->size = size; - stream->buffer = buf; - *stream->size = 16; - *stream->buffer = GC_MALLOC_ATOMIC(*stream->size); - (*stream->buffer)[0] = '\0'; - stream->position = 0; - cookie_io_functions_t functions = {.write = _gc_stream_write}; - return fopencookie(stream, "w", functions); - } +public +FILE *gc_memory_stream(char **buf, size_t *size) { + gc_stream_t *stream = GC_MALLOC(sizeof(gc_stream_t)); + stream->size = size; + stream->buffer = buf; + *stream->size = 16; + *stream->buffer = GC_MALLOC_ATOMIC(*stream->size); + (*stream->buffer)[0] = '\0'; + stream->position = 0; + cookie_io_functions_t functions = {.write = _gc_stream_write}; + return fopencookie(stream, "w", functions); +} #elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) - // BSDs have funopen() and fwopen() - static int _gc_stream_write(void *cookie, const char *buf, int size) { - gc_stream_t *stream = (gc_stream_t *)cookie; - if (stream->position + size + 1 > *stream->size) - *stream->buffer = GC_REALLOC(*stream->buffer, (*stream->size += MAX(MAX(16UL, *stream->size/2UL), size + 1UL))); - memcpy(&(*stream->buffer)[stream->position], buf, size); - stream->position += size; - (*stream->buffer)[stream->position] = '\0'; - return size; - } +// BSDs have funopen() and fwopen() +static int _gc_stream_write(void *cookie, const char *buf, int size) { + gc_stream_t *stream = (gc_stream_t *)cookie; + if (stream->position + size + 1 > *stream->size) + *stream->buffer = + GC_REALLOC(*stream->buffer, (*stream->size += MAX(MAX(16UL, *stream->size / 2UL), size + 1UL))); + memcpy(&(*stream->buffer)[stream->position], buf, size); + stream->position += size; + (*stream->buffer)[stream->position] = '\0'; + return size; +} - public FILE *gc_memory_stream(char **buf, size_t *size) { - gc_stream_t *stream = GC_MALLOC(sizeof(gc_stream_t)); - stream->size = size; - stream->buffer = buf; - *stream->size = 16; - *stream->buffer = GC_MALLOC_ATOMIC(*stream->size); - (*stream->buffer)[0] = '\0'; - stream->position = 0; - return fwopen(stream, _gc_stream_write); - } +public +FILE *gc_memory_stream(char **buf, size_t *size) { + gc_stream_t *stream = GC_MALLOC(sizeof(gc_stream_t)); + stream->size = size; + stream->buffer = buf; + *stream->size = 16; + *stream->buffer = GC_MALLOC_ATOMIC(*stream->size); + (*stream->buffer)[0] = '\0'; + stream->position = 0; + return fwopen(stream, _gc_stream_write); +} #else -# error "This platform doesn't support fopencookie() or funopen()!" +#error "This platform doesn't support fopencookie() or funopen()!" #endif // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/print.h b/src/stdlib/print.h index 56953866..c7e59f8b 100644 --- a/src/stdlib/print.h +++ b/src/stdlib/print.h @@ -38,19 +38,19 @@ typedef struct { bool uppercase; int digits; } hex_format_t; -#define hex(x, ...) ((hex_format_t){.n=x, __VA_ARGS__}) +#define hex(x, ...) ((hex_format_t){.n = x, __VA_ARGS__}) typedef struct { double d; } hex_double_t; -#define hex_double(x, ...) ((hex_double_t){.d=x, __VA_ARGS__}) +#define hex_double(x, ...) ((hex_double_t){.d = x, __VA_ARGS__}) typedef struct { uint64_t n; bool no_prefix; int digits; } oct_format_t; -#define oct(x, ...) ((oct_format_t){.n=x, __VA_ARGS__}) +#define oct(x, ...) ((oct_format_t){.n = x, __VA_ARGS__}) typedef struct { const char *str; @@ -67,7 +67,7 @@ typedef struct { char c; int length; } repeated_char_t; -#define repeated_char(ch, len) ((repeated_char_t){.c=ch, .length=len}) +#define repeated_char(ch, len) ((repeated_char_t){.c = ch, .length = len}) #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) #define FMT64 "ll" @@ -87,7 +87,9 @@ PRINT_FN _print_bool(FILE *f, bool b) { return fputs(b ? "yes" : "no", f); } PRINT_FN _print_str(FILE *f, const char *s) { return fputs(s ? s : "(null)", f); } int _print_char(FILE *f, char c); int _print_quoted(FILE *f, quoted_t quoted); -PRINT_FN _print_string_slice(FILE *f, string_slice_t slice) { return slice.str ? fwrite(slice.str, 1, slice.length, f) : (size_t)fputs("(null)", f); } +PRINT_FN _print_string_slice(FILE *f, string_slice_t slice) { + return slice.str ? fwrite(slice.str, 1, slice.length, f) : (size_t)fputs("(null)", f); +} PRINT_FN _print_repeated_char(FILE *f, repeated_char_t repeated) { int len = 0; for (int n = 0; n < repeated.length; n++) @@ -99,31 +101,32 @@ extern int Text$print(FILE *stream, Text_t text); extern int Path$print(FILE *stream, Path_t path); extern int Int$print(FILE *f, Int_t i); #ifndef _fprint1 -#define _fprint1(f, x) _Generic((x), \ - char*: _print_str, \ - const char*: _print_str, \ - char: _print_char, \ - bool: _print_bool, \ - int64_t: _print_int, \ - int32_t: _print_int, \ - int16_t: _print_int, \ - int8_t: _print_int, \ - uint64_t: _print_uint, \ - uint32_t: _print_uint, \ - uint16_t: _print_uint, \ - uint8_t: _print_uint, \ - float: _print_float, \ - double: _print_double, \ - hex_format_t: _print_hex, \ - hex_double_t: _print_hex_double, \ - oct_format_t: _print_oct, \ - quoted_t: _print_quoted, \ - string_slice_t: _print_string_slice, \ - repeated_char_t: _print_repeated_char, \ - Text_t: Text$print, \ - Path_t: Path$print, \ - Int_t: Int$print, \ - void*: _print_pointer)(f, x) +#define _fprint1(f, x) \ + _Generic((x), \ + char *: _print_str, \ + const char *: _print_str, \ + char: _print_char, \ + bool: _print_bool, \ + int64_t: _print_int, \ + int32_t: _print_int, \ + int16_t: _print_int, \ + int8_t: _print_int, \ + uint64_t: _print_uint, \ + uint32_t: _print_uint, \ + uint16_t: _print_uint, \ + uint8_t: _print_uint, \ + float: _print_float, \ + double: _print_double, \ + hex_format_t: _print_hex, \ + hex_double_t: _print_hex_double, \ + oct_format_t: _print_oct, \ + quoted_t: _print_quoted, \ + string_slice_t: _print_string_slice, \ + repeated_char_t: _print_repeated_char, \ + Text_t: Text$print, \ + Path_t: Path$print, \ + Int_t: Int$print, \ + void *: _print_pointer)(f, x) #endif typedef struct { @@ -135,19 +138,31 @@ typedef struct { FILE *gc_memory_stream(char **buf, size_t *size); #define _print(x) _n += _fprint1(_printing, x) -#define _fprint(f, ...) ({ FILE *_printing = f; int _n = 0; MAP_LIST(_print, __VA_ARGS__); _n; }) +#define _fprint(f, ...) \ + ({ \ + FILE *_printing = f; \ + int _n = 0; \ + MAP_LIST(_print, __VA_ARGS__); \ + _n; \ + }) #define fprint(f, ...) _fprint(f, __VA_ARGS__, "\n") #define print(...) fprint(stdout, __VA_ARGS__) #define fprint_inline(f, ...) _fprint(f, __VA_ARGS__) #define print_inline(...) fprint_inline(stdout, __VA_ARGS__) -#define String(...) ({ \ - char *_buf = NULL; \ - size_t _size = 0; \ - FILE *_stream = gc_memory_stream(&_buf, &_size); \ - assert(_stream); \ - _fprint(_stream, __VA_ARGS__); \ - fflush(_stream); \ - _buf; }) -#define print_err(...) ({ fprint(stderr, "\033[31;1m", __VA_ARGS__, "\033[m"); exit(EXIT_FAILURE); }) +#define String(...) \ + ({ \ + char *_buf = NULL; \ + size_t _size = 0; \ + FILE *_stream = gc_memory_stream(&_buf, &_size); \ + assert(_stream); \ + _fprint(_stream, __VA_ARGS__); \ + fflush(_stream); \ + _buf; \ + }) +#define print_err(...) \ + ({ \ + fprint(stderr, "\033[31;1m", __VA_ARGS__, "\033[m"); \ + exit(EXIT_FAILURE); \ + }) // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/random.h b/src/stdlib/random.h index 8509dbd7..1a6e89a5 100644 --- a/src/stdlib/random.h +++ b/src/stdlib/random.h @@ -1,5 +1,5 @@ -#include <stdint.h> #include <assert.h> +#include <stdint.h> #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__) #include <stdlib.h> @@ -10,9 +10,9 @@ static ssize_t getrandom(void *buf, size_t buflen, unsigned int flags) { } #elif defined(__linux__) // Use getrandom() -# include <sys/random.h> +#include <sys/random.h> #else - #error "Unsupported platform for secure random number generation" +#error "Unsupported platform for secure random number generation" #endif static int64_t random_range(int64_t low, int64_t high) { diff --git a/src/stdlib/simpleparse.c b/src/stdlib/simpleparse.c index 1ee64036..3929c32b 100644 --- a/src/stdlib/simpleparse.c +++ b/src/stdlib/simpleparse.c @@ -26,41 +26,42 @@ static bool _match_word(const char **str, const char *target) { return false; } -public const char *simpleparse(const char *str, int n, parse_type_e types[n], void *destinations[n]) -{ +public +const char *simpleparse(const char *str, int n, parse_type_e types[n], void *destinations[n]) { for (int i = 0; i < n; i++) { switch (types[i]) { case PARSE_SOME_OF: { - if (destinations[i]) str += strspn(str, (char*)destinations[i]); + if (destinations[i]) str += strspn(str, (char *)destinations[i]); break; } case PARSE_LITERAL: { - const char *target = (const char*)destinations[i]; + const char *target = (const char *)destinations[i]; if (target) { - if (strncmp(str, target, strlen(target)) != 0) - return str; + if (strncmp(str, target, strlen(target)) != 0) return str; str += strlen(target); } break; } case PARSE_STRING: { size_t len; - static const char matching_pair[256] = {[(int)'(']=')', [(int)'{']='}', [(int)'[']=']', - [(int)'"']='"', [(int)'\'']='\'', [(int)'`']='`', [(int)'<']='>'}; - if (i > 0 && i + 1 < n && types[i-1] == PARSE_LITERAL && types[i+1] == PARSE_LITERAL - && destinations[i-1] && destinations[i+1] - && strlen((char*)destinations[i-1]) == 1 && strlen((char*)destinations[i+1]) == 1 - && *(char*)destinations[i+1] == matching_pair[(int)*(char*)destinations[i-1]]) { + static const char matching_pair[256] = {[(int)'('] = ')', [(int)'{'] = '}', [(int)'['] = ']', + [(int)'"'] = '"', [(int)'\''] = '\'', [(int)'`'] = '`', + [(int)'<'] = '>'}; + if (i > 0 && i + 1 < n && types[i - 1] == PARSE_LITERAL && types[i + 1] == PARSE_LITERAL + && destinations[i - 1] && destinations[i + 1] && strlen((char *)destinations[i - 1]) == 1 + && strlen((char *)destinations[i + 1]) == 1 + && *(char *)destinations[i + 1] == matching_pair[(int)*(char *)destinations[i - 1]]) { len = 0; - char special_characters[4] = {'\\', *(char*)destinations[i-1], *(char*)destinations[i+1], 0}; - for (int depth = 1; depth > 0; ) { + char special_characters[4] = {'\\', *(char *)destinations[i - 1], *(char *)destinations[i + 1], 0}; + for (int depth = 1; depth > 0;) { len += strcspn(str + len, special_characters); if (str[len] == '\0') { return str; } else if (str[len] == '\\' - && (special_characters[1] == '"' || special_characters[1] == '\'' || special_characters[1] == '`')) { - if (str[len+1] == '\0') return str; - len += 2; + && (special_characters[1] == '"' || special_characters[1] == '\'' + || special_characters[1] == '`')) { + if (str[len + 1] == '\0') return str; + len += 2; } else if (str[len] == special_characters[2]) { // Check for closing quotes before opening quotes depth -= 1; if (depth > 0) len += 1; @@ -70,8 +71,8 @@ public const char *simpleparse(const char *str, int n, parse_type_e types[n], vo len += 1; } } - } else if (i + 1 < n && types[i+1] == PARSE_LITERAL) { - const char *terminator = (const char*)destinations[i+1]; + } else if (i + 1 < n && types[i + 1] == PARSE_LITERAL) { + const char *terminator = (const char *)destinations[i + 1]; if (terminator) { const char *end = strstr(str, terminator); if (!end) return str; @@ -79,16 +80,17 @@ public const char *simpleparse(const char *str, int n, parse_type_e types[n], vo } else { len = strlen(str); } - } else if (i + 1 < n && types[i+1] == PARSE_SOME_OF) { - len = destinations[i+1] ? strcspn(str, (char*)destinations[i+1]) : strlen(str);; + } else if (i + 1 < n && types[i + 1] == PARSE_SOME_OF) { + len = destinations[i + 1] ? strcspn(str, (char *)destinations[i + 1]) : strlen(str); + ; } else { len = strlen(str); } if (destinations[i]) { - char *matched = GC_MALLOC_ATOMIC(len+1); + char *matched = GC_MALLOC_ATOMIC(len + 1); memcpy(matched, str, len); matched[len] = '\0'; - *(const char**)destinations[i] = matched; + *(const char **)destinations[i] = matched; } str += len; break; @@ -97,7 +99,7 @@ public const char *simpleparse(const char *str, int n, parse_type_e types[n], vo char *end = NULL; double val = strtod(str, &end); if (end == str) return str; - if (destinations[i]) *(double*)destinations[i] = val; + if (destinations[i]) *(double *)destinations[i] = val; str = end; break; } @@ -105,15 +107,17 @@ public const char *simpleparse(const char *str, int n, parse_type_e types[n], vo char *end = NULL; long val = strtol(str, &end, 10); if (end == str) return str; - if (destinations[i]) *(long*)destinations[i] = val; + if (destinations[i]) *(long *)destinations[i] = val; str = end; break; } case PARSE_BOOL: { - if (_match_word(&str, "true") || _match_word(&str, "yes") || _match_word(&str, "on") || _match_word(&str, "1")) { - if (destinations[i]) *(bool*)destinations[i] = true; - } else if (_match_word(&str, "false") || _match_word(&str, "no") || _match_word(&str, "off") || _match_word(&str, "0")) { - if (destinations[i]) *(bool*)destinations[i] = false; + if (_match_word(&str, "true") || _match_word(&str, "yes") || _match_word(&str, "on") + || _match_word(&str, "1")) { + if (destinations[i]) *(bool *)destinations[i] = true; + } else if (_match_word(&str, "false") || _match_word(&str, "no") || _match_word(&str, "off") + || _match_word(&str, "0")) { + if (destinations[i]) *(bool *)destinations[i] = false; } else { return str; } diff --git a/src/stdlib/simpleparse.h b/src/stdlib/simpleparse.h index da077e20..d35a8b3b 100644 --- a/src/stdlib/simpleparse.h +++ b/src/stdlib/simpleparse.h @@ -22,30 +22,42 @@ #include "mapmacro.h" -typedef struct { char c; } some_char_t; -#define PARSE_SOME_OF(chars) ((some_char_t*)chars) +typedef struct { + char c; +} some_char_t; +#define PARSE_SOME_OF(chars) ((some_char_t *)chars) #define PARSE_WHITESPACE PARSE_SOME_OF(" \t\r\n\v") -typedef enum {PARSE_LITERAL, PARSE_LONG, PARSE_DOUBLE, PARSE_BOOL, PARSE_STRING, PARSE_SOME_OF} parse_type_e; - -typedef struct { parse_type_e type; void *dest; } parse_element_t; - -#define _parse_type(dest) _Generic((dest), \ - some_char_t*: PARSE_SOME_OF, \ - const char*: PARSE_LITERAL, \ - char*: PARSE_LITERAL, \ - const char**: PARSE_STRING, \ - char**: PARSE_STRING, \ - double*: PARSE_DOUBLE, \ - long*: PARSE_LONG, \ - bool*: PARSE_BOOL) - -#define as_void_star(x) ((void*)x) -#define strparse(str, ...) simpleparse(str, sizeof((const void*[]){__VA_ARGS__})/sizeof(void*), (parse_type_e[]){MAP_LIST(_parse_type, __VA_ARGS__)}, (void*[]){MAP_LIST(as_void_star, __VA_ARGS__)}) -#define fparse(file, ...) ({ char *_file_contents = NULL; size_t _capacity; \ - ssize_t _just_read = getdelim(&_file_contents, &_capacity, '\0', file); \ - const char *_parse_err = _just_read > 0 ? strparse(_file_contents, __VA_ARGS__) : "No such file"; \ - if (_file_contents) free(_file_contents); \ - _parse_err; }) +typedef enum { PARSE_LITERAL, PARSE_LONG, PARSE_DOUBLE, PARSE_BOOL, PARSE_STRING, PARSE_SOME_OF } parse_type_e; + +typedef struct { + parse_type_e type; + void *dest; +} parse_element_t; + +#define _parse_type(dest) \ + _Generic((dest), \ + some_char_t *: PARSE_SOME_OF, \ + const char *: PARSE_LITERAL, \ + char *: PARSE_LITERAL, \ + const char **: PARSE_STRING, \ + char **: PARSE_STRING, \ + double *: PARSE_DOUBLE, \ + long *: PARSE_LONG, \ + bool *: PARSE_BOOL) + +#define as_void_star(x) ((void *)x) +#define strparse(str, ...) \ + simpleparse(str, sizeof((const void *[]){__VA_ARGS__}) / sizeof(void *), \ + (parse_type_e[]){MAP_LIST(_parse_type, __VA_ARGS__)}, (void *[]){MAP_LIST(as_void_star, __VA_ARGS__)}) +#define fparse(file, ...) \ + ({ \ + char *_file_contents = NULL; \ + size_t _capacity; \ + ssize_t _just_read = getdelim(&_file_contents, &_capacity, '\0', file); \ + const char *_parse_err = _just_read > 0 ? strparse(_file_contents, __VA_ARGS__) : "No such file"; \ + if (_file_contents) free(_file_contents); \ + _parse_err; \ + }) const char *simpleparse(const char *str, int n, parse_type_e types[n], void *destinations[n]); diff --git a/src/stdlib/siphash-internals.h b/src/stdlib/siphash-internals.h index b359cea7..c8ec1142 100644 --- a/src/stdlib/siphash-internals.h +++ b/src/stdlib/siphash-internals.h @@ -51,24 +51,25 @@ struct siphash { uint64_t v1; uint64_t v2; uint64_t v3; - uint64_t b; + uint64_t b; }; typedef struct siphash siphash; -#define ROTATE(x, b) (uint64_t)( ((x) << (b)) | ( (x) >> (64 - (b))) ) +#define ROTATE(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b)))) -#define HALF_ROUND(a,b,c,d,s,t) \ - a += b; c += d; \ - b = ROTATE(b, s) ^ a; \ - d = ROTATE(d, t) ^ c; \ +#define HALF_ROUND(a, b, c, d, s, t) \ + a += b; \ + c += d; \ + b = ROTATE(b, s) ^ a; \ + d = ROTATE(d, t) ^ c; \ a = ROTATE(a, 32); -#define DOUBLE_ROUND(v0,v1,v2,v3) \ - HALF_ROUND(v0,v1,v2,v3,13,16); \ - HALF_ROUND(v2,v1,v0,v3,17,21); \ - HALF_ROUND(v0,v1,v2,v3,13,16); \ - HALF_ROUND(v2,v1,v0,v3,17,21); +#define DOUBLE_ROUND(v0, v1, v2, v3) \ + HALF_ROUND(v0, v1, v2, v3, 13, 16); \ + HALF_ROUND(v2, v1, v0, v3, 17, 21); \ + HALF_ROUND(v0, v1, v2, v3, 13, 16); \ + HALF_ROUND(v2, v1, v0, v3, 17, 21); -MACROLIKE void siphashinit (siphash *sh, size_t src_sz) { +MACROLIKE void siphashinit(siphash *sh, size_t src_sz) { const uint64_t k0 = TOMO_HASH_KEY[0]; const uint64_t k1 = TOMO_HASH_KEY[1]; sh->b = (uint64_t)src_sz << 56; @@ -77,20 +78,20 @@ MACROLIKE void siphashinit (siphash *sh, size_t src_sz) { sh->v2 = k0 ^ 0x6c7967656e657261ULL; sh->v3 = k1 ^ 0x7465646279746573ULL; } -MACROLIKE void siphashadd64bits (siphash *sh, const uint64_t in) { +MACROLIKE void siphashadd64bits(siphash *sh, const uint64_t in) { const uint64_t mi = in; sh->v3 ^= mi; - DOUBLE_ROUND(sh->v0,sh->v1,sh->v2,sh->v3); + DOUBLE_ROUND(sh->v0, sh->v1, sh->v2, sh->v3); sh->v0 ^= mi; } -MACROLIKE uint64_t siphashfinish_last_part (siphash *sh, uint64_t t) { +MACROLIKE uint64_t siphashfinish_last_part(siphash *sh, uint64_t t) { sh->b |= t; sh->v3 ^= sh->b; - DOUBLE_ROUND(sh->v0,sh->v1,sh->v2,sh->v3); + DOUBLE_ROUND(sh->v0, sh->v1, sh->v2, sh->v3); sh->v0 ^= sh->b; sh->v2 ^= 0xff; - DOUBLE_ROUND(sh->v0,sh->v1,sh->v2,sh->v3); - DOUBLE_ROUND(sh->v0,sh->v1,sh->v2,sh->v3); + DOUBLE_ROUND(sh->v0, sh->v1, sh->v2, sh->v3); + DOUBLE_ROUND(sh->v0, sh->v1, sh->v2, sh->v3); return (sh->v0 ^ sh->v1) ^ (sh->v2 ^ sh->v3); } /* This union helps us avoid doing weird things with pointers that can cause old @@ -99,26 +100,26 @@ MACROLIKE uint64_t siphashfinish_last_part (siphash *sh, uint64_t t) { union SipHash64_union { uint64_t u64; uint32_t u32; - uint8_t u8[8]; + uint8_t u8[8]; }; -MACROLIKE uint64_t siphashfinish (siphash *sh, const uint8_t *src, size_t src_sz) { - union SipHash64_union t = { 0 }; +MACROLIKE uint64_t siphashfinish(siphash *sh, const uint8_t *src, size_t src_sz) { + union SipHash64_union t = {0}; switch (src_sz) { - /* Falls through */ - case 7: t.u8[6] = src[6]; - /* Falls through */ - case 6: t.u8[5] = src[5]; - /* Falls through */ - case 5: t.u8[4] = src[4]; - /* Falls through */ - case 4: t.u8[3] = src[3]; - /* Falls through */ - case 3: t.u8[2] = src[2]; - /* Falls through */ - case 2: t.u8[1] = src[1]; - /* Falls through */ - case 1: t.u8[0] = src[0]; - default: break; + /* Falls through */ + case 7: t.u8[6] = src[6]; + /* Falls through */ + case 6: t.u8[5] = src[5]; + /* Falls through */ + case 5: t.u8[4] = src[4]; + /* Falls through */ + case 4: t.u8[3] = src[3]; + /* Falls through */ + case 3: t.u8[2] = src[2]; + /* Falls through */ + case 2: t.u8[1] = src[1]; + /* Falls through */ + case 1: t.u8[0] = src[0]; + default: break; } return siphashfinish_last_part(sh, t.u64); } diff --git a/src/stdlib/siphash.c b/src/stdlib/siphash.c index 274b3195..9af845e7 100644 --- a/src/stdlib/siphash.c +++ b/src/stdlib/siphash.c @@ -5,7 +5,8 @@ #include "siphash.h" #include "util.h" -public uint64_t TOMO_HASH_KEY[2] = {23, 42}; // Randomized in tomo_init() +public +uint64_t TOMO_HASH_KEY[2] = {23, 42}; // Randomized in tomo_init() /* <MIT License> Copyright (c) 2013 Marek Majkowski <marek@popcount.org> @@ -53,10 +54,10 @@ PUREFUNC public uint64_t siphash24(const uint8_t *src, size_t src_sz) { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wcast-align" #endif - const uint64_t *in = (uint64_t*)src; + const uint64_t *in = (uint64_t *)src; /* Find largest src_sz evenly divisible by 8 bytes. */ const ptrdiff_t src_sz_nearest_8bits = ((ptrdiff_t)src_sz >> 3) << 3; - const uint64_t *goal = (uint64_t*)(src + src_sz_nearest_8bits); + const uint64_t *goal = (uint64_t *)(src + src_sz_nearest_8bits); #ifdef __GNUC__ #pragma GCC diagnostic pop #endif @@ -74,7 +75,8 @@ PUREFUNC public uint64_t siphash24(const uint8_t *src, size_t src_sz) { uint64_t in_64; memcpy(&in_64, in, sizeof(uint64_t)); siphashadd64bits(&sh, in_64); - in += 8; src_sz -= 8; + in += 8; + src_sz -= 8; } return siphashfinish(&sh, (uint8_t *)in, src_sz); } diff --git a/src/stdlib/siphash.h b/src/stdlib/siphash.h index 67bad582..3dbef0fd 100644 --- a/src/stdlib/siphash.h +++ b/src/stdlib/siphash.h @@ -2,8 +2,8 @@ // An implementation of the SipHash algorithm. -#include <stdint.h> #include <stddef.h> +#include <stdint.h> #include "util.h" diff --git a/src/stdlib/stacktrace.c b/src/stdlib/stacktrace.c index f408d753..9f01a4bf 100644 --- a/src/stdlib/stacktrace.c +++ b/src/stdlib/stacktrace.c @@ -1,6 +1,6 @@ #ifndef _GNU_SOURCE #define _GNU_SOURCE -#endif +#endif #include <dlfcn.h> #include <err.h> @@ -19,8 +19,7 @@ extern bool USE_COLOR; -static void fprint_context(FILE *out, const char *filename, int lineno, int context_before, int context_after) -{ +static void fprint_context(FILE *out, const char *filename, int lineno, int context_before, int context_after) { FILE *f = fopen(filename, "r"); if (!f) return; char *line = NULL; @@ -33,35 +32,31 @@ static void fprint_context(FILE *out, const char *filename, int lineno, int cont num_width += 1; while ((nread = getline(&line, &size, f)) != -1) { - if (line[strlen(line)-1] == '\n') - line[strlen(line)-1] = '\0'; + if (line[strlen(line) - 1] == '\n') line[strlen(line) - 1] = '\0'; if (cur_line >= lineno - context_before) { int w = 1; - for (int n = cur_line; n >= 10; n /= 10) w += 1; + for (int n = cur_line; n >= 10; n /= 10) + w += 1; if (USE_COLOR) { fprint(out, cur_line == lineno ? "\033[31;1m>\033[m " : " ", "\033[2m", - repeated_char(' ', num_width-w), - cur_line, "\033(0\x78\033(B", cur_line == lineno ? "\033[0;31;1m" : "\033[0m", - line, "\033[m"); + repeated_char(' ', num_width - w), cur_line, "\033(0\x78\033(B", + cur_line == lineno ? "\033[0;31;1m" : "\033[0m", line, "\033[m"); } else { - fprint(out, cur_line == lineno ? "> " : " ", - repeated_char(' ', num_width-w), - cur_line, "| ", line); + fprint(out, cur_line == lineno ? "> " : " ", repeated_char(' ', num_width - w), cur_line, "| ", line); } } cur_line += 1; - if (cur_line > lineno + context_after) - break; + if (cur_line > lineno + context_after) break; } if (line) free(line); fclose(f); } -static void _print_stack_frame(FILE *out, const char *cwd, const char *install_dir, const char *function, const char *filename, int lineno) -{ +static void _print_stack_frame(FILE *out, const char *cwd, const char *install_dir, const char *function, + const char *filename, int lineno) { if (function == NULL) { fprint(out, USE_COLOR ? "\033[2m...unknown function...\033[m" : "...unknown function..."); return; @@ -71,7 +66,7 @@ static void _print_stack_frame(FILE *out, const char *cwd, const char *install_d if (function[0] == '\0') function = "???"; char *function_display = GC_MALLOC_ATOMIC(strlen(function)); - memcpy(function_display, function, strlen(function)+1); + memcpy(function_display, function, strlen(function) + 1); char *last_dollar = strrchr(function_display, '$'); if (last_dollar) *last_dollar = '\0'; for (char *p = function_display; *p; p++) { @@ -79,14 +74,12 @@ static void _print_stack_frame(FILE *out, const char *cwd, const char *install_d } if (filename) { - if (strncmp(filename, cwd, strlen(cwd)) == 0) - filename += strlen(cwd); + if (strncmp(filename, cwd, strlen(cwd)) == 0) filename += strlen(cwd); fprint_inline(out, USE_COLOR ? "\033[1mIn \033[33m" : "In ", function_display, USE_COLOR ? "()\033[37m" : "()"); if (install_dir[0] && strncmp(filename, install_dir, strlen(install_dir)) == 0) fprint_inline(out, USE_COLOR ? " in library \033[35m" : " in library ", filename, ":", lineno); - else - fprint(out, USE_COLOR ? " in \033[35m" : " in ", filename, ":", lineno); + else fprint(out, USE_COLOR ? " in \033[35m" : " in ", filename, ":", lineno); fprint(out, USE_COLOR ? "\033[m" : ""); fprint_context(out, filename, lineno, 3, 1); } else { @@ -94,48 +87,41 @@ static void _print_stack_frame(FILE *out, const char *cwd, const char *install_d } } -__attribute__ ((noinline)) -public void print_stacktrace(FILE *out, int offset) -{ +__attribute__((noinline)) public +void print_stacktrace(FILE *out, int offset) { char cwd[PATH_MAX]; - if (getcwd(cwd, sizeof(cwd)) == NULL) - errx(1, "Path too large!"); + if (getcwd(cwd, sizeof(cwd)) == NULL) errx(1, "Path too large!"); size_t cwd_len = strlen(cwd); - if (cwd_len + 2 > sizeof(cwd)) - errx(1, "Path too large!"); + if (cwd_len + 2 > sizeof(cwd)) errx(1, "Path too large!"); cwd[cwd_len++] = '/'; cwd[cwd_len] = '\0'; - const char *install_dir = TOMO_PREFIX"/share/tomo_"TOMO_VERSION"/installed/"; + const char *install_dir = TOMO_PREFIX "/share/tomo_" TOMO_VERSION "/installed/"; static void *stack[1024]; - int64_t size = (int64_t)backtrace(stack, sizeof(stack)/sizeof(stack[0])); + int64_t size = (int64_t)backtrace(stack, sizeof(stack) / sizeof(stack[0])); char **strings = backtrace_symbols(stack, size); bool main_func_onwards = false; - for (int64_t i = size-1; i > offset; i--) { + for (int64_t i = size - 1; i > offset; i--) { Dl_info info; - void *call_address = stack[i]-1; + void *call_address = stack[i] - 1; if (dladdr(call_address, &info) && info.dli_fname) { const char *file = info.dli_fname; uintptr_t frame_offset = (uintptr_t)call_address - (uintptr_t)info.dli_fbase; - FILE *fp = popen(String("addr2line -f -e '", file, "' ", (void*)frame_offset, " 2>/dev/null"), "r"); + FILE *fp = popen(String("addr2line -f -e '", file, "' ", (void *)frame_offset, " 2>/dev/null"), "r"); if (fp) { const char *function = NULL, *filename = NULL; long line_num = 0; if (fparse(fp, &function, "\n", &filename, ":", &line_num) == NULL) { - if (starts_with(function, "main$")) - main_func_onwards = true; - if (main_func_onwards) - _print_stack_frame(out, cwd, install_dir, function, filename, line_num); + if (starts_with(function, "main$")) main_func_onwards = true; + if (main_func_onwards) _print_stack_frame(out, cwd, install_dir, function, filename, line_num); } else { - if (main_func_onwards) - _print_stack_frame(out, cwd, install_dir, NULL, NULL, line_num); + if (main_func_onwards) _print_stack_frame(out, cwd, install_dir, NULL, NULL, line_num); } pclose(fp); } } else { - if (main_func_onwards) - _print_stack_frame(out, cwd, install_dir, NULL, NULL, 0); + if (main_func_onwards) _print_stack_frame(out, cwd, install_dir, NULL, NULL, 0); } if (main_func_onwards && i - 1 > offset) fputs("\n", out); } diff --git a/src/stdlib/stacktrace.h b/src/stdlib/stacktrace.h index 828bbe98..36e81bea 100644 --- a/src/stdlib/stacktrace.h +++ b/src/stdlib/stacktrace.h @@ -1,5 +1,4 @@ #pragma once #include <stdio.h> -__attribute__ ((noinline)) -void print_stacktrace(FILE *out, int offset); +__attribute__((noinline)) void print_stacktrace(FILE *out, int offset); diff --git a/src/stdlib/stdlib.c b/src/stdlib/stdlib.c index 159acdb3..411ce300 100644 --- a/src/stdlib/stdlib.c +++ b/src/stdlib/stdlib.c @@ -37,16 +37,17 @@ static ssize_t getrandom(void *buf, size_t buflen, unsigned int flags) { } #elif defined(__linux__) // Use getrandom() -# include <sys/random.h> +#include <sys/random.h> #else - #error "Unsupported platform for secure random number generation" +#error "Unsupported platform for secure random number generation" #endif -public bool USE_COLOR; -public Text_t TOMO_VERSION_TEXT = Text(TOMO_VERSION); +public +bool USE_COLOR; +public +Text_t TOMO_VERSION_TEXT = Text(TOMO_VERSION); -static _Noreturn void signal_handler(int sig, siginfo_t *info, void *userdata) -{ +static _Noreturn void signal_handler(int sig, siginfo_t *info, void *userdata) { (void)info, (void)userdata; assert(sig == SIGILL); fflush(stdout); @@ -58,107 +59,92 @@ static _Noreturn void signal_handler(int sig, siginfo_t *info, void *userdata) _exit(1); } -public void tomo_init(void) -{ - GC_INIT(); - USE_COLOR = getenv("COLOR") ? strcmp(getenv("COLOR"), "1") == 0 : isatty(STDOUT_FILENO); - if (getenv("NO_COLOR") && getenv("NO_COLOR")[0] != '\0') - USE_COLOR = false; - - setlocale(LC_ALL, ""); - assert(getrandom(TOMO_HASH_KEY, sizeof(TOMO_HASH_KEY), 0) == sizeof(TOMO_HASH_KEY)); - - struct sigaction sigact; - sigact.sa_sigaction = signal_handler; - sigemptyset(&sigact.sa_mask); - sigact.sa_flags = 0; - sigaction(SIGILL, &sigact, (struct sigaction *)NULL); +public +void tomo_init(void) { + GC_INIT(); + USE_COLOR = getenv("COLOR") ? strcmp(getenv("COLOR"), "1") == 0 : isatty(STDOUT_FILENO); + if (getenv("NO_COLOR") && getenv("NO_COLOR")[0] != '\0') USE_COLOR = false; + + setlocale(LC_ALL, ""); + assert(getrandom(TOMO_HASH_KEY, sizeof(TOMO_HASH_KEY), 0) == sizeof(TOMO_HASH_KEY)); + + struct sigaction sigact; + sigact.sa_sigaction = signal_handler; + sigemptyset(&sigact.sa_mask); + sigact.sa_flags = 0; + sigaction(SIGILL, &sigact, (struct sigaction *)NULL); } -static bool parse_single_arg(const TypeInfo_t *info, char *arg, void *dest) -{ +static bool parse_single_arg(const TypeInfo_t *info, char *arg, void *dest) { if (!arg) return false; - if (info->tag == OptionalInfo && streq(arg, "none")) - return true; + if (info->tag == OptionalInfo && streq(arg, "none")) return true; while (info->tag == OptionalInfo) info = info->OptionalInfo.type; if (info == &Int$info) { OptionalInt_t parsed = Int$from_str(arg); - if (parsed.small != 0) - *(OptionalInt_t*)dest = parsed; + if (parsed.small != 0) *(OptionalInt_t *)dest = parsed; return parsed.small != 0; } else if (info == &Int64$info) { OptionalInt64_t parsed = Int64$parse(Text$from_str(arg), NULL); - if (!parsed.is_none) - *(OptionalInt64_t*)dest = parsed; + if (!parsed.is_none) *(OptionalInt64_t *)dest = parsed; return !parsed.is_none; } else if (info == &Int32$info) { OptionalInt32_t parsed = Int32$parse(Text$from_str(arg), NULL); - if (!parsed.is_none) - *(OptionalInt32_t*)dest = parsed; + if (!parsed.is_none) *(OptionalInt32_t *)dest = parsed; return !parsed.is_none; } else if (info == &Int16$info) { OptionalInt16_t parsed = Int16$parse(Text$from_str(arg), NULL); - if (!parsed.is_none) - *(OptionalInt16_t*)dest = parsed; + if (!parsed.is_none) *(OptionalInt16_t *)dest = parsed; return !parsed.is_none; } else if (info == &Int8$info) { OptionalInt8_t parsed = Int8$parse(Text$from_str(arg), NULL); - if (!parsed.is_none) - *(OptionalInt8_t*)dest = parsed; + if (!parsed.is_none) *(OptionalInt8_t *)dest = parsed; return !parsed.is_none; } else if (info == &Bool$info) { OptionalBool_t parsed = Bool$parse(Text$from_str(arg), NULL); - if (parsed != NONE_BOOL) - *(OptionalBool_t*)dest = parsed; + if (parsed != NONE_BOOL) *(OptionalBool_t *)dest = parsed; return parsed != NONE_BOOL; } else if (info == &Num$info) { OptionalNum_t parsed = Num$parse(Text$from_str(arg), NULL); - if (!isnan(parsed)) - *(OptionalNum_t*)dest = parsed; + if (!isnan(parsed)) *(OptionalNum_t *)dest = parsed; return !isnan(parsed); } else if (info == &Num32$info) { OptionalNum32_t parsed = Num32$parse(Text$from_str(arg), NULL); - if (!isnan(parsed)) - *(OptionalNum32_t*)dest = parsed; + if (!isnan(parsed)) *(OptionalNum32_t *)dest = parsed; return !isnan(parsed); } else if (info == &Path$info) { - *(OptionalPath_t*)dest = Path$from_str(arg); + *(OptionalPath_t *)dest = Path$from_str(arg); return true; } else if (info->tag == TextInfo) { - *(OptionalText_t*)dest = Text$from_str(arg); + *(OptionalText_t *)dest = Text$from_str(arg); return true; } else if (info->tag == EnumInfo) { for (int t = 0; t < info->EnumInfo.num_tags; t++) { NamedType_t named = info->EnumInfo.tags[t]; size_t len = strlen(named.name); if (strncmp(arg, named.name, len) == 0 && (arg[len] == '\0' || arg[len] == ':')) { - *(int32_t*)dest = (t + 1); + *(int32_t *)dest = (t + 1); // Simple tag (no associated data): if (!named.type || (named.type->tag == StructInfo && named.type->StructInfo.num_fields == 0)) return true; // Single-argument tag: - if (arg[len] != ':') - print_err("Invalid value for ", t, ".", named.name, ": ", arg); + if (arg[len] != ':') print_err("Invalid value for ", t, ".", named.name, ": ", arg); size_t offset = sizeof(int32_t); if (named.type->align > 0 && offset % (size_t)named.type->align > 0) offset += (size_t)named.type->align - (offset % (size_t)named.type->align); - if (!parse_single_arg(named.type, arg + len + 1, dest + offset)) - return false; + if (!parse_single_arg(named.type, arg + len + 1, dest + offset)) return false; return true; } } print_err("Invalid value for ", info->EnumInfo.name, ": ", arg); } else if (info->tag == StructInfo) { - if (info->StructInfo.num_fields == 0) - return true; - else if (info->StructInfo.num_fields == 1) - return parse_single_arg(info->StructInfo.fields[0].type, arg, dest); + if (info->StructInfo.num_fields == 0) return true; + else if (info->StructInfo.num_fields == 1) return parse_single_arg(info->StructInfo.fields[0].type, arg, dest); Text_t t = generic_as_text(NULL, false, info); print_err("Unsupported multi-argument struct type for argument parsing: ", t); @@ -173,41 +159,36 @@ static bool parse_single_arg(const TypeInfo_t *info, char *arg, void *dest) return false; } -static List_t parse_list(const TypeInfo_t *item_info, int n, char *args[]) -{ +static List_t parse_list(const TypeInfo_t *item_info, int n, char *args[]) { int64_t padded_size = item_info->size; if ((padded_size % item_info->align) > 0) padded_size = padded_size + item_info->align - (padded_size % item_info->align); List_t items = { - .stride=padded_size, - .length=n, - .data=GC_MALLOC((size_t)(padded_size*n)), + .stride = padded_size, + .length = n, + .data = GC_MALLOC((size_t)(padded_size * n)), }; for (int i = 0; i < n; i++) { - bool success = parse_single_arg(item_info, args[i], items.data + items.stride*i); - if (!success) - print_err("Couldn't parse argument: ", args[i]); + bool success = parse_single_arg(item_info, args[i], items.data + items.stride * i); + if (!success) print_err("Couldn't parse argument: ", args[i]); } return items; } // Arguments take the form key=value, with a guarantee that there is an '=' -static Table_t parse_table(const TypeInfo_t *table, int n, char *args[]) -{ +static Table_t parse_table(const TypeInfo_t *table, int n, char *args[]) { const TypeInfo_t *key = table->TableInfo.key, *value = table->TableInfo.value; int64_t padded_size = key->size; - if ((padded_size % value->align) > 0) - padded_size = padded_size + value->align - (padded_size % value->align); + if ((padded_size % value->align) > 0) padded_size = padded_size + value->align - (padded_size % value->align); int64_t value_offset = padded_size; padded_size += value->size; - if ((padded_size % key->align) > 0) - padded_size = padded_size + key->align - (padded_size % key->align); + if ((padded_size % key->align) > 0) padded_size = padded_size + key->align - (padded_size % key->align); List_t entries = { - .stride=padded_size, - .length=n, - .data=GC_MALLOC((size_t)(padded_size*n)), + .stride = padded_size, + .length = n, + .data = GC_MALLOC((size_t)(padded_size * n)), }; for (int i = 0; i < n; i++) { char *key_arg = args[i]; @@ -216,13 +197,11 @@ static Table_t parse_table(const TypeInfo_t *table, int n, char *args[]) char *value_arg = equals + 1; *equals = '\0'; - bool success = parse_single_arg(key, key_arg, entries.data + entries.stride*i); - if (!success) - print_err("Couldn't parse table key: ", key_arg); + bool success = parse_single_arg(key, key_arg, entries.data + entries.stride * i); + if (!success) print_err("Couldn't parse table key: ", key_arg); - success = parse_single_arg(value, value_arg, entries.data + entries.stride*i + value_offset); - if (!success) - print_err("Couldn't parse table value: ", value_arg); + success = parse_single_arg(value, value_arg, entries.data + entries.stride * i + value_offset); + if (!success) print_err("Couldn't parse table value: ", value_arg); *equals = '='; } @@ -233,13 +212,14 @@ static Table_t parse_table(const TypeInfo_t *table, int n, char *args[]) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstack-protector" #endif -public void _tomo_parse_args(int argc, char *argv[], Text_t usage, Text_t help, const char *version, int spec_len, cli_arg_t spec[spec_len]) -{ +public +void _tomo_parse_args(int argc, char *argv[], Text_t usage, Text_t help, const char *version, int spec_len, + cli_arg_t spec[spec_len]) { bool populated_args[spec_len]; bool used_args[argc]; memset(populated_args, 0, sizeof(populated_args)); memset(used_args, 0, sizeof(used_args)); - for (int i = 1; i < argc; ) { + for (int i = 1; i < argc;) { if (argv[i][0] == '-' && argv[i][1] == '-') { if (argv[i][2] == '\0') { // "--" signals the rest of the arguments are literal used_args[i] = true; @@ -252,58 +232,54 @@ public void _tomo_parse_args(int argc, char *argv[], Text_t usage, Text_t help, while (non_opt_type->tag == OptionalInfo) non_opt_type = non_opt_type->OptionalInfo.type; - if (non_opt_type == &Bool$info - && strncmp(argv[i], "--no-", strlen("--no-")) == 0 + if (non_opt_type == &Bool$info && strncmp(argv[i], "--no-", strlen("--no-")) == 0 && strcmp(argv[i] + strlen("--no-"), spec[s].name) == 0) { - *(OptionalBool_t*)spec[s].dest = false; + *(OptionalBool_t *)spec[s].dest = false; populated_args[s] = true; used_args[i] = true; goto next_arg; } - if (strncmp(spec[s].name, argv[i] + 2, strlen(spec[s].name)) != 0) - continue; + if (strncmp(spec[s].name, argv[i] + 2, strlen(spec[s].name)) != 0) continue; - char after_name = argv[i][2+strlen(spec[s].name)]; + char after_name = argv[i][2 + strlen(spec[s].name)]; if (after_name == '\0') { // --foo val used_args[i] = true; if (non_opt_type->tag == ListInfo) { int num_args = 0; while (i + 1 + num_args < argc) { - if (argv[i+1+num_args][0] == '-') - break; - used_args[i+1+num_args] = true; + if (argv[i + 1 + num_args][0] == '-') break; + used_args[i + 1 + num_args] = true; num_args += 1; } populated_args[s] = true; - *(OptionalList_t*)spec[s].dest = parse_list(non_opt_type->ListInfo.item, num_args, &argv[i+1]); + *(OptionalList_t *)spec[s].dest = + parse_list(non_opt_type->ListInfo.item, num_args, &argv[i + 1]); } else if (non_opt_type->tag == TableInfo) { int num_args = 0; while (i + 1 + num_args < argc) { - if (argv[i+1+num_args][0] == '-' || !strchr(argv[i+1+num_args], '=')) - break; - used_args[i+1+num_args] = true; + if (argv[i + 1 + num_args][0] == '-' || !strchr(argv[i + 1 + num_args], '=')) break; + used_args[i + 1 + num_args] = true; num_args += 1; } populated_args[s] = true; - *(OptionalTable_t*)spec[s].dest = parse_table(non_opt_type, num_args, &argv[i+1]); + *(OptionalTable_t *)spec[s].dest = parse_table(non_opt_type, num_args, &argv[i + 1]); } else if (non_opt_type == &Bool$info) { // --flag populated_args[s] = true; - *(OptionalBool_t*)spec[s].dest = true; + *(OptionalBool_t *)spec[s].dest = true; } else { - if (i + 1 >= argc) - print_err("Missing argument: ", argv[i], "\n", usage); - used_args[i+1] = true; - populated_args[s] = parse_single_arg(spec[s].type, argv[i+1], spec[s].dest); + if (i + 1 >= argc) print_err("Missing argument: ", argv[i], "\n", usage); + used_args[i + 1] = true; + populated_args[s] = parse_single_arg(spec[s].type, argv[i + 1], spec[s].dest); if (!populated_args[s]) - print_err("Couldn't parse argument: ", argv[i], " ", argv[i+1], "\n", usage); + print_err("Couldn't parse argument: ", argv[i], " ", argv[i + 1], "\n", usage); } goto next_arg; } else if (after_name == '=') { // --foo=val used_args[i] = true; - populated_args[s] = parse_single_arg(spec[s].type, 2 + argv[i] + strlen(spec[s].name) + 1, spec[s].dest); - if (!populated_args[s]) - print_err("Couldn't parse argument: ", argv[i], "\n", usage); + populated_args[s] = + parse_single_arg(spec[s].type, 2 + argv[i] + strlen(spec[s].name) + 1, spec[s].dest); + if (!populated_args[s]) print_err("Couldn't parse argument: ", argv[i], "\n", usage); goto next_arg; } else { continue; @@ -324,8 +300,7 @@ public void _tomo_parse_args(int argc, char *argv[], Text_t usage, Text_t help, for (char *f = argv[i] + 1; *f; f++) { char flag[] = {'-', *f, 0}; for (int s = 0; s < spec_len; s++) { - if (spec[s].name[0] != *f || strlen(spec[s].name) > 1) - continue; + if (spec[s].name[0] != *f || strlen(spec[s].name) > 1) continue; const TypeInfo_t *non_opt_type = spec[s].type; while (non_opt_type->tag == OptionalInfo) @@ -335,32 +310,31 @@ public void _tomo_parse_args(int argc, char *argv[], Text_t usage, Text_t help, if (f[1]) print_err("No value provided for ", flag, "\n", usage); int num_args = 0; while (i + 1 + num_args < argc) { - if (argv[i+1+num_args][0] == '-') - break; - used_args[i+1+num_args] = true; + if (argv[i + 1 + num_args][0] == '-') break; + used_args[i + 1 + num_args] = true; num_args += 1; } populated_args[s] = true; - *(OptionalList_t*)spec[s].dest = parse_list(non_opt_type->ListInfo.item, num_args, &argv[i+1]); + *(OptionalList_t *)spec[s].dest = + parse_list(non_opt_type->ListInfo.item, num_args, &argv[i + 1]); } else if (non_opt_type->tag == TableInfo) { int num_args = 0; while (i + 1 + num_args < argc) { - if (argv[i+1+num_args][0] == '-' || !strchr(argv[i+1+num_args], '=')) - break; - used_args[i+1+num_args] = true; + if (argv[i + 1 + num_args][0] == '-' || !strchr(argv[i + 1 + num_args], '=')) break; + used_args[i + 1 + num_args] = true; num_args += 1; } populated_args[s] = true; - *(OptionalTable_t*)spec[s].dest = parse_table(non_opt_type, num_args, &argv[i+1]); + *(OptionalTable_t *)spec[s].dest = parse_table(non_opt_type, num_args, &argv[i + 1]); } else if (non_opt_type == &Bool$info) { // -f populated_args[s] = true; - *(OptionalBool_t*)spec[s].dest = true; + *(OptionalBool_t *)spec[s].dest = true; } else { - if (f[1] || i+1 >= argc) print_err("No value provided for ", flag, "\n", usage); - used_args[i+1] = true; - populated_args[s] = parse_single_arg(spec[s].type, argv[i+1], spec[s].dest); + if (f[1] || i + 1 >= argc) print_err("No value provided for ", flag, "\n", usage); + used_args[i + 1] = true; + populated_args[s] = parse_single_arg(spec[s].type, argv[i + 1], spec[s].dest); if (!populated_args[s]) - print_err("Couldn't parse argument: ", argv[i], " ", argv[i+1], "\n", usage); + print_err("Couldn't parse argument: ", argv[i], " ", argv[i + 1], "\n", usage); } goto next_flag; } @@ -370,7 +344,7 @@ public void _tomo_parse_args(int argc, char *argv[], Text_t usage, Text_t help, exit(0); } print_err("Unrecognized flag: ", flag, "\n", usage); - next_flag:; + next_flag:; } } else { // Handle positional args later @@ -378,7 +352,7 @@ public void _tomo_parse_args(int argc, char *argv[], Text_t usage, Text_t help, continue; } - next_arg: + next_arg: while (used_args[i] && i < argc) i += 1; } @@ -393,10 +367,9 @@ public void _tomo_parse_args(int argc, char *argv[], Text_t usage, Text_t help, if (used_args[i]) continue; while (populated_args[s]) { - next_non_bool_flag: + next_non_bool_flag: ++s; - if (s >= spec_len) - print_err("Extra argument: ", argv[i], "\n", usage); + if (s >= spec_len) print_err("Extra argument: ", argv[i], "\n", usage); } const TypeInfo_t *non_opt_type = spec[s].type; @@ -404,45 +377,40 @@ public void _tomo_parse_args(int argc, char *argv[], Text_t usage, Text_t help, non_opt_type = non_opt_type->OptionalInfo.type; // You can't specify boolean flags positionally - if (non_opt_type == &Bool$info) - goto next_non_bool_flag; + if (non_opt_type == &Bool$info) goto next_non_bool_flag; if (non_opt_type->tag == ListInfo) { int num_args = 0; while (i + num_args < argc) { - if (!ignore_dashes && (argv[i+num_args][0] == '-' && !isdigit(argv[i+num_args][1]))) - break; - used_args[i+num_args] = true; + if (!ignore_dashes && (argv[i + num_args][0] == '-' && !isdigit(argv[i + num_args][1]))) break; + used_args[i + num_args] = true; num_args += 1; } populated_args[s] = true; - *(OptionalList_t*)spec[s].dest = parse_list(non_opt_type->ListInfo.item, num_args, &argv[i]); + *(OptionalList_t *)spec[s].dest = parse_list(non_opt_type->ListInfo.item, num_args, &argv[i]); } else if (non_opt_type->tag == TableInfo) { int num_args = 0; while (i + num_args < argc) { - if ((argv[i+num_args][0] == '-' && !isdigit(argv[i+num_args][1])) || !strchr(argv[i+num_args], '=')) + if ((argv[i + num_args][0] == '-' && !isdigit(argv[i + num_args][1])) + || !strchr(argv[i + num_args], '=')) break; - used_args[i+num_args] = true; + used_args[i + num_args] = true; num_args += 1; } populated_args[s] = true; - *(OptionalTable_t*)spec[s].dest = parse_table(non_opt_type, num_args, &argv[i]); + *(OptionalTable_t *)spec[s].dest = parse_table(non_opt_type, num_args, &argv[i]); } else { populated_args[s] = parse_single_arg(spec[s].type, argv[i], spec[s].dest); } - if (!populated_args[s]) - print_err("Invalid value for ", spec[s].name, ": ", argv[i], "\n", usage); + if (!populated_args[s]) print_err("Invalid value for ", spec[s].name, ": ", argv[i], "\n", usage); } for (int s = 0; s < spec_len; s++) { if (!populated_args[s] && spec[s].required) { - if (spec[s].type->tag == ListInfo) - *(OptionalList_t*)spec[s].dest = (List_t){}; - else if (spec[s].type->tag == TableInfo) - *(OptionalTable_t*)spec[s].dest = (Table_t){}; - else - print_err("The required argument '", spec[s].name, "' was not provided\n", usage); + if (spec[s].type->tag == ListInfo) *(OptionalList_t *)spec[s].dest = (List_t){}; + else if (spec[s].type->tag == TableInfo) *(OptionalTable_t *)spec[s].dest = (Table_t){}; + else print_err("The required argument '", spec[s].name, "' was not provided\n", usage); } } } @@ -450,24 +418,18 @@ public void _tomo_parse_args(int argc, char *argv[], Text_t usage, Text_t help, #pragma GCC diagnostic pop #endif -public _Noreturn void fail_text(Text_t message) -{ - fail(message); -} +public +_Noreturn void fail_text(Text_t message) { fail(message); } -public Text_t builtin_last_err() -{ - return Text$from_str(strerror(errno)); -} +public +Text_t builtin_last_err() { return Text$from_str(strerror(errno)); } static int _inspect_depth = 0; static file_t *file = NULL; -__attribute__((nonnull)) -public void start_inspect(const char *filename, int64_t start, int64_t end) -{ - if (file == NULL || strcmp(file->filename, filename) != 0) - file = load_file(filename); +__attribute__((nonnull)) public +void start_inspect(const char *filename, int64_t start, int64_t end) { + if (file == NULL || strcmp(file->filename, filename) != 0) file = load_file(filename); if (file) { size_t first_line_len = strcspn(file->text + start, "\r\n"); @@ -476,26 +438,25 @@ public void start_inspect(const char *filename, int64_t start, int64_t end) int64_t line_num = get_line_number(file, file->text + start); if (USE_COLOR) { - print(repeated_char(' ', 3*_inspect_depth), "\x1b[33;1m>> \x1b[m", - string_slice(file->text + start, first_line_len), - " ", repeated_char(' ', MAX(0, 35-(int64_t)first_line_len-3*_inspect_depth)), - "\x1b[32;2m[", file_base, ":", line_num, "]\x1b[m"); + print(repeated_char(' ', 3 * _inspect_depth), "\x1b[33;1m>> \x1b[m", + string_slice(file->text + start, first_line_len), " ", + repeated_char(' ', MAX(0, 35 - (int64_t)first_line_len - 3 * _inspect_depth)), "\x1b[32;2m[", + file_base, ":", line_num, "]\x1b[m"); } else { - print(repeated_char(' ', 3*_inspect_depth), ">> ", - string_slice(file->text + start, first_line_len), - " ", repeated_char(' ', MAX(0, 35-(int64_t)first_line_len-3*_inspect_depth)), - "[", file_base, ":", line_num, "]"); + print(repeated_char(' ', 3 * _inspect_depth), ">> ", string_slice(file->text + start, first_line_len), + " ", repeated_char(' ', MAX(0, 35 - (int64_t)first_line_len - 3 * _inspect_depth)), "[", file_base, + ":", line_num, "]"); } // For multi-line expressions, dedent each and print it on a new line with ".. " in front: if (end > start + (int64_t)first_line_len) { const char *line_start = get_line(file, line_num); int64_t indent_len = (int64_t)strspn(line_start, " \t"); - for (const char *line = file->text + start + first_line_len; line < file->text + end; line += strcspn(line, "\r\n")) { + for (const char *line = file->text + start + first_line_len; line < file->text + end; + line += strcspn(line, "\r\n")) { line += strspn(line, "\r\n"); - if ((int64_t)strspn(line, " \t") >= indent_len) - line += indent_len; - print(repeated_char(' ', 3*_inspect_depth), USE_COLOR ? "\x1b[33m.. " : ".. ", + if ((int64_t)strspn(line, " \t") >= indent_len) line += indent_len; + print(repeated_char(' ', 3 * _inspect_depth), USE_COLOR ? "\x1b[33m.. " : ".. ", string_slice(line, strcspn(line, "\r\n"))); } } @@ -503,23 +464,24 @@ public void start_inspect(const char *filename, int64_t start, int64_t end) _inspect_depth += 1; } -public void end_inspect(const void *expr, const TypeInfo_t *type) -{ +public +void end_inspect(const void *expr, const TypeInfo_t *type) { _inspect_depth -= 1; if (type && type->metamethods.as_text) { Text_t expr_text = generic_as_text(expr, USE_COLOR, type); Text_t type_name = generic_as_text(NULL, false, type); - for (int i = 0; i < 3*_inspect_depth; i++) fputc(' ', stdout); - fprint(stdout, USE_COLOR ? "\x1b[33;1m=\x1b[0m " : "= ", expr_text, USE_COLOR ? " \x1b[2m: \x1b[36m" : " : ", type_name, USE_COLOR ? "\033[m" : ""); + for (int i = 0; i < 3 * _inspect_depth; i++) + fputc(' ', stdout); + fprint(stdout, USE_COLOR ? "\x1b[33;1m=\x1b[0m " : "= ", expr_text, USE_COLOR ? " \x1b[2m: \x1b[36m" : " : ", + type_name, USE_COLOR ? "\033[m" : ""); } } -__attribute__((nonnull)) -public void test_value(const char *filename, int64_t start, int64_t end, const void *expr, const void *expected, const TypeInfo_t *type) -{ - if (generic_equal(expr, expected, type)) - return; +__attribute__((nonnull)) public +void test_value(const char *filename, int64_t start, int64_t end, const void *expr, const void *expected, + const TypeInfo_t *type) { + if (generic_equal(expr, expected, type)) return; print_stacktrace(stderr, 2); fprint(stderr, ""); @@ -532,38 +494,42 @@ public void test_value(const char *filename, int64_t start, int64_t end, const v Text_t expr_text = generic_as_text(expr, USE_COLOR, type); Text_t expected_text = generic_as_text(expected, USE_COLOR, type); if (USE_COLOR) { - fprint(stderr, - "\n\x1b[31;7m ==================== TEST FAILED ==================== \x1b[0;1m\n\n" - "You expected: \x1b[m", expected_text, "\x1b[0m\n" - "\x1b[1m But I got:\x1b[m ", expr_text, "\n"); + fprint(stderr, + "\n\x1b[31;7m ==================== TEST FAILED ==================== \x1b[0;1m\n\n" + "You expected: \x1b[m", + expected_text, + "\x1b[0m\n" + "\x1b[1m But I got:\x1b[m ", + expr_text, "\n"); } else { - fprint(stderr, - "\n==================== TEST FAILED ====================\n\n" - "You expected: ", expected_text, "\n" - " But I got: ", expr_text, "\n"); + fprint(stderr, + "\n==================== TEST FAILED ====================\n\n" + "You expected: ", + expected_text, + "\n" + " But I got: ", + expr_text, "\n"); } fflush(stderr); raise(SIGABRT); } -public void say(Text_t text, bool newline) -{ +public +void say(Text_t text, bool newline) { Text$print(stdout, text); - if (newline) - fputc('\n', stdout); + if (newline) fputc('\n', stdout); fflush(stdout); } -public _Noreturn void tomo_exit(Text_t text, int32_t status) -{ - if (text.length > 0) - print(text); +public +_Noreturn void tomo_exit(Text_t text, int32_t status) { + if (text.length > 0) print(text); _exit(status); } -public OptionalText_t ask(Text_t prompt, bool bold, bool force_tty) -{ +public +OptionalText_t ask(Text_t prompt, bool bold, bool force_tty) { OptionalText_t ret = NONE_TEXT; FILE *out = stdout; FILE *in = stdin; @@ -597,8 +563,8 @@ public OptionalText_t ask(Text_t prompt, bool bold, bool force_tty) goto cleanup; } - if (length > 0 && line[length-1] == '\n') { - line[length-1] = '\0'; + if (length > 0 && line[length - 1] == '\n') { + line[length - 1] = '\0'; --length; } @@ -607,14 +573,14 @@ public OptionalText_t ask(Text_t prompt, bool bold, bool force_tty) ret = Text$from_strn(gc_input, (size_t)(length)); - cleanup: +cleanup: if (out && out != stdout) fclose(out); if (in && in != stdin) fclose(in); return ret; } -public bool pop_flag(char **argv, int *i, const char *flag, Text_t *result) -{ +public +bool pop_flag(char **argv, int *i, const char *flag, Text_t *result) { if (argv[*i][0] != '-' || argv[*i][1] != '-') { return false; } else if (streq(argv[*i] + 2, flag)) { @@ -637,23 +603,21 @@ public bool pop_flag(char **argv, int *i, const char *flag, Text_t *result) } } -public void sleep_num(double seconds) -{ +public +void sleep_num(double seconds) { struct timespec ts; ts.tv_sec = (time_t)seconds; ts.tv_nsec = (long)((seconds - (double)ts.tv_sec) * 1e9); nanosleep(&ts, NULL); } -public OptionalText_t getenv_text(Text_t name) -{ +public +OptionalText_t getenv_text(Text_t name) { const char *val = getenv(Text$as_c_string(name)); return val ? Text$from_str(val) : NONE_TEXT; } -public void setenv_text(Text_t name, Text_t value) -{ - setenv(Text$as_c_string(name), Text$as_c_string(value), 1); -} +public +void setenv_text(Text_t name, Text_t value) { setenv(Text$as_c_string(name), Text$as_c_string(value), 1); } // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/stdlib.h b/src/stdlib/stdlib.h index 8ac35f72..c676beb1 100644 --- a/src/stdlib/stdlib.h +++ b/src/stdlib/stdlib.h @@ -23,66 +23,72 @@ typedef struct { } cli_arg_t; void tomo_init(void); -void _tomo_parse_args(int argc, char *argv[], Text_t usage, Text_t help, const char *version, int spec_len, cli_arg_t spec[spec_len]); -#define tomo_parse_args(argc, argv, usage, help, version, ...) \ - _tomo_parse_args(argc, argv, usage, help, version, sizeof((cli_arg_t[]){__VA_ARGS__})/sizeof(cli_arg_t), (cli_arg_t[]){__VA_ARGS__}) +void _tomo_parse_args(int argc, char *argv[], Text_t usage, Text_t help, const char *version, int spec_len, + cli_arg_t spec[spec_len]); +#define tomo_parse_args(argc, argv, usage, help, version, ...) \ + _tomo_parse_args(argc, argv, usage, help, version, sizeof((cli_arg_t[]){__VA_ARGS__}) / sizeof(cli_arg_t), \ + (cli_arg_t[]){__VA_ARGS__}) -#define fail(...) ({ \ - fflush(stdout); \ - if (USE_COLOR) fputs("\x1b[31;7m ==================== ERROR ==================== \033[m\n\n", stderr); \ - else fputs("==================== ERROR ====================\n\n", stderr); \ - print_stacktrace(stderr, 1); \ - if (USE_COLOR) fputs("\n\x1b[31;1m", stderr); \ - else fputs("\n", stderr); \ - fprint_inline(stderr, "Error: ", __VA_ARGS__); \ - if (USE_COLOR) fputs("\x1b[m\n", stderr); \ - else fputs("\n", stderr); \ - fflush(stderr); \ - raise(SIGABRT); \ - _exit(1); \ -}) +#define fail(...) \ + ({ \ + fflush(stdout); \ + if (USE_COLOR) fputs("\x1b[31;7m ==================== ERROR ==================== \033[m\n\n", stderr); \ + else fputs("==================== ERROR ====================\n\n", stderr); \ + print_stacktrace(stderr, 1); \ + if (USE_COLOR) fputs("\n\x1b[31;1m", stderr); \ + else fputs("\n", stderr); \ + fprint_inline(stderr, "Error: ", __VA_ARGS__); \ + if (USE_COLOR) fputs("\x1b[m\n", stderr); \ + else fputs("\n", stderr); \ + fflush(stderr); \ + raise(SIGABRT); \ + _exit(1); \ + }) -#define fail_source(filename, start, end, ...) ({ \ - fflush(stdout); \ - if (USE_COLOR) fputs("\x1b[31;7m ==================== ERROR ==================== \n\n\x1b[0;1m", stderr); \ - else fputs("==================== ERROR ====================\n\n", stderr); \ - print_stacktrace(stderr, 0); \ - fputs("\n", stderr); \ - if (USE_COLOR) fputs("\x1b[31;1m", stderr); \ - fprint_inline(stderr, __VA_ARGS__); \ - file_t *_file = (filename) ? load_file(filename) : NULL; \ - if ((filename) && _file) { \ - fputs("\n", stderr); \ - highlight_error(_file, _file->text+(start), _file->text+(end), "\x1b[31;1m", 1, USE_COLOR); \ - } \ - if (USE_COLOR) fputs("\x1b[m", stderr); \ - fflush(stderr); \ - raise(SIGABRT); \ - _exit(1); \ -}) +#define fail_source(filename, start, end, ...) \ + ({ \ + fflush(stdout); \ + if (USE_COLOR) fputs("\x1b[31;7m ==================== ERROR ==================== \n\n\x1b[0;1m", stderr); \ + else fputs("==================== ERROR ====================\n\n", stderr); \ + print_stacktrace(stderr, 0); \ + fputs("\n", stderr); \ + if (USE_COLOR) fputs("\x1b[31;1m", stderr); \ + fprint_inline(stderr, __VA_ARGS__); \ + file_t *_file = (filename) ? load_file(filename) : NULL; \ + if ((filename) && _file) { \ + fputs("\n", stderr); \ + highlight_error(_file, _file->text + (start), _file->text + (end), "\x1b[31;1m", 1, USE_COLOR); \ + } \ + if (USE_COLOR) fputs("\x1b[m", stderr); \ + fflush(stderr); \ + raise(SIGABRT); \ + _exit(1); \ + }) _Noreturn void fail_text(Text_t message); Text_t builtin_last_err(); -__attribute__((nonnull)) -void start_inspect(const char *filename, int64_t start, int64_t end); +__attribute__((nonnull)) void start_inspect(const char *filename, int64_t start, int64_t end); void end_inspect(const void *expr, const TypeInfo_t *type); -#define inspect(type, expr, typeinfo, start, end) {\ - start_inspect(__SOURCE_FILE__, start, end); \ - type _expr = expr; \ - end_inspect(&_expr, typeinfo); \ -} -#define inspect_void(expr, typeinfo, start, end) {\ - start_inspect(__SOURCE_FILE__, start, end); \ - expr; \ - end_inspect(NULL, typeinfo); \ -} -__attribute__((nonnull)) -void test_value(const char *filename, int64_t start, int64_t end, const void *expr, const void *expected, const TypeInfo_t *type); -#define test(type, expr, expected, typeinfo, start, end) {\ - type _expr = expr; \ - type _expected = expected; \ - test_value(__SOURCE_FILE__, start, end, &_expr, &_expected, typeinfo); \ -} +#define inspect(type, expr, typeinfo, start, end) \ + { \ + start_inspect(__SOURCE_FILE__, start, end); \ + type _expr = expr; \ + end_inspect(&_expr, typeinfo); \ + } +#define inspect_void(expr, typeinfo, start, end) \ + { \ + start_inspect(__SOURCE_FILE__, start, end); \ + expr; \ + end_inspect(NULL, typeinfo); \ + } +__attribute__((nonnull)) void test_value(const char *filename, int64_t start, int64_t end, const void *expr, + const void *expected, const TypeInfo_t *type); +#define test(type, expr, expected, typeinfo, start, end) \ + { \ + type _expr = expr; \ + type _expected = expected; \ + test_value(__SOURCE_FILE__, start, end, &_expr, &_expected, typeinfo); \ + } void say(Text_t text, bool newline); Text_t ask(Text_t prompt, bool bold, bool force_tty); diff --git a/src/stdlib/structs.c b/src/stdlib/structs.c index 5d6b2319..d2300b74 100644 --- a/src/stdlib/structs.c +++ b/src/stdlib/structs.c @@ -13,13 +13,10 @@ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstack-protector" #endif -PUREFUNC public uint64_t Struct$hash(const void *obj, const TypeInfo_t *type) -{ - if (type->StructInfo.num_fields == 0) - return 0; +PUREFUNC public uint64_t Struct$hash(const void *obj, const TypeInfo_t *type) { + if (type->StructInfo.num_fields == 0) return 0; - if (type->StructInfo.num_fields == 1) - return generic_hash(obj, type->StructInfo.fields[0].type); + if (type->StructInfo.num_fields == 1) return generic_hash(obj, type->StructInfo.fields[0].type); uint64_t field_hashes[type->StructInfo.num_fields]; ptrdiff_t byte_offset = 0; @@ -27,7 +24,7 @@ PUREFUNC public uint64_t Struct$hash(const void *obj, const TypeInfo_t *type) for (int i = 0; i < type->StructInfo.num_fields; i++) { NamedType_t field = type->StructInfo.fields[i]; if (field.type == &Bool$info) { - bool b = ((*(char*)(obj + byte_offset)) >> bit_offset) & 0x1; + bool b = ((*(char *)(obj + byte_offset)) >> bit_offset) & 0x1; field_hashes[i] = (uint32_t)b; bit_offset += 1; if (bit_offset >= 8) { @@ -45,34 +42,29 @@ PUREFUNC public uint64_t Struct$hash(const void *obj, const TypeInfo_t *type) byte_offset += field.type->size; } } - return siphash24((void*)field_hashes, sizeof(field_hashes)); + return siphash24((void *)field_hashes, sizeof(field_hashes)); } #ifdef __GNUC__ #pragma GCC diagnostic pop #endif -PUREFUNC public uint64_t PackedData$hash(const void *obj, const TypeInfo_t *type) -{ - if (type->StructInfo.num_fields == 0) - return 0; +PUREFUNC public uint64_t PackedData$hash(const void *obj, const TypeInfo_t *type) { + if (type->StructInfo.num_fields == 0) return 0; return siphash24(obj, (size_t)type->size); } -PUREFUNC public int32_t Struct$compare(const void *x, const void *y, const TypeInfo_t *type) -{ - if (x == y) - return 0; +PUREFUNC public int32_t Struct$compare(const void *x, const void *y, const TypeInfo_t *type) { + if (x == y) return 0; ptrdiff_t byte_offset = 0; ptrdiff_t bit_offset = 0; for (int i = 0; i < type->StructInfo.num_fields; i++) { NamedType_t field = type->StructInfo.fields[i]; if (field.type == &Bool$info) { - bool bx = ((*(char*)(x + byte_offset)) >> bit_offset) & 0x1; - bool by = ((*(char*)(y + byte_offset)) >> bit_offset) & 0x1; - if (bx != by) - return (int32_t)bx - (int32_t)by; + bool bx = ((*(char *)(x + byte_offset)) >> bit_offset) & 0x1; + bool by = ((*(char *)(y + byte_offset)) >> bit_offset) & 0x1; + if (bx != by) return (int32_t)bx - (int32_t)by; bit_offset += 1; if (bit_offset >= 8) { byte_offset += 1; @@ -86,28 +78,24 @@ PUREFUNC public int32_t Struct$compare(const void *x, const void *y, const TypeI if (field.type->align && byte_offset % field.type->align > 0) byte_offset += field.type->align - (byte_offset % field.type->align); int32_t cmp = generic_compare(x + byte_offset, y + byte_offset, field.type); - if (cmp != 0) - return cmp; + if (cmp != 0) return cmp; byte_offset += field.type->size; } } return 0; } -PUREFUNC public bool Struct$equal(const void *x, const void *y, const TypeInfo_t *type) -{ - if (x == y) - return true; +PUREFUNC public bool Struct$equal(const void *x, const void *y, const TypeInfo_t *type) { + if (x == y) return true; ptrdiff_t byte_offset = 0; ptrdiff_t bit_offset = 0; for (int i = 0; i < type->StructInfo.num_fields; i++) { NamedType_t field = type->StructInfo.fields[i]; if (field.type == &Bool$info) { - bool bx = ((*(char*)(x + byte_offset)) >> bit_offset) & 0x1; - bool by = ((*(char*)(y + byte_offset)) >> bit_offset) & 0x1; - if (bx != by) - return false; + bool bx = ((*(char *)(x + byte_offset)) >> bit_offset) & 0x1; + bool by = ((*(char *)(y + byte_offset)) >> bit_offset) & 0x1; + if (bx != by) return false; bit_offset += 1; if (bit_offset >= 8) { byte_offset += 1; @@ -120,22 +108,19 @@ PUREFUNC public bool Struct$equal(const void *x, const void *y, const TypeInfo_t } if (field.type->align && byte_offset % field.type->align > 0) byte_offset += field.type->align - (byte_offset % field.type->align); - if (!generic_equal(x + byte_offset, y + byte_offset, field.type)) - return false; + if (!generic_equal(x + byte_offset, y + byte_offset, field.type)) return false; byte_offset += field.type->size; } } return true; } -PUREFUNC public bool PackedData$equal(const void *x, const void *y, const TypeInfo_t *type) -{ +PUREFUNC public bool PackedData$equal(const void *x, const void *y, const TypeInfo_t *type) { if (x == y) return true; return (memcmp(x, y, (size_t)type->size) == 0); } -PUREFUNC public Text_t Struct$as_text(const void *obj, bool colorize, const TypeInfo_t *type) -{ +PUREFUNC public Text_t Struct$as_text(const void *obj, bool colorize, const TypeInfo_t *type) { if (!obj) return Text$from_str(type->StructInfo.name); Text_t name = Text$from_str(type->StructInfo.name); @@ -148,15 +133,14 @@ PUREFUNC public Text_t Struct$as_text(const void *obj, bool colorize, const Type ptrdiff_t bit_offset = 0; for (int i = 0; i < type->StructInfo.num_fields; i++) { NamedType_t field = type->StructInfo.fields[i]; - if (i > 0) - text = Text$concat(text, Text(", ")); + if (i > 0) text = Text$concat(text, Text(", ")); - if (type->StructInfo.num_fields > 1) - text = Text$concat(text, Text$from_str(field.name), Text("=")); + if (type->StructInfo.num_fields > 1) text = Text$concat(text, Text$from_str(field.name), Text("=")); if (field.type == &Bool$info) { - bool b = ((*(char*)(obj + byte_offset)) >> bit_offset) & 0x1; - text = Text$concat(text, Text$from_str(colorize ? (b ? "\x1b[35myes\x1b[m" : "\x1b[35mno\x1b[m") : (b ? "yes" : "no"))); + bool b = ((*(char *)(obj + byte_offset)) >> bit_offset) & 0x1; + text = Text$concat( + text, Text$from_str(colorize ? (b ? "\x1b[35myes\x1b[m" : "\x1b[35mno\x1b[m") : (b ? "yes" : "no"))); bit_offset += 1; if (bit_offset >= 8) { byte_offset += 1; @@ -176,19 +160,16 @@ PUREFUNC public Text_t Struct$as_text(const void *obj, bool colorize, const Type return Text$concat(text, Text(")")); } -PUREFUNC public bool Struct$is_none(const void *obj, const TypeInfo_t *type) -{ - return *(bool*)(obj + type->size); -} +PUREFUNC public bool Struct$is_none(const void *obj, const TypeInfo_t *type) { return *(bool *)(obj + type->size); } -public void Struct$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) -{ +public +void Struct$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) { ptrdiff_t byte_offset = 0; ptrdiff_t bit_offset = 0; for (int i = 0; i < type->StructInfo.num_fields; i++) { NamedType_t field = type->StructInfo.fields[i]; if (field.type == &Bool$info) { - bool b = ((*(char*)(obj + byte_offset)) >> bit_offset) & 0x1; + bool b = ((*(char *)(obj + byte_offset)) >> bit_offset) & 0x1; fputc((int)b, out); bit_offset += 1; if (bit_offset >= 8) { @@ -208,15 +189,15 @@ public void Struct$serialize(const void *obj, FILE *out, Table_t *pointers, cons } } -public void Struct$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *type) -{ +public +void Struct$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *type) { ptrdiff_t byte_offset = 0; ptrdiff_t bit_offset = 0; for (int i = 0; i < type->StructInfo.num_fields; i++) { NamedType_t field = type->StructInfo.fields[i]; if (field.type == &Bool$info) { bool b = (bool)fgetc(in); - *(char*)(outval + byte_offset) |= (b << bit_offset); + *(char *)(outval + byte_offset) |= (b << bit_offset); bit_offset += 1; if (bit_offset >= 8) { byte_offset += 1; diff --git a/src/stdlib/structs.h b/src/stdlib/structs.h index c9c6c40a..03c051ec 100644 --- a/src/stdlib/structs.h +++ b/src/stdlib/structs.h @@ -17,24 +17,26 @@ PUREFUNC bool Struct$is_none(const void *obj, const TypeInfo_t *type); void Struct$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type); void Struct$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *type); -#define Struct$metamethods { \ - .hash=Struct$hash, \ - .compare=Struct$compare, \ - .equal=Struct$equal, \ - .as_text=Struct$as_text, \ - .is_none=Struct$is_none, \ - .serialize=Struct$serialize, \ - .deserialize=Struct$deserialize, \ -} +#define Struct$metamethods \ + { \ + .hash = Struct$hash, \ + .compare = Struct$compare, \ + .equal = Struct$equal, \ + .as_text = Struct$as_text, \ + .is_none = Struct$is_none, \ + .serialize = Struct$serialize, \ + .deserialize = Struct$deserialize, \ + } -#define PackedData$metamethods { \ - .hash=PackedData$hash, \ - .compare=Struct$compare, \ - .equal=PackedData$equal, \ - .as_text=Struct$as_text, \ - .is_none=Struct$is_none, \ - .serialize=Struct$serialize, \ - .deserialize=Struct$deserialize, \ -} +#define PackedData$metamethods \ + { \ + .hash = PackedData$hash, \ + .compare = Struct$compare, \ + .equal = PackedData$equal, \ + .as_text = Struct$as_text, \ + .is_none = Struct$is_none, \ + .serialize = Struct$serialize, \ + .deserialize = Struct$deserialize, \ + } // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/tables.c b/src/stdlib/tables.c index 63f8eb09..781da415 100644 --- a/src/stdlib/tables.c +++ b/src/stdlib/tables.c @@ -41,29 +41,29 @@ #define EQUAL_KEYS(x, y) (generic_equal((x), (y), type->TableInfo.key)) #define END_OF_CHAIN UINT32_MAX -#define GET_ENTRY(t, i) ((t).entries.data + (t).entries.stride*(i)) +#define GET_ENTRY(t, i) ((t).entries.data + (t).entries.stride * (i)) static TypeInfo_t MemoryPointer = { - .size=sizeof(void*), - .align=__alignof__(void*), - .tag=PointerInfo, - .PointerInfo={ - .sigil="@", - .pointed=&Memory$info, - }, - .metamethods=Pointer$metamethods, + .size = sizeof(void *), + .align = __alignof__(void *), + .tag = PointerInfo, + .PointerInfo = + { + .sigil = "@", + .pointed = &Memory$info, + }, + .metamethods = Pointer$metamethods, }; const TypeInfo_t CStrToVoidStarTable = { - .size=sizeof(Table_t), - .align=__alignof__(Table_t), - .tag=TableInfo, - .TableInfo={.key=&CString$info, .value=&MemoryPointer}, - .metamethods=Table$metamethods, + .size = sizeof(Table_t), + .align = __alignof__(Table_t), + .tag = TableInfo, + .TableInfo = {.key = &CString$info, .value = &MemoryPointer}, + .metamethods = Table$metamethods, }; -PUREFUNC static INLINE size_t entry_size(const TypeInfo_t *info) -{ +PUREFUNC static INLINE size_t entry_size(const TypeInfo_t *info) { size_t size = (size_t)info->TableInfo.key->size; if (info->TableInfo.value->align > 1 && size % (size_t)info->TableInfo.value->align) size += (size_t)info->TableInfo.value->align - (size % (size_t)info->TableInfo.value->align); // padding @@ -73,31 +73,27 @@ PUREFUNC static INLINE size_t entry_size(const TypeInfo_t *info) return size; } -PUREFUNC static INLINE size_t value_offset(const TypeInfo_t *info) -{ +PUREFUNC static INLINE size_t value_offset(const TypeInfo_t *info) { size_t offset = (size_t)info->TableInfo.key->size; if ((size_t)info->TableInfo.value->align > 1 && offset % (size_t)info->TableInfo.value->align) offset += (size_t)info->TableInfo.value->align - (offset % (size_t)info->TableInfo.value->align); // padding return offset; } -static INLINE void hshow(const Table_t *t) -{ +static INLINE void hshow(const Table_t *t) { hdebug("{"); for (uint32_t i = 0; t->bucket_info && i < t->bucket_info->count; i++) { if (i > 0) hdebug(" "); if (t->bucket_info->buckets[i].occupied) - hdebug("[", i, "]=", (uint32_t)t->bucket_info->buckets[i].index, "(", t->bucket_info->buckets[i].next_bucket, ")"); - else - hdebug("[", i, "]=_"); + hdebug("[", i, "]=", (uint32_t)t->bucket_info->buckets[i].index, "(", + t->bucket_info->buckets[i].next_bucket, ")"); + else hdebug("[", i, "]=_"); } hdebug("}\n"); } -static void maybe_copy_on_write(Table_t *t, const TypeInfo_t *type) -{ - if (t->entries.data_refcount != 0) - List$compact(&t->entries, (int64_t)entry_size(type)); +static void maybe_copy_on_write(Table_t *t, const TypeInfo_t *type) { + if (t->entries.data_refcount != 0) List$compact(&t->entries, (int64_t)entry_size(type)); if (t->bucket_info && t->bucket_info->data_refcount != 0) { size_t size = sizeof(bucket_info_t) + sizeof(bucket_t[t->bucket_info->count]); @@ -107,8 +103,7 @@ static void maybe_copy_on_write(Table_t *t, const TypeInfo_t *type) } // Return address of value or NULL -PUREFUNC public void *Table$get_raw(Table_t t, const void *key, const TypeInfo_t *type) -{ +PUREFUNC public void *Table$get_raw(Table_t t, const void *key, const TypeInfo_t *type) { assert(type->tag == TableInfo); if (!key || !t.bucket_info) return NULL; @@ -123,14 +118,12 @@ PUREFUNC public void *Table$get_raw(Table_t t, const void *key, const TypeInfo_t hdebug("Found key!\n"); return entry + value_offset(type); } - if (buckets[i].next_bucket == END_OF_CHAIN) - break; + if (buckets[i].next_bucket == END_OF_CHAIN) break; } return NULL; } -PUREFUNC public void *Table$get(Table_t t, const void *key, const TypeInfo_t *type) -{ +PUREFUNC public void *Table$get(Table_t t, const void *key, const TypeInfo_t *type) { assert(type->tag == TableInfo); for (const Table_t *iter = &t; iter; iter = iter->fallback) { void *ret = Table$get_raw(*iter, key, type); @@ -139,8 +132,7 @@ PUREFUNC public void *Table$get(Table_t t, const void *key, const TypeInfo_t *ty return NULL; } -static void Table$set_bucket(Table_t *t, const void *entry, int32_t index, const TypeInfo_t *type) -{ +static void Table$set_bucket(Table_t *t, const void *entry, int32_t index, const TypeInfo_t *type) { assert(t->bucket_info); hshow(t); const void *key = entry; @@ -182,15 +174,14 @@ static void Table$set_bucket(Table_t *t, const void *entry, int32_t index, const bucket->next_bucket = END_OF_CHAIN; } else { // Collided with the start of a chain, put the new entry in chain position #2 hdebug("Hit start of a chain\n"); - buckets[t->bucket_info->last_free] = (bucket_t){ - .occupied = 1, .index=index, .next_bucket=bucket->next_bucket}; + buckets[t->bucket_info->last_free] = + (bucket_t){.occupied = 1, .index = index, .next_bucket = bucket->next_bucket}; bucket->next_bucket = t->bucket_info->last_free; } hshow(t); } -static void hashmap_resize_buckets(Table_t *t, uint32_t new_capacity, const TypeInfo_t *type) -{ +static void hashmap_resize_buckets(Table_t *t, uint32_t new_capacity, const TypeInfo_t *type) { if (unlikely(new_capacity > TABLE_MAX_BUCKETS)) fail("Table has exceeded the maximum table size (2^31) and cannot grow further!"); hdebug("About to resize from ", t->bucket_info ? (int32_t)t->bucket_info->count : 0, " to ", new_capacity, "\n"); @@ -199,7 +190,7 @@ static void hashmap_resize_buckets(Table_t *t, uint32_t new_capacity, const Type t->bucket_info = GC_MALLOC_ATOMIC(alloc_size); memset(t->bucket_info->buckets, 0, sizeof(bucket_t[new_capacity])); t->bucket_info->count = new_capacity; - t->bucket_info->last_free = new_capacity-1; + t->bucket_info->last_free = new_capacity - 1; // Rehash: for (int64_t i = 0; i < Table$length(*t); i++) { hdebug("Rehashing ", i, "\n"); @@ -215,16 +206,15 @@ static void hashmap_resize_buckets(Table_t *t, uint32_t new_capacity, const Type #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstack-protector" #endif -public void *Table$reserve(Table_t *t, const void *key, const void *value, const TypeInfo_t *type) -{ +public +void *Table$reserve(Table_t *t, const void *key, const void *value, const TypeInfo_t *type) { assert(type->tag == TableInfo); if (!t || !key) return NULL; hshow(t); t->hash = 0; - int64_t key_size = type->TableInfo.key->size, - value_size = type->TableInfo.value->size; + int64_t key_size = type->TableInfo.key->size, value_size = type->TableInfo.value->size; if (!t->bucket_info || t->bucket_info->count == 0) { hashmap_resize_buckets(t, 8, type); } else { @@ -236,8 +226,7 @@ public void *Table$reserve(Table_t *t, const void *key, const void *value, const maybe_copy_on_write(t, type); value_home = t->entries.data + offset; - if (value && value_size > 0) - memcpy(value_home, value, (size_t)value_size); + if (value && value_size > 0) memcpy(value_home, value, (size_t)value_size); return value_home; } @@ -247,9 +236,8 @@ public void *Table$reserve(Table_t *t, const void *key, const void *value, const // Resize buckets if necessary if (t->entries.length >= (int64_t)t->bucket_info->count) { // Current resize policy: +50% at a time: - uint32_t newsize = MAX(8, (uint32_t)(3*t->bucket_info->count)/2); - if (unlikely(newsize > TABLE_MAX_BUCKETS)) - newsize = TABLE_MAX_BUCKETS; + uint32_t newsize = MAX(8, (uint32_t)(3 * t->bucket_info->count) / 2); + if (unlikely(newsize > TABLE_MAX_BUCKETS)) newsize = TABLE_MAX_BUCKETS; hashmap_resize_buckets(t, newsize, type); } @@ -265,13 +253,11 @@ public void *Table$reserve(Table_t *t, const void *key, const void *value, const char buf[entry_size(type)]; memset(buf, 0, sizeof(buf)); memcpy(buf, key, (size_t)key_size); - if (value && value_size > 0) - memcpy(buf + value_offset(type), value, (size_t)value_size); - else if (value_size > 0) - memset(buf + value_offset(type), 0, (size_t)value_size); + if (value && value_size > 0) memcpy(buf + value_offset(type), value, (size_t)value_size); + else if (value_size > 0) memset(buf + value_offset(type), 0, (size_t)value_size); List$insert(&t->entries, buf, I(0), (int64_t)entry_size(type)); - int64_t entry_index = t->entries.length-1; + int64_t entry_index = t->entries.length - 1; void *entry = GET_ENTRY(*t, entry_index); Table$set_bucket(t, entry, entry_index, type); return entry + value_offset(type); @@ -280,14 +266,14 @@ public void *Table$reserve(Table_t *t, const void *key, const void *value, const #pragma GCC diagnostic pop #endif -public void Table$set(Table_t *t, const void *key, const void *value, const TypeInfo_t *type) -{ +public +void Table$set(Table_t *t, const void *key, const void *value, const TypeInfo_t *type) { assert(type->tag == TableInfo); (void)Table$reserve(t, key, value, type); } -public void Table$remove(Table_t *t, const void *key, const TypeInfo_t *type) -{ +public +void Table$remove(Table_t *t, const void *key, const TypeInfo_t *type) { assert(type->tag == TableInfo); if (!t || Table$length(*t) == 0) return; @@ -295,8 +281,7 @@ public void Table$remove(Table_t *t, const void *key, const TypeInfo_t *type) maybe_copy_on_write(t, type); // If unspecified, pop the last key: - if (!key) - key = GET_ENTRY(*t, t->entries.length-1); + if (!key) key = GET_ENTRY(*t, t->entries.length - 1); // Steps: look up the bucket for the removed key // If missing, then return immediately @@ -322,13 +307,12 @@ public void Table$remove(Table_t *t, const void *key, const TypeInfo_t *type) hdebug("Found key to delete in bucket ", i, "\n"); goto found_it; } - if (t->bucket_info->buckets[i].next_bucket == END_OF_CHAIN) - return; + if (t->bucket_info->buckets[i].next_bucket == END_OF_CHAIN) return; prev = &t->bucket_info->buckets[i]; } return; - found_it:; +found_it:; assert(bucket->occupied); t->hash = 0; @@ -337,7 +321,7 @@ public void Table$remove(Table_t *t, const void *key, const TypeInfo_t *type) // swap the other entry into the last position and then remove the last // entry. This disturbs the ordering of the table, but keeps removal O(1) // instead of O(N) - int64_t last_entry = t->entries.length-1; + int64_t last_entry = t->entries.length - 1; if (bucket->index != last_entry) { hdebug("Removing key/value from the middle of the entries list\n"); @@ -374,70 +358,58 @@ public void Table$remove(Table_t *t, const void *key, const TypeInfo_t *type) } t->bucket_info->buckets[bucket_to_clear] = (bucket_t){0}; - if (bucket_to_clear > t->bucket_info->last_free) - t->bucket_info->last_free = bucket_to_clear; + if (bucket_to_clear > t->bucket_info->last_free) t->bucket_info->last_free = bucket_to_clear; hshow(t); } -CONSTFUNC public void *Table$entry(Table_t t, int64_t n) -{ - if (n < 1 || n > Table$length(t)) - return NULL; - return GET_ENTRY(t, n-1); +CONSTFUNC public void *Table$entry(Table_t t, int64_t n) { + if (n < 1 || n > Table$length(t)) return NULL; + return GET_ENTRY(t, n - 1); } -public void Table$clear(Table_t *t) -{ - memset(t, 0, sizeof(Table_t)); -} +public +void Table$clear(Table_t *t) { memset(t, 0, sizeof(Table_t)); } -public Table_t Table$sorted(Table_t t, const TypeInfo_t *type) -{ - Closure_t cmp = (Closure_t){.fn=generic_compare, .userdata=(void*)type->TableInfo.key}; +public +Table_t Table$sorted(Table_t t, const TypeInfo_t *type) { + Closure_t cmp = (Closure_t){.fn = generic_compare, .userdata = (void *)type->TableInfo.key}; List_t entries = List$sorted(t.entries, cmp, (int64_t)entry_size(type)); return Table$from_entries(entries, type); } -PUREFUNC public bool Table$equal(const void *vx, const void *vy, const TypeInfo_t *type) -{ +PUREFUNC public bool Table$equal(const void *vx, const void *vy, const TypeInfo_t *type) { if (vx == vy) return true; - Table_t *x = (Table_t*)vx, *y = (Table_t*)vy; + Table_t *x = (Table_t *)vx, *y = (Table_t *)vy; - if (x->hash && y->hash && x->hash != y->hash) - return false; + if (x->hash && y->hash && x->hash != y->hash) return false; assert(type->tag == TableInfo); - if (x->entries.length != y->entries.length) - return false; - - if ((x->fallback != NULL) != (y->fallback != NULL)) - return false; + if (x->entries.length != y->entries.length) return false; + + if ((x->fallback != NULL) != (y->fallback != NULL)) return false; const TypeInfo_t *value_type = type->TableInfo.value; size_t offset = value_offset(type); for (int64_t i = 0; i < x->entries.length; i++) { - void *x_key = x->entries.data + i*x->entries.stride; + void *x_key = x->entries.data + i * x->entries.stride; void *y_value = Table$get_raw(*y, x_key, type); if (!y_value) return false; void *x_value = x_key + offset; - if (!generic_equal(y_value, x_value, value_type)) - return false; + if (!generic_equal(y_value, x_value, value_type)) return false; } return true; } -PUREFUNC public int32_t Table$compare(const void *vx, const void *vy, const TypeInfo_t *type) -{ +PUREFUNC public int32_t Table$compare(const void *vx, const void *vy, const TypeInfo_t *type) { if (vx == vy) return 0; - Table_t *x = (Table_t*)vx, *y = (Table_t*)vy; + Table_t *x = (Table_t *)vx, *y = (Table_t *)vy; assert(type->tag == TableInfo); __typeof(type->TableInfo) table = type->TableInfo; // Sort empty tables before non-empty tables: - if (x->entries.length == 0 || y->entries.length == 0) - return ((x->entries.length > 0) - (y->entries.length > 0)); + if (x->entries.length == 0 || y->entries.length == 0) return ((x->entries.length > 0) - (y->entries.length > 0)); // Table comparison rules: // - If two tables have different keys, then compare as if comparing a @@ -446,22 +418,20 @@ PUREFUNC public int32_t Table$compare(const void *vx, const void *vy, const Type // - Otherwise, compare as if comparing lists of values for the sorted key // lists: // `[x[k] for k in x.keys.sorted()] <> [y[k] for k in y.keys.sorted()]` - // + // // We can do this in _linear_ time if we find the smallest `k` such that // `x[k] != y[k]`, as well as the largest key in `x` and `y`. void *mismatched_key = NULL, *max_x_key = NULL; for (int64_t i = 0; i < x->entries.length; i++) { void *key = x->entries.data + x->entries.stride * i; - if (max_x_key == NULL || generic_compare(key, max_x_key, table.key) > 0) - max_x_key = key; + if (max_x_key == NULL || generic_compare(key, max_x_key, table.key) > 0) max_x_key = key; void *x_value = key + value_offset(type); void *y_value = Table$get_raw(*y, key, type); if (!y_value || (table.value->size > 0 && !generic_equal(x_value, y_value, table.value))) { - if (mismatched_key == NULL || generic_compare(key, mismatched_key, table.key) < 0) - mismatched_key = key; + if (mismatched_key == NULL || generic_compare(key, mismatched_key, table.key) < 0) mismatched_key = key; } } @@ -470,14 +440,12 @@ PUREFUNC public int32_t Table$compare(const void *vx, const void *vy, const Type void *max_y_key = NULL; for (int64_t i = 0; i < y->entries.length; i++) { void *key = y->entries.data + y->entries.stride * i; - if (max_y_key == NULL || generic_compare(key, max_y_key, table.key) > 0) - max_y_key = key; + if (max_y_key == NULL || generic_compare(key, max_y_key, table.key) > 0) max_y_key = key; void *y_value = key + value_offset(type); void *x_value = Table$get_raw(*x, key, type); if (!x_value || !generic_equal(x_value, y_value, table.value)) { - if (mismatched_key == NULL || generic_compare(key, mismatched_key, table.key) < 0) - mismatched_key = key; + if (mismatched_key == NULL || generic_compare(key, mismatched_key, table.key) < 0) mismatched_key = key; } } @@ -529,12 +497,10 @@ PUREFUNC public int32_t Table$compare(const void *vx, const void *vy, const Type return 0; } -PUREFUNC public uint64_t Table$hash(const void *obj, const TypeInfo_t *type) -{ +PUREFUNC public uint64_t Table$hash(const void *obj, const TypeInfo_t *type) { assert(type->tag == TableInfo); - Table_t *t = (Table_t*)obj; - if (t->hash != 0) - return t->hash; + Table_t *t = (Table_t *)obj; + if (t->hash != 0) return t->hash; // Table hashes are computed as: // hash(t.length, (xor: t.keys), (xor: t.values), t.fallback) @@ -544,12 +510,12 @@ PUREFUNC public uint64_t Table$hash(const void *obj, const TypeInfo_t *type) size_t offset = value_offset(type); if (table.value->size > 0) { for (int64_t i = 0; i < t->entries.length; i++) { - keys_hash ^= generic_hash(t->entries.data + i*t->entries.stride, table.key); - values_hash ^= generic_hash(t->entries.data + i*t->entries.stride + offset, table.value); + keys_hash ^= generic_hash(t->entries.data + i * t->entries.stride, table.key); + values_hash ^= generic_hash(t->entries.data + i * t->entries.stride + offset, table.value); } } else { for (int64_t i = 0; i < t->entries.length; i++) - keys_hash ^= generic_hash(t->entries.data + i*t->entries.stride, table.key); + keys_hash ^= generic_hash(t->entries.data + i * t->entries.stride, table.key); } volatile struct { @@ -561,41 +527,31 @@ PUREFUNC public uint64_t Table$hash(const void *obj, const TypeInfo_t *type) values_hash, t->fallback ? Table$hash(t->fallback, type) : 0, }; - t->hash = siphash24((void*)&components, sizeof(components)); - if unlikely (t->hash == 0) - t->hash = 1234567; + t->hash = siphash24((void *)&components, sizeof(components)); + if unlikely (t->hash == 0) t->hash = 1234567; return t->hash; } -public Text_t Table$as_text(const void *obj, bool colorize, const TypeInfo_t *type) -{ - Table_t *t = (Table_t*)obj; +public +Text_t Table$as_text(const void *obj, bool colorize, const TypeInfo_t *type) { + Table_t *t = (Table_t *)obj; assert(type->tag == TableInfo); __typeof(type->TableInfo) table = type->TableInfo; if (!t) { - if (table.value != &Void$info) - return Text$concat( - Text("{"), - generic_as_text(NULL, false, table.key), - Text("="), - generic_as_text(NULL, false, table.value), - Text("}")); - else - return Text$concat( - Text("|"), - generic_as_text(NULL, false, table.key), - Text("|")); + if (table.value != &Void$info) + return Text$concat(Text("{"), generic_as_text(NULL, false, table.key), Text("="), + generic_as_text(NULL, false, table.value), Text("}")); + else return Text$concat(Text("|"), generic_as_text(NULL, false, table.key), Text("|")); } int64_t val_off = (int64_t)value_offset(type); Text_t text = table.value == &Void$info ? Text("|") : Text("{"); for (int64_t i = 0, length = Table$length(*t); i < length; i++) { - if (i > 0) - text = Text$concat(text, Text(", ")); + if (i > 0) text = Text$concat(text, Text(", ")); void *entry = GET_ENTRY(*t, i); text = Text$concat(text, generic_as_text(entry, colorize, table.key)); - if (table.value != &Void$info) + if (table.value != &Void$info) text = Text$concat(text, Text("="), generic_as_text(entry + val_off, colorize, table.value)); } @@ -607,11 +563,10 @@ public Text_t Table$as_text(const void *obj, bool colorize, const TypeInfo_t *ty return text; } -public Table_t Table$from_entries(List_t entries, const TypeInfo_t *type) -{ +public +Table_t Table$from_entries(List_t entries, const TypeInfo_t *type) { assert(type->tag == TableInfo); - if (entries.length == 0) - return (Table_t){}; + if (entries.length == 0) return (Table_t){}; Table_t t = {}; int64_t length = entries.length + entries.length / 4; @@ -619,19 +574,19 @@ public Table_t Table$from_entries(List_t entries, const TypeInfo_t *type) t.bucket_info = GC_MALLOC_ATOMIC(alloc_size); memset(t.bucket_info->buckets, 0, sizeof(bucket_t[length])); t.bucket_info->count = length; - t.bucket_info->last_free = length-1; + t.bucket_info->last_free = length - 1; size_t offset = value_offset(type); for (int64_t i = 0; i < entries.length; i++) { - void *key = entries.data + i*entries.stride; + void *key = entries.data + i * entries.stride; Table$set(&t, key, key + offset, type); } return t; } // Overlap is "set intersection" in formal terms -public Table_t Table$overlap(Table_t a, Table_t b, const TypeInfo_t *type) -{ +public +Table_t Table$overlap(Table_t a, Table_t b, const TypeInfo_t *type) { // Return a table such that t[k]==a[k] for all k such that a.has(k), b.has(k), and a[k]==b[k] Table_t result = {}; const size_t offset = value_offset(type); @@ -648,9 +603,10 @@ public Table_t Table$overlap(Table_t a, Table_t b, const TypeInfo_t *type) } // With is "set union" in formal terms -public Table_t Table$with(Table_t a, Table_t b, const TypeInfo_t *type) -{ - // return a table such that t[k]==b[k] for all k such that b.has(k), and t[k]==a[k] for all k such that a.has(k) and not b.has(k) +public +Table_t Table$with(Table_t a, Table_t b, const TypeInfo_t *type) { + // return a table such that t[k]==b[k] for all k such that b.has(k), and t[k]==a[k] for all k such that a.has(k) and + // not b.has(k) Table_t result = {}; const size_t offset = value_offset(type); for (Table_t *t = &a; t; t = t->fallback) { @@ -669,31 +625,29 @@ public Table_t Table$with(Table_t a, Table_t b, const TypeInfo_t *type) } // Xor is "disjunctive union" or "symmetric difference" in formal terms -public Table_t Table$xor(Table_t a, Table_t b, const TypeInfo_t *type) -{ +public +Table_t Table$xor(Table_t a, Table_t b, const TypeInfo_t *type) { // return a table with elements in `a` or `b`, but not both Table_t result = {}; const size_t offset = value_offset(type); for (Table_t *t = &a; t; t = t->fallback) { for (int64_t i = 0; i < Table$length(*t); i++) { void *key = GET_ENTRY(*t, i); - if (Table$get(b, key, type) == NULL) - Table$set(&result, key, key + offset, type); + if (Table$get(b, key, type) == NULL) Table$set(&result, key, key + offset, type); } } for (Table_t *t = &b; t; t = t->fallback) { for (int64_t i = 0; i < Table$length(*t); i++) { void *key = GET_ENTRY(*t, i); - if (Table$get(a, key, type) == NULL) - Table$set(&result, key, key + offset, type); + if (Table$get(a, key, type) == NULL) Table$set(&result, key, key + offset, type); } } return result; } // Without is "set difference" in formal terms -public Table_t Table$without(Table_t a, Table_t b, const TypeInfo_t *type) -{ +public +Table_t Table$without(Table_t a, Table_t b, const TypeInfo_t *type) { // Return a table such that t[k]==a[k] for all k such that not b.has(k) or b[k] != a[k] Table_t result = {}; const size_t offset = value_offset(type); @@ -709,8 +663,8 @@ public Table_t Table$without(Table_t a, Table_t b, const TypeInfo_t *type) return result; } -public Table_t Table$with_fallback(Table_t t, OptionalTable_t fallback) -{ +public +Table_t Table$with_fallback(Table_t t, OptionalTable_t fallback) { if (fallback.entries.length <= 0) { t.fallback = NULL; return t; @@ -722,10 +676,8 @@ public Table_t Table$with_fallback(Table_t t, OptionalTable_t fallback) } } -PUREFUNC public bool Table$is_subset_of(Table_t a, Table_t b, bool strict, const TypeInfo_t *type) -{ - if (a.entries.length > b.entries.length || (strict && a.entries.length == b.entries.length)) - return false; +PUREFUNC public bool Table$is_subset_of(Table_t a, Table_t b, bool strict, const TypeInfo_t *type) { + if (a.entries.length > b.entries.length || (strict && a.entries.length == b.entries.length)) return false; for (int64_t i = 0; i < Table$length(a); i++) { void *found = Table$get_raw(b, GET_ENTRY(a, i), type); @@ -734,73 +686,61 @@ PUREFUNC public bool Table$is_subset_of(Table_t a, Table_t b, bool strict, const return true; } -PUREFUNC public bool Table$is_superset_of(Table_t a, Table_t b, bool strict, const TypeInfo_t *type) -{ +PUREFUNC public bool Table$is_superset_of(Table_t a, Table_t b, bool strict, const TypeInfo_t *type) { return Table$is_subset_of(b, a, strict, type); } -PUREFUNC public void *Table$str_get(Table_t t, const char *key) -{ +PUREFUNC public void *Table$str_get(Table_t t, const char *key) { void **ret = Table$get(t, &key, &CStrToVoidStarTable); return ret ? *ret : NULL; } -PUREFUNC public void *Table$str_get_raw(Table_t t, const char *key) -{ +PUREFUNC public void *Table$str_get_raw(Table_t t, const char *key) { void **ret = Table$get_raw(t, &key, &CStrToVoidStarTable); return ret ? *ret : NULL; } -public void *Table$str_reserve(Table_t *t, const char *key, const void *value) -{ +public +void *Table$str_reserve(Table_t *t, const char *key, const void *value) { return Table$reserve(t, &key, &value, &CStrToVoidStarTable); } -public void Table$str_set(Table_t *t, const char *key, const void *value) -{ - Table$set(t, &key, &value, &CStrToVoidStarTable); -} +public +void Table$str_set(Table_t *t, const char *key, const void *value) { Table$set(t, &key, &value, &CStrToVoidStarTable); } -public void Table$str_remove(Table_t *t, const char *key) -{ - return Table$remove(t, &key, &CStrToVoidStarTable); -} +public +void Table$str_remove(Table_t *t, const char *key) { return Table$remove(t, &key, &CStrToVoidStarTable); } -CONSTFUNC public void *Table$str_entry(Table_t t, int64_t n) -{ - return Table$entry(t, n); -} +CONSTFUNC public void *Table$str_entry(Table_t t, int64_t n) { return Table$entry(t, n); } -PUREFUNC public bool Table$is_none(const void *obj, const TypeInfo_t *info) -{ +PUREFUNC public bool Table$is_none(const void *obj, const TypeInfo_t *info) { (void)info; - return ((Table_t*)obj)->entries.length < 0; + return ((Table_t *)obj)->entries.length < 0; } -public void Table$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) -{ - Table_t *t = (Table_t*)obj; +public +void Table$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) { + Table_t *t = (Table_t *)obj; int64_t len = t->entries.length; Int64$serialize(&len, out, pointers, &Int64$info); size_t offset = value_offset(type); for (int64_t i = 0; i < len; i++) { - _serialize(t->entries.data + i*t->entries.stride, out, pointers, type->TableInfo.key); + _serialize(t->entries.data + i * t->entries.stride, out, pointers, type->TableInfo.key); if (type->TableInfo.value->size > 0) - _serialize(t->entries.data + i*t->entries.stride + offset, out, pointers, type->TableInfo.value); + _serialize(t->entries.data + i * t->entries.stride + offset, out, pointers, type->TableInfo.value); } assert(fputc(t->fallback != NULL ? 1 : 0, out) != EOF); - if (t->fallback) - Table$serialize(t->fallback, out, pointers, type); + if (t->fallback) Table$serialize(t->fallback, out, pointers, type); } #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstack-protector" #endif -public void Table$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *type) -{ +public +void Table$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *type) { int64_t len; Int64$deserialize(in, &len, pointers, &Int$info); @@ -809,8 +749,7 @@ public void Table$deserialize(FILE *in, void *outval, List_t *pointers, const Ty char key[type->TableInfo.key->size]; _deserialize(in, key, pointers, type->TableInfo.key); char value[type->TableInfo.value->size]; - if (type->TableInfo.value->size > 0) - _deserialize(in, value, pointers, type->TableInfo.value); + if (type->TableInfo.value->size > 0) _deserialize(in, value, pointers, type->TableInfo.value); Table$set(&t, key, value, type); } @@ -819,7 +758,7 @@ public void Table$deserialize(FILE *in, void *outval, List_t *pointers, const Ty Table$deserialize(in, t.fallback, pointers, type); } - *(Table_t*)outval = t; + *(Table_t *)outval = t; } #ifdef __GNUC__ #pragma GCC diagnostic pop diff --git a/src/stdlib/tables.h b/src/stdlib/tables.h index f80c16c3..65f35060 100644 --- a/src/stdlib/tables.h +++ b/src/stdlib/tables.h @@ -2,59 +2,94 @@ // Hash table datastructure with methods and type information -#include <stdint.h> #include <stdbool.h> +#include <stdint.h> #include <string.h> -#include "lists.h" #include "datatypes.h" +#include "lists.h" #include "types.h" #include "util.h" -#define Table(key_t, val_t, key_info, value_info, fb, N, ...) ({ \ - struct { key_t k; val_t v; } ents[N] = {__VA_ARGS__}; \ - Table_t table = Table$from_entries((List_t){ \ - .data=memcpy(GC_MALLOC(sizeof(ents)), ents, sizeof(ents)), \ - .length=sizeof(ents)/sizeof(ents[0]), \ - .stride=(void*)&ents[1] - (void*)&ents[0], \ - }, Table$info(key_info, value_info)); \ - table.fallback = fb; \ - table; }) -#define Set(item_t, item_info, N, ...) ({ \ - item_t ents[N] = {__VA_ARGS__}; \ - Table_t set = Table$from_entries((List_t){ \ - .data=memcpy(GC_MALLOC(sizeof(ents)), ents, sizeof(ents)), \ - .length=sizeof(ents)/sizeof(ents[0]), \ - .stride=(void*)&ents[1] - (void*)&ents[0], \ - }, Set$info(item_info)); \ - set; }) +#define Table(key_t, val_t, key_info, value_info, fb, N, ...) \ + ({ \ + struct { \ + key_t k; \ + val_t v; \ + } ents[N] = {__VA_ARGS__}; \ + Table_t table = Table$from_entries( \ + (List_t){ \ + .data = memcpy(GC_MALLOC(sizeof(ents)), ents, sizeof(ents)), \ + .length = sizeof(ents) / sizeof(ents[0]), \ + .stride = (void *)&ents[1] - (void *)&ents[0], \ + }, \ + Table$info(key_info, value_info)); \ + table.fallback = fb; \ + table; \ + }) +#define Set(item_t, item_info, N, ...) \ + ({ \ + item_t ents[N] = {__VA_ARGS__}; \ + Table_t set = Table$from_entries( \ + (List_t){ \ + .data = memcpy(GC_MALLOC(sizeof(ents)), ents, sizeof(ents)), \ + .length = sizeof(ents) / sizeof(ents[0]), \ + .stride = (void *)&ents[1] - (void *)&ents[0], \ + }, \ + Set$info(item_info)); \ + set; \ + }) Table_t Table$from_entries(List_t entries, const TypeInfo_t *type); void *Table$get(Table_t t, const void *key, const TypeInfo_t *type); -#define Table$get_optional(table_expr, key_t, val_t, key_expr, nonnull_var, nonnull_expr, null_expr, info_expr) ({ \ - const Table_t t = table_expr; const key_t k = key_expr; \ - val_t *nonnull_var = Table$get(t, &k, info_expr); \ - nonnull_var ? nonnull_expr : null_expr; }) -#define Table$get_or_setdefault(table_expr, key_t, val_t, key_expr, default_expr, info_expr) ({ \ - Table_t *t = table_expr; const key_t k = key_expr; \ - if (t->entries.data_refcount > 0) List$compact(&t->entries, sizeof(struct {key_t k; val_t v;})); \ - val_t *v = Table$get(*t, &k, info_expr); \ - v ? v : (val_t*)Table$reserve(t, &k, (val_t[1]){default_expr}, info_expr); }) -#define Table$get_or_default(table_expr, key_t, val_t, key_expr, default_expr, info_expr) ({ \ - const Table_t t = table_expr; const key_t k = key_expr; \ - val_t *v = Table$get(t, &k, info_expr); \ - v ? *v : default_expr; }) -#define Table$has_value(table_expr, key_expr, info_expr) ({ \ - const Table_t t = table_expr; __typeof(key_expr) k = key_expr; \ - (Table$get(t, &k, info_expr) != NULL); }) +#define Table$get_optional(table_expr, key_t, val_t, key_expr, nonnull_var, nonnull_expr, null_expr, info_expr) \ + ({ \ + const Table_t t = table_expr; \ + const key_t k = key_expr; \ + val_t *nonnull_var = Table$get(t, &k, info_expr); \ + nonnull_var ? nonnull_expr : null_expr; \ + }) +#define Table$get_or_setdefault(table_expr, key_t, val_t, key_expr, default_expr, info_expr) \ + ({ \ + Table_t *t = table_expr; \ + const key_t k = key_expr; \ + if (t->entries.data_refcount > 0) \ + List$compact(&t->entries, sizeof(struct { \ + key_t k; \ + val_t v; \ + })); \ + val_t *v = Table$get(*t, &k, info_expr); \ + v ? v : (val_t *)Table$reserve(t, &k, (val_t[1]){default_expr}, info_expr); \ + }) +#define Table$get_or_default(table_expr, key_t, val_t, key_expr, default_expr, info_expr) \ + ({ \ + const Table_t t = table_expr; \ + const key_t k = key_expr; \ + val_t *v = Table$get(t, &k, info_expr); \ + v ? *v : default_expr; \ + }) +#define Table$has_value(table_expr, key_expr, info_expr) \ + ({ \ + const Table_t t = table_expr; \ + __typeof(key_expr) k = key_expr; \ + (Table$get(t, &k, info_expr) != NULL); \ + }) PUREFUNC void *Table$get_raw(Table_t t, const void *key, const TypeInfo_t *type); CONSTFUNC void *Table$entry(Table_t t, int64_t n); void *Table$reserve(Table_t *t, const void *key, const void *value, const TypeInfo_t *type); void Table$set(Table_t *t, const void *key, const void *value, const TypeInfo_t *type); -#define Table$set_value(t, key_expr, value_expr, type) ({ __typeof(key_expr) k = key_expr; __typeof(value_expr) v = value_expr; \ - Table$set(t, &k, &v, type); }) +#define Table$set_value(t, key_expr, value_expr, type) \ + ({ \ + __typeof(key_expr) k = key_expr; \ + __typeof(value_expr) v = value_expr; \ + Table$set(t, &k, &v, type); \ + }) void Table$remove(Table_t *t, const void *key, const TypeInfo_t *type); -#define Table$remove_value(t, key_expr, type) ({ __typeof(key_expr) k = key_expr; Table$remove(t, &k, type); }) +#define Table$remove_value(t, key_expr, type) \ + ({ \ + __typeof(key_expr) k = key_expr; \ + Table$remove(t, &k, type); \ + }) Table_t Table$overlap(Table_t a, Table_t b, const TypeInfo_t *type); Table_t Table$with(Table_t a, Table_t b, const TypeInfo_t *type); @@ -67,13 +102,22 @@ PUREFUNC bool Table$is_superset_of(Table_t a, Table_t b, bool strict, const Type void Table$clear(Table_t *t); Table_t Table$sorted(Table_t t, const TypeInfo_t *type); void Table$mark_copy_on_write(Table_t *t); -#define TABLE_INCREF(t) ({ LIST_INCREF((t).entries); if ((t).bucket_info) (t).bucket_info->data_refcount += ((t).bucket_info->data_refcount < TABLE_MAX_DATA_REFCOUNT); }) -#define TABLE_COPY(t) ({ TABLE_INCREF(t); t; }) +#define TABLE_INCREF(t) \ + ({ \ + LIST_INCREF((t).entries); \ + if ((t).bucket_info) \ + (t).bucket_info->data_refcount += ((t).bucket_info->data_refcount < TABLE_MAX_DATA_REFCOUNT); \ + }) +#define TABLE_COPY(t) \ + ({ \ + TABLE_INCREF(t); \ + t; \ + }) PUREFUNC int32_t Table$compare(const void *x, const void *y, const TypeInfo_t *type); PUREFUNC bool Table$equal(const void *x, const void *y, const TypeInfo_t *type); PUREFUNC uint64_t Table$hash(const void *t, const TypeInfo_t *type); Text_t Table$as_text(const void *t, bool colorize, const TypeInfo_t *type); -PUREFUNC bool Table$is_none(const void *obj, const TypeInfo_t*); +PUREFUNC bool Table$is_none(const void *obj, const TypeInfo_t *); CONSTFUNC void *Table$str_entry(Table_t t, int64_t n); PUREFUNC void *Table$str_get(Table_t t, const char *key); @@ -88,19 +132,30 @@ void Table$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_ extern const TypeInfo_t CStrToVoidStarTable; -#define Table$metamethods { \ - .as_text=Table$as_text, \ - .compare=Table$compare, \ - .equal=Table$equal, \ - .hash=Table$hash, \ - .is_none=Table$is_none, \ - .serialize=Table$serialize, \ - .deserialize=Table$deserialize, \ -} +#define Table$metamethods \ + { \ + .as_text = Table$as_text, \ + .compare = Table$compare, \ + .equal = Table$equal, \ + .hash = Table$hash, \ + .is_none = Table$is_none, \ + .serialize = Table$serialize, \ + .deserialize = Table$deserialize, \ + } -#define Table$info(key_expr, value_expr) &((TypeInfo_t){.size=sizeof(Table_t), .align=__alignof__(Table_t), \ - .tag=TableInfo, .TableInfo.key=key_expr, .TableInfo.value=value_expr, .metamethods=Table$metamethods}) -#define Set$info(item_info) &((TypeInfo_t){.size=sizeof(Table_t), .align=__alignof__(Table_t), \ - .tag=TableInfo, .TableInfo.key=item_info, .TableInfo.value=&Void$info, .metamethods=Table$metamethods}) +#define Table$info(key_expr, value_expr) \ + &((TypeInfo_t){.size = sizeof(Table_t), \ + .align = __alignof__(Table_t), \ + .tag = TableInfo, \ + .TableInfo.key = key_expr, \ + .TableInfo.value = value_expr, \ + .metamethods = Table$metamethods}) +#define Set$info(item_info) \ + &((TypeInfo_t){.size = sizeof(Table_t), \ + .align = __alignof__(Table_t), \ + .tag = TableInfo, \ + .TableInfo.key = item_info, \ + .TableInfo.value = &Void$info, \ + .metamethods = Table$metamethods}) // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1 diff --git a/src/stdlib/text.c b/src/stdlib/text.c index d9793eb8..aad3fd76 100644 --- a/src/stdlib/text.c +++ b/src/stdlib/text.c @@ -116,8 +116,8 @@ #include "text.h" // Use inline version of the siphash code for performance: -#include "siphash.h" #include "siphash-internals.h" +#include "siphash.h" typedef struct { ucs4_t main_codepoint; @@ -133,9 +133,9 @@ static synthetic_grapheme_t *synthetic_graphemes = NULL; static int32_t synthetic_grapheme_capacity = 0; static int32_t num_synthetic_graphemes = 0; -#define NUM_GRAPHEME_CODEPOINTS(id) (synthetic_graphemes[-(id)-1].utf32_cluster[0]) -#define GRAPHEME_CODEPOINTS(id) (&synthetic_graphemes[-(id)-1].utf32_cluster[1]) -#define GRAPHEME_UTF8(id) (synthetic_graphemes[-(id)-1].utf8) +#define NUM_GRAPHEME_CODEPOINTS(id) (synthetic_graphemes[-(id) - 1].utf32_cluster[0]) +#define GRAPHEME_CODEPOINTS(id) (&synthetic_graphemes[-(id) - 1].utf32_cluster[1]) +#define GRAPHEME_UTF8(id) (synthetic_graphemes[-(id) - 1].utf8) // Somewhat arbitrarily chosen, if two short literal ASCII or grapheme chunks // are concatenated below this length threshold, we just merge them into a @@ -145,16 +145,17 @@ static int32_t num_synthetic_graphemes = 0; static Text_t simple_concatenation(Text_t a, Text_t b); -public Text_t EMPTY_TEXT = { - .length=0, - .tag=TEXT_ASCII, - .ascii=0, +public +Text_t EMPTY_TEXT = { + .length = 0, + .tag = TEXT_ASCII, + .ascii = 0, }; PUREFUNC static bool graphemes_equal(const void *va, const void *vb, const TypeInfo_t *info) { (void)info; - ucs4_t *a = *(ucs4_t**)va; - ucs4_t *b = *(ucs4_t**)vb; + ucs4_t *a = *(ucs4_t **)va; + ucs4_t *b = *(ucs4_t **)vb; if (a[0] != b[0]) return false; for (int i = 0; i < (int)a[0]; i++) if (a[i] != b[i]) return false; @@ -163,37 +164,37 @@ PUREFUNC static bool graphemes_equal(const void *va, const void *vb, const TypeI PUREFUNC static uint64_t grapheme_hash(const void *g, const TypeInfo_t *info) { (void)info; - ucs4_t *cluster = *(ucs4_t**)g; - return siphash24((void*)&cluster[1], sizeof(ucs4_t[cluster[0]])); + ucs4_t *cluster = *(ucs4_t **)g; + return siphash24((void *)&cluster[1], sizeof(ucs4_t[cluster[0]])); } static const TypeInfo_t GraphemeClusterInfo = { - .size=sizeof(ucs4_t*), - .align=__alignof__(ucs4_t*), - .metamethods={ - .equal=graphemes_equal, - .hash=grapheme_hash, - }, + .size = sizeof(ucs4_t *), + .align = __alignof__(ucs4_t *), + .metamethods = + { + .equal = graphemes_equal, + .hash = grapheme_hash, + }, }; #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstack-protector" #endif -public int32_t get_synthetic_grapheme(const ucs4_t *codepoints, int64_t utf32_len) -{ - if (utf32_len == 1) - return (int32_t)*codepoints; +public +int32_t get_synthetic_grapheme(const ucs4_t *codepoints, int64_t utf32_len) { + if (utf32_len == 1) return (int32_t)*codepoints; - ucs4_t length_prefixed[1+utf32_len]; + ucs4_t length_prefixed[1 + utf32_len]; length_prefixed[0] = (ucs4_t)utf32_len; for (int i = 0; i < utf32_len; i++) - length_prefixed[i+1] = codepoints[i]; + length_prefixed[i + 1] = codepoints[i]; ucs4_t *ptr = &length_prefixed[0]; // Optimization for common case of one frequently used synthetic grapheme: static int32_t last_grapheme = 0; - if (last_grapheme != 0 && graphemes_equal(&ptr, &synthetic_graphemes[-last_grapheme-1].utf32_cluster, NULL)) + if (last_grapheme != 0 && graphemes_equal(&ptr, &synthetic_graphemes[-last_grapheme - 1].utf32_cluster, NULL)) return last_grapheme; TypeInfo_t GraphemeIDLookupTableInfo = *Table$info(&GraphemeClusterInfo, &Int32$info); @@ -209,12 +210,12 @@ public int32_t get_synthetic_grapheme(const ucs4_t *codepoints, int64_t utf32_le synthetic_graphemes = new; } - int32_t grapheme_id = -(num_synthetic_graphemes+1); + int32_t grapheme_id = -(num_synthetic_graphemes + 1); num_synthetic_graphemes += 1; // Get UTF8 representation: uint8_t u8_buf[64]; - size_t u8_len = sizeof(u8_buf)/sizeof(u8_buf[0]); + size_t u8_len = sizeof(u8_buf) / sizeof(u8_buf[0]); uint8_t *u8 = u32_to_u8(codepoints, (size_t)utf32_len, u8_buf, &u8_len); if (u8 == NULL) fail("Invalid graphemes encountered!"); @@ -223,11 +224,10 @@ public int32_t get_synthetic_grapheme(const ucs4_t *codepoints, int64_t utf32_le // area with good cache locality: static void *arena = NULL, *arena_end = NULL; // Eat up any space needed to make arena 32-bit aligned: - if ((size_t)arena % __alignof__(ucs4_t) != 0) - arena += __alignof__(ucs4_t) - ((size_t)arena % __alignof__(ucs4_t)); + if ((size_t)arena % __alignof__(ucs4_t) != 0) arena += __alignof__(ucs4_t) - ((size_t)arena % __alignof__(ucs4_t)); // If we have filled up this arena, allocate a new one: - size_t needed_memory = sizeof(ucs4_t[1+utf32_len]) + sizeof(uint8_t[u8_len + 1]); + size_t needed_memory = sizeof(ucs4_t[1 + utf32_len]) + sizeof(uint8_t[u8_len + 1]); if (arena + needed_memory > arena_end) { // Do reasonably big chunks at a time, so most synthetic codepoints are // nearby each other in memory and cache locality is good. This is a @@ -239,28 +239,27 @@ public int32_t get_synthetic_grapheme(const ucs4_t *codepoints, int64_t utf32_le // Copy length-prefixed UTF32 codepoints into the arena and store where they live: ucs4_t *codepoint_copy = arena; - memcpy(codepoint_copy, length_prefixed, sizeof(ucs4_t[1+utf32_len])); - synthetic_graphemes[-grapheme_id-1].utf32_cluster = codepoint_copy; - arena += sizeof(ucs4_t[1+utf32_len]); + memcpy(codepoint_copy, length_prefixed, sizeof(ucs4_t[1 + utf32_len])); + synthetic_graphemes[-grapheme_id - 1].utf32_cluster = codepoint_copy; + arena += sizeof(ucs4_t[1 + utf32_len]); // Copy UTF8 bytes into the arena and store where they live: uint8_t *utf8_final = arena; memcpy(utf8_final, u8, sizeof(uint8_t[u8_len])); utf8_final[u8_len] = '\0'; // Add a terminating NUL byte - synthetic_graphemes[-grapheme_id-1].utf8 = utf8_final; + synthetic_graphemes[-grapheme_id - 1].utf8 = utf8_final; arena += sizeof(uint8_t[u8_len + 1]); // Sickos at the unicode consortium decreed that you can have grapheme clusters // that begin with *prefix* modifiers, so we gotta check for that case: - synthetic_graphemes[-grapheme_id-1].main_codepoint = length_prefixed[1]; + synthetic_graphemes[-grapheme_id - 1].main_codepoint = length_prefixed[1]; for (ucs4_t i = 0; i < utf32_len; i++) { #if _LIBUNISTRING_VERSION >= 0x010200 -// libuinstring version 1.2.0 introduced uc_is_property_prepended_concatenation_mark() -// It's not critical, but it's technically more correct to have this check: - if (unlikely(uc_is_property_prepended_concatenation_mark(length_prefixed[1+i]))) - continue; + // libuinstring version 1.2.0 introduced uc_is_property_prepended_concatenation_mark() + // It's not critical, but it's technically more correct to have this check: + if (unlikely(uc_is_property_prepended_concatenation_mark(length_prefixed[1 + i]))) continue; #endif - synthetic_graphemes[-grapheme_id-1].main_codepoint = length_prefixed[1+i]; + synthetic_graphemes[-grapheme_id - 1].main_codepoint = length_prefixed[1 + i]; break; } @@ -276,8 +275,8 @@ public int32_t get_synthetic_grapheme(const ucs4_t *codepoints, int64_t utf32_le #pragma GCC diagnostic pop #endif -public int Text$print(FILE *stream, Text_t t) -{ +public +int Text$print(FILE *stream, Text_t t) { if (t.length == 0) return 0; switch (t.tag) { @@ -290,14 +289,14 @@ public int Text$print(FILE *stream, Text_t t) if (grapheme >= 0) { uint8_t buf[8]; size_t len = sizeof(buf); - uint8_t *u8 = u32_to_u8((ucs4_t*)&grapheme, 1, buf, &len); + uint8_t *u8 = u32_to_u8((ucs4_t *)&grapheme, 1, buf, &len); if (u8 == NULL) fail("Invalid grapheme encountered: ", grapheme); written += (int)fwrite(u8, sizeof(char), len, stream); if (u8 != buf) free(u8); } else { const uint8_t *u8 = GRAPHEME_UTF8(grapheme); assert(u8); - written += (int)fwrite(u8, sizeof(uint8_t), strlen((char*)u8), stream); + written += (int)fwrite(u8, sizeof(uint8_t), strlen((char *)u8), stream); } } return written; @@ -309,14 +308,14 @@ public int Text$print(FILE *stream, Text_t t) if (grapheme >= 0) { uint8_t buf[8]; size_t len = sizeof(buf); - uint8_t *u8 = u32_to_u8((ucs4_t*)&grapheme, 1, buf, &len); + uint8_t *u8 = u32_to_u8((ucs4_t *)&grapheme, 1, buf, &len); if (u8 == NULL) fail("Invalid grapheme encountered: ", grapheme); written += (int)fwrite(u8, sizeof(char), len, stream); if (u8 != buf) free(u8); } else { const uint8_t *u8 = GRAPHEME_UTF8(grapheme); assert(u8); - written += (int)fwrite(u8, sizeof(uint8_t), strlen((char*)u8), stream); + written += (int)fwrite(u8, sizeof(uint8_t), strlen((char *)u8), stream); } } return written; @@ -332,16 +331,16 @@ public int Text$print(FILE *stream, Text_t t) static const int64_t min_len_for_depth[MAX_TEXT_DEPTH] = { // Fibonacci numbers (skipping first two) - 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, - 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, - 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, - 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049, + 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, + 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, + 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, + 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, + 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049, }; #define IS_BALANCED_TEXT(t) ((t).length >= min_len_for_depth[(t).depth]) -static void insert_balanced_recursive(Text_t balanced_texts[MAX_TEXT_DEPTH], Text_t text) -{ +static void insert_balanced_recursive(Text_t balanced_texts[MAX_TEXT_DEPTH], Text_t text) { if (text.tag == TEXT_CONCAT && (!IS_BALANCED_TEXT(text) || text.depth >= MAX_TEXT_DEPTH)) { insert_balanced_recursive(balanced_texts, *text.left); insert_balanced_recursive(balanced_texts, *text.right); @@ -370,8 +369,7 @@ static void insert_balanced_recursive(Text_t balanced_texts[MAX_TEXT_DEPTH], Tex balanced_texts[i] = accumulator; } -static Text_t rebalanced(Text_t a, Text_t b) -{ +static Text_t rebalanced(Text_t a, Text_t b) { Text_t balanced_texts[MAX_TEXT_DEPTH]; memset(balanced_texts, 0, sizeof(balanced_texts)); insert_balanced_recursive(balanced_texts, a); @@ -379,14 +377,12 @@ static Text_t rebalanced(Text_t a, Text_t b) Text_t ret = EMPTY_TEXT; for (int i = 0; ret.length < a.length + b.length; i++) { - if (balanced_texts[i].length) - ret = simple_concatenation(balanced_texts[i], ret); + if (balanced_texts[i].length) ret = simple_concatenation(balanced_texts[i], ret); } return ret; } -Text_t simple_concatenation(Text_t a, Text_t b) -{ +Text_t simple_concatenation(Text_t a, Text_t b) { if (a.length == 0) return b; if (b.length == 0) return a; @@ -395,53 +391,53 @@ Text_t simple_concatenation(Text_t a, Text_t b) // every concatenation to yield a balanced text, since many concatenations // are ephemeral (e.g. doing a loop repeatedly concatenating without using // the intermediary values). - if (new_depth >= MAX_TEXT_DEPTH) - return rebalanced(a, b); + if (new_depth >= MAX_TEXT_DEPTH) return rebalanced(a, b); Text_t *children = GC_MALLOC(sizeof(Text_t[2])); children[0] = a; children[1] = b; return (Text_t){ - .tag=TEXT_CONCAT, - .length=a.length + b.length, - .depth=new_depth, - .left=&children[0], - .right=&children[1], + .tag = TEXT_CONCAT, + .length = a.length + b.length, + .depth = new_depth, + .left = &children[0], + .right = &children[1], }; } -static Text_t concat2_assuming_safe(Text_t a, Text_t b) -{ +static Text_t concat2_assuming_safe(Text_t a, Text_t b) { if (a.length == 0) return b; if (b.length == 0) return a; if (a.tag == TEXT_ASCII && b.tag == TEXT_ASCII && (size_t)(a.length + b.length) <= SHORT_ASCII_LENGTH) { struct Text_s ret = { - .tag=TEXT_ASCII, - .length=a.length + b.length, + .tag = TEXT_ASCII, + .length = a.length + b.length, }; ret.ascii = GC_MALLOC_ATOMIC(sizeof(char[ret.length])); - memcpy((char*)ret.ascii, a.ascii, sizeof(char[a.length])); - memcpy((char*)&ret.ascii[a.length], b.ascii, sizeof(char[b.length])); + memcpy((char *)ret.ascii, a.ascii, sizeof(char[a.length])); + memcpy((char *)&ret.ascii[a.length], b.ascii, sizeof(char[b.length])); return ret; - } else if (a.tag == TEXT_GRAPHEMES && b.tag == TEXT_GRAPHEMES && (size_t)(a.length + b.length) <= SHORT_GRAPHEMES_LENGTH) { + } else if (a.tag == TEXT_GRAPHEMES && b.tag == TEXT_GRAPHEMES + && (size_t)(a.length + b.length) <= SHORT_GRAPHEMES_LENGTH) { struct Text_s ret = { - .tag=TEXT_GRAPHEMES, - .length=a.length + b.length, + .tag = TEXT_GRAPHEMES, + .length = a.length + b.length, }; ret.graphemes = GC_MALLOC_ATOMIC(sizeof(int32_t[ret.length])); - memcpy((int32_t*)ret.graphemes, a.graphemes, sizeof(int32_t[a.length])); - memcpy((int32_t*)&ret.graphemes[a.length], b.graphemes, sizeof(int32_t[b.length])); + memcpy((int32_t *)ret.graphemes, a.graphemes, sizeof(int32_t[a.length])); + memcpy((int32_t *)&ret.graphemes[a.length], b.graphemes, sizeof(int32_t[b.length])); return ret; - } else if (a.tag != TEXT_CONCAT && b.tag != TEXT_CONCAT && (size_t)(a.length + b.length) <= SHORT_GRAPHEMES_LENGTH) { + } else if (a.tag != TEXT_CONCAT && b.tag != TEXT_CONCAT + && (size_t)(a.length + b.length) <= SHORT_GRAPHEMES_LENGTH) { // Turn a small bit of ASCII into graphemes if it helps make things smaller // Text structs come with an extra 8 bytes, so allocate enough to hold the text struct Text_s ret = { - .tag=TEXT_GRAPHEMES, - .length=a.length + b.length, + .tag = TEXT_GRAPHEMES, + .length = a.length + b.length, }; ret.graphemes = GC_MALLOC_ATOMIC(sizeof(int32_t[ret.length])); - int32_t *dest = (int32_t*)ret.graphemes; + int32_t *dest = (int32_t *)ret.graphemes; if (a.tag == TEXT_GRAPHEMES) { memcpy(dest, a.graphemes, sizeof(int32_t[a.length])); dest += a.length; @@ -474,12 +470,11 @@ static Text_t concat2_assuming_safe(Text_t a, Text_t b) return simple_concatenation(a, b); } -static Text_t concat2(Text_t a, Text_t b) -{ +static Text_t concat2(Text_t a, Text_t b) { if (a.length == 0) return b; if (b.length == 0) return a; - int32_t last_a = Text$get_grapheme(a, a.length-1); + int32_t last_a = Text$get_grapheme(a, a.length - 1); int32_t first_b = Text$get_grapheme(b, 0); // Magic number, we know that no codepoints below here trigger instability: @@ -509,60 +504,51 @@ static Text_t concat2(Text_t a, Text_t b) // Do a normalization run for these two codepoints and see if it looks different. // Normalization should not exceed 3x in the input length (but if it does, it will be // handled gracefully) - ucs4_t norm_buf[3*len]; - size_t norm_length = sizeof(norm_buf)/sizeof(norm_buf[0]); + ucs4_t norm_buf[3 * len]; + size_t norm_length = sizeof(norm_buf) / sizeof(norm_buf[0]); ucs4_t *normalized = u32_normalize(UNINORM_NFC, codepoints, len, norm_buf, &norm_length); bool stable = (norm_length == len && memcmp(codepoints, normalized, sizeof(codepoints)) == 0); if (stable) { const void *second_grapheme = u32_grapheme_next(normalized, &normalized[norm_length]); - if (second_grapheme == &normalized[norm_length]) - stable = false; + if (second_grapheme == &normalized[norm_length]) stable = false; } if likely (stable) { - if (normalized != norm_buf) - free(normalized); + if (normalized != norm_buf) free(normalized); return concat2_assuming_safe(a, b); } - Text_t glue = Text$from_codepoints((List_t){.data=norm_buf, .length=(int64_t)norm_length, .stride=sizeof(int32_t)}); + Text_t glue = + Text$from_codepoints((List_t){.data = norm_buf, .length = (int64_t)norm_length, .stride = sizeof(int32_t)}); - if (normalized != norm_buf) - free(normalized); + if (normalized != norm_buf) free(normalized); - if (a.length == 1 && b.length == 1) - return glue; - else if (a.length == 1) - return concat2_assuming_safe(glue, Text$slice(b, I(2), I(b.length))); - else if (b.length == 1) - return concat2_assuming_safe(Text$slice(a, I(1), I(a.length-1)), glue); + if (a.length == 1 && b.length == 1) return glue; + else if (a.length == 1) return concat2_assuming_safe(glue, Text$slice(b, I(2), I(b.length))); + else if (b.length == 1) return concat2_assuming_safe(Text$slice(a, I(1), I(a.length - 1)), glue); else - return concat2_assuming_safe( - concat2_assuming_safe(Text$slice(a, I(1), I(a.length-1)), glue), - Text$slice(b, I(2), I(b.length))); + return concat2_assuming_safe(concat2_assuming_safe(Text$slice(a, I(1), I(a.length - 1)), glue), + Text$slice(b, I(2), I(b.length))); } -public Text_t Text$_concat(int n, Text_t items[n]) -{ +public +Text_t Text$_concat(int n, Text_t items[n]) { if (n == 0) return EMPTY_TEXT; Text_t ret = items[0]; for (int i = 1; i < n; i++) { - if (items[i].length > 0) - ret = concat2(ret, items[i]); + if (items[i].length > 0) ret = concat2(ret, items[i]); } return ret; } -public Text_t Text$repeat(Text_t text, Int_t count) -{ - if (text.length == 0 || Int$is_negative(count)) - return EMPTY_TEXT; +public +Text_t Text$repeat(Text_t text, Int_t count) { + if (text.length == 0 || Int$is_negative(count)) return EMPTY_TEXT; Int_t result_len = Int$times(count, I(text.length)); - if (Int$compare_value(result_len, I(1l<<40)) > 0) - fail("Text repeating would produce too big of an result!"); + if (Int$compare_value(result_len, I(1l << 40)) > 0) fail("Text repeating would produce too big of an result!"); int64_t count64 = Int64$from_int(count, false); Text_t ret = text; @@ -571,19 +557,17 @@ public Text_t Text$repeat(Text_t text, Int_t count) return ret; } -public Int_t Text$width(Text_t text, Text_t language) -{ - int width = u8_strwidth((const uint8_t*)Text$as_c_string(text), Text$as_c_string(language)); +public +Int_t Text$width(Text_t text, Text_t language) { + int width = u8_strwidth((const uint8_t *)Text$as_c_string(text), Text$as_c_string(language)); return Int$from_int32(width); } -static Text_t Text$repeat_to_width(Text_t to_repeat, int64_t target_width, Text_t language) -{ - if (target_width <= 0) - return EMPTY_TEXT; +static Text_t Text$repeat_to_width(Text_t to_repeat, int64_t target_width, Text_t language) { + if (target_width <= 0) return EMPTY_TEXT; const char *lang_str = Text$as_c_string(language); - int64_t width = (int64_t)u8_strwidth((const uint8_t*)Text$as_c_string(to_repeat), lang_str); + int64_t width = (int64_t)u8_strwidth((const uint8_t *)Text$as_c_string(to_repeat), lang_str); Text_t repeated = EMPTY_TEXT; int64_t repeated_width = 0; while (repeated_width + width <= target_width) { @@ -593,8 +577,8 @@ static Text_t Text$repeat_to_width(Text_t to_repeat, int64_t target_width, Text_ if (repeated_width < target_width) { for (int64_t i = 0; repeated_width < target_width && i < to_repeat.length; i++) { - Text_t c = Text$slice(to_repeat, I_small(i+1), I_small(i+1)); - int64_t w = (int64_t)u8_strwidth((const uint8_t*)Text$as_c_string(c), lang_str); + Text_t c = Text$slice(to_repeat, I_small(i + 1), I_small(i + 1)); + int64_t w = (int64_t)u8_strwidth((const uint8_t *)Text$as_c_string(c), lang_str); if (repeated_width + w > target_width) { repeated = concat2(repeated, Text$repeat(Text(" "), I(target_width - repeated_width))); repeated_width = target_width; @@ -608,35 +592,33 @@ static Text_t Text$repeat_to_width(Text_t to_repeat, int64_t target_width, Text_ return repeated; } -public Text_t Text$left_pad(Text_t text, Int_t width, Text_t padding, Text_t language) -{ - if (padding.length == 0) - fail("Cannot pad with an empty text!"); +public +Text_t Text$left_pad(Text_t text, Int_t width, Text_t padding, Text_t language) { + if (padding.length == 0) fail("Cannot pad with an empty text!"); int64_t needed = Int64$from_int(width, false) - Int64$from_int(Text$width(text, language), false); return concat2(Text$repeat_to_width(padding, needed, language), text); } -public Text_t Text$right_pad(Text_t text, Int_t width, Text_t padding, Text_t language) -{ - if (padding.length == 0) - fail("Cannot pad with an empty text!"); +public +Text_t Text$right_pad(Text_t text, Int_t width, Text_t padding, Text_t language) { + if (padding.length == 0) fail("Cannot pad with an empty text!"); int64_t needed = Int64$from_int(width, false) - Int64$from_int(Text$width(text, language), false); return concat2(text, Text$repeat_to_width(padding, needed, language)); } -public Text_t Text$middle_pad(Text_t text, Int_t width, Text_t padding, Text_t language) -{ - if (padding.length == 0) - fail("Cannot pad with an empty text!"); +public +Text_t Text$middle_pad(Text_t text, Int_t width, Text_t padding, Text_t language) { + if (padding.length == 0) fail("Cannot pad with an empty text!"); int64_t needed = Int64$from_int(width, false) - Int64$from_int(Text$width(text, language), false); - return Texts(Text$repeat_to_width(padding, needed/2, language), text, Text$repeat_to_width(padding, (needed+1)/2, language)); + return Texts(Text$repeat_to_width(padding, needed / 2, language), text, + Text$repeat_to_width(padding, (needed + 1) / 2, language)); } -public Text_t Text$slice(Text_t text, Int_t first_int, Int_t last_int) -{ +public +Text_t Text$slice(Text_t text, Int_t first_int, Int_t last_int) { int64_t first = Int64$from_int(first_int, false); int64_t last = Int64$from_int(last_int, false); if (first == 0) fail("Invalid index: 0"); @@ -647,11 +629,9 @@ public Text_t Text$slice(Text_t text, Int_t first_int, Int_t last_int) if (last > text.length) last = text.length; - if (first > text.length || last < first) - return EMPTY_TEXT; + if (first > text.length || last < first) return EMPTY_TEXT; - if (first == 1 && last == text.length) - return text; + if (first == 1 && last == text.length) return text; while (text.tag == TEXT_CONCAT) { if (last < text.left->length) { @@ -662,31 +642,31 @@ public Text_t Text$slice(Text_t text, Int_t first_int, Int_t last_int) text = *text.right; } else { return concat2_assuming_safe(Text$slice(*text.left, I(first), I(text.length)), - Text$slice(*text.right, I(1), I(last-text.left->length))); + Text$slice(*text.right, I(1), I(last - text.left->length))); } } switch (text.tag) { case TEXT_ASCII: { return (Text_t){ - .tag=TEXT_ASCII, - .length=last - first + 1, - .ascii=text.ascii + (first-1), + .tag = TEXT_ASCII, + .length = last - first + 1, + .ascii = text.ascii + (first - 1), }; } case TEXT_GRAPHEMES: { return (Text_t){ - .tag=TEXT_GRAPHEMES, - .length=last - first + 1, - .graphemes=text.graphemes + (first-1), + .tag = TEXT_GRAPHEMES, + .length = last - first + 1, + .graphemes = text.graphemes + (first - 1), }; } case TEXT_BLOB: { Text_t ret = (Text_t){ - .tag=TEXT_BLOB, - .length=last - first + 1, - .blob.map=text.blob.map, - .blob.bytes=text.blob.bytes + (first-1), + .tag = TEXT_BLOB, + .length = last - first + 1, + .blob.map = text.blob.map, + .blob.bytes = text.blob.bytes + (first - 1), }; return ret; } @@ -695,48 +675,44 @@ public Text_t Text$slice(Text_t text, Int_t first_int, Int_t last_int) return EMPTY_TEXT; } -public Text_t Text$from(Text_t text, Int_t first) -{ - return Text$slice(text, first, I_small(-1)); -} +public +Text_t Text$from(Text_t text, Int_t first) { return Text$slice(text, first, I_small(-1)); } -public Text_t Text$to(Text_t text, Int_t last) -{ - return Text$slice(text, I_small(1), last); -} +public +Text_t Text$to(Text_t text, Int_t last) { return Text$slice(text, I_small(1), last); } -public Text_t Text$reversed(Text_t text) -{ +public +Text_t Text$reversed(Text_t text) { switch (text.tag) { case TEXT_ASCII: { struct Text_s ret = { - .tag=TEXT_ASCII, - .length=text.length, + .tag = TEXT_ASCII, + .length = text.length, }; ret.ascii = GC_MALLOC_ATOMIC(sizeof(char[ret.length])); for (int64_t i = 0; i < text.length; i++) - ((char*)ret.ascii)[text.length-1-i] = text.ascii[i]; + ((char *)ret.ascii)[text.length - 1 - i] = text.ascii[i]; return ret; } case TEXT_GRAPHEMES: { struct Text_s ret = { - .tag=TEXT_GRAPHEMES, - .length=text.length, + .tag = TEXT_GRAPHEMES, + .length = text.length, }; ret.graphemes = GC_MALLOC_ATOMIC(sizeof(int32_t[ret.length])); for (int64_t i = 0; i < text.length; i++) - ((int32_t*)ret.graphemes)[text.length-1-i] = text.graphemes[i]; + ((int32_t *)ret.graphemes)[text.length - 1 - i] = text.graphemes[i]; return ret; } case TEXT_BLOB: { struct Text_s ret = { - .tag=TEXT_BLOB, - .length=text.length, - .blob.map=text.blob.map, + .tag = TEXT_BLOB, + .length = text.length, + .blob.map = text.blob.map, }; ret.blob.bytes = GC_MALLOC_ATOMIC(sizeof(uint8_t[ret.length])); for (int64_t i = 0; i < text.length; i++) - ((uint8_t*)ret.blob.bytes)[text.length-1-i] = text.graphemes[i]; + ((uint8_t *)ret.blob.bytes)[text.length - 1 - i] = text.graphemes[i]; return ret; } case TEXT_CONCAT: { @@ -747,32 +723,30 @@ public Text_t Text$reversed(Text_t text) return EMPTY_TEXT; } -public PUREFUNC Text_t Text$cluster(Text_t text, Int_t index) -{ - return Text$slice(text, index, index); -} +public +PUREFUNC Text_t Text$cluster(Text_t text, Int_t index) { return Text$slice(text, index, index); } -static Text_t Text$from_components(List_t graphemes, Table_t unique_clusters) -{ - size_t blob_size = ( - sizeof(int32_t[unique_clusters.entries.length]) - + sizeof(uint8_t[graphemes.length])); +static Text_t Text$from_components(List_t graphemes, Table_t unique_clusters) { + size_t blob_size = (sizeof(int32_t[unique_clusters.entries.length]) + sizeof(uint8_t[graphemes.length])); // If blob optimization will save at least 200 bytes: if (unique_clusters.entries.length <= 256 && blob_size + 200 < sizeof(int32_t[graphemes.length])) { Text_t ret = { - .tag=TEXT_BLOB, - .length=graphemes.length, - .depth=0, + .tag = TEXT_BLOB, + .length = graphemes.length, + .depth = 0, }; void *blob = GC_MALLOC_ATOMIC(blob_size); int32_t *map = blob; uint8_t *bytes = blob + sizeof(int32_t[unique_clusters.entries.length]); for (int64_t i = 0; i < unique_clusters.entries.length; i++) { - struct { int32_t g; uint8_t b; } *entry = unique_clusters.entries.data + i*unique_clusters.entries.stride; + struct { + int32_t g; + uint8_t b; + } *entry = unique_clusters.entries.data + i * unique_clusters.entries.stride; map[entry->b] = entry->g; } for (int64_t i = 0; i < graphemes.length; i++) { - int32_t g = *(int32_t*)(graphemes.data + i*graphemes.stride); + int32_t g = *(int32_t *)(graphemes.data + i * graphemes.stride); uint8_t *byte = Table$get(unique_clusters, &g, Table$info(&Int32$info, &Byte$info)); assert(byte); bytes[i] = *byte; @@ -782,15 +756,15 @@ static Text_t Text$from_components(List_t graphemes, Table_t unique_clusters) return ret; } else { return (Text_t){ - .tag=TEXT_GRAPHEMES, - .length=graphemes.length, - .graphemes=graphemes.data, + .tag = TEXT_GRAPHEMES, + .length = graphemes.length, + .graphemes = graphemes.data, }; } } -public OptionalText_t Text$from_strn(const char *str, size_t len) -{ +public +OptionalText_t Text$from_strn(const char *str, size_t len) { int64_t ascii_span = 0; for (size_t i = 0; i < len && isascii(str[i]); i++) ascii_span++; @@ -799,52 +773,48 @@ public OptionalText_t Text$from_strn(const char *str, size_t len) char *copy = GC_MALLOC_ATOMIC(len); memcpy(copy, str, len); return (Text_t){ - .tag=TEXT_ASCII, - .length=ascii_span, - .ascii=copy, + .tag = TEXT_ASCII, + .length = ascii_span, + .ascii = copy, }; } - if (u8_check((uint8_t*)str, len) != NULL) - return NONE_TEXT; + if (u8_check((uint8_t *)str, len) != NULL) return NONE_TEXT; List_t graphemes = {}; Table_t unique_clusters = {}; - const uint8_t *pos = (const uint8_t*)str; - const uint8_t *end = (const uint8_t*)&str[len]; + const uint8_t *pos = (const uint8_t *)str; + const uint8_t *end = (const uint8_t *)&str[len]; // Iterate over grapheme clusters - for (const uint8_t *next; (next=u8_grapheme_next(pos, end)); pos = next) { + for (const uint8_t *next; (next = u8_grapheme_next(pos, end)); pos = next) { uint32_t buf[256]; - size_t u32_len = sizeof(buf)/sizeof(buf[0]); - uint32_t *u32s = u8_to_u32(pos, (size_t)(next-pos), buf, &u32_len); + size_t u32_len = sizeof(buf) / sizeof(buf[0]); + uint32_t *u32s = u8_to_u32(pos, (size_t)(next - pos), buf, &u32_len); uint32_t buf2[256]; - size_t u32_normlen = sizeof(buf2)/sizeof(buf2[0]); + size_t u32_normlen = sizeof(buf2) / sizeof(buf2[0]); uint32_t *u32s_normalized = u32_normalize(UNINORM_NFC, u32s, u32_len, buf2, &u32_normlen); int32_t g = get_synthetic_grapheme(u32s_normalized, (int64_t)u32_normlen); List$insert(&graphemes, &g, I(0), sizeof(int32_t)); - Table$get_or_setdefault(&unique_clusters, int32_t, uint8_t, g, (uint8_t)unique_clusters.entries.length, Table$info(&Int32$info, &Byte$info)); + Table$get_or_setdefault(&unique_clusters, int32_t, uint8_t, g, (uint8_t)unique_clusters.entries.length, + Table$info(&Int32$info, &Byte$info)); if (u32s != buf) free(u32s); if (u32s_normalized != buf2) free(u32s_normalized); if (unique_clusters.entries.length >= 256) { - return concat2_assuming_safe( - Text$from_components(graphemes, unique_clusters), - Text$from_strn((const char*)next, (size_t)(end-next))); + return concat2_assuming_safe(Text$from_components(graphemes, unique_clusters), + Text$from_strn((const char *)next, (size_t)(end - next))); } } return Text$from_components(graphemes, unique_clusters); } -public OptionalText_t Text$from_str(const char *str) -{ - return str ? Text$from_strn(str, strlen(str)) : Text(""); -} +public +OptionalText_t Text$from_str(const char *str) { return str ? Text$from_strn(str, strlen(str)) : Text(""); } -static void u8_buf_append(Text_t text, char **buf, int64_t *capacity, int64_t *i) -{ +static void u8_buf_append(Text_t text, char **buf, int64_t *capacity, int64_t *i) { switch (text.tag) { case TEXT_ASCII: { if (*i + text.length > (int64_t)*capacity) { @@ -863,7 +833,7 @@ static void u8_buf_append(Text_t text, char **buf, int64_t *capacity, int64_t *i if (graphemes[g] >= 0) { uint8_t u8_buf[64]; size_t u8_len = sizeof(u8_buf); - uint8_t *u8 = u32_to_u8((ucs4_t*)&graphemes[g], 1, u8_buf, &u8_len); + uint8_t *u8 = u32_to_u8((ucs4_t *)&graphemes[g], 1, u8_buf, &u8_len); if (u8 == NULL) fail("Invalid grapheme encountered: ", graphemes[g]); if (*i + (int64_t)u8_len > (int64_t)*capacity) { @@ -894,7 +864,7 @@ static void u8_buf_append(Text_t text, char **buf, int64_t *capacity, int64_t *i if (grapheme >= 0) { uint8_t u8_buf[64]; size_t u8_len = sizeof(u8_buf); - uint8_t *u8 = u32_to_u8((ucs4_t*)&grapheme, 1, u8_buf, &u8_len); + uint8_t *u8 = u32_to_u8((ucs4_t *)&grapheme, 1, u8_buf, &u8_len); if (u8 == NULL) fail("Invalid grapheme encountered: ", grapheme); if (*i + (int64_t)u8_len > (int64_t)*capacity) { @@ -928,8 +898,8 @@ static void u8_buf_append(Text_t text, char **buf, int64_t *capacity, int64_t *i } } -public char *Text$as_c_string(Text_t text) -{ +public +char *Text$as_c_string(Text_t text) { int64_t capacity = text.length + 1; char *buf = GC_MALLOC_ATOMIC((size_t)capacity); int64_t i = 0; @@ -943,10 +913,9 @@ public char *Text$as_c_string(Text_t text) return buf; } -PUREFUNC public uint64_t Text$hash(const void *obj, const TypeInfo_t *info) -{ +PUREFUNC public uint64_t Text$hash(const void *obj, const TypeInfo_t *info) { (void)info; - Text_t text = *(Text_t*)obj; + Text_t text = *(Text_t *)obj; siphash sh; siphashinit(&sh, sizeof(int32_t[text.length])); @@ -959,40 +928,41 @@ PUREFUNC public uint64_t Text$hash(const void *obj, const TypeInfo_t *info) const char *bytes = text.ascii; for (int64_t i = 0; i + 1 < text.length; i += 2) { tmp.chunks[0] = (int32_t)bytes[i]; - tmp.chunks[1] = (int32_t)bytes[i+1]; + tmp.chunks[1] = (int32_t)bytes[i + 1]; siphashadd64bits(&sh, tmp.whole); } - int32_t last = text.length & 0x1 ? (int32_t)bytes[text.length-1] : 0; // Odd number of graphemes + int32_t last = text.length & 0x1 ? (int32_t)bytes[text.length - 1] : 0; // Odd number of graphemes return siphashfinish_last_part(&sh, (uint64_t)last); } case TEXT_GRAPHEMES: { const int32_t *graphemes = text.graphemes; for (int64_t i = 0; i + 1 < text.length; i += 2) { tmp.chunks[0] = graphemes[i]; - tmp.chunks[1] = graphemes[i+1]; + tmp.chunks[1] = graphemes[i + 1]; siphashadd64bits(&sh, tmp.whole); } - int32_t last = text.length & 0x1 ? graphemes[text.length-1] : 0; // Odd number of graphemes + int32_t last = text.length & 0x1 ? graphemes[text.length - 1] : 0; // Odd number of graphemes return siphashfinish_last_part(&sh, (uint64_t)last); } case TEXT_BLOB: { for (int64_t i = 0; i + 1 < text.length; i += 2) { tmp.chunks[0] = text.blob.map[text.blob.bytes[i]]; - tmp.chunks[1] = text.blob.map[text.blob.bytes[i+1]]; + tmp.chunks[1] = text.blob.map[text.blob.bytes[i + 1]]; siphashadd64bits(&sh, tmp.whole); } - int32_t last = text.length & 0x1 ? text.blob.map[text.blob.bytes[text.length-1]] : 0; // Odd number of graphemes + int32_t last = + text.length & 0x1 ? text.blob.map[text.blob.bytes[text.length - 1]] : 0; // Odd number of graphemes return siphashfinish_last_part(&sh, (uint64_t)last); } case TEXT_CONCAT: { TextIter_t state = NEW_TEXT_ITER_STATE(text); for (int64_t i = 0; i + 1 < text.length; i += 2) { tmp.chunks[0] = Text$get_grapheme_fast(&state, i); - tmp.chunks[1] = Text$get_grapheme_fast(&state, i+1); + tmp.chunks[1] = Text$get_grapheme_fast(&state, i + 1); siphashadd64bits(&sh, tmp.whole); } - int32_t last = (text.length & 0x1) ? Text$get_grapheme_fast(&state, text.length-1) : 0; + int32_t last = (text.length & 0x1) ? Text$get_grapheme_fast(&state, text.length - 1) : 0; return siphashfinish_last_part(&sh, (uint64_t)last); } default: errx(1, "Invalid text"); @@ -1000,8 +970,8 @@ PUREFUNC public uint64_t Text$hash(const void *obj, const TypeInfo_t *info) return 0; } -public int32_t Text$get_grapheme_fast(TextIter_t *state, int64_t index) -{ +public +int32_t Text$get_grapheme_fast(TextIter_t *state, int64_t index) { if (index < 0) return 0; if (index >= state->stack[0].text.length) return 0; @@ -1051,18 +1021,17 @@ public int32_t Text$get_grapheme_fast(TextIter_t *state, int64_t index) return 0; } -public uint32_t Text$get_main_grapheme_fast(TextIter_t *state, int64_t index) -{ +public +uint32_t Text$get_main_grapheme_fast(TextIter_t *state, int64_t index) { int32_t g = Text$get_grapheme_fast(state, index); return (g) >= 0 ? (ucs4_t)(g) : synthetic_graphemes[-(g)-1].main_codepoint; } -PUREFUNC public int32_t Text$compare(const void *va, const void *vb, const TypeInfo_t *info) -{ +PUREFUNC public int32_t Text$compare(const void *va, const void *vb, const TypeInfo_t *info) { (void)info; if (va == vb) return 0; - const Text_t a = *(const Text_t*)va; - const Text_t b = *(const Text_t*)vb; + const Text_t a = *(const Text_t *)va; + const Text_t b = *(const Text_t *)vb; // TODO: make this smarter and more efficient int64_t len = MAX(a.length, b.length); @@ -1073,31 +1042,21 @@ PUREFUNC public int32_t Text$compare(const void *va, const void *vb, const TypeI if (ai == bi) continue; int32_t cmp; if (ai > 0 && bi > 0) { - cmp = u32_cmp((ucs4_t*)&ai, (ucs4_t*)&bi, 1); + cmp = u32_cmp((ucs4_t *)&ai, (ucs4_t *)&bi, 1); } else if (ai > 0) { - cmp = u32_cmp2( - (ucs4_t*)&ai, 1, - GRAPHEME_CODEPOINTS(bi), - NUM_GRAPHEME_CODEPOINTS(bi)); + cmp = u32_cmp2((ucs4_t *)&ai, 1, GRAPHEME_CODEPOINTS(bi), NUM_GRAPHEME_CODEPOINTS(bi)); } else if (bi > 0) { - cmp = u32_cmp2( - GRAPHEME_CODEPOINTS(ai), - NUM_GRAPHEME_CODEPOINTS(ai), - (ucs4_t*)&bi, 1); + cmp = u32_cmp2(GRAPHEME_CODEPOINTS(ai), NUM_GRAPHEME_CODEPOINTS(ai), (ucs4_t *)&bi, 1); } else { - cmp = u32_cmp2( - GRAPHEME_CODEPOINTS(ai), - NUM_GRAPHEME_CODEPOINTS(ai), - GRAPHEME_CODEPOINTS(bi), - NUM_GRAPHEME_CODEPOINTS(bi)); + cmp = u32_cmp2(GRAPHEME_CODEPOINTS(ai), NUM_GRAPHEME_CODEPOINTS(ai), GRAPHEME_CODEPOINTS(bi), + NUM_GRAPHEME_CODEPOINTS(bi)); } if (cmp != 0) return cmp; } return 0; } -bool _matches(TextIter_t *text_state, TextIter_t *target_state, int64_t pos) -{ +bool _matches(TextIter_t *text_state, TextIter_t *target_state, int64_t pos) { for (int64_t i = 0; i < target_state->stack[0].text.length; i++) { int32_t text_i = Text$get_grapheme_fast(text_state, pos + i); int32_t prefix_i = Text$get_grapheme_fast(target_state, i); @@ -1106,10 +1065,8 @@ bool _matches(TextIter_t *text_state, TextIter_t *target_state, int64_t pos) return true; } -PUREFUNC public bool Text$starts_with(Text_t text, Text_t prefix, Text_t *remainder) -{ - if (text.length < prefix.length) - return false; +PUREFUNC public bool Text$starts_with(Text_t text, Text_t prefix, Text_t *remainder) { + if (text.length < prefix.length) return false; TextIter_t text_state = NEW_TEXT_ITER_STATE(text), prefix_state = NEW_TEXT_ITER_STATE(prefix); if (_matches(&text_state, &prefix_state, 0)) { if (remainder) *remainder = Text$from(text, Int$from_int64(prefix.length + 1)); @@ -1120,10 +1077,8 @@ PUREFUNC public bool Text$starts_with(Text_t text, Text_t prefix, Text_t *remain } } -PUREFUNC public bool Text$ends_with(Text_t text, Text_t suffix, Text_t *remainder) -{ - if (text.length < suffix.length) - return false; +PUREFUNC public bool Text$ends_with(Text_t text, Text_t suffix, Text_t *remainder) { + if (text.length < suffix.length) return false; TextIter_t text_state = NEW_TEXT_ITER_STATE(text), suffix_state = NEW_TEXT_ITER_STATE(suffix); if (_matches(&text_state, &suffix_state, text.length - suffix.length)) { if (remainder) *remainder = Text$to(text, Int$from_int64(text.length - suffix.length)); @@ -1134,18 +1089,17 @@ PUREFUNC public bool Text$ends_with(Text_t text, Text_t suffix, Text_t *remainde } } -public Text_t Text$without_prefix(Text_t text, Text_t prefix) -{ +public +Text_t Text$without_prefix(Text_t text, Text_t prefix) { return Text$starts_with(text, prefix, NULL) ? Text$slice(text, I(prefix.length + 1), I(text.length)) : text; } -public Text_t Text$without_suffix(Text_t text, Text_t suffix) -{ +public +Text_t Text$without_suffix(Text_t text, Text_t suffix) { return Text$ends_with(text, suffix, NULL) ? Text$slice(text, I(1), I(text.length - suffix.length)) : text; } -static bool _has_grapheme(TextIter_t *text, int32_t g) -{ +static bool _has_grapheme(TextIter_t *text, int32_t g) { for (int64_t t = 0; t < text->stack[0].text.length; t++) { if (g == Text$get_grapheme_fast(text, t)) { return true; @@ -1154,8 +1108,8 @@ static bool _has_grapheme(TextIter_t *text, int32_t g) return false; } -public Text_t Text$trim(Text_t text, Text_t to_trim, bool left, bool right) -{ +public +Text_t Text$trim(Text_t text, Text_t to_trim, bool left, bool right) { int64_t first = 0; TextIter_t text_state = NEW_TEXT_ITER_STATE(text), trim_state = NEW_TEXT_ITER_STATE(to_trim); if (left) { @@ -1163,28 +1117,29 @@ public Text_t Text$trim(Text_t text, Text_t to_trim, bool left, bool right) first += 1; } } - int64_t last = text.length-1; + int64_t last = text.length - 1; if (right) { while (last >= first && _has_grapheme(&trim_state, Text$get_grapheme_fast(&text_state, last))) { last -= 1; } } - return (first != 0 || last != text.length-1) ? Text$slice(text, I(first+1), I(last+1)) : text; + return (first != 0 || last != text.length - 1) ? Text$slice(text, I(first + 1), I(last + 1)) : text; } -public Text_t Text$translate(Text_t text, Table_t translations) -{ +public +Text_t Text$translate(Text_t text, Table_t translations) { TextIter_t text_state = NEW_TEXT_ITER_STATE(text); Text_t result = EMPTY_TEXT; int64_t span_start = 0; List_t replacement_list = translations.entries; - for (int64_t i = 0; i < text.length; ) { + for (int64_t i = 0; i < text.length;) { for (int64_t r = 0; r < replacement_list.length; r++) { - struct { Text_t target, replacement; } *entry = replacement_list.data + r*replacement_list.stride; + struct { + Text_t target, replacement; + } *entry = replacement_list.data + r * replacement_list.stride; TextIter_t target_state = NEW_TEXT_ITER_STATE(entry->target); if (_matches(&text_state, &target_state, i)) { - if (i > span_start) - result = concat2(result, Text$slice(text, I(span_start+1), I(i))); + if (i > span_start) result = concat2(result, Text$slice(text, I(span_start + 1), I(i))); result = concat2(result, entry->replacement); i += entry->target.length; @@ -1193,22 +1148,21 @@ public Text_t Text$translate(Text_t text, Table_t translations) } } i += 1; - found_match: continue; + found_match: + continue; } - if (span_start < text.length) - result = concat2(result, Text$slice(text, I(span_start+1), I(text.length))); + if (span_start < text.length) result = concat2(result, Text$slice(text, I(span_start + 1), I(text.length))); return result; } -public Text_t Text$replace(Text_t text, Text_t target, Text_t replacement) -{ +public +Text_t Text$replace(Text_t text, Text_t target, Text_t replacement) { TextIter_t text_state = NEW_TEXT_ITER_STATE(text), target_state = NEW_TEXT_ITER_STATE(target); Text_t result = EMPTY_TEXT; int64_t span_start = 0; - for (int64_t i = 0; i < text.length; ) { + for (int64_t i = 0; i < text.length;) { if (_matches(&text_state, &target_state, i)) { - if (i > span_start) - result = concat2(result, Text$slice(text, I(span_start+1), I(i))); + if (i > span_start) result = concat2(result, Text$slice(text, I(span_start + 1), I(i))); result = concat2(result, replacement); i += target.length; @@ -1217,34 +1171,31 @@ public Text_t Text$replace(Text_t text, Text_t target, Text_t replacement) i += 1; } } - if (span_start < text.length) - result = concat2(result, Text$slice(text, I(span_start+1), I(text.length))); + if (span_start < text.length) result = concat2(result, Text$slice(text, I(span_start + 1), I(text.length))); return result; } -public PUREFUNC bool Text$has(Text_t text, Text_t target) -{ +public +PUREFUNC bool Text$has(Text_t text, Text_t target) { TextIter_t text_state = NEW_TEXT_ITER_STATE(text), target_state = NEW_TEXT_ITER_STATE(target); for (int64_t i = 0; i < text.length; i++) { - if (_matches(&text_state, &target_state, i)) - return true; + if (_matches(&text_state, &target_state, i)) return true; } return false; } -public List_t Text$split(Text_t text, Text_t delimiters) -{ - if (delimiters.length == 0) - return Text$clusters(text); +public +List_t Text$split(Text_t text, Text_t delimiters) { + if (delimiters.length == 0) return Text$clusters(text); TextIter_t text_state = NEW_TEXT_ITER_STATE(text), delim_state = NEW_TEXT_ITER_STATE(delimiters); List_t splits = {}; - for (int64_t i = 0; i < text.length; ) { + for (int64_t i = 0; i < text.length;) { int64_t span_len = 0; while (i + span_len < text.length && !_matches(&text_state, &delim_state, i + span_len)) { span_len += 1; } - Text_t slice = Text$slice(text, I(i+1), I(i+span_len)); + Text_t slice = Text$slice(text, I(i + 1), I(i + span_len)); List$insert(&splits, &slice, I(0), sizeof(slice)); i += span_len + delimiters.length; if (i == text.length) { @@ -1255,20 +1206,20 @@ public List_t Text$split(Text_t text, Text_t delimiters) return splits; } -public List_t Text$split_any(Text_t text, Text_t delimiters) -{ - if (delimiters.length == 0) - return List(text); +public +List_t Text$split_any(Text_t text, Text_t delimiters) { + if (delimiters.length == 0) return List(text); TextIter_t text_state = NEW_TEXT_ITER_STATE(text), delim_state = NEW_TEXT_ITER_STATE(delimiters); List_t splits = {}; - for (int64_t i = 0; i < text.length; ) { + for (int64_t i = 0; i < text.length;) { int64_t span_len = 0; - while (i + span_len < text.length && !_has_grapheme(&delim_state, Text$get_grapheme_fast(&text_state, i + span_len))) { + while (i + span_len < text.length + && !_has_grapheme(&delim_state, Text$get_grapheme_fast(&text_state, i + span_len))) { span_len += 1; } bool trailing_delim = i + span_len < text.length; - Text_t slice = Text$slice(text, I(i+1), I(i+span_len)); + Text_t slice = Text$slice(text, I(i + 1), I(i + span_len)); List$insert(&splits, &slice, I(0), sizeof(slice)); i += span_len + 1; while (i < text.length && _has_grapheme(&delim_state, Text$get_grapheme_fast(&text_state, i))) { @@ -1288,8 +1239,7 @@ typedef struct { Text_t delimiter; } split_iter_state_t; -static OptionalText_t next_split(split_iter_state_t *state) -{ +static OptionalText_t next_split(split_iter_state_t *state) { Text_t text = state->state.stack[0].text; if (state->i >= text.length) { if (state->delimiter.length > 0 && state->i == text.length) { // special case @@ -1310,21 +1260,20 @@ static OptionalText_t next_split(split_iter_state_t *state) while (i + span_len < text.length && !_matches(&state->state, &delim_state, i + span_len)) { span_len += 1; } - Text_t slice = Text$slice(text, I(i+1), I(i+span_len)); + Text_t slice = Text$slice(text, I(i + 1), I(i + span_len)); state->i = i + span_len + state->delimiter.length; return slice; } -public Closure_t Text$by_split(Text_t text, Text_t delimiter) -{ +public +Closure_t Text$by_split(Text_t text, Text_t delimiter) { return (Closure_t){ - .fn=(void*)next_split, - .userdata=new(split_iter_state_t, .state=NEW_TEXT_ITER_STATE(text), .i=0, .delimiter=delimiter), + .fn = (void *)next_split, + .userdata = new (split_iter_state_t, .state = NEW_TEXT_ITER_STATE(text), .i = 0, .delimiter = delimiter), }; } -static OptionalText_t next_split_any(split_iter_state_t *state) -{ +static OptionalText_t next_split_any(split_iter_state_t *state) { Text_t text = state->state.stack[0].text; if (state->i >= text.length) { if (state->delimiter.length > 0 && state->i == text.length) { // special case @@ -1335,7 +1284,7 @@ static OptionalText_t next_split_any(split_iter_state_t *state) } if (state->delimiter.length == 0) { // special case - Text_t ret = Text$cluster(text, I(state->i+1)); + Text_t ret = Text$cluster(text, I(state->i + 1)); state->i += 1; return ret; } @@ -1343,10 +1292,11 @@ static OptionalText_t next_split_any(split_iter_state_t *state) TextIter_t delim_state = NEW_TEXT_ITER_STATE(state->delimiter); int64_t i = state->i; int64_t span_len = 0; - while (i + span_len < text.length && !_has_grapheme(&delim_state, Text$get_grapheme_fast(&state->state, i + span_len))) { + while (i + span_len < text.length + && !_has_grapheme(&delim_state, Text$get_grapheme_fast(&state->state, i + span_len))) { span_len += 1; } - Text_t slice = Text$slice(text, I(i+1), I(i+span_len)); + Text_t slice = Text$slice(text, I(i + 1), I(i + span_len)); i += span_len + 1; while (i < text.length && _has_grapheme(&delim_state, Text$get_grapheme_fast(&state->state, i))) { i += 1; @@ -1355,18 +1305,16 @@ static OptionalText_t next_split_any(split_iter_state_t *state) return slice; } -public Closure_t Text$by_split_any(Text_t text, Text_t delimiters) -{ +public +Closure_t Text$by_split_any(Text_t text, Text_t delimiters) { return (Closure_t){ - .fn=(void*)next_split_any, - .userdata=new(split_iter_state_t, .state=NEW_TEXT_ITER_STATE(text), .i=0, .delimiter=delimiters), + .fn = (void *)next_split_any, + .userdata = new (split_iter_state_t, .state = NEW_TEXT_ITER_STATE(text), .i = 0, .delimiter = delimiters), }; } -PUREFUNC public bool Text$equal_values(Text_t a, Text_t b) -{ - if (a.length != b.length) - return false; +PUREFUNC public bool Text$equal_values(Text_t a, Text_t b) { + if (a.length != b.length) return false; int64_t len = a.length; TextIter_t a_state = NEW_TEXT_ITER_STATE(a), b_state = NEW_TEXT_ITER_STATE(b); // TODO: make this smarter and more efficient @@ -1378,17 +1326,14 @@ PUREFUNC public bool Text$equal_values(Text_t a, Text_t b) return true; } -PUREFUNC public bool Text$equal(const void *a, const void *b, const TypeInfo_t *info) -{ +PUREFUNC public bool Text$equal(const void *a, const void *b, const TypeInfo_t *info) { (void)info; if (a == b) return true; - return Text$equal_values(*(Text_t*)a, *(Text_t*)b); + return Text$equal_values(*(Text_t *)a, *(Text_t *)b); } -PUREFUNC public bool Text$equal_ignoring_case(Text_t a, Text_t b, Text_t language) -{ - if (a.length != b.length) - return false; +PUREFUNC public bool Text$equal_ignoring_case(Text_t a, Text_t b, Text_t language) { + if (a.length != b.length) return false; int64_t len = a.length; TextIter_t a_state = NEW_TEXT_ITER_STATE(a), b_state = NEW_TEXT_ITER_STATE(b); const char *uc_language = Text$as_c_string(language); @@ -1396,76 +1341,79 @@ PUREFUNC public bool Text$equal_ignoring_case(Text_t a, Text_t b, Text_t languag int32_t ai = Text$get_grapheme_fast(&a_state, i); int32_t bi = Text$get_grapheme_fast(&b_state, i); if (ai != bi) { - const ucs4_t *a_codepoints = ai >= 0 ? (ucs4_t*)&ai : GRAPHEME_CODEPOINTS(ai); + const ucs4_t *a_codepoints = ai >= 0 ? (ucs4_t *)&ai : GRAPHEME_CODEPOINTS(ai); int64_t a_len = ai >= 0 ? 1 : NUM_GRAPHEME_CODEPOINTS(ai); - const ucs4_t *b_codepoints = bi >= 0 ? (ucs4_t*)&bi : GRAPHEME_CODEPOINTS(bi); + const ucs4_t *b_codepoints = bi >= 0 ? (ucs4_t *)&bi : GRAPHEME_CODEPOINTS(bi); int64_t b_len = bi >= 0 ? 1 : NUM_GRAPHEME_CODEPOINTS(bi); int cmp = 0; (void)u32_casecmp(a_codepoints, (size_t)a_len, b_codepoints, (size_t)b_len, uc_language, UNINORM_NFC, &cmp); - if (cmp != 0) - return false; + if (cmp != 0) return false; } } return true; } -public Text_t Text$upper(Text_t text, Text_t language) -{ +public +Text_t Text$upper(Text_t text, Text_t language) { if (text.length == 0) return text; List_t codepoints = Text$utf32_codepoints(text); const char *uc_language = Text$as_c_string(language); size_t out_len = 0; ucs4_t *upper = u32_toupper(codepoints.data, (size_t)codepoints.length, uc_language, UNINORM_NFC, NULL, &out_len); - Text_t ret = Text$from_codepoints((List_t){.data=upper, .length=(int64_t)out_len, .stride=sizeof(int32_t)}); + Text_t ret = Text$from_codepoints((List_t){.data = upper, .length = (int64_t)out_len, .stride = sizeof(int32_t)}); return ret; } -public Text_t Text$lower(Text_t text, Text_t language) -{ +public +Text_t Text$lower(Text_t text, Text_t language) { if (text.length == 0) return text; List_t codepoints = Text$utf32_codepoints(text); const char *uc_language = Text$as_c_string(language); size_t out_len = 0; ucs4_t *lower = u32_tolower(codepoints.data, (size_t)codepoints.length, uc_language, UNINORM_NFC, NULL, &out_len); - Text_t ret = Text$from_codepoints((List_t){.data=lower, .length=(int64_t)out_len, .stride=sizeof(int32_t)}); + Text_t ret = Text$from_codepoints((List_t){.data = lower, .length = (int64_t)out_len, .stride = sizeof(int32_t)}); return ret; } -public Text_t Text$title(Text_t text, Text_t language) -{ +public +Text_t Text$title(Text_t text, Text_t language) { if (text.length == 0) return text; List_t codepoints = Text$utf32_codepoints(text); const char *uc_language = Text$as_c_string(language); size_t out_len = 0; ucs4_t *title = u32_totitle(codepoints.data, (size_t)codepoints.length, uc_language, UNINORM_NFC, NULL, &out_len); - Text_t ret = Text$from_codepoints((List_t){.data=title, .length=(int64_t)out_len, .stride=sizeof(int32_t)}); + Text_t ret = Text$from_codepoints((List_t){.data = title, .length = (int64_t)out_len, .stride = sizeof(int32_t)}); return ret; } -public Text_t Text$quoted(Text_t text, bool colorize, Text_t quotation_mark) -{ - if (quotation_mark.length != 1) - fail("Invalid quote text: ", quotation_mark, " (must have length == 1)"); +public +Text_t Text$quoted(Text_t text, bool colorize, Text_t quotation_mark) { + if (quotation_mark.length != 1) fail("Invalid quote text: ", quotation_mark, " (must have length == 1)"); Text_t ret = colorize ? Text("\x1b[35m") : EMPTY_TEXT; - if (!Text$equal_values(quotation_mark, Text("\"")) && !Text$equal_values(quotation_mark, Text("'")) && !Text$equal_values(quotation_mark, Text("`"))) + if (!Text$equal_values(quotation_mark, Text("\"")) && !Text$equal_values(quotation_mark, Text("'")) + && !Text$equal_values(quotation_mark, Text("`"))) ret = concat2_assuming_safe(ret, Text("$")); ret = concat2_assuming_safe(ret, quotation_mark); int32_t quote_char = Text$get_grapheme(quotation_mark, 0); -#define flush_unquoted() ({ \ - if (unquoted_span > 0) { \ - ret = concat2_assuming_safe(ret, Text$slice(text, I(i-unquoted_span+1), I(i))); \ - unquoted_span = 0; \ - } }) -#define add_escaped(str) ({ \ - flush_unquoted(); \ - if (colorize) ret = concat2_assuming_safe(ret, Text("\x1b[34;1m")); \ - ret = concat2_assuming_safe(ret, Text("\\" str)); \ - if (colorize) ret = concat2_assuming_safe(ret, Text("\x1b[0;35m")); }) +#define flush_unquoted() \ + ({ \ + if (unquoted_span > 0) { \ + ret = concat2_assuming_safe(ret, Text$slice(text, I(i - unquoted_span + 1), I(i))); \ + unquoted_span = 0; \ + } \ + }) +#define add_escaped(str) \ + ({ \ + flush_unquoted(); \ + if (colorize) ret = concat2_assuming_safe(ret, Text("\x1b[34;1m")); \ + ret = concat2_assuming_safe(ret, Text("\\" str)); \ + if (colorize) ret = concat2_assuming_safe(ret, Text("\x1b[0;35m")); \ + }) TextIter_t state = NEW_TEXT_ITER_STATE(text); int64_t unquoted_span = 0; int64_t i = 0; @@ -1488,8 +1436,10 @@ public Text_t Text$quoted(Text_t text, bool colorize, Text_t quotation_mark) add_escaped("$"); break; } - case '\x00' ... '\x06': case '\x0E' ... '\x1A': - case '\x1C' ... '\x1F': case '\x7F' ... '\x7F': { + case '\x00' ... '\x06': + case '\x0E' ... '\x1A': + case '\x1C' ... '\x1F': + case '\x7F' ... '\x7F': { flush_unquoted(); if (colorize) ret = concat2_assuming_safe(ret, Text("\x1b[34;1m")); ret = concat2_assuming_safe(ret, Text("\\x")); @@ -1499,8 +1449,7 @@ public Text_t Text$quoted(Text_t text, bool colorize, Text_t quotation_mark) '\0', }; ret = concat2_assuming_safe(ret, Text$from_strn(tmp, 2)); - if (colorize) - ret = concat2_assuming_safe(ret, Text("\x1b[0;35m")); + if (colorize) ret = concat2_assuming_safe(ret, Text("\x1b[0;35m")); break; } default: { @@ -1522,21 +1471,19 @@ public Text_t Text$quoted(Text_t text, bool colorize, Text_t quotation_mark) #undef flush_unquoted ret = concat2_assuming_safe(ret, quotation_mark); - if (colorize) - ret = concat2_assuming_safe(ret, Text("\x1b[m")); + if (colorize) ret = concat2_assuming_safe(ret, Text("\x1b[m")); return ret; } -public Text_t Text$as_text(const void *vtext, bool colorize, const TypeInfo_t *info) -{ +public +Text_t Text$as_text(const void *vtext, bool colorize, const TypeInfo_t *info) { (void)info; if (!vtext) return info && info->TextInfo.lang ? Text$from_str(info->TextInfo.lang) : Text("Text"); - Text_t text = *(Text_t*)vtext; + Text_t text = *(Text_t *)vtext; // Figure out the best quotation mark to use: - bool has_double_quote = false, has_backtick = false, - has_single_quote = false, needs_escapes = false; + bool has_double_quote = false, has_backtick = false, has_single_quote = false, needs_escapes = false; TextIter_t state = NEW_TEXT_ITER_STATE(text); for (int64_t i = 0; i < text.length; i++) { int32_t g = Text$get_grapheme_fast(&state, i); @@ -1554,39 +1501,33 @@ public Text_t Text$as_text(const void *vtext, bool colorize, const TypeInfo_t *i // needing to escape them by using single quotes, but only if we don't have // single quotes or need to escape anything else (because single quotes // don't have interpolation): - if (has_double_quote && !has_single_quote) - quote = Text("'"); + if (has_double_quote && !has_single_quote) quote = Text("'"); // If there is a double quote, but no backtick, we can save a bit of // escaping by using backtick instead of double quote: - else if (has_double_quote && has_single_quote && !has_backtick && !needs_escapes) - quote = Text("`"); + else if (has_double_quote && has_single_quote && !has_backtick && !needs_escapes) quote = Text("`"); // Otherwise fall back to double quotes as the default quoting style: - else - quote = Text("\""); + else quote = Text("\""); Text_t as_text = Text$quoted(text, colorize, quote); if (info && info->TextInfo.lang && info != &Text$info) - as_text = Text$concat( - colorize ? Text("\x1b[1m$") : Text("$"), - Text$from_str(info->TextInfo.lang), - colorize ? Text("\x1b[0m") : Text(""), - as_text); + as_text = Text$concat(colorize ? Text("\x1b[1m$") : Text("$"), Text$from_str(info->TextInfo.lang), + colorize ? Text("\x1b[0m") : Text(""), as_text); return as_text; } -public Text_t Text$join(Text_t glue, List_t pieces) -{ +public +Text_t Text$join(Text_t glue, List_t pieces) { if (pieces.length == 0) return EMPTY_TEXT; - Text_t result = *(Text_t*)pieces.data; + Text_t result = *(Text_t *)pieces.data; for (int64_t i = 1; i < pieces.length; i++) { - result = Text$concat(result, glue, *(Text_t*)(pieces.data + i*pieces.stride)); + result = Text$concat(result, glue, *(Text_t *)(pieces.data + i * pieces.stride)); } return result; } -public List_t Text$clusters(Text_t text) -{ +public +List_t Text$clusters(Text_t text) { List_t clusters = {}; for (int64_t i = 1; i <= text.length; i++) { Text_t cluster = Text$slice(text, I(i), I(i)); @@ -1595,9 +1536,9 @@ public List_t Text$clusters(Text_t text) return clusters; } -public List_t Text$utf32_codepoints(Text_t text) -{ - List_t codepoints = {.atomic=1}; +public +List_t Text$utf32_codepoints(Text_t text) { + List_t codepoints = {.atomic = 1}; TextIter_t state = NEW_TEXT_ITER_STATE(text); for (int64_t i = 0; i < text.length; i++) { int32_t grapheme = Text$get_grapheme_fast(&state, i); @@ -1613,24 +1554,23 @@ public List_t Text$utf32_codepoints(Text_t text) return codepoints; } -public List_t Text$utf8_bytes(Text_t text) -{ +public +List_t Text$utf8_bytes(Text_t text) { const char *str = Text$as_c_string(text); - return (List_t){.length=(int64_t)strlen(str), .stride=1, .atomic=1, .data=(void*)str}; + return (List_t){.length = (int64_t)strlen(str), .stride = 1, .atomic = 1, .data = (void *)str}; } -static INLINE const char *codepoint_name(ucs4_t c) -{ +static INLINE const char *codepoint_name(ucs4_t c) { char *name = GC_MALLOC_ATOMIC(UNINAME_MAX); char *found_name = unicode_character_name(c, name); if (found_name) return found_name; const uc_block_t *block = uc_block(c); assert(block); - return String(block->name, "-", hex(c, .no_prefix=true, .uppercase=true)); + return String(block->name, "-", hex(c, .no_prefix = true, .uppercase = true)); } -public List_t Text$codepoint_names(Text_t text) -{ +public +List_t Text$codepoint_names(Text_t text) { List_t names = {}; TextIter_t state = NEW_TEXT_ITER_STATE(text); for (int64_t i = 0; i < text.length; i++) { @@ -1650,81 +1590,78 @@ public List_t Text$codepoint_names(Text_t text) return names; } -public Text_t Text$from_codepoints(List_t codepoints) -{ - if (codepoints.stride != sizeof(uint32_t)) - List$compact(&codepoints, sizeof(uint32_t)); +public +Text_t Text$from_codepoints(List_t codepoints) { + if (codepoints.stride != sizeof(uint32_t)) List$compact(&codepoints, sizeof(uint32_t)); List_t graphemes = {}; Table_t unique_clusters = {}; - const uint32_t *pos = (const uint32_t*)codepoints.data; - const uint32_t *end = (const uint32_t*)&pos[codepoints.length]; + const uint32_t *pos = (const uint32_t *)codepoints.data; + const uint32_t *end = (const uint32_t *)&pos[codepoints.length]; // Iterate over grapheme clusters - for (const uint32_t *next; (next=u32_grapheme_next(pos, end)); pos = next) { + for (const uint32_t *next; (next = u32_grapheme_next(pos, end)); pos = next) { // Buffer for normalized cluster: uint32_t buf[256]; - size_t u32_normlen = sizeof(buf)/sizeof(buf[0]); - uint32_t *u32s_normalized = u32_normalize(UNINORM_NFC, pos, (size_t)(next-pos), buf, &u32_normlen); + size_t u32_normlen = sizeof(buf) / sizeof(buf[0]); + uint32_t *u32s_normalized = u32_normalize(UNINORM_NFC, pos, (size_t)(next - pos), buf, &u32_normlen); int32_t g = get_synthetic_grapheme(u32s_normalized, (int64_t)u32_normlen); List$insert(&graphemes, &g, I(0), sizeof(int32_t)); - Table$get_or_setdefault( - &unique_clusters, int32_t, uint8_t, g, (uint8_t)unique_clusters.entries.length, - Table$info(&Int32$info, &Byte$info)); + Table$get_or_setdefault(&unique_clusters, int32_t, uint8_t, g, (uint8_t)unique_clusters.entries.length, + Table$info(&Int32$info, &Byte$info)); if (u32s_normalized != buf) free(u32s_normalized); if (unique_clusters.entries.length == 256) { List_t remaining_codepoints = { - .length=(int64_t)(end-next), - .data=(void*)next, - .stride=sizeof(int32_t), + .length = (int64_t)(end - next), + .data = (void *)next, + .stride = sizeof(int32_t), }; - return concat2_assuming_safe(Text$from_components(graphemes, unique_clusters), Text$from_codepoints(remaining_codepoints)); + return concat2_assuming_safe(Text$from_components(graphemes, unique_clusters), + Text$from_codepoints(remaining_codepoints)); } } return Text$from_components(graphemes, unique_clusters); } -public OptionalText_t Text$from_codepoint_names(List_t codepoint_names) -{ +public +OptionalText_t Text$from_codepoint_names(List_t codepoint_names) { List_t codepoints = {}; for (int64_t i = 0; i < codepoint_names.length; i++) { - Text_t *name = ((Text_t*)(codepoint_names.data + i*codepoint_names.stride)); + Text_t *name = ((Text_t *)(codepoint_names.data + i * codepoint_names.stride)); const char *name_str = Text$as_c_string(*name); ucs4_t codepoint = unicode_name_character(name_str); - if (codepoint == UNINAME_INVALID) - return NONE_TEXT; + if (codepoint == UNINAME_INVALID) return NONE_TEXT; List$insert(&codepoints, &codepoint, I_small(0), sizeof(ucs4_t)); } return Text$from_codepoints(codepoints); } -public OptionalText_t Text$from_bytes(List_t bytes) -{ - if (bytes.stride != sizeof(int8_t)) - List$compact(&bytes, sizeof(int8_t)); +public +OptionalText_t Text$from_bytes(List_t bytes) { + if (bytes.stride != sizeof(int8_t)) List$compact(&bytes, sizeof(int8_t)); return Text$from_strn(bytes.data, (size_t)bytes.length); } -public List_t Text$lines(Text_t text) -{ +public +List_t Text$lines(Text_t text) { List_t lines = {}; TextIter_t state = NEW_TEXT_ITER_STATE(text); for (int64_t i = 0, line_start = 0; i < text.length; i++) { int32_t grapheme = Text$get_grapheme_fast(&state, i); if (grapheme == '\r' && Text$get_grapheme_fast(&state, i + 1) == '\n') { // CRLF - Text_t line = Text$slice(text, I(line_start+1), I(i)); + Text_t line = Text$slice(text, I(line_start + 1), I(i)); List$insert(&lines, &line, I_small(0), sizeof(Text_t)); i += 1; // skip one extra for CR line_start = i + 1; } else if (grapheme == '\n') { // newline - Text_t line = Text$slice(text, I(line_start+1), I(i)); + Text_t line = Text$slice(text, I(line_start + 1), I(i)); List$insert(&lines, &line, I_small(0), sizeof(Text_t)); line_start = i + 1; - } else if (i == text.length-1 && line_start != i) { // last line - Text_t line = Text$slice(text, I(line_start+1), I(i+1)); + } else if (i == text.length - 1 && line_start != i) { // last line + Text_t line = Text$slice(text, I(line_start + 1), I(i + 1)); List$insert(&lines, &line, I_small(0), sizeof(Text_t)); } } @@ -1736,21 +1673,20 @@ typedef struct { int64_t i; } line_iter_state_t; -static OptionalText_t next_line(line_iter_state_t *state) -{ +static OptionalText_t next_line(line_iter_state_t *state) { Text_t text = state->state.stack[0].text; for (int64_t i = state->i; i < text.length; i++) { int32_t grapheme = Text$get_grapheme_fast(&state->state, i); if (grapheme == '\r' && Text$get_grapheme_fast(&state->state, i + 1) == '\n') { // CRLF - Text_t line = Text$slice(text, I(state->i+1), I(i)); + Text_t line = Text$slice(text, I(state->i + 1), I(i)); state->i = i + 2; // skip one extra for CR return line; } else if (grapheme == '\n') { // newline - Text_t line = Text$slice(text, I(state->i+1), I(i)); + Text_t line = Text$slice(text, I(state->i + 1), I(i)); state->i = i + 1; return line; - } else if (i == text.length-1 && state->i != i) { // last line - Text_t line = Text$slice(text, I(state->i+1), I(i+1)); + } else if (i == text.length - 1 && state->i != i) { // last line + Text_t line = Text$slice(text, I(state->i + 1), I(i + 1)); state->i = i + 1; return line; } @@ -1758,81 +1694,75 @@ static OptionalText_t next_line(line_iter_state_t *state) return NONE_TEXT; } -public Closure_t Text$by_line(Text_t text) -{ +public +Closure_t Text$by_line(Text_t text) { return (Closure_t){ - .fn=(void*)next_line, - .userdata=new(line_iter_state_t, .state=NEW_TEXT_ITER_STATE(text), .i=0), + .fn = (void *)next_line, + .userdata = new (line_iter_state_t, .state = NEW_TEXT_ITER_STATE(text), .i = 0), }; } -PUREFUNC public bool Text$is_none(const void *t, const TypeInfo_t *info) -{ +PUREFUNC public bool Text$is_none(const void *t, const TypeInfo_t *info) { (void)info; - return ((Text_t*)t)->length < 0; + return ((Text_t *)t)->length < 0; } -public Int_t Text$memory_size(Text_t text) -{ +public +Int_t Text$memory_size(Text_t text) { switch (text.tag) { - case TEXT_ASCII: - return Int$from_int64((int64_t)sizeof(Text_t) + (int64_t)sizeof(char[text.length])); - case TEXT_GRAPHEMES: - return Int$from_int64((int64_t)sizeof(Text_t) + (int64_t)sizeof(int32_t[text.length])); + case TEXT_ASCII: return Int$from_int64((int64_t)sizeof(Text_t) + (int64_t)sizeof(char[text.length])); + case TEXT_GRAPHEMES: return Int$from_int64((int64_t)sizeof(Text_t) + (int64_t)sizeof(int32_t[text.length])); case TEXT_BLOB: - return Int$from_int64((int64_t)sizeof(Text_t) + (int64_t)((void*)text.blob.bytes - (void*)text.blob.map) + (int64_t)sizeof(uint8_t[text.length])); + return Int$from_int64((int64_t)sizeof(Text_t) + (int64_t)((void *)text.blob.bytes - (void *)text.blob.map) + + (int64_t)sizeof(uint8_t[text.length])); case TEXT_CONCAT: - return Int$plus( - Int$from_int64((int64_t)sizeof(Text_t)), - Int$plus(Text$memory_size(*text.left), Text$memory_size(*text.right))); + return Int$plus(Int$from_int64((int64_t)sizeof(Text_t)), + Int$plus(Text$memory_size(*text.left), Text$memory_size(*text.right))); default: errx(1, "Invalid text tag: %d", text.tag); } } -public Text_t Text$layout(Text_t text) -{ +public +Text_t Text$layout(Text_t text) { switch (text.tag) { - case TEXT_ASCII: - return Texts(Text("ASCII("), Int64$as_text((int64_t[1]){text.length}, false, NULL), Text(")")); + case TEXT_ASCII: return Texts(Text("ASCII("), Int64$as_text((int64_t[1]){text.length}, false, NULL), Text(")")); case TEXT_GRAPHEMES: return Texts(Text("Graphemes("), Int64$as_text((int64_t[1]){text.length}, false, NULL), Text(")")); - case TEXT_BLOB: - return Texts(Text("Blob("), Int64$as_text((int64_t[1]){text.length}, false, NULL), Text(")")); + case TEXT_BLOB: return Texts(Text("Blob("), Int64$as_text((int64_t[1]){text.length}, false, NULL), Text(")")); case TEXT_CONCAT: return Texts(Text("Concat("), Text$layout(*text.left), Text(", "), Text$layout(*text.right), Text(")")); default: errx(1, "Invalid text tag: %d", text.tag); } } -public void Text$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *info) -{ +public +void Text$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *info) { (void)info; - const char *str = Text$as_c_string(*(Text_t*)obj); + const char *str = Text$as_c_string(*(Text_t *)obj); int64_t len = (int64_t)strlen(str); Int64$serialize(&len, out, pointers, &Int64$info); fwrite(str, sizeof(char), (size_t)len, out); } -public void Text$deserialize(FILE *in, void *out, List_t *pointers, const TypeInfo_t *info) -{ +public +void Text$deserialize(FILE *in, void *out, List_t *pointers, const TypeInfo_t *info) { (void)info; int64_t len = 0; Int64$deserialize(in, &len, pointers, &Int64$info); - if (len < 0) - fail("Cannot deserialize text with a negative length!"); - char *buf = GC_MALLOC_ATOMIC((size_t)len+1); - if (fread(buf, sizeof(char), (size_t)len, in) != (size_t)len) - fail("Not enough data in stream to deserialize"); - buf[len+1] = '\0'; - *(Text_t*)out = Text$from_strn(buf, (size_t)len); -} - -public const TypeInfo_t Text$info = { - .size=sizeof(Text_t), - .align=__alignof__(Text_t), - .tag=TextInfo, - .TextInfo={.lang="Text"}, - .metamethods=Text$metamethods, + if (len < 0) fail("Cannot deserialize text with a negative length!"); + char *buf = GC_MALLOC_ATOMIC((size_t)len + 1); + if (fread(buf, sizeof(char), (size_t)len, in) != (size_t)len) fail("Not enough data in stream to deserialize"); + buf[len + 1] = '\0'; + *(Text_t *)out = Text$from_strn(buf, (size_t)len); +} + +public +const TypeInfo_t Text$info = { + .size = sizeof(Text_t), + .align = __alignof__(Text_t), + .tag = TextInfo, + .TextInfo = {.lang = "Text"}, + .metamethods = Text$metamethods, }; // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/text.h b/src/stdlib/text.h index cb3f1b90..6bedcb60 100644 --- a/src/stdlib/text.h +++ b/src/stdlib/text.h @@ -21,22 +21,20 @@ typedef struct { int64_t stack_index; } TextIter_t; -#define NEW_TEXT_ITER_STATE(t) (TextIter_t){.stack={{t, 0}}, .stack_index=0} +#define NEW_TEXT_ITER_STATE(t) (TextIter_t){.stack = {{t, 0}}, .stack_index = 0} -#define Text(str) ((Text_t){.length=sizeof(str)-1, .tag=TEXT_ASCII, .ascii="" str}) +#define Text(str) ((Text_t){.length = sizeof(str) - 1, .tag = TEXT_ASCII, .ascii = "" str}) static inline Text_t Text_from_str_literal(const char *str) { - return (Text_t){.length=strlen(str), .tag=TEXT_ASCII, .ascii=str}; + return (Text_t){.length = strlen(str), .tag = TEXT_ASCII, .ascii = str}; } -static inline Text_t Text_from_text(Text_t t) { - return t; -} +static inline Text_t Text_from_text(Text_t t) { return t; } -#define convert_to_text(x) _Generic(x, Text_t: Text_from_text, char*: Text$from_str, const char*: Text$from_str)(x) +#define convert_to_text(x) _Generic(x, Text_t: Text_from_text, char *: Text$from_str, const char *: Text$from_str)(x) Text_t Text$_concat(int n, Text_t items[n]); -#define Text$concat(...) Text$_concat(sizeof((Text_t[]){__VA_ARGS__})/sizeof(Text_t), (Text_t[]){__VA_ARGS__}) +#define Text$concat(...) Text$_concat(sizeof((Text_t[]){__VA_ARGS__}) / sizeof(Text_t), (Text_t[]){__VA_ARGS__}) #define Texts(...) Text$concat(MAP_LIST(convert_to_text, __VA_ARGS__)) // int Text$print(FILE *stream, Text_t t); Text_t Text$slice(Text_t text, Int_t first_int, Int_t last_int); @@ -46,12 +44,12 @@ Text_t Text$reversed(Text_t text); Text_t Text$cluster(Text_t text, Int_t index_int); OptionalText_t Text$from_str(const char *str); OptionalText_t Text$from_strn(const char *str, size_t len); -PUREFUNC uint64_t Text$hash(const void *text, const TypeInfo_t*); -PUREFUNC int32_t Text$compare(const void *va, const void *vb, const TypeInfo_t*); -PUREFUNC bool Text$equal(const void *a, const void *b, const TypeInfo_t*); +PUREFUNC uint64_t Text$hash(const void *text, const TypeInfo_t *); +PUREFUNC int32_t Text$compare(const void *va, const void *vb, const TypeInfo_t *); +PUREFUNC bool Text$equal(const void *a, const void *b, const TypeInfo_t *); PUREFUNC bool Text$equal_values(Text_t a, Text_t b); PUREFUNC bool Text$equal_ignoring_case(Text_t a, Text_t b, Text_t language); -PUREFUNC bool Text$is_none(const void *t, const TypeInfo_t*); +PUREFUNC bool Text$is_none(const void *t, const TypeInfo_t *); Text_t Text$upper(Text_t text, Text_t language); Text_t Text$lower(Text_t text, Text_t language); Text_t Text$title(Text_t text, Text_t language); @@ -92,8 +90,7 @@ Text_t Text$layout(Text_t text); void Text$serialize(const void *obj, FILE *out, Table_t *, const TypeInfo_t *); void Text$deserialize(FILE *in, void *out, List_t *, const TypeInfo_t *); -MACROLIKE int32_t Text$get_grapheme(Text_t text, int64_t index) -{ +MACROLIKE int32_t Text$get_grapheme(Text_t text, int64_t index) { TextIter_t state = NEW_TEXT_ITER_STATE(text); return Text$get_grapheme_fast(&state, index); } @@ -101,14 +98,15 @@ MACROLIKE int32_t Text$get_grapheme(Text_t text, int64_t index) extern const TypeInfo_t Text$info; extern Text_t EMPTY_TEXT; -#define Text$metamethods { \ - .as_text=Text$as_text, \ - .hash=Text$hash, \ - .compare=Text$compare, \ - .equal=Text$equal, \ - .is_none=Text$is_none, \ - .serialize=Text$serialize, \ - .deserialize=Text$deserialize, \ -} +#define Text$metamethods \ + { \ + .as_text = Text$as_text, \ + .hash = Text$hash, \ + .compare = Text$compare, \ + .equal = Text$equal, \ + .is_none = Text$is_none, \ + .serialize = Text$serialize, \ + .deserialize = Text$deserialize, \ + } // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/types.c b/src/stdlib/types.c index 0f17cb21..e64195fe 100644 --- a/src/stdlib/types.c +++ b/src/stdlib/types.c @@ -3,24 +3,21 @@ #include <gc.h> #include <sys/param.h> -#include "util.h" #include "text.h" #include "types.h" +#include "util.h" -public Text_t Type$as_text(const void *typeinfo, bool colorize, const TypeInfo_t *type) -{ +public +Text_t Type$as_text(const void *typeinfo, bool colorize, const TypeInfo_t *type) { if (!typeinfo) return Text("Type"); - if (colorize) - return Text$concat( - Text("\x1b[36;1m"), - Text$from_str(type->TypeInfoInfo.type_str), - Text("\x1b[m")); - else - return Text$from_str(type->TypeInfoInfo.type_str); + if (colorize) return Text$concat(Text("\x1b[36;1m"), Text$from_str(type->TypeInfoInfo.type_str), Text("\x1b[m")); + else return Text$from_str(type->TypeInfoInfo.type_str); } -public const TypeInfo_t Void$info = {.size=0, .align=0, .tag=StructInfo}; -public const TypeInfo_t Abort$info = {.size=0, .align=0, .tag=StructInfo}; +public +const TypeInfo_t Void$info = {.size = 0, .align = 0, .tag = StructInfo}; +public +const TypeInfo_t Abort$info = {.size = 0, .align = 0, .tag = StructInfo}; // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/types.h b/src/stdlib/types.h index 60f1fcfd..a6509183 100644 --- a/src/stdlib/types.h +++ b/src/stdlib/types.h @@ -10,13 +10,13 @@ typedef struct TypeInfo_s TypeInfo_t; -typedef void (*serialize_fn_t)(const void*, FILE*, Table_t*, const TypeInfo_t*); -typedef void (*deserialize_fn_t)(FILE*, void*, List_t*, const TypeInfo_t*); -typedef bool (*is_none_fn_t)(const void*, const TypeInfo_t*); -typedef uint64_t (*hash_fn_t)(const void*, const TypeInfo_t*); -typedef int32_t (*compare_fn_t)(const void*, const void*, const TypeInfo_t*); -typedef bool (*equal_fn_t)(const void*, const void*, const TypeInfo_t*); -typedef Text_t (*as_text_fn_t)(const void*, bool, const TypeInfo_t*); +typedef void (*serialize_fn_t)(const void *, FILE *, Table_t *, const TypeInfo_t *); +typedef void (*deserialize_fn_t)(FILE *, void *, List_t *, const TypeInfo_t *); +typedef bool (*is_none_fn_t)(const void *, const TypeInfo_t *); +typedef uint64_t (*hash_fn_t)(const void *, const TypeInfo_t *); +typedef int32_t (*compare_fn_t)(const void *, const void *, const TypeInfo_t *); +typedef bool (*equal_fn_t)(const void *, const void *, const TypeInfo_t *); +typedef Text_t (*as_text_fn_t)(const void *, bool, const TypeInfo_t *); typedef struct { hash_fn_t hash; @@ -36,11 +36,22 @@ typedef struct { struct TypeInfo_s { int64_t size, align; metamethods_t metamethods; - struct { // Anonymous tagged union for convenience - enum { OpaqueInfo, StructInfo, EnumInfo, PointerInfo, TextInfo, ListInfo, TableInfo, FunctionInfo, - OptionalInfo, TypeInfoInfo } tag; + struct { // Anonymous tagged union for convenience + enum { + OpaqueInfo, + StructInfo, + EnumInfo, + PointerInfo, + TextInfo, + ListInfo, + TableInfo, + FunctionInfo, + OptionalInfo, + TypeInfoInfo + } tag; union { - struct {} OpaqueInfo; + struct { + } OpaqueInfo; struct { const char *sigil; const TypeInfo_t *pointed; @@ -72,7 +83,7 @@ struct TypeInfo_s { const char *name; NamedType_t *fields; int num_fields; - bool is_secret:1, is_opaque:1; + bool is_secret : 1, is_opaque : 1; } StructInfo; }; }; @@ -84,18 +95,22 @@ extern const TypeInfo_t Abort$info; Text_t Type$as_text(const void *typeinfo, bool colorize, const TypeInfo_t *type); -#define Type$info(typestr) &((TypeInfo_t){.size=sizeof(TypeInfo_t), .align=__alignof__(TypeInfo_t), \ - .tag=TypeInfoInfo, .TypeInfoInfo.type_str=typestr, \ - .metamethods={.serialize=cannot_serialize, .deserialize=cannot_deserialize, .as_text=Type$as_text}}) +#define Type$info(typestr) \ + &((TypeInfo_t){ \ + .size = sizeof(TypeInfo_t), \ + .align = __alignof__(TypeInfo_t), \ + .tag = TypeInfoInfo, \ + .TypeInfoInfo.type_str = typestr, \ + .metamethods = {.serialize = cannot_serialize, .deserialize = cannot_deserialize, .as_text = Type$as_text}}) -#define DEFINE_OPTIONAL_TYPE(t, unpadded_size, name) \ - typedef struct { \ - union { \ - t value; \ - struct { \ - char _padding[unpadded_size]; \ - Bool_t is_none; \ - }; \ - }; \ +#define DEFINE_OPTIONAL_TYPE(t, unpadded_size, name) \ + typedef struct { \ + union { \ + t value; \ + struct { \ + char _padding[unpadded_size]; \ + Bool_t is_none; \ + }; \ + }; \ } name // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/util.h b/src/stdlib/util.h index 3b00e6e9..819cecd9 100644 --- a/src/stdlib/util.h +++ b/src/stdlib/util.h @@ -3,38 +3,56 @@ // Built-in utility functions #include <assert.h> +#include <err.h> #include <gc.h> #include <stdbool.h> #include <string.h> -#include <err.h> #define streq(a, b) (((a) == NULL && (b) == NULL) || (((a) == NULL) == ((b) == NULL) && strcmp(a, b) == 0)) #define starts_with(line, prefix) (strncmp(line, prefix, strlen(prefix)) == 0) -#define ends_with(line, suffix) (strlen(line) >= strlen(suffix) && strcmp(line + strlen(line) - strlen(suffix), suffix) == 0) -#define new(t, ...) ((t*)memcpy(GC_MALLOC(sizeof(t)), &(t){__VA_ARGS__}, sizeof(t))) -#define heap(x) (__typeof(x)*)memcpy(GC_MALLOC(sizeof(x)), (__typeof(x)[1]){x}, sizeof(x)) -#define stack(x) (__typeof(x)*)((__typeof(x)[1]){x}) -#define check_initialized(var, init_var, name) *({ if (!init_var) fail("The variable " name " is being accessed before it has been initialized!"); \ - &var; }) +#define ends_with(line, suffix) \ + (strlen(line) >= strlen(suffix) && strcmp(line + strlen(line) - strlen(suffix), suffix) == 0) +#define new(t, ...) ((t *)memcpy(GC_MALLOC(sizeof(t)), &(t){__VA_ARGS__}, sizeof(t))) +#define heap(x) (__typeof(x) *)memcpy(GC_MALLOC(sizeof(x)), (__typeof(x)[1]){x}, sizeof(x)) +#define stack(x) (__typeof(x) *)((__typeof(x)[1]){x}) +#define check_initialized(var, init_var, name) \ + *({ \ + if (!init_var) fail("The variable " name " is being accessed before it has been initialized!"); \ + &var; \ + }) -#define IF_DECLARE(decl, expr, block) if (({ decl; expr ? ({ block; 1; }) : 0; })) {} +#define IF_DECLARE(decl, expr, block) \ + if (({ \ + decl; \ + expr ? ({ \ + block; \ + 1; \ + }) \ + : 0; \ + })) { \ + } -#define WHEN(type, subj, var, body) { type var = subj; switch (var.$tag) body } +#define WHEN(type, subj, var, body) \ + { \ + type var = subj; \ + switch (var.$tag) \ + body \ + } #ifndef public -#define public __attribute__ ((visibility ("default"))) +#define public __attribute__((visibility("default"))) #endif #ifndef PUREFUNC -#define PUREFUNC __attribute__ ((pure)) +#define PUREFUNC __attribute__((pure)) #endif #ifndef CONSTFUNC -#define CONSTFUNC __attribute__ ((const)) +#define CONSTFUNC __attribute__((const)) #endif #ifndef INLINE -#define INLINE inline __attribute__ ((always_inline)) +#define INLINE inline __attribute__((always_inline)) #endif #ifndef likely |