diff options
Diffstat (limited to 'src/stdlib')
38 files changed, 1521 insertions, 1521 deletions
diff --git a/src/stdlib/bools.c b/src/stdlib/bools.c index 85de0621..fd669579 100644 --- a/src/stdlib/bools.c +++ b/src/stdlib/bools.c @@ -12,7 +12,7 @@ #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"); @@ -26,9 +26,9 @@ static bool try_parse(Text_t text, Text_t target, bool target_value, Text_t *rem { 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)); - if (Text$equal_ignoring_case(prefix, target, lang)) { - if (remainder) *remainder = Text$from(text, Int$from_int64(target.length + 1)); + Text_t prefix = Textヽto(text, Intヽfrom_int64(target.length)); + if (Textヽequal_ignoring_case(prefix, target, lang)) { + if (remainder) *remainder = Textヽfrom(text, Intヽfrom_int64(target.length + 1)); else if (text.length > target.length) return false; *result = target_value; return true; @@ -37,7 +37,7 @@ 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) @@ -53,18 +53,18 @@ PUREFUNC public OptionalBool_t Bool$parse(Text_t text, Text_t *remainder) 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; } -public const TypeInfo_t Bool$info = { +public const TypeInfo_t Boolヽinfo = { .size=sizeof(bool), .align=__alignof__(bool), .metamethods={ - .as_text=Bool$as_text, - .is_none=Bool$is_none, + .as_text=Boolヽas_text, + .is_none=Boolヽis_none, }, }; diff --git a/src/stdlib/bools.h b/src/stdlib/bools.h index ae6c5feb..db282b12 100644 --- a/src/stdlib/bools.h +++ b/src/stdlib/bools.h @@ -12,15 +12,15 @@ #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); -MACROLIKE Bool_t Bool$from_int(Int_t i) { return (i.small != 0); } -MACROLIKE Bool_t Bool$from_int64(Int64_t i) { return (i != 0); } -MACROLIKE Bool_t Bool$from_int32(Int32_t i) { return (i != 0); } -MACROLIKE Bool_t Bool$from_int16(Int16_t i) { return (i != 0); } -MACROLIKE Bool_t Bool$from_int8(Int8_t i) { return (i != 0); } -MACROLIKE Bool_t Bool$from_byte(uint8_t b) { return (b != 0); } +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); +MACROLIKE Bool_t Boolヽfrom_int(Int_t i) { return (i.small != 0); } +MACROLIKE Bool_t Boolヽfrom_int64(Int64_t i) { return (i != 0); } +MACROLIKE Bool_t Boolヽfrom_int32(Int32_t i) { return (i != 0); } +MACROLIKE Bool_t Boolヽfrom_int16(Int16_t i) { return (i != 0); } +MACROLIKE Bool_t Boolヽfrom_int8(Int8_t i) { return (i != 0); } +MACROLIKE Bool_t Boolヽfrom_byte(uint8_t b) { return (b != 0); } -extern const TypeInfo_t Bool$info; +extern const TypeInfo_t Boolヽinfo; // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/bytes.c b/src/stdlib/bytes.c index 130a645f..9492c14c 100644 --- a/src/stdlib/bytes.c +++ b/src/stdlib/bytes.c @@ -8,10 +8,10 @@ #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"); @@ -21,28 +21,28 @@ PUREFUNC public Text_t Byte$as_text(const void *b, bool colorize, const TypeInfo (byte & 15) <= 9 ? '0' + (byte & 15) : 'a' + (byte & 15) - 10, '\0', }; - Text_t text = Text$from_str(digits); + Text_t text = Textヽfrom_str(digits); if (colorize) text = Texts(Text("\x1b[35m"), text, Text("\x1b[m")); return text; } -public CONSTFUNC bool Byte$is_between(const Byte_t x, const Byte_t low, const Byte_t 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); + 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)}; + && 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) { +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; @@ -62,12 +62,12 @@ public Text_t Byte$hex(Byte_t byte, bool uppercase, bool prefix) { return text; } -public bool Byte$get_bit(Byte_t x, Int_t bit_index) { - if (Int$compare_value(bit_index, I(1)) < 0) +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) + 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__ @@ -91,7 +91,7 @@ static OptionalByte_t _next_Byte(ByteRange_t *info) { 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}; @@ -99,34 +99,34 @@ public CONSTFUNC Closure_t Byte$to(Byte_t first, Byte_t last, OptionalInt8_t ste return (Closure_t){.fn=_next_Byte, .userdata=range}; } -public PUREFUNC Byte_t Byte$from_int(Int_t i, bool truncate) { - if unlikely (!truncate && Int$compare_value(i, I_small(0xFF)) > 0) +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) + 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 = { +public const TypeInfo_t Byteヽinfo = { .size=sizeof(Byte_t), .align=__alignof__(Byte_t), .metamethods={ - .as_text=Byte$as_text, + .as_text=Byteヽas_text, }, }; diff --git a/src/stdlib/bytes.h b/src/stdlib/bytes.h index ab88b5bc..669303d4 100644 --- a/src/stdlib/bytes.h +++ b/src/stdlib/bytes.h @@ -13,24 +13,24 @@ #define Byte(b) ((Byte_t)(b)) -PUREFUNC Text_t Byte$as_text(const void *b, bool colorize, const TypeInfo_t *type); +PUREFUNC Text_t Byteヽas_text(const void *b, bool colorize, const TypeInfo_t *type); -Byte_t Byte$from_int(Int_t i, bool truncate); -Byte_t Byte$from_int64(int64_t i, bool truncate); -Byte_t Byte$from_int32(int32_t i, bool truncate); -Byte_t Byte$from_int16(int16_t i, bool truncate); -OptionalByte_t Byte$parse(Text_t text, Text_t *remainder); -Closure_t Byte$to(Byte_t first, Byte_t last, OptionalInt8_t step); -MACROLIKE Byte_t Byte$from_int8(int8_t i) { return (Byte_t)i; } -MACROLIKE Byte_t Byte$from_bool(bool b) { return (Byte_t)b; } -CONSTFUNC bool Byte$is_between(const Byte_t x, const Byte_t low, const Byte_t high); +Byte_t Byteヽfrom_int(Int_t i, bool truncate); +Byte_t Byteヽfrom_int64(int64_t i, bool truncate); +Byte_t Byteヽfrom_int32(int32_t i, bool truncate); +Byte_t Byteヽfrom_int16(int16_t i, bool truncate); +OptionalByte_t Byteヽparse(Text_t text, Text_t *remainder); +Closure_t Byteヽto(Byte_t first, Byte_t last, OptionalInt8_t step); +MACROLIKE Byte_t Byteヽfrom_int8(int8_t i) { return (Byte_t)i; } +MACROLIKE Byte_t Byteヽfrom_bool(bool b) { return (Byte_t)b; } +CONSTFUNC bool Byteヽis_between(const Byte_t x, const Byte_t low, const Byte_t high); -extern const Byte_t Byte$min; -extern const Byte_t Byte$max; +extern const Byte_t Byteヽmin; +extern const Byte_t Byteヽmax; -extern const TypeInfo_t Byte$info; +extern const TypeInfo_t Byteヽinfo; -Text_t Byte$hex(Byte_t byte, bool uppercase, bool prefix); -bool Byte$get_bit(Byte_t x, Int_t bit_index); +Text_t Byteヽhex(Byte_t byte, bool uppercase, bool prefix); +bool Byteヽget_bit(Byte_t x, Int_t bit_index); // 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 860a69ff..e4836ffe 100644 --- a/src/stdlib/c_strings.c +++ b/src/stdlib/c_strings.c @@ -11,15 +11,15 @@ #include "siphash.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) @@ -31,38 +31,38 @@ PUREFUNC public int32_t CString$compare(const void *x, const void *y, const Type 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; + 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)); } -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; } -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); - Int64$serialize(&len, out, pointers, &Int64$info); + Int64ヽserialize(&len, out, pointers, &Int64ヽinfo); 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); + 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"); @@ -70,17 +70,17 @@ static void CString$deserialize(FILE *in, void *out, List_t *pointers, const Typ *(const char**)out = str; } -public const TypeInfo_t CString$info = { +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, + .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, }, }; diff --git a/src/stdlib/c_strings.h b/src/stdlib/c_strings.h index 4df5c3ac..d9e871de 100644 --- a/src/stdlib/c_strings.h +++ b/src/stdlib/c_strings.h @@ -8,11 +8,11 @@ #include "types.h" #include "util.h" -Text_t CString$as_text(const char **str, bool colorize, const TypeInfo_t *info); -PUREFUNC int CString$compare(const void *x, const void *y, const TypeInfo_t *type); -PUREFUNC bool CString$equal(const void *x, const void *y, const TypeInfo_t *type); -PUREFUNC uint64_t CString$hash(const void *str, const TypeInfo_t *type); +Text_t CStringヽas_text(const char **str, bool colorize, const TypeInfo_t *info); +PUREFUNC int CStringヽcompare(const void *x, const void *y, const TypeInfo_t *type); +PUREFUNC bool CStringヽequal(const void *x, const void *y, const TypeInfo_t *type); +PUREFUNC uint64_t CStringヽhash(const void *str, const TypeInfo_t *type); -extern const TypeInfo_t CString$info; +extern const TypeInfo_t CStringヽinfo; // 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 fce1ea74..f786598b 100644 --- a/src/stdlib/datatypes.h +++ b/src/stdlib/datatypes.h @@ -100,7 +100,7 @@ typedef struct Text_s { } Text_t; typedef struct { - enum { PATH_NONE, PATH_RELATIVE, PATH_ABSOLUTE, PATH_HOME } $tag; + enum { PATH_NONE, PATH_RELATIVE, PATH_ABSOLUTE, PATH_HOME } ヽtag; } PathType_t; #define OptionalPathType_t PathType_t diff --git a/src/stdlib/enums.c b/src/stdlib/enums.c index ae9f440f..57c4a2b4 100644 --- a/src/stdlib/enums.c +++ b/src/stdlib/enums.c @@ -24,7 +24,7 @@ CONSTFUNC static ptrdiff_t value_offset(const TypeInfo_t *type) { return offset; } -PUREFUNC public uint64_t Enum$hash(const void *obj, const TypeInfo_t *type) +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}; @@ -36,7 +36,7 @@ PUREFUNC public uint64_t Enum$hash(const void *obj, const TypeInfo_t *type) 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; @@ -53,7 +53,7 @@ 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; @@ -70,30 +70,30 @@ 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); + if (!obj) return Textヽfrom_str(type->EnumInfo.name); 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); + Text_t text = Textヽfrom_str(value.name); return colorize ? Texts(Text("\x1b[1m"), text, Text("\x1b[m")) : text; } 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; } -public void Enum$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) +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); + Int32ヽserialize(&tag, out, pointers, &Int32ヽinfo); NamedType_t value = type->EnumInfo.tags[tag-1]; if (value.type && value.type->size > 0) { @@ -101,10 +101,10 @@ public void Enum$serialize(const void *obj, FILE *out, Table_t *pointers, const } } -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ヽdeserialize(in, &tag, pointers, &Int32ヽinfo); *(int32_t*)outval = tag; NamedType_t value = type->EnumInfo.tags[tag-1]; diff --git a/src/stdlib/enums.h b/src/stdlib/enums.h index 8345c527..c5e38953 100644 --- a/src/stdlib/enums.h +++ b/src/stdlib/enums.h @@ -7,32 +7,32 @@ #include "types.h" #include "util.h" -PUREFUNC uint64_t Enum$hash(const void *obj, const TypeInfo_t *type); -PUREFUNC int32_t Enum$compare(const void *x, const void *y, const TypeInfo_t *type); -PUREFUNC bool Enum$equal(const void *x, const void *y, const TypeInfo_t *type); -PUREFUNC Text_t Enum$as_text(const void *obj, bool colorize, const TypeInfo_t *type); -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); +PUREFUNC uint64_t Enumヽhash(const void *obj, const TypeInfo_t *type); +PUREFUNC int32_t Enumヽcompare(const void *x, const void *y, const TypeInfo_t *type); +PUREFUNC bool Enumヽequal(const void *x, const void *y, const TypeInfo_t *type); +PUREFUNC Text_t Enumヽas_text(const void *obj, bool colorize, const TypeInfo_t *type); +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/functiontype.c b/src/stdlib/functiontype.c index b0fff1a7..ef7b7b5b 100644 --- a/src/stdlib/functiontype.c +++ b/src/stdlib/functiontype.c @@ -11,15 +11,15 @@ #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); + Text_t text = Textヽfrom_str(type->FunctionInfo.type_str); if (fn && colorize) - text = Text$concat(Text("\x1b[32;1m"), text, Text("\x1b[m")); + 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; diff --git a/src/stdlib/functiontype.h b/src/stdlib/functiontype.h index d308be96..02345c6b 100644 --- a/src/stdlib/functiontype.h +++ b/src/stdlib/functiontype.h @@ -14,21 +14,21 @@ void register_function(void *fn, Text_t filename, int64_t line_num, Text_t name) 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*); +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*); -#define Func$metamethods { \ - .as_text=Func$as_text, \ - .is_none=Func$is_none, \ +#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*), \ +#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*), \ + .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}) + .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 037aba0f..6b5f55c4 100644 --- a/src/stdlib/integers.c +++ b/src/stdlib/integers.c @@ -18,7 +18,7 @@ #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)); } else { @@ -44,33 +44,33 @@ static inline Text_t _int64_to_text(int64_t n) if (negative) *(p--) = '-'; - return Text$from_strn(p + 1, (size_t)(&buf[19] - 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 { char *str = mpz_get_str(NULL, 10, *i.big); - return Text$from_str(str); + return Textヽfrom_str(str); } } -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); - if (colorize) text = Text$concat(Text("\x1b[35m"), text, Text("\x1b[m")); + 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; } -public PUREFUNC int32_t Int$compare_value(const Int_t x, const Int_t y) { +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) @@ -81,32 +81,32 @@ public PUREFUNC int32_t Int$compare_value(const Int_t x, const Int_t y) { 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) { +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) { - return (Int$compare(&x, &low, &Int$info) <= 0) ? low : (Int$compare(&x, &high, &Int$info) >= 0 ? high : x); +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) { - return Int$compare_value(low, x) <= 0 && Int$compare_value(x, high) <= 0; +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; if (likely(x->small & 1L)) { @@ -117,57 +117,57 @@ public PUREFUNC uint64_t Int$hash(const void *vx, const TypeInfo_t *info) { } } -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) { for (char *c = str; *c; c++) *c = (char)toupper(*c); } - int64_t digits = Int64$from_int(digits_int, false); + 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); + 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)); + 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)); + 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); + 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); + 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)); + 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)); + 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) { @@ -178,10 +178,10 @@ public Int_t Int$slow_plus(Int_t x, Int_t y) { } else { mpz_add(result, result, *y.big); } - return Int$from_mpz(result); + 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) { @@ -192,20 +192,20 @@ public Int_t Int$slow_minus(Int_t x, Int_t y) { } else { mpz_sub(result, result, *y.big); } - return Int$from_mpz(result); + 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); - return Int$from_mpz(result); + return Intヽfrom_mpz(result); } -public Int_t Int$slow_divided_by(Int_t dividend, Int_t divisor) { +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); @@ -218,20 +218,20 @@ public Int_t Int$slow_divided_by(Int_t dividend, Int_t divisor) { else mpz_add_ui(quotient, quotient, 1); } - return Int$from_mpz(quotient); + 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; mpz_init_set_int(divisor, modulus); mpz_mod(result, result, divisor); - return Int$from_mpz(result); + 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); @@ -240,67 +240,67 @@ public Int_t Int$slow_modulo1(Int_t x, Int_t modulus) mpz_init_set_int(divisor, modulus); mpz_mod(result, result, divisor); mpz_add_ui(result, result, 1); - return Int$from_mpz(result); + 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); + mp_bitcnt_t bits = (mp_bitcnt_t)Int64ヽfrom_int(y, false); mpz_t result; mpz_init_set_int(result, x); mpz_mul_2exp(result, result, bits); - return Int$from_mpz(result); + 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); + mp_bitcnt_t bits = (mp_bitcnt_t)Int64ヽfrom_int(y, false); mpz_t result; mpz_init_set_int(result, x); mpz_tdiv_q_2exp(result, result, bits); - return Int$from_mpz(result); + 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; mpz_init_set_int(y_mpz, y); mpz_and(result, result, y_mpz); - return Int$from_mpz(result); + 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; mpz_init_set_int(y_mpz, y); mpz_ior(result, result, y_mpz); - return Int$from_mpz(result); + 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; mpz_init_set_int(y_mpz, y); mpz_xor(result, result, y_mpz); - return Int$from_mpz(result); + 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); mpz_sub_ui(result, result, 1); - return Int$from_mpz(result); + return Intヽfrom_mpz(result); } -public Int_t Int$slow_negative(Int_t x) +public Int_t Intヽslow_negative(Int_t x) { if (likely(x.small & 1L)) return (Int_t){.small=4L*-((x.small)>>2L) + 1L}; @@ -308,10 +308,10 @@ public Int_t Int$slow_negative(Int_t x) mpz_t result; mpz_init_set_int(result, x); mpz_neg(result, result); - return Int$from_mpz(result); + return Intヽfrom_mpz(result); } -public Int_t Int$abs(Int_t x) +public Int_t Intヽabs(Int_t x) { if (likely(x.small & 1L)) return (Int_t){.small=4L*labs((x.small)>>2L) + 1L}; @@ -319,24 +319,24 @@ public Int_t Int$abs(Int_t x) mpz_t result; mpz_init_set_int(result, x); mpz_abs(result, result); - return Int$from_mpz(result); + 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); + int64_t exp = Int64ヽfrom_int(exponent, false); 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); + return Intヽfrom_mpz(result); } -public Int_t Int$gcd(Int_t x, Int_t y) +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)); + return I_small(Int32ヽgcd(x.small >> 2L, y.small >> 2L)); mpz_t result; mpz_init(result); @@ -346,29 +346,29 @@ public Int_t Int$gcd(Int_t x, Int_t y) 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); + return Intヽfrom_mpz(result); } -public OptionalInt_t Int$sqrt(Int_t i) +public OptionalInt_t Intヽsqrt(Int_t i) { - if (Int$compare_value(i, I(0)) < 0) + 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); + 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) + 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) + 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; } @@ -380,26 +380,26 @@ typedef struct { 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(&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))) 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} + 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; @@ -407,7 +407,7 @@ public PUREFUNC Closure_t Int$onward(Int_t first, Int_t step) { 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) { @@ -421,31 +421,31 @@ public Int_t Int$from_str(const char *str) { } if (result != 0) return NONE_INT; - return Int$from_mpz(i); + return Intヽfrom_mpz(i); } -public OptionalInt_t Int$parse(Text_t text, Text_t *remainder) { - const char *str = Text$as_c_string(text); +public OptionalInt_t Intヽparse(Text_t text, Text_t *remainder) { + const char *str = Textヽas_c_string(text); mpz_t i; int result; if (strncmp(str, "0x", 2) == 0) { const char *end = str + 2 + strspn(str + 2, "0123456789abcdefABCDEF"); - if (remainder) *remainder = Text$from_str(end); + if (remainder) *remainder = Textヽfrom_str(end); else if (*end != '\0') return NONE_INT; result = mpz_init_set_str(i, str + 2, 16); } else if (strncmp(str, "0o", 2) == 0) { const char *end = str + 2 + strspn(str + 2, "01234567"); - if (remainder) *remainder = Text$from_str(end); + if (remainder) *remainder = Textヽfrom_str(end); else if (*end != '\0') return NONE_INT; result = mpz_init_set_str(i, str + 2, 8); } else if (strncmp(str, "0b", 2) == 0) { const char *end = str + 2 + strspn(str + 2, "01"); - if (remainder) *remainder = Text$from_str(end); + if (remainder) *remainder = Textヽfrom_str(end); else if (*end != '\0') return NONE_INT; result = mpz_init_set_str(i, str + 2, 2); } else { const char *end = str + 2 + strspn(str + 2, "0123456789"); - if (remainder) *remainder = Text$from_str(end); + if (remainder) *remainder = Textヽfrom_str(end); else if (*end != '\0') return NONE_INT; result = mpz_init_set_str(i, str, 10); } @@ -453,49 +453,49 @@ public OptionalInt_t Int$parse(Text_t text, Text_t *remainder) { if (remainder) *remainder = text; return NONE_INT; } - return Int$from_mpz(i); + 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)) + if (unlikely(Intヽcompare_value(reps, I(9999)) > 0)) fail("Number of prime-test repetitions should not be above 9999"); - int reps_int = Int32$from_int(reps, false); + int reps_int = Int32ヽfrom_int(reps, false); 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); - return Int$from_mpz(p); + return Intヽfrom_mpz(p); } #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; - return Int$from_mpz(p); + return Intヽfrom_mpz(p); } #endif #endif -public Int_t Int$choose(Int_t n, Int_t k) +public Int_t Intヽchoose(Int_t n, Int_t k) { - if unlikely (Int$compare_value(n, I_small(0)) < 0) + 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); + int64_t k_i64 = Int64ヽfrom_int(k, false); if unlikely (k_i64 < 0) fail("Negative inputs are not supported for choose()"); @@ -506,28 +506,28 @@ public Int_t Int$choose(Int_t n, Int_t k) mpz_init_set_int(n_mpz, n); mpz_bin_ui(ret, n_mpz, (unsigned long)k_i64); } - return Int$from_mpz(ret); + 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); + int64_t n_i64 = Int64ヽfrom_int(n, false); 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); + 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; if (likely(i.small & 1L)) { fputc(0, out); int64_t i64 = i.small >> 2L; - Int64$serialize(&i64, out, pointers, &Int64$info); + Int64ヽserialize(&i64, out, pointers, &Int64ヽinfo); } else { fputc(1, out); mpz_t n; @@ -536,36 +536,36 @@ static void Int$serialize(const void *obj, FILE *out, Table_t *pointers, const T } } -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); + Int64ヽdeserialize(in, &i, pointers, &Int64ヽinfo); *(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 = { +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, + .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; @@ -577,7 +577,7 @@ 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; @@ -589,7 +589,7 @@ public void Int64$deserialize(FILE *in, void *outval, List_t *pointers, const Ty *(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; @@ -601,7 +601,7 @@ 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; @@ -614,45 +614,45 @@ public void Int32$deserialize(FILE *in, void *outval, List_t *pointers, const Ty } // The space savings for smaller ints are not worth having: -#define Int16$serialize NULL -#define Int16$deserialize NULL -#define Int8$serialize NULL -#define Int8$deserialize NULL +#define Int16ヽserialize NULL +#define Int16ヽdeserialize NULL +#define Int8ヽserialize NULL +#define Int8ヽdeserialize NULL #ifdef __TINYC__ #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) { \ + 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) { \ + 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) { \ + 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) { \ + 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) { \ + 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 ## ヽ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 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) { \ + 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++) { \ @@ -661,12 +661,12 @@ public void Int32$deserialize(FILE *in, void *outval, List_t *pointers, const Ty } \ return bit_list; \ } \ - public bool KindOfInt ## $get_bit(c_type x, Int_t bit_index) { \ - if (Int$compare_value(bit_index, I(1)) < 0) \ + 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) \ + if (Intヽcompare_value(bit_index, Intヽfrom_int64(sizeof(c_type)*8)) > 0) \ fail("Bit index is too large! There are only ", sizeof(c_type)*8, " bits, but index is: ", bit_index); \ - return ((x & (c_type)(1L << (Int64$from_int(bit_index, true)-1L))) != 0); \ + return ((x & (c_type)(1L << (Int64ヽfrom_int(bit_index, true)-1L))) != 0); \ } \ typedef struct { \ Optional##KindOfInt##_t current, last; \ @@ -684,51 +684,51 @@ public void Int32$deserialize(FILE *in, void *outval, List_t *pointers, const Ty } \ return i; \ } \ - public to_attr Closure_t KindOfInt ## $to(c_type first, c_type last, Optional ## KindOfInt ## _t step) { \ + 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) { \ + 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); \ + 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) { \ + 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) { \ + 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)}; \ + return (Optional ## KindOfInt ## _t){.value=KindOfInt##ヽfrom_int(full_int, true)}; \ } \ - public CONSTFUNC c_type KindOfInt ## $gcd(c_type x, c_type y) { \ + 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); \ + 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 = { \ + 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, \ + .compare=KindOfInt##ヽcompare, \ + .as_text=KindOfInt##ヽas_text, \ + .serialize=KindOfInt##ヽserialize, \ + .deserialize=KindOfInt##ヽdeserialize, \ }, \ }; diff --git a/src/stdlib/integers.h b/src/stdlib/integers.h index 50ca485f..25ccecb3 100644 --- a/src/stdlib/integers.h +++ b/src/stdlib/integers.h @@ -23,46 +23,46 @@ 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) { \ + 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) { \ + 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 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) { \ + 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) { \ + 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) { \ + 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) { \ + MACROLIKE PUREFUNC c_type type_name ## ヽunsigned_right_shifted(c_type x, c_type y) { \ return (c_type)((u##c_type)x >> y); \ } @@ -77,41 +77,41 @@ DEFINE_INT_TYPE(int8_t, Int8) #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*); - -Text_t Int$as_text(const void *i, bool colorize, const TypeInfo_t *type); -Text_t Int$value_as_text(Int_t i); -PUREFUNC uint64_t Int$hash(const void *x, const TypeInfo_t *type); -PUREFUNC int32_t Int$compare(const void *x, const void *y, const TypeInfo_t *type); -PUREFUNC int32_t Int$compare_value(const Int_t x, const Int_t y); -CONSTFUNC bool Int$is_between(const Int_t x, const Int_t low, const Int_t high); -CONSTFUNC Int_t Int$clamped(Int_t x, Int_t low, Int_t high); -PUREFUNC bool Int$equal(const void *x, const void *y, const TypeInfo_t *type); -PUREFUNC bool Int$equal_value(const Int_t x, const Int_t y); -Text_t Int$hex(Int_t i, Int_t digits, bool uppercase, bool prefix); -Text_t Int$octal(Int_t i, Int_t digits, bool prefix); -PUREFUNC Closure_t Int$to(Int_t first, Int_t last, OptionalInt_t step); -PUREFUNC Closure_t Int$onward(Int_t first, Int_t step); -OptionalInt_t Int$from_str(const char *str); -OptionalInt_t Int$parse(Text_t text, Text_t *remainder); -Int_t Int$abs(Int_t x); -Int_t Int$power(Int_t base, Int_t exponent); -Int_t Int$gcd(Int_t x, Int_t y); -OptionalInt_t Int$sqrt(Int_t i); -bool Int$get_bit(Int_t x, Int_t bit_index); +#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*); + +Text_t Intヽas_text(const void *i, bool colorize, const TypeInfo_t *type); +Text_t Intヽvalue_as_text(Int_t i); +PUREFUNC uint64_t Intヽhash(const void *x, const TypeInfo_t *type); +PUREFUNC int32_t Intヽcompare(const void *x, const void *y, const TypeInfo_t *type); +PUREFUNC int32_t Intヽcompare_value(const Int_t x, const Int_t y); +CONSTFUNC bool Intヽis_between(const Int_t x, const Int_t low, const Int_t high); +CONSTFUNC Int_t Intヽclamped(Int_t x, Int_t low, Int_t high); +PUREFUNC bool Intヽequal(const void *x, const void *y, const TypeInfo_t *type); +PUREFUNC bool Intヽequal_value(const Int_t x, const Int_t y); +Text_t Intヽhex(Int_t i, Int_t digits, bool uppercase, bool prefix); +Text_t Intヽoctal(Int_t i, Int_t digits, bool prefix); +PUREFUNC Closure_t Intヽto(Int_t first, Int_t last, OptionalInt_t step); +PUREFUNC Closure_t Intヽonward(Int_t first, Int_t step); +OptionalInt_t Intヽfrom_str(const char *str); +OptionalInt_t Intヽparse(Text_t text, Text_t *remainder); +Int_t Intヽabs(Int_t x); +Int_t Intヽpower(Int_t base, Int_t exponent); +Int_t Intヽgcd(Int_t x, Int_t y); +OptionalInt_t Intヽsqrt(Int_t i); +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) (\ +#define Intヽfrom_mpz(mpz) (\ mpz_cmpabs_ui(mpz, BIGGEST_SMALL_INT) <= 0 ? ( \ (Int_t){.small=(mpz_get_si(mpz)<<2L)|1L} \ ) : ( \ @@ -124,61 +124,61 @@ bool Int$get_bit(Int_t x, Int_t bit_index); } while (0) #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(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) -Int_t Int$slow_plus(Int_t x, Int_t y); -Int_t Int$slow_minus(Int_t x, Int_t y); -Int_t Int$slow_times(Int_t x, Int_t y); -Int_t Int$slow_divided_by(Int_t x, Int_t y); -Int_t Int$slow_modulo(Int_t x, Int_t y); -Int_t Int$slow_modulo1(Int_t x, Int_t y); -Int_t Int$slow_left_shifted(Int_t x, Int_t y); -Int_t Int$slow_right_shifted(Int_t x, Int_t y); -Int_t Int$slow_bit_and(Int_t x, Int_t y); -Int_t Int$slow_bit_or(Int_t x, Int_t y); -Int_t Int$slow_bit_xor(Int_t x, Int_t y); -Int_t Int$slow_negative(Int_t x); -Int_t Int$slow_negated(Int_t x); -bool Int$is_prime(Int_t x, Int_t reps); -Int_t Int$next_prime(Int_t x); +Int_t Intヽslow_plus(Int_t x, Int_t y); +Int_t Intヽslow_minus(Int_t x, Int_t y); +Int_t Intヽslow_times(Int_t x, Int_t y); +Int_t Intヽslow_divided_by(Int_t x, Int_t y); +Int_t Intヽslow_modulo(Int_t x, Int_t y); +Int_t Intヽslow_modulo1(Int_t x, Int_t y); +Int_t Intヽslow_left_shifted(Int_t x, Int_t y); +Int_t Intヽslow_right_shifted(Int_t x, Int_t y); +Int_t Intヽslow_bit_and(Int_t x, Int_t y); +Int_t Intヽslow_bit_or(Int_t x, Int_t y); +Int_t Intヽslow_bit_xor(Int_t x, Int_t y); +Int_t Intヽslow_negative(Int_t x); +Int_t Intヽslow_negated(Int_t x); +bool Intヽis_prime(Int_t x, Int_t reps); +Int_t Intヽnext_prime(Int_t x); #if __GNU_MP_VERSION >= 6 #if __GNU_MP_VERSION_MINOR >= 3 -OptionalInt_t Int$prev_prime(Int_t x); +OptionalInt_t Intヽprev_prime(Int_t x); #endif #endif -Int_t Int$choose(Int_t n, Int_t k); -Int_t Int$factorial(Int_t n); +Int_t Intヽchoose(Int_t n, Int_t k); +Int_t Intヽfactorial(Int_t n); -extern const TypeInfo_t Int$info; +extern const TypeInfo_t Intヽinfo; // Fast-path inline versions for the common case where integer arithmetic is // between two small ints. -MACROLIKE Int_t Int$plus(Int_t x, Int_t y) { +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)}; - return Int$slow_plus(x, y); + return Intヽslow_plus(x, y); } -MACROLIKE Int_t Int$minus(Int_t x, Int_t 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}; - return Int$slow_minus(x, y); + return Intヽslow_minus(x, y); } -MACROLIKE Int_t Int$times(Int_t x, Int_t 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}; } - return Int$slow_times(x, y); + return Intヽslow_times(x, y); } -MACROLIKE Int_t Int$divided_by(Int_t x, Int_t 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); @@ -188,10 +188,10 @@ MACROLIKE Int_t Int$divided_by(Int_t x, Int_t y) { if likely (q == (int32_t)q) return (Int_t){.small=(q<<2L)|1L}; } - return Int$slow_divided_by(x, y); + return Intヽslow_divided_by(x, y); } -MACROLIKE Int_t Int$modulo(Int_t x, Int_t 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); @@ -200,10 +200,10 @@ MACROLIKE Int_t Int$modulo(Int_t x, Int_t y) { r -= (r < 0L) * (2L*(d < 0L) - 1L) * d; return (Int_t){.small=(r<<2L)|1L}; } - return Int$slow_modulo(x, y); + return Intヽslow_modulo(x, y); } -MACROLIKE Int_t Int$modulo1(Int_t x, Int_t 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; @@ -212,62 +212,62 @@ MACROLIKE Int_t Int$modulo1(Int_t x, Int_t y) { r -= (r < 0L) * (2L*(d < 0L) - 1L) * d; return (Int_t){.small=((r+1L)<<2L)|1L}; } - return Int$slow_modulo1(x, y); + return Intヽslow_modulo1(x, y); } -MACROLIKE Int_t Int$left_shifted(Int_t x, Int_t 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}; } - return Int$slow_left_shifted(x, y); + return Intヽslow_left_shifted(x, y); } -MACROLIKE Int_t Int$right_shifted(Int_t x, Int_t 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}; } - return Int$slow_right_shifted(x, y); + return Intヽslow_right_shifted(x, y); } -MACROLIKE Int_t Int$bit_and(Int_t x, Int_t 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}; - return Int$slow_bit_and(x, y); + return Intヽslow_bit_and(x, y); } -MACROLIKE Int_t Int$bit_or(Int_t x, Int_t 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)}; - return Int$slow_bit_or(x, y); + return Intヽslow_bit_or(x, y); } -MACROLIKE Int_t Int$bit_xor(Int_t x, Int_t 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}; - return Int$slow_bit_xor(x, y); + return Intヽslow_bit_xor(x, y); } -MACROLIKE Int_t Int$negated(Int_t x) { +MACROLIKE Int_t Intヽnegated(Int_t x) { if likely (x.small & 1L) return (Int_t){.small=(~x.small) ^ 3L}; - return Int$slow_negated(x); + return Intヽslow_negated(x); } -MACROLIKE Int_t Int$negative(Int_t x) { +MACROLIKE Int_t Intヽnegative(Int_t x) { if likely (x.small & 1L) return (Int_t){.small=((-((x.small)>>2L))<<2L) | 1L}; - return Int$slow_negative(x); + return Intヽslow_negative(x); } -MACROLIKE PUREFUNC bool Int$is_negative(Int_t x) { +MACROLIKE PUREFUNC bool Intヽis_negative(Int_t x) { if likely (x.small & 1L) return x.small < 0L; - return Int$compare_value(x, I_small(0)) < 0L; + return Intヽcompare_value(x, I_small(0)) < 0L; } // Constructors/conversion functions: @@ -277,147 +277,147 @@ MACROLIKE PUREFUNC bool Int$is_negative(Int_t x) { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wfloat-equal" #endif -MACROLIKE PUREFUNC Int_t Int$from_num(double n, bool truncate) { +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); - return Int$from_mpz(result); + 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) { +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}; mpz_t result; mpz_init_set_si(result, i); - return Int$from_mpz(result); + 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_byte(Byte_t b) { return I_small(b); } -MACROLIKE CONSTFUNC Int_t Int$from_bool(Bool_t b) { return I_small(b); } +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_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) { +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); return i64; } -MACROLIKE PUREFUNC Int64_t Int64$from_num32(Num32_t n, bool truncate) { +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); return i64; } -MACROLIKE PUREFUNC Int64_t Int64$from_int(Int_t i, bool truncate) { +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); return mpz_get_si(*i.big); } -MACROLIKE CONSTFUNC Int64_t Int64$from_int32(Int32_t i) { return (Int64_t)i; } -MACROLIKE CONSTFUNC Int64_t Int64$from_int16(Int16_t i) { return (Int64_t)i; } -MACROLIKE CONSTFUNC Int64_t Int64$from_int8(Int8_t i) { return (Int64_t)i; } +MACROLIKE CONSTFUNC Int64_t Int64ヽfrom_int32(Int32_t i) { return (Int64_t)i; } +MACROLIKE CONSTFUNC Int64_t Int64ヽfrom_int16(Int16_t i) { return (Int64_t)i; } +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) { +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); return i32; } -MACROLIKE PUREFUNC Int32_t Int32$from_num32(Num32_t n, bool truncate) { +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); return i32; } -MACROLIKE PUREFUNC Int32_t Int32$from_int(Int_t i, bool truncate) { - int64_t i64 = Int64$from_int(i, truncate); +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); return i32; } -MACROLIKE PUREFUNC Int32_t Int32$from_int64(Int64_t i64, bool truncate) { +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); return i32; } -MACROLIKE CONSTFUNC Int32_t Int32$from_int16(Int16_t i) { return (Int32_t)i; } -MACROLIKE CONSTFUNC Int32_t Int32$from_int8(Int8_t i) { return (Int32_t)i; } +MACROLIKE CONSTFUNC Int32_t Int32ヽfrom_int16(Int16_t i) { return (Int32_t)i; } +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) { +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); return i16; } -MACROLIKE PUREFUNC Int16_t Int16$from_num32(Num32_t n, bool truncate) { +MACROLIKE PUREFUNC Int16_t Int16ヽfrom_num32(Num32_t n, bool truncate) { int16_t i16 = (int16_t)n; if (!truncate && unlikely((Num32_t)i16 != n)) fail("Could not convert Num32 to Int16 without truncation: ", (double)n); return i16; } -MACROLIKE PUREFUNC Int16_t Int16$from_int(Int_t i, bool truncate) { - int64_t i64 = Int64$from_int(i, 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!"); return i16; } -MACROLIKE PUREFUNC Int16_t Int16$from_int64(Int64_t i64, bool truncate) { +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); return i16; } -MACROLIKE PUREFUNC Int16_t Int16$from_int32(Int32_t i32, bool truncate) { +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); return i16; } -MACROLIKE CONSTFUNC Int16_t Int16$from_int8(Int8_t i) { return (Int16_t)i; } +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) { +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); return i8; } -MACROLIKE PUREFUNC Int8_t Int8$from_num32(Num32_t n, bool truncate) { +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); return i8; } -MACROLIKE PUREFUNC Int8_t Int8$from_int(Int_t i, bool truncate) { - int64_t i64 = Int64$from_int(i, truncate); +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!"); return i8; } -MACROLIKE PUREFUNC Int8_t Int8$from_int64(Int64_t i64, bool truncate) { +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); return i8; } -MACROLIKE PUREFUNC Int8_t Int8$from_int32(Int32_t i32, bool truncate) { +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); return i8; } -MACROLIKE PUREFUNC Int8_t Int8$from_int16(Int16_t i16, bool truncate) { +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); diff --git a/src/stdlib/lists.c b/src/stdlib/lists.c index 31e25f15..8ea29081 100644 --- a/src/stdlib/lists.c +++ b/src/stdlib/lists.c @@ -28,7 +28,7 @@ PUREFUNC static INLINE int64_t get_padded_item_size(const TypeInfo_t *info) // 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) { @@ -49,9 +49,9 @@ public void List$compact(List_t *list, int64_t padded_item_size) }; } -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); + int64_t index = Int64ヽfrom_int(int_index, false); if (index <= 0) index = list->length + index + 1; if (index < 1) index = 1; @@ -92,9 +92,9 @@ public void List$insert(List_t *list, const void *item, Int_t int_index, int64_t 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); + int64_t index = Int64ヽfrom_int(int_index, false); if (to_insert.length == 0) return; @@ -174,12 +174,12 @@ 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); + 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); + 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) @@ -210,7 +210,7 @@ public void List$remove_at(List_t *list, Int_t int_index, Int_t int_count, int64 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}; @@ -221,15 +221,15 @@ public void List$remove_item(List_t *list, void *item, Int_t max_removals, const break; 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); + Listヽremove_at(list, I(i+1), ONE, padded_item_size); + max_removals = Intヽminus(max_removals, ONE); } else { i++; } } } -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++) { @@ -239,7 +239,7 @@ public OptionalInt_t List$find(List_t list, void *item, const TypeInfo_t *type) return NONE_INT; } -public OptionalInt_t List$first(List_t list, Closure_t predicate) +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++) { @@ -257,18 +257,18 @@ int _compare_closure(const void *a, const void *b) 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) +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); + 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); + Listヽcompact(&list, padded_item_size); _sort_comparison = comparison; qsort(list.data, (size_t)list.length, (size_t)padded_item_size, _compare_closure); return list; @@ -303,10 +303,10 @@ 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) +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); + Listヽcompact(list, padded_item_size); 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; @@ -321,14 +321,14 @@ public void List$shuffle(List_t *list, OptionalClosure_t random_int64, int64_t p } } -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); + 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) +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!"); @@ -341,15 +341,15 @@ public void *List$random(List_t list, OptionalClosure_t random_int64) 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); + 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; - int64_t *count = Table$get(counts, key, &count_type); + int64_t *count = Tableヽget(counts, key, &count_type); int64_t val = count ? *count + 1 : 1; - Table$set(&counts, key, &val, &count_type); + Tableヽset(&counts, key, &val, &count_type); } return counts; } @@ -369,9 +369,9 @@ 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); + int64_t n = Int64ヽfrom_int(int_n, false); if (n < 0) fail("Cannot select a negative number of values"); @@ -459,19 +459,19 @@ public List_t List$sample(List_t list, Int_t int_n, List_t weights, OptionalClos return selected; } -public List_t List$from(List_t list, Int_t first) +public List_t Listヽfrom(List_t list, Int_t first) { - return List$slice(list, first, I_small(-1)); + return Listヽslice(list, first, I_small(-1)); } -public List_t List$to(List_t list, Int_t last) +public List_t Listヽto(List_t list, Int_t last) { - return List$slice(list, I_small(1), 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); + 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)) { @@ -503,14 +503,14 @@ public List_t List$by(List_t list, Int_t int_stride, int64_t padded_item_size) }; } -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); + int64_t first = Int64ヽfrom_int(int_first, false); if (first < 0) first = list.length + first + 1; - int64_t last = Int64$from_int(int_last, false); + int64_t last = Int64ヽfrom_int(int_last, false); if (last < 0) last = list.length + last + 1; @@ -529,14 +529,14 @@ public List_t List$slice(List_t list, Int_t int_first, Int_t int_last) }; } -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 + // 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 // begin with (very unlikely). if (unlikely(-list.stride < LIST_MIN_STRIDE || -list.stride > LIST_MAX_STRIDE)) - return List$by(list, I(-1), padded_item_size); + return Listヽby(list, I(-1), padded_item_size); List_t reversed = list; reversed.stride = -list.stride; @@ -544,7 +544,7 @@ public List_t List$reversed(List_t list, int64_t padded_item_size) return reversed; } -public List_t List$concat(List_t x, List_t y, int64_t padded_item_size) +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))); @@ -571,7 +571,7 @@ public List_t List$concat(List_t x, List_t y, int64_t padded_item_size) }; } -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++) { @@ -581,12 +581,12 @@ public bool List$has(List_t list, void *item, const TypeInfo_t *type) return false; } -public void List$clear(List_t *list) +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) +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: @@ -617,30 +617,30 @@ public int32_t List$compare(const void *vx, const void *vy, const TypeInfo_t *ty return (x->length > y->length) - (x->length < y->length); } -public bool List$equal(const void *x, const void *y, const TypeInfo_t *type) +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); + 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) +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("]")); + 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 = 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, item_text); } - text = Text$concat(text, Text("]")); + text = Textヽconcat(text, Text("]")); return text; } -public uint64_t List$hash(const void *obj, const TypeInfo_t *type) +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; @@ -706,18 +706,18 @@ static void siftup(List_t *heap, int64_t pos, Closure_t comparison, int64_t padd 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); + Listヽinsert(heap, item, I(0), padded_item_size); if (heap->length > 1) { if (heap->data_refcount != 0) - List$compact(heap, padded_item_size); + 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) +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"); @@ -729,17 +729,17 @@ public void List$heap_pop(List_t *heap, Closure_t comparison, int64_t padded_ite --heap->length; } else { if (heap->data_refcount != 0) - List$compact(heap, padded_item_size); + 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) +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); + 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. @@ -750,7 +750,7 @@ public void List$heapify(List_t *heap, Closure_t comparison, int64_t padded_item LIST_DECREF(*heap); } -public Int_t List$binary_search(List_t list, void *target, Closure_t comparison) +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; @@ -768,17 +768,17 @@ public Int_t List$binary_search(List_t list, void *target, Closure_t comparison) 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; } -public void List$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) +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); + 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++) @@ -791,10 +791,10 @@ public void List$serialize(const void *obj, FILE *out, Table_t *pointers, const } } -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ヽ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); diff --git a/src/stdlib/lists.h b/src/stdlib/lists.h index a2853e48..95ff8966 100644 --- a/src/stdlib/lists.h +++ b/src/stdlib/lists.h @@ -25,13 +25,13 @@ 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)); \ + 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)); \ + 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 @@ -59,79 +59,79 @@ #define LIST_DECREF(list) (list).data_refcount -= ((list).data_refcount < LIST_MAX_DATA_REFCOUNT) #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) -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ヽ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$pop(arr_expr, index_expr, item_type, nonnone_var, 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 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)); \ + 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); }) -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); }) -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); }) -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); -PUREFUNC List_t List$slice(List_t list, Int_t int_first, Int_t int_last); -PUREFUNC List_t List$reversed(List_t list, int64_t padded_item_size); -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*); -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); }) -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) \ +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); }) +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); }) +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); }) +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); +PUREFUNC List_t Listヽslice(List_t list, Int_t int_first, Int_t int_last); +PUREFUNC List_t Listヽreversed(List_t list, int64_t padded_item_size); +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*); +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); }) +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)); \ + 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); }) -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); +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); }) +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), \ +#define Listヽinfo(item_info) &((TypeInfo_t){.size=sizeof(List_t), .align=__alignof__(List_t), \ .tag=ListInfo, .ListInfo.item=item_info, \ - .metamethods=List$metamethods}) + .metamethods=Listヽmetamethods}) // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/stdlib/memory.c b/src/stdlib/memory.c index 46729f83..21893fd0 100644 --- a/src/stdlib/memory.c +++ b/src/stdlib/memory.c @@ -13,18 +13,18 @@ #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 = { +public const TypeInfo_t Memoryヽinfo = { .size=0, .align=0, .metamethods={ - .as_text=Memory$as_text, + .as_text=Memoryヽas_text, .serialize=cannot_serialize, .deserialize=cannot_deserialize, }, diff --git a/src/stdlib/memory.h b/src/stdlib/memory.h index e03d5931..c8a777e6 100644 --- a/src/stdlib/memory.h +++ b/src/stdlib/memory.h @@ -7,7 +7,7 @@ #include "types.h" -extern const TypeInfo_t Memory$info; -Text_t Memory$as_text(const void *p, bool colorize, const TypeInfo_t *type); +extern const TypeInfo_t Memoryヽinfo; +Text_t Memoryヽas_text(const void *p, bool colorize, const TypeInfo_t *type); // 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 e007a52c..7c12a724 100644 --- a/src/stdlib/metamethods.c +++ b/src/stdlib/metamethods.c @@ -94,7 +94,7 @@ public void _deserialize(FILE *input, void *outval, List_t *pointers, const Type public void generic_deserialize(List_t bytes, void *outval, const TypeInfo_t *type) { if (bytes.stride != 1) - List$compact(&bytes, 1); + Listヽcompact(&bytes, 1); FILE *input = fmemopen(bytes.data, (size_t)bytes.length, "r"); List_t pointers = {}; @@ -105,7 +105,7 @@ public void generic_deserialize(List_t bytes, void *outval, const TypeInfo_t *ty 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); + return Textヽprint(stdout, text) + fputc('\n', stdout); } __attribute__((noreturn)) diff --git a/src/stdlib/nums.c b/src/stdlib/nums.c index 3775c8f4..7627c887 100644 --- a/src/stdlib/nums.c +++ b/src/stdlib/nums.c @@ -14,17 +14,17 @@ #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); static const Text_t color_prefix = Text("\x1b[35m"), color_suffix = Text("\x1b[m"); - Text_t text = Text$from_strn(str, (size_t)len); + 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; @@ -37,12 +37,12 @@ public PUREFUNC int32_t Num$compare(const void *x, const void *y, const TypeInfo 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; } -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; @@ -57,13 +57,13 @@ 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("%")); + 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.) { @@ -76,35 +76,35 @@ public CONSTFUNC double Num$with_precision(double num, double precision) { } } -public CONSTFUNC double Num$mod(double num, double modulus) { +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; 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) { +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) { +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) { +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) { - const char *str = Text$as_c_string(text); +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); + *remainder = Textヽfrom_str(end); else if (*end != '\0') return nan("none"); return d; @@ -114,45 +114,45 @@ public OptionalNum_t Num$parse(Text_t text, Text_t *remainder) { } } -static bool Num$is_none(const void *n, const TypeInfo_t *info) +static 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 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 = { +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, + .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); - return Num$as_text(&d, colorize, &Num$info); + 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); } -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; } -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; @@ -167,13 +167,13 @@ 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("%")); + 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) { @@ -186,35 +186,35 @@ public CONSTFUNC float Num32$with_precision(float num, float precision) { } } -public CONSTFUNC float Num32$mod(float num, float modulus) { +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; 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) { +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) { +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) { +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) { - const char *str = Text$as_c_string(text); +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); + if (remainder) *remainder = Textヽfrom_str(end); else if (*end != '\0') return nan("none"); return d; @@ -224,24 +224,24 @@ public OptionalNum32_t Num32$parse(Text_t text, Text_t *remainder) { } } -static bool Num32$is_none(const void *n, const TypeInfo_t *info) +static 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 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 = { +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, + .compare=Num32ヽcompare, + .equal=Num32ヽequal, + .as_text=Num32ヽas_text, + .is_none=Num32ヽis_none, }, }; diff --git a/src/stdlib/nums.h b/src/stdlib/nums.h index fe76d1c3..1b757e4e 100644 --- a/src/stdlib/nums.h +++ b/src/stdlib/nums.h @@ -17,28 +17,28 @@ #define N32(n) ((float)(n)) #define N64(n) ((double)(n)) -Text_t Num$as_text(const void *f, bool colorize, const TypeInfo_t *type); -PUREFUNC int32_t Num$compare(const void *x, const void *y, const TypeInfo_t *type); -PUREFUNC bool Num$equal(const void *x, const void *y, const TypeInfo_t *type); -CONSTFUNC bool Num$near(double a, double b, double ratio, double absolute); -Text_t Num$percent(double f, double precision); -double CONSTFUNC Num$with_precision(double num, double precision); -double Num$mod(double num, double modulus); -double Num$mod1(double num, double modulus); -CONSTFUNC bool Num$isinf(double n); -CONSTFUNC bool Num$finite(double n); -CONSTFUNC bool Num$isnan(double n); -double Num$nan(Text_t tag); -CONSTFUNC double Num$mix(double amount, double x, double y); -OptionalNum_t Num$parse(Text_t text, Text_t *remainder); -CONSTFUNC bool Num$is_between(const double x, const double low, const double high); -CONSTFUNC double Num$clamped(double x, double low, double high); -MACROLIKE CONSTFUNC double Num$from_num32(Num32_t n) { return (double)n; } +Text_t Numヽas_text(const void *f, bool colorize, const TypeInfo_t *type); +PUREFUNC int32_t Numヽcompare(const void *x, const void *y, const TypeInfo_t *type); +PUREFUNC bool Numヽequal(const void *x, const void *y, const TypeInfo_t *type); +CONSTFUNC bool Numヽnear(double a, double b, double ratio, double absolute); +Text_t Numヽpercent(double f, double precision); +double CONSTFUNC Numヽwith_precision(double num, double precision); +double Numヽmod(double num, double modulus); +double Numヽmod1(double num, double modulus); +CONSTFUNC bool Numヽisinf(double n); +CONSTFUNC bool Numヽfinite(double n); +CONSTFUNC bool Numヽisnan(double n); +double Numヽnan(Text_t tag); +CONSTFUNC double Numヽmix(double amount, double x, double y); +OptionalNum_t Numヽparse(Text_t text, Text_t *remainder); +CONSTFUNC bool Numヽis_between(const double x, const double low, const double high); +CONSTFUNC double Numヽclamped(double x, double low, double high); +MACROLIKE CONSTFUNC double Numヽfrom_num32(Num32_t n) { return (double)n; } #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wfloat-equal" #endif -MACROLIKE CONSTFUNC double Num$from_int(Int_t i, bool truncate) { +MACROLIKE CONSTFUNC double Numヽfrom_int(Int_t i, bool truncate) { if likely (i.small & 0x1) { double ret = (double)(i.small >> 2); if unlikely (!truncate && (int64_t)ret != (i.small >> 2)) @@ -58,41 +58,41 @@ MACROLIKE CONSTFUNC double Num$from_int(Int_t i, bool truncate) { #ifdef __GNUC__ #pragma GCC diagnostic pop #endif -MACROLIKE CONSTFUNC double Num$from_int64(Int64_t i, bool truncate) { +MACROLIKE CONSTFUNC double Numヽfrom_int64(Int64_t i, bool truncate) { double n = (double)i; if unlikely (!truncate && (Int64_t)n != i) fail("Could not convert integer to 64-bit floating point without losing precision: ", i); return n; } -MACROLIKE CONSTFUNC double Num$from_int32(Int32_t i) { return (double)i; } -MACROLIKE CONSTFUNC double Num$from_int16(Int16_t i) { return (double)i; } -MACROLIKE CONSTFUNC double Num$from_int8(Int8_t i) { return (double)i; } -MACROLIKE CONSTFUNC double Num$from_byte(Byte_t i) { return (double)i; } +MACROLIKE CONSTFUNC double Numヽfrom_int32(Int32_t i) { return (double)i; } +MACROLIKE CONSTFUNC double Numヽfrom_int16(Int16_t i) { return (double)i; } +MACROLIKE CONSTFUNC double Numヽfrom_int8(Int8_t i) { return (double)i; } +MACROLIKE CONSTFUNC double Numヽfrom_byte(Byte_t i) { return (double)i; } -extern const TypeInfo_t Num$info; +extern const TypeInfo_t Numヽinfo; -Text_t Num32$as_text(const void *f, bool colorize, const TypeInfo_t *type); -PUREFUNC int32_t Num32$compare(const void *x, const void *y, const TypeInfo_t *type); -PUREFUNC bool Num32$equal(const void *x, const void *y, const TypeInfo_t *type); -CONSTFUNC bool Num32$near(float a, float b, float ratio, float absolute); -Text_t Num32$percent(float f, float precision); -float CONSTFUNC Num32$with_precision(float num, float precision); -float Num32$mod(float num, float modulus); -float Num32$mod1(float num, float modulus); -CONSTFUNC bool Num32$isinf(float n); -CONSTFUNC bool Num32$finite(float n); -CONSTFUNC bool Num32$isnan(float n); -CONSTFUNC float Num32$mix(float amount, float x, float y); -OptionalNum32_t Num32$parse(Text_t text, Text_t *remainder); -float Num32$nan(Text_t tag); -CONSTFUNC bool Num32$is_between(const float x, const float low, const float high); -CONSTFUNC float Num32$clamped(float x, float low, float high); -MACROLIKE CONSTFUNC float Num32$from_num(Num_t n) { return (float)n; } +Text_t Num32ヽas_text(const void *f, bool colorize, const TypeInfo_t *type); +PUREFUNC int32_t Num32ヽcompare(const void *x, const void *y, const TypeInfo_t *type); +PUREFUNC bool Num32ヽequal(const void *x, const void *y, const TypeInfo_t *type); +CONSTFUNC bool Num32ヽnear(float a, float b, float ratio, float absolute); +Text_t Num32ヽpercent(float f, float precision); +float CONSTFUNC Num32ヽwith_precision(float num, float precision); +float Num32ヽmod(float num, float modulus); +float Num32ヽmod1(float num, float modulus); +CONSTFUNC bool Num32ヽisinf(float n); +CONSTFUNC bool Num32ヽfinite(float n); +CONSTFUNC bool Num32ヽisnan(float n); +CONSTFUNC float Num32ヽmix(float amount, float x, float y); +OptionalNum32_t Num32ヽparse(Text_t text, Text_t *remainder); +float Num32ヽnan(Text_t tag); +CONSTFUNC bool Num32ヽis_between(const float x, const float low, const float high); +CONSTFUNC float Num32ヽclamped(float x, float low, float high); +MACROLIKE CONSTFUNC float Num32ヽfrom_num(Num_t n) { return (float)n; } #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wfloat-equal" #endif -MACROLIKE CONSTFUNC float Num32$from_int(Int_t i, bool truncate) { +MACROLIKE CONSTFUNC float Num32ヽfrom_int(Int_t i, bool truncate) { if likely (i.small & 0x1) { float ret = (float)(i.small >> 2); if unlikely (!truncate && (int64_t)ret != (i.small >> 2)) @@ -112,22 +112,22 @@ MACROLIKE CONSTFUNC float Num32$from_int(Int_t i, bool truncate) { #ifdef __GNUC__ #pragma GCC diagnostic pop #endif -MACROLIKE CONSTFUNC float Num32$from_int64(Int64_t i, bool truncate) { +MACROLIKE CONSTFUNC float Num32ヽfrom_int64(Int64_t i, bool truncate) { float n = (float)i; if unlikely (!truncate && (Int64_t)n != i) fail("Could not convert integer to 32-bit floating point without losing precision: ", i); return n; } -MACROLIKE CONSTFUNC float Num32$from_int32(Int32_t i, bool truncate) { +MACROLIKE CONSTFUNC float Num32ヽfrom_int32(Int32_t i, bool truncate) { float n = (float)i; if unlikely (!truncate && (Int32_t)n != i) fail("Could not convert integer to 32-bit floating point without losing precision: ", i); return n; } -MACROLIKE CONSTFUNC float Num32$from_int16(Int16_t i) { return (float)i; } -MACROLIKE CONSTFUNC float Num32$from_int8(Int8_t i) { return (float)i; } -MACROLIKE CONSTFUNC float Num32$from_byte(Byte_t i) { return (float)i; } +MACROLIKE CONSTFUNC float Num32ヽfrom_int16(Int16_t i) { return (float)i; } +MACROLIKE CONSTFUNC float Num32ヽfrom_int8(Int8_t i) { return (float)i; } +MACROLIKE CONSTFUNC float Num32ヽfrom_byte(Byte_t i) { return (float)i; } -extern const TypeInfo_t Num32$info; +extern const TypeInfo_t Num32ヽinfo; // 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 ead9428a..9aaf5400 100644 --- a/src/stdlib/optionals.c +++ b/src/stdlib/optionals.c @@ -18,12 +18,12 @@ public PUREFUNC bool is_none(const void *obj, const TypeInfo_t *non_optional_typ 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); @@ -33,7 +33,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; @@ -44,17 +44,17 @@ 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) +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("?")); + 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"); 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); @@ -62,7 +62,7 @@ public void Optional$serialize(const void *obj, FILE *out, Table_t *pointers, co _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; @@ -76,9 +76,9 @@ public void Optional$deserialize(FILE *in, void *outval, List_t *pointers, const *(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) + else if (nonnull == &Numヽinfo) *(double*)outval = (double)NAN; - else if (nonnull == &Num32$info) + 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)); diff --git a/src/stdlib/optionals.h b/src/stdlib/optionals.h index 5be52e93..223cf47b 100644 --- a/src/stdlib/optionals.h +++ b/src/stdlib/optionals.h @@ -19,24 +19,24 @@ #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); -PUREFUNC int32_t Optional$compare(const void *x, const void *y, const TypeInfo_t *type); -PUREFUNC bool Optional$equal(const void *x, const void *y, const TypeInfo_t *type); -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, \ +PUREFUNC uint64_t Optionalヽhash(const void *obj, const TypeInfo_t *type); +PUREFUNC int32_t Optionalヽcompare(const void *x, const void *y, const TypeInfo_t *type); +PUREFUNC bool Optionalヽequal(const void *x, const void *y, const TypeInfo_t *type); +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, \ +#define Optionalヽinfo(_size, _align, t) &((TypeInfo_t){.size=_size, .align=_align, \ .tag=OptionalInfo, .OptionalInfo.type=t, \ - .metamethods=Optional$metamethods}) + .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 58702ec7..8aa57f17 100644 --- a/src/stdlib/paths.c +++ b/src/stdlib/paths.c @@ -33,20 +33,20 @@ #include "siphash.h" #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); - if (component->length == 0 || Text$equal_values(*component, Text("."))) { - List$remove_at(components, I(i+1), I(1), sizeof(Text_t)); - } else if (i > 0 && Text$equal_values(*component, Text(".."))) { + if (component->length == 0 || Textヽequal_values(*component, Text("."))) { + 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); - if (!Text$equal_values(*prev, Text(".."))) { - List$remove_at(components, I(i), I(2), sizeof(Text_t)); + if (!Textヽequal_values(*prev, Text(".."))) { + Listヽremove_at(components, I(i), I(2), sizeof(Text_t)); i -= 1; } else { i += 1; @@ -57,7 +57,7 @@ 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; @@ -68,16 +68,16 @@ public Path_t Path$from_str(const char *str) Path_t result = {.components={}}; if (str[0] == '/') { - result.type.$tag = PATH_ABSOLUTE; + result.type.ヽtag = PATH_ABSOLUTE; str += 1; } else if (str[0] == '~' && str[1] == '/') { - result.type.$tag = PATH_HOME; + result.type.ヽtag = PATH_HOME; str += 2; } else if (str[0] == '.' && str[1] == '/') { - result.type.$tag = PATH_RELATIVE; + result.type.ヽtag = PATH_RELATIVE; str += 2; } else { - result.type.$tag = PATH_RELATIVE; + result.type.ヽtag = PATH_RELATIVE; } while (str && *str) { @@ -87,12 +87,12 @@ public Path_t Path$from_str(const char *str) // 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)))) { + && !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)); + Listヽremove_at(&result.components, I(result.components.length), I(1), sizeof(Text_t)); } else { - Text_t component = Text$from_strn(str, component_len); - List$insert_value(&result.components, component, I(0), sizeof(Text_t)); + Text_t component = Textヽfrom_strn(str, component_len); + Listヽinsert_value(&result.components, component, I(0), sizeof(Text_t)); } str += component_len; } @@ -101,90 +101,90 @@ public Path_t Path$from_str(const char *str) return result; } -public Path_t Path$from_text(Text_t text) +public Path_t Pathヽfrom_text(Text_t text) { - return Path$from_str(Text$as_c_string(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)); + 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); for (int i = 1; i < n; i++) { - if (items[i].type.$tag != PATH_RELATIVE) + if (items[i].type.ヽtag != PATH_RELATIVE) fail("Cannot concatenate an absolute or home-based path onto another path: (", items[i], ")"); - List$insert_all(&result.components, items[i].components, I(0), sizeof(Text_t)); + Listヽinsert_all(&result.components, items[i].components, I(0), sizeof(Text_t)); } clean_components(&result.components); return result; } -public Path_t Path$resolved(Path_t path, Path_t relative_to) +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}; + 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)); + Listヽinsert_all(&result.components, path.components, I(0), sizeof(Text_t)); clean_components(&result.components); return result; } 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) + 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, ")"); - 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)) + 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)); + 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); - List$insert(&result.components, p, I(0), sizeof(Text_t)); + Listヽinsert(&result.components, p, I(0), sizeof(Text_t)); } //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); + path = Pathヽexpand_home(path); struct stat sb; - return (stat(Path$as_c_string(path), &sb) == 0); + return (stat(Pathヽas_c_string(path), &sb) == 0); } 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); + 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); @@ -192,7 +192,7 @@ public bool Path$is_file(Path_t path, bool follow_symlinks) 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); @@ -200,7 +200,7 @@ public bool Path$is_directory(Path_t path, bool follow_symlinks) 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); @@ -208,7 +208,7 @@ public bool Path$is_pipe(Path_t path, bool follow_symlinks) 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); @@ -216,7 +216,7 @@ public bool Path$is_socket(Path_t path, bool follow_symlinks) 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); @@ -224,10 +224,10 @@ public bool Path$is_symlink(Path_t path) 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); + path = Pathヽexpand_home(path); + const char *path_str = Pathヽas_c_string(path); #ifdef _GNU_SOURCE return (euidaccess(path_str, R_OK) == 0); #else @@ -235,10 +235,10 @@ 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); + path = Pathヽexpand_home(path); + const char *path_str = Pathヽas_c_string(path); #ifdef _GNU_SOURCE return (euidaccess(path_str, W_OK) == 0); #else @@ -246,10 +246,10 @@ 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); + path = Pathヽexpand_home(path); + const char *path_str = Pathヽas_c_string(path); #ifdef _GNU_SOURCE return (euidaccess(path_str, X_OK) == 0); #else @@ -257,7 +257,7 @@ 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); @@ -265,7 +265,7 @@ public OptionalInt64_t Path$modified(Path_t path, bool follow_symlinks) 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); @@ -273,7 +273,7 @@ public OptionalInt64_t Path$accessed(Path_t path, bool follow_symlinks) 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); @@ -283,46 +283,46 @@ public OptionalInt64_t Path$changed(Path_t path, bool follow_symlinks) 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); + 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 (bytes.stride != 1) - List$compact(&bytes, 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)); 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); + 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); + 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); + path = Pathヽexpand_home(path); + int fd = open(Pathヽas_c_string(path), O_RDONLY); if (fd == -1) return NONE_LIST; @@ -330,7 +330,7 @@ public OptionalList_t Path$read_bytes(Path_t path, OptionalInt_t count) if (fstat(fd, &sb) != 0) return NONE_LIST; - int64_t const target_count = count.small ? Int64$from_int(count, false) : INT64_MAX; + 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!"); @@ -376,47 +376,47 @@ public OptionalList_t Path$read_bytes(Path_t path, OptionalInt_t count) } } -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); + List_t bytes = Pathヽread_bytes(path, NONE_INT); if (bytes.length < 0) return NONE_TEXT; - return Text$from_bytes(bytes); + 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; struct passwd *pw = getpwuid(sb.st_uid); - return pw ? Text$from_str(pw->pw_name) : NONE_TEXT; + 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; struct group *gr = getgrgid(sb.st_uid); - return gr ? Text$from_str(gr->gr_name) : NONE_TEXT; + 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)); + struct passwd *pwd = getpwnam(Textヽas_c_string(owner)); if (pwd == NULL) fail("Not a valid user: ", owner); owner_id = pwd->pw_uid; } gid_t group_id = (gid_t)-1; if (group.length >= 0) { - struct group *grp = getgrnam(Text$as_c_string(group)); + struct group *grp = getgrnam(Textヽas_c_string(group)); if (grp == NULL) fail("Not a valid group: ", group); group_id = grp->gr_gid; } - const char *path_str = Path$as_c_string(path); + 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!"); @@ -442,10 +442,10 @@ static int _remove_files(const char *path, const struct stat *sbuf, int type, st } } -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); + 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) @@ -465,10 +465,10 @@ public void Path$remove(Path_t path, bool ignore_missing) } } -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); + 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), ")"); @@ -476,10 +476,10 @@ public void Path$create_directory(Path_t path, int permissions) static List_t _filtered_children(Path_t path, bool include_hidden, mode_t filter) { - path = Path$expand_home(path); + path = Pathヽexpand_home(path); struct dirent *dir; List_t children = {}; - const char *path_str = Path$as_c_string(path); + const char *path_str = Pathヽas_c_string(path); size_t path_len = strlen(path_str); DIR *d = opendir(path_str); if (!d) @@ -501,32 +501,32 @@ static List_t _filtered_children(Path_t path, bool include_hidden, mode_t filter 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)); + Path_t child = Pathヽfrom_str(child_str); + Listヽinsert(&children, &child, I(0), sizeof(Path_t)); } closedir(d); return children; } -public List_t Path$children(Path_t path, bool include_hidden) +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) +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); + path = Pathヽexpand_home(path); + const char *path_str = Pathヽas_c_string(path); size_t len = strlen(path_str); if (len >= PATH_MAX) fail("Path is too long: ", path_str); char buf[PATH_MAX] = {}; @@ -536,13 +536,13 @@ public Path_t Path$unique_directory(Path_t path) buf[--len] = '\0'; char *created = mkdtemp(buf); if (!created) fail("Failed to create temporary directory: ", path_str, " (", strerror(errno), ")"); - return Path$from_str(created); + 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); + path = Pathヽexpand_home(path); + const char *path_str = Pathヽas_c_string(path); size_t len = strlen(path_str); if (len >= PATH_MAX) fail("Path is too long: ", path_str); char buf[PATH_MAX] = {}; @@ -560,56 +560,56 @@ public Path_t Path$write_unique_bytes(Path_t path, List_t bytes) fail("Could not write to unique file: ", buf, "\n", strerror(errno)); if (bytes.stride != 1) - List$compact(&bytes, 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)); close(fd); - return Path$from_str(buf); + return Pathヽfrom_str(buf); } -public Path_t Path$write_unique(Path_t path, Text_t text) +public Path_t Pathヽwrite_unique(Path_t path, Text_t text) { - return Path$write_unique_bytes(path, Text$utf8_bytes(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) { + 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)), + } 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))}; + 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)); + 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) + else if (path.type.ヽtag == PATH_HOME) return Text("~"); - else if (path.type.$tag == PATH_RELATIVE) + 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 *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); + return Textヽfrom_str(extension); } -public bool Path$has_extension(Path_t path, Text_t extension) +public bool Pathヽhas_extension(Path_t path, Text_t extension) { if (path.components.length < 2) return extension.length == 0; @@ -617,57 +617,57 @@ public bool Path$has_extension(Path_t path, Text_t extension) 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("..")); + return !Textヽhas(Textヽfrom(last, I(2)), Text(".")) || Textヽequal_values(last, Text("..")); - if (!Text$starts_with(extension, Text("."), NULL)) + if (!Textヽstarts_with(extension, Text("."), NULL)) extension = Texts(Text("."), extension); - return Text$ends_with(Text$from(last, I(2)), extension, NULL); + return Textヽends_with(Textヽfrom(last, I(2)), extension, NULL); } -public Path_t Path$child(Path_t path, Text_t name) +public Path_t Pathヽchild(Path_t path, Text_t name) { - if (Text$has(name, Text("/")) || Text$has(name, Text(";"))) + if (Textヽhas(name, Text("/")) || Textヽhas(name, Text(";"))) fail("Path name has invalid characters: ", name); Path_t result = { - .type.$tag=path.type.$tag, + .type.ヽtag=path.type.ヽtag, .components=path.components, }; LIST_INCREF(result.components); - List$insert(&result.components, &name, I(0), sizeof(Text_t)); + Listヽinsert(&result.components, &name, I(0), sizeof(Text_t)); clean_components(&result.components); return result; } -public Path_t Path$sibling(Path_t path, Text_t name) +public Path_t Pathヽsibling(Path_t path, Text_t name) { - return Path$child(Path$parent(path), name); + return Pathヽchild(Pathヽparent(path), name); } -public Path_t Path$with_extension(Path_t path, Text_t extension, bool replace) +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(";"))) + if (Textヽhas(extension, Text("/")) || Textヽhas(extension, Text(";"))) fail("Path extension has invalid characters: ", extension); Path_t result = { - .type.$tag=path.type.$tag, + .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)); - List$remove_at(&result.components, I(-1), I(1), sizeof(Text_t)); + Listヽremove_at(&result.components, I(-1), I(1), sizeof(Text_t)); if (replace) { - const char *base = Text$as_c_string(last); + 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)); + last = Textヽfrom_strn(base, (size_t)(dot - base)); } - last = Text$concat(last, extension); - List$insert(&result.components, &last, I(0), sizeof(Text_t)); + last = Textヽconcat(last, extension); + Listヽinsert(&result.components, &last, I(0), sizeof(Text_t)); return result; } @@ -697,16 +697,16 @@ static Text_t _next_line(FILE **f) if (u8_check((uint8_t*)line, (size_t)len) != NULL) fail("Invalid UTF8!"); - Text_t line_text = Text$from_strn(line, (size_t)len); + 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); + path = Pathヽexpand_home(path); - FILE *f = fopen(Path$as_c_string(path), "r"); + FILE *f = fopen(Pathヽas_c_string(path), "r"); if (f == NULL) return NONE_CLOSURE; @@ -716,10 +716,10 @@ public OptionalClosure_t Path$by_line(Path_t path) 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); + 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"); @@ -729,100 +729,100 @@ public List_t Path$glob(Path_t path) 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)); + Path_t p = Pathヽfrom_str(glob_result.gl_pathv[i]); + Listヽinsert(&glob_files, &p, I(0), sizeof(Path_t)); } 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"); - return Path$from_str(cwd); + 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; siphash sh; - siphashinit(&sh, (uint64_t)path->type.$tag); + 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; - int diff = ((int)a->type.$tag - (int)b->type.$tag); + 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)); + 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; - if (a->type.$tag != b->type.$tag) return false; - return List$equal(&a->components, &b->components, List$info(&Text$info)); + 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)); + 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); - else if (path.type.$tag == PATH_HOME) return fputs("~", f); + if (path.type.ヽtag == PATH_ABSOLUTE) return fputs("/", f); + else if (path.type.ヽtag == PATH_RELATIVE) return fputs(".", f); + else if (path.type.ヽtag == PATH_HOME) return fputs("~", f); } int n = 0; - if (path.type.$tag == PATH_ABSOLUTE) { + if (path.type.ヽtag == PATH_ABSOLUTE) { n += fputc('/', f); - } else if (path.type.$tag == PATH_HOME) { + } 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(".."))) + } else if (path.type.ヽtag == PATH_RELATIVE) { + 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); - n += Text$print(f, *comp); + n += Textヽprint(f, *comp); if (i + 1 < path.components.length) n += fputc('/', f); } return n; } -public const char *Path$as_c_string(Path_t 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; - 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("..")))) - text = Text$concat(path->components.length > 0 ? Text("./") : Text("."), text); + 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("..")))) + text = Textヽconcat(path->components.length > 0 ? Text("./") : Text("."), text); if (color) text = Texts(Text("\033[32;1m"), text, Text("\033[m")); @@ -830,48 +830,48 @@ public Text_t Path$as_text(const void *obj, bool color, const TypeInfo_t *type) 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; - fputc((int)path->type.$tag, out); - List$serialize(&path->components, out, pointers, List$info(&Text$info)); + 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.type.ヽtag = fgetc(in); + Listヽdeserialize(in, &path.components, pointers, Listヽinfo(&Textヽinfo)); *(Path_t*)obj = path; } -public const TypeInfo_t Path$info = { +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, + .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 = { +public const TypeInfo_t PathTypeヽinfo = { .size=sizeof(PathType_t), .align=__alignof__(PathType_t), - .metamethods=PackedDataEnum$metamethods, + .metamethods=PackedDataEnumヽmetamethods, .tag=EnumInfo, .EnumInfo={ .name="PathType", diff --git a/src/stdlib/paths.h b/src/stdlib/paths.h index 3a9cdef7..4ae78cd5 100644 --- a/src/stdlib/paths.h +++ b/src/stdlib/paths.h @@ -9,67 +9,67 @@ #include "datatypes.h" #include "optionals.h" -Path_t Path$from_str(const char *str); -Path_t Path$from_text(Text_t text); -// int Path$print(FILE *f, Path_t path); -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__})) -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); -bool Path$exists(Path_t path); -bool Path$is_file(Path_t path, bool follow_symlinks); -bool Path$is_directory(Path_t path, bool follow_symlinks); -bool Path$is_pipe(Path_t path, bool follow_symlinks); -bool Path$is_socket(Path_t path, bool follow_symlinks); -bool Path$is_symlink(Path_t path); -bool Path$can_read(Path_t path); -bool Path$can_write(Path_t path); -bool Path$can_execute(Path_t path); -OptionalInt64_t Path$modified(Path_t path, bool follow_symlinks); -OptionalInt64_t Path$accessed(Path_t path, bool follow_symlinks); -OptionalInt64_t Path$changed(Path_t path, bool follow_symlinks); -void Path$write(Path_t path, Text_t text, int permissions); -void Path$write_bytes(Path_t path, List_t bytes, int permissions); -void Path$append(Path_t path, Text_t text, int permissions); -void Path$append_bytes(Path_t path, List_t bytes, int permissions); -OptionalText_t Path$read(Path_t path); -OptionalList_t Path$read_bytes(Path_t path, OptionalInt_t limit); -void Path$set_owner(Path_t path, OptionalText_t owner, OptionalText_t group, bool follow_symlinks); -OptionalText_t Path$owner(Path_t path, bool follow_symlinks); -OptionalText_t Path$group(Path_t path, bool follow_symlinks); -void Path$remove(Path_t path, bool ignore_missing); -void Path$create_directory(Path_t path, int permissions); -List_t Path$children(Path_t path, bool include_hidden); -List_t Path$files(Path_t path, bool include_hidden); -List_t Path$subdirectories(Path_t path, bool include_hidden); -Path_t Path$unique_directory(Path_t path); -Path_t Path$write_unique(Path_t path, Text_t text); -Path_t Path$write_unique_bytes(Path_t path, List_t bytes); -Path_t Path$parent(Path_t path); -Text_t Path$base_name(Path_t path); -Text_t Path$extension(Path_t path, bool full); -bool Path$has_extension(Path_t path, Text_t extension); -Path_t Path$child(Path_t path, Text_t name); -Path_t Path$sibling(Path_t path, Text_t name); -Path_t Path$with_extension(Path_t path, Text_t extension, bool replace); -Path_t Path$current_dir(void); -Closure_t Path$by_line(Path_t path); -List_t Path$glob(Path_t path); +Path_t Pathヽfrom_str(const char *str); +Path_t Pathヽfrom_text(Text_t text); +// int Pathヽprint(FILE *f, Path_t path); +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__})) +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); +bool Pathヽexists(Path_t path); +bool Pathヽis_file(Path_t path, bool follow_symlinks); +bool Pathヽis_directory(Path_t path, bool follow_symlinks); +bool Pathヽis_pipe(Path_t path, bool follow_symlinks); +bool Pathヽis_socket(Path_t path, bool follow_symlinks); +bool Pathヽis_symlink(Path_t path); +bool Pathヽcan_read(Path_t path); +bool Pathヽcan_write(Path_t path); +bool Pathヽcan_execute(Path_t path); +OptionalInt64_t Pathヽmodified(Path_t path, bool follow_symlinks); +OptionalInt64_t Pathヽaccessed(Path_t path, bool follow_symlinks); +OptionalInt64_t Pathヽchanged(Path_t path, bool follow_symlinks); +void Pathヽwrite(Path_t path, Text_t text, int permissions); +void Pathヽwrite_bytes(Path_t path, List_t bytes, int permissions); +void Pathヽappend(Path_t path, Text_t text, int permissions); +void Pathヽappend_bytes(Path_t path, List_t bytes, int permissions); +OptionalText_t Pathヽread(Path_t path); +OptionalList_t Pathヽread_bytes(Path_t path, OptionalInt_t limit); +void Pathヽset_owner(Path_t path, OptionalText_t owner, OptionalText_t group, bool follow_symlinks); +OptionalText_t Pathヽowner(Path_t path, bool follow_symlinks); +OptionalText_t Pathヽgroup(Path_t path, bool follow_symlinks); +void Pathヽremove(Path_t path, bool ignore_missing); +void Pathヽcreate_directory(Path_t path, int permissions); +List_t Pathヽchildren(Path_t path, bool include_hidden); +List_t Pathヽfiles(Path_t path, bool include_hidden); +List_t Pathヽsubdirectories(Path_t path, bool include_hidden); +Path_t Pathヽunique_directory(Path_t path); +Path_t Pathヽwrite_unique(Path_t path, Text_t text); +Path_t Pathヽwrite_unique_bytes(Path_t path, List_t bytes); +Path_t Pathヽparent(Path_t path); +Text_t Pathヽbase_name(Path_t path); +Text_t Pathヽextension(Path_t path, bool full); +bool Pathヽhas_extension(Path_t path, Text_t extension); +Path_t Pathヽchild(Path_t path, Text_t name); +Path_t Pathヽsibling(Path_t path, Text_t name); +Path_t Pathヽwith_extension(Path_t path, Text_t extension, bool replace); +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*); -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); -Text_t Path$as_text(const void *obj, bool color, const TypeInfo_t *type); -bool Path$is_none(const void *obj, const TypeInfo_t *type); -void Path$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type); -void Path$deserialize(FILE *in, void *obj, List_t *pointers, const TypeInfo_t *type); +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); +Text_t Pathヽas_text(const void *obj, bool color, const TypeInfo_t *type); +bool Pathヽis_none(const void *obj, const TypeInfo_t *type); +void Pathヽserialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type); +void Pathヽdeserialize(FILE *in, void *obj, List_t *pointers, const TypeInfo_t *type); -extern const TypeInfo_t Path$info; -extern const TypeInfo_t PathType$info; +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 6874dd3c..08fce9e4 100644 --- a/src/stdlib/pointers.c +++ b/src/stdlib/pointers.c @@ -14,22 +14,22 @@ #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")); + 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); + return Textヽconcat(Textヽfrom_str(ptr_info.sigil), typename); } 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")); + return Textヽconcat(Text("\x1b[34;1m!"), typename, Text("\x1b[m")); else - return Text$concat(Text("!"), typename); + return Textヽconcat(Text("!"), typename); } static const void *root = NULL; @@ -41,17 +41,17 @@ public Text_t Pointer$as_text(const void *x, bool colorize, const TypeInfo_t *ty if (top_level) { root = ptr; } else if (ptr == root) { - Text_t text = Texts(Text$from_str(ptr_info.sigil), Text("~1")); + Text_t text = Texts(Textヽfrom_str(ptr_info.sigil), Text("~1")); return colorize ? Texts(Text("\x1b[34;1m"), text, Text("\x1b[m")) : text; } else { - TypeInfo_t rec_table = *Table$info(type, &Int64$info); - int64_t *id = Table$get(pending, x, &rec_table); + TypeInfo_t rec_table = *Tableヽinfo(type, &Int64ヽinfo); + int64_t *id = Tableヽget(pending, x, &rec_table); if (id) { - Text_t text = Texts(Text$from_str(ptr_info.sigil), Int64$as_text(id, false, &Int64$info)); + Text_t text = Texts(Textヽfrom_str(ptr_info.sigil), Int64ヽas_text(id, false, &Int64ヽinfo)); return colorize ? Texts(Text("\x1b[34;1m"), text, Text("\x1b[m")) : text; } int64_t next_id = pending.entries.length + 2; - Table$set(&pending, x, &next_id, &rec_table); + Tableヽset(&pending, x, &next_id, &rec_table); } Text_t pointed = generic_as_text(ptr, colorize, ptr_info.pointed); @@ -63,62 +63,62 @@ 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); + 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); + 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) { +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; return (xp > yp) - (xp < yp); } -PUREFUNC public bool Pointer$equal(const void *x, const void *y, const TypeInfo_t *info) { +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; 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; } -public void Pointer$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) +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}; + .tag=TableInfo, .TableInfo.key=type, .TableInfo.value=&Int64ヽinfo}; - int64_t *id_ptr = Table$get(*pointers, &ptr, &ptr_to_int_table); + int64_t *id_ptr = Tableヽget(*pointers, &ptr, &ptr_to_int_table); int64_t id; if (id_ptr) { id = *id_ptr; } else { id = pointers->entries.length + 1; - Table$set(pointers, &ptr, &id, &ptr_to_int_table); + Tableヽset(pointers, &ptr, &id, &ptr_to_int_table); } - Int64$serialize(&id, out, pointers, &Int64$info); + Int64ヽserialize(&id, out, pointers, &Int64ヽinfo); 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); + 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; } else { diff --git a/src/stdlib/pointers.h b/src/stdlib/pointers.h index b818452e..b0711d5c 100644 --- a/src/stdlib/pointers.h +++ b/src/stdlib/pointers.h @@ -9,28 +9,28 @@ #include "types.h" #include "util.h" -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*); -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); +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*); +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ヽ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*), \ +#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}) + .metamethods=Pointerヽmetamethods}) // 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 ce20152b..2dbe8373 100644 --- a/src/stdlib/print.h +++ b/src/stdlib/print.h @@ -96,9 +96,9 @@ PRINT_FN _print_repeated_char(FILE *f, repeated_char_t repeated) { return len; } -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); +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, \ @@ -121,9 +121,9 @@ extern int Int$print(FILE *f, Int_t i); 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, \ + Text_t: Textヽprint, \ + Path_t: Pathヽprint, \ + Int_t: Intヽprint, \ void*: _print_pointer)(f, x) #endif diff --git a/src/stdlib/stacktrace.c b/src/stdlib/stacktrace.c index 3904ae70..5e92f10f 100644 --- a/src/stdlib/stacktrace.c +++ b/src/stdlib/stacktrace.c @@ -119,7 +119,7 @@ public void print_stacktrace(FILE *out, int offset) const char *function = NULL, *filename = NULL; long line_num = 0; if (fparse(fp, &function, "\n", &filename, ":", &line_num) == NULL) { - if (starts_with(function, "main$")) + if (starts_with(function, "mainヽ")) main_func_onwards = true; if (main_func_onwards) _print_stack_frame(out, cwd, install_dir, function, filename, line_num); diff --git a/src/stdlib/stdlib.c b/src/stdlib/stdlib.c index 02ccd710..1372d945 100644 --- a/src/stdlib/stdlib.c +++ b/src/stdlib/stdlib.c @@ -84,51 +84,51 @@ static bool parse_single_arg(const TypeInfo_t *info, char *arg, void *dest) while (info->tag == OptionalInfo) info = info->OptionalInfo.type; - if (info == &Int$info) { - OptionalInt_t parsed = Int$from_str(arg); + if (info == &Intヽinfo) { + OptionalInt_t parsed = Intヽfrom_str(arg); 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); + } else if (info == &Int64ヽinfo) { + OptionalInt64_t parsed = Int64ヽparse(Textヽfrom_str(arg), NULL); 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); + } else if (info == &Int32ヽinfo) { + OptionalInt32_t parsed = Int32ヽparse(Textヽfrom_str(arg), NULL); 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); + } else if (info == &Int16ヽinfo) { + OptionalInt16_t parsed = Int16ヽparse(Textヽfrom_str(arg), NULL); 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); + } else if (info == &Int8ヽinfo) { + OptionalInt8_t parsed = Int8ヽparse(Textヽfrom_str(arg), NULL); 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); + } else if (info == &Boolヽinfo) { + OptionalBool_t parsed = Boolヽparse(Textヽfrom_str(arg), NULL); 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); + } else if (info == &Numヽinfo) { + OptionalNum_t parsed = Numヽparse(Textヽfrom_str(arg), NULL); 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); + } else if (info == &Num32ヽinfo) { + OptionalNum32_t parsed = Num32ヽparse(Textヽfrom_str(arg), NULL); if (!isnan(parsed)) *(OptionalNum32_t*)dest = parsed; return !isnan(parsed); - } else if (info == &Path$info) { - *(OptionalPath_t*)dest = Path$from_str(arg); + } else if (info == &Pathヽinfo) { + *(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++) { @@ -225,7 +225,7 @@ static Table_t parse_table(const TypeInfo_t *table, int n, char *args[]) *equals = '='; } - return Table$from_entries(entries, table); + return Tableヽfrom_entries(entries, table); } #ifdef __GNUC__ @@ -251,7 +251,7 @@ 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 + 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; @@ -286,7 +286,7 @@ public void _tomo_parse_args(int argc, char *argv[], Text_t usage, Text_t help, } populated_args[s] = true; *(OptionalTable_t*)spec[s].dest = parse_table(non_opt_type, num_args, &argv[i+1]); - } else if (non_opt_type == &Bool$info) { // --flag + } else if (non_opt_type == &Boolヽinfo) { // --flag populated_args[s] = true; *(OptionalBool_t*)spec[s].dest = true; } else { @@ -351,7 +351,7 @@ public void _tomo_parse_args(int argc, char *argv[], Text_t usage, Text_t help, } populated_args[s] = true; *(OptionalTable_t*)spec[s].dest = parse_table(non_opt_type, num_args, &argv[i+1]); - } else if (non_opt_type == &Bool$info) { // -f + } else if (non_opt_type == &Boolヽinfo) { // -f populated_args[s] = true; *(OptionalBool_t*)spec[s].dest = true; } else { @@ -403,7 +403,7 @@ 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) + if (non_opt_type == &Boolヽinfo) goto next_non_bool_flag; if (non_opt_type->tag == ListInfo) { @@ -456,7 +456,7 @@ public _Noreturn void fail_text(Text_t message) public Text_t builtin_last_err() { - return Text$from_str(strerror(errno)); + return Textヽfrom_str(strerror(errno)); } static int _inspect_depth = 0; @@ -548,7 +548,7 @@ public void test_value(const char *filename, int64_t start, int64_t end, const v public void say(Text_t text, bool newline) { - Text$print(stdout, text); + Textヽprint(stdout, text); if (newline) fputc('\n', stdout); fflush(stdout); @@ -578,7 +578,7 @@ public OptionalText_t ask(Text_t prompt, bool bold, bool force_tty) } if (bold) fputs("\x1b[1m", out); - Text$print(out, prompt); + Textヽprint(out, prompt); if (bold) fputs("\x1b[m", out); fflush(out); @@ -604,7 +604,7 @@ public OptionalText_t ask(Text_t prompt, bool bold, bool force_tty) gc_input = GC_MALLOC_ATOMIC((size_t)(length + 1)); memcpy(gc_input, line, (size_t)(length + 1)); - ret = Text$from_strn(gc_input, (size_t)(length)); + ret = Textヽfrom_strn(gc_input, (size_t)(length)); cleanup: if (out && out != stdout) fclose(out); @@ -627,7 +627,7 @@ public bool pop_flag(char **argv, int *i, const char *flag, Text_t *result) *i += 1; return true; } else if (strncmp(argv[*i] + 2, flag, strlen(flag)) == 0 && argv[*i][2 + strlen(flag)] == '=') { - *result = Text$from_str(argv[*i] + 2 + strlen(flag) + 1); + *result = Textヽfrom_str(argv[*i] + 2 + strlen(flag) + 1); argv[*i] = NULL; *i += 1; return true; @@ -646,13 +646,13 @@ public void sleep_num(double seconds) 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; + 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); + 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/structs.c b/src/stdlib/structs.c index d4a22d93..3b42f2ac 100644 --- a/src/stdlib/structs.c +++ b/src/stdlib/structs.c @@ -18,7 +18,7 @@ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstack-protector" #endif -PUREFUNC public uint64_t Struct$hash(const void *obj, const TypeInfo_t *type) +PUREFUNC public uint64_t Structヽhash(const void *obj, const TypeInfo_t *type) { if (type->StructInfo.num_fields == 0) return 0; @@ -31,7 +31,7 @@ PUREFUNC public uint64_t Struct$hash(const void *obj, const TypeInfo_t *type) 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) { + if (field.type == &Boolヽinfo) { bool b = ((*(char*)(obj + byte_offset)) >> bit_offset) & 0x1; field_hashes[i] = (uint32_t)b; bit_offset += 1; @@ -56,7 +56,7 @@ PUREFUNC public uint64_t Struct$hash(const void *obj, const TypeInfo_t *type) #pragma GCC diagnostic pop #endif -PUREFUNC public uint64_t PackedData$hash(const void *obj, const TypeInfo_t *type) +PUREFUNC public uint64_t PackedDataヽhash(const void *obj, const TypeInfo_t *type) { if (type->StructInfo.num_fields == 0) return 0; @@ -64,7 +64,7 @@ PUREFUNC public uint64_t PackedData$hash(const void *obj, const TypeInfo_t *type return siphash24(obj, (size_t)type->size); } -PUREFUNC public int32_t Struct$compare(const void *x, const void *y, const TypeInfo_t *type) +PUREFUNC public int32_t Structヽcompare(const void *x, const void *y, const TypeInfo_t *type) { if (x == y) return 0; @@ -73,7 +73,7 @@ PUREFUNC public int32_t Struct$compare(const void *x, const void *y, const TypeI 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) { + 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) @@ -99,7 +99,7 @@ PUREFUNC public int32_t Struct$compare(const void *x, const void *y, const TypeI return 0; } -PUREFUNC public bool Struct$equal(const void *x, const void *y, const TypeInfo_t *type) +PUREFUNC public bool Structヽequal(const void *x, const void *y, const TypeInfo_t *type) { if (x == y) return true; @@ -108,7 +108,7 @@ PUREFUNC public bool Struct$equal(const void *x, const void *y, const TypeInfo_t 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) { + 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) @@ -133,35 +133,35 @@ PUREFUNC public bool Struct$equal(const void *x, const void *y, const TypeInfo_t 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); + if (!obj) return Textヽfrom_str(type->StructInfo.name); - Text_t name = Text$from_str(type->StructInfo.name); + Text_t name = Textヽfrom_str(type->StructInfo.name); if (type->StructInfo.is_secret || type->StructInfo.is_opaque) { - return colorize ? Texts(Text("\x1b[0;1m"), name, Text("\x1b[m(...)")) : Texts(name, Text("(...)")); + return colorize ? Texts(Text("\x1b[0;1m"), name, Text("\x1b[m(...)")) : Texts(name, "(...)"); } - Text_t text = colorize ? Texts(Text("\x1b[0;1m"), name, Text("\x1b[m(")) : Texts(name, Text("(")); + Text_t text = colorize ? Texts(Text("\x1b[0;1m"), name, Text("\x1b[m(")) : Texts(name, "("); 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 (i > 0) - text = Text$concat(text, Text(", ")); + text = Textヽconcat(text, Text(", ")); if (type->StructInfo.num_fields > 1) - text = Text$concat(text, Text$from_str(field.name), Text("=")); + text = Textヽconcat(text, Textヽfrom_str(field.name), Text("=")); - if (field.type == &Bool$info) { + 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"))); + 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; @@ -174,25 +174,25 @@ PUREFUNC public Text_t Struct$as_text(const void *obj, bool colorize, const Type } if (field.type->align && byte_offset % field.type->align > 0) byte_offset += field.type->align - (byte_offset % field.type->align); - text = Text$concat(text, generic_as_text(obj + byte_offset, colorize, field.type)); + text = Textヽconcat(text, generic_as_text(obj + byte_offset, colorize, field.type)); byte_offset += field.type->size; } } - return Text$concat(text, Text(")")); + return Textヽconcat(text, Text(")")); } -PUREFUNC public bool Struct$is_none(const void *obj, const TypeInfo_t *type) +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) { + if (field.type == &Boolヽinfo) { bool b = ((*(char*)(obj + byte_offset)) >> bit_offset) & 0x1; fputc((int)b, out); bit_offset += 1; @@ -213,13 +213,13 @@ 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) { + if (field.type == &Boolヽinfo) { bool b = (bool)fgetc(in); *(char*)(outval + byte_offset) |= (b << bit_offset); bit_offset += 1; diff --git a/src/stdlib/structs.h b/src/stdlib/structs.h index c9c6c40a..c04df1fc 100644 --- a/src/stdlib/structs.h +++ b/src/stdlib/structs.h @@ -7,34 +7,34 @@ #include "types.h" #include "util.h" -PUREFUNC uint64_t Struct$hash(const void *obj, const TypeInfo_t *type); -PUREFUNC uint64_t PackedData$hash(const void *obj, const TypeInfo_t *type); -PUREFUNC int32_t Struct$compare(const void *x, const void *y, const TypeInfo_t *type); -PUREFUNC bool Struct$equal(const void *x, const void *y, const TypeInfo_t *type); -PUREFUNC bool PackedData$equal(const void *x, const void *y, const TypeInfo_t *type); -PUREFUNC Text_t Struct$as_text(const void *obj, bool colorize, const TypeInfo_t *type); -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); +PUREFUNC uint64_t Structヽhash(const void *obj, const TypeInfo_t *type); +PUREFUNC uint64_t PackedDataヽhash(const void *obj, const TypeInfo_t *type); +PUREFUNC int32_t Structヽcompare(const void *x, const void *y, const TypeInfo_t *type); +PUREFUNC bool Structヽequal(const void *x, const void *y, const TypeInfo_t *type); +PUREFUNC bool PackedDataヽequal(const void *x, const void *y, const TypeInfo_t *type); +PUREFUNC Text_t Structヽas_text(const void *obj, bool colorize, const TypeInfo_t *type); +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 9301914c..284b6e83 100644 --- a/src/stdlib/tables.c +++ b/src/stdlib/tables.c @@ -50,17 +50,17 @@ static TypeInfo_t MemoryPointer = { .tag=PointerInfo, .PointerInfo={ .sigil="@", - .pointed=&Memory$info, + .pointed=&Memoryヽinfo, }, - .metamethods=Pointer$metamethods, + .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, + .TableInfo={.key=&CStringヽinfo, .value=&MemoryPointer}, + .metamethods=Tableヽmetamethods, }; PUREFUNC static INLINE size_t entry_size(const TypeInfo_t *info) @@ -98,7 +98,7 @@ static INLINE void hshow(const Table_t *t) 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)); + 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]); @@ -108,7 +108,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; @@ -130,17 +130,17 @@ PUREFUNC public void *Table$get_raw(Table_t t, const void *key, const TypeInfo_t 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); + void *ret = Tableヽget_raw(*iter, key, type); if (ret) return ret; } 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); @@ -202,9 +202,9 @@ static void hashmap_resize_buckets(Table_t *t, uint32_t new_capacity, const Type t->bucket_info->count = new_capacity; t->bucket_info->last_free = new_capacity-1; // Rehash: - for (int64_t i = 0; i < Table$length(*t); i++) { + for (int64_t i = 0; i < Tableヽlength(*t); i++) { hdebug("Rehashing ", i, "\n"); - Table$set_bucket(t, GET_ENTRY(*t, i), i, type); + Tableヽset_bucket(t, GET_ENTRY(*t, i), i, type); } hshow(t); @@ -216,7 +216,7 @@ 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; @@ -230,7 +230,7 @@ public void *Table$reserve(Table_t *t, const void *key, const void *value, const hashmap_resize_buckets(t, 8, type); } else { // Check if we are clobbering a value: - void *value_home = Table$get_raw(*t, key, type); + void *value_home = Tableヽget_raw(*t, key, type); if (value_home) { // Update existing slot // Ensure that `value_home` is still inside t->entries, even if COW occurs ptrdiff_t offset = value_home - t->entries.data; @@ -256,7 +256,7 @@ public void *Table$reserve(Table_t *t, const void *key, const void *value, const if (!value && value_size > 0) { for (Table_t *iter = t->fallback; iter; iter = iter->fallback) { - value = Table$get_raw(*iter, key, type); + value = Tableヽget_raw(*iter, key, type); if (value) break; } } @@ -270,27 +270,27 @@ public void *Table$reserve(Table_t *t, const void *key, const void *value, const 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)); + Listヽinsert(&t->entries, buf, I(0), (int64_t)entry_size(type)); int64_t entry_index = t->entries.length-1; void *entry = GET_ENTRY(*t, entry_index); - Table$set_bucket(t, entry, entry_index, type); + Tableヽset_bucket(t, entry, entry_index, type); return entry + value_offset(type); } #ifdef __GNUC__ #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); + (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; + if (!t || Tableヽlength(*t) == 0) return; // TODO: this work doesn't need to be done if the key is already missing maybe_copy_on_write(t, type); @@ -358,7 +358,7 @@ public void Table$remove(Table_t *t, const void *key, const TypeInfo_t *type) // Last entry is being removed, so clear it out to be safe: memset(GET_ENTRY(*t, last_entry), 0, entry_size(type)); - List$remove_at(&t->entries, I(t->entries.length), I(1), (int64_t)entry_size(type)); + Listヽremove_at(&t->entries, I(t->entries.length), I(1), (int64_t)entry_size(type)); int64_t bucket_to_clear; if (prev) { // Middle (or end) of a chain @@ -381,26 +381,26 @@ public void Table$remove(Table_t *t, const void *key, const TypeInfo_t *type) hshow(t); } -CONSTFUNC public void *Table$entry(Table_t t, int64_t n) +CONSTFUNC public void *Tableヽentry(Table_t t, int64_t n) { - if (n < 1 || n > Table$length(t)) + if (n < 1 || n > Tableヽlength(t)) return NULL; return GET_ENTRY(t, n-1); } -public void Table$clear(Table_t *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) +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); + 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; @@ -419,7 +419,7 @@ PUREFUNC public bool Table$equal(const void *vx, const void *vy, const TypeInfo_ 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 *y_value = Table$get_raw(*y, x_key, type); + 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)) @@ -428,7 +428,7 @@ PUREFUNC public bool Table$equal(const void *vx, const void *vy, const TypeInfo_ 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; @@ -458,7 +458,7 @@ PUREFUNC public int32_t Table$compare(const void *vx, const void *vy, const Type max_x_key = key; void *x_value = key + value_offset(type); - void *y_value = Table$get_raw(*y, key, 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) @@ -475,7 +475,7 @@ PUREFUNC public int32_t Table$compare(const void *vx, const void *vy, const Type max_y_key = key; void *y_value = key + value_offset(type); - void *x_value = Table$get_raw(*x, key, 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; @@ -483,8 +483,8 @@ PUREFUNC public int32_t Table$compare(const void *vx, const void *vy, const Type } if (mismatched_key) { - void *x_value = Table$get_raw(*x, mismatched_key, type); - void *y_value = Table$get_raw(*y, mismatched_key, type); + void *x_value = Tableヽget_raw(*x, mismatched_key, type); + void *y_value = Tableヽget_raw(*y, mismatched_key, type); if (x_value && y_value) { return generic_compare(x_value, y_value, table.value); } else if (y_value) { @@ -515,7 +515,7 @@ PUREFUNC public int32_t Table$compare(const void *vx, const void *vy, const Type for (int64_t i = 0; i < x->entries.length; i++) { void *key = x->entries.data + x->entries.stride * i; void *x_value = key + value_offset(type); - void *y_value = Table$get_raw(*y, key, type); + void *y_value = Tableヽget_raw(*y, key, type); int32_t diff = generic_compare(x_value, y_value, table.value); if (diff != 0) return diff; } @@ -530,7 +530,7 @@ 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; @@ -560,7 +560,7 @@ PUREFUNC public uint64_t Table$hash(const void *obj, const TypeInfo_t *type) t->entries.length, keys_hash, values_hash, - t->fallback ? Table$hash(t->fallback, type) : 0, + t->fallback ? Tableヽhash(t->fallback, type) : 0, }; t->hash = siphash24((void*)&components, sizeof(components)); if unlikely (t->hash == 0) @@ -568,47 +568,47 @@ PUREFUNC public uint64_t Table$hash(const void *obj, const TypeInfo_t *type) return t->hash; } -public Text_t Table$as_text(const void *obj, bool colorize, const TypeInfo_t *type) +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( + 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( + 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++) { + 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(", ")); + 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) - text = Text$concat(text, Text("="), generic_as_text(entry + val_off, colorize, table.value)); + text = Textヽconcat(text, generic_as_text(entry, colorize, table.key)); + if (table.value != &Voidヽinfo) + text = Textヽconcat(text, Text("="), generic_as_text(entry + val_off, colorize, table.value)); } if (t->fallback) { - text = Text$concat(text, Text("; fallback="), Table$as_text(t->fallback, colorize, type)); + text = Textヽconcat(text, Text("; fallback="), Tableヽas_text(t->fallback, colorize, type)); } - text = Text$concat(text, table.value == &Void$info ? Text("|") : Text("}")); + text = Textヽconcat(text, table.value == &Voidヽinfo ? Text("|") : Text("}")); 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) @@ -625,92 +625,92 @@ public Table_t Table$from_entries(List_t entries, const TypeInfo_t *type) size_t offset = value_offset(type); for (int64_t i = 0; i < entries.length; i++) { void *key = entries.data + i*entries.stride; - Table$set(&t, key, key + offset, type); + 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); for (Table_t *t = &a; t; t = t->fallback) { - for (int64_t i = 0; i < Table$length(*t); i++) { + for (int64_t i = 0; i < Tableヽlength(*t); i++) { void *key = GET_ENTRY(*t, i); void *a_value = key + offset; - void *b_value = Table$get(b, key, type); + void *b_value = Tableヽget(b, key, type); if (b_value && generic_equal(a_value, b_value, type->TableInfo.value)) - Table$set(&result, key, a_value, type); + Tableヽset(&result, key, a_value, type); } } return result; } // With is "set union" in formal terms -public Table_t Table$with(Table_t a, Table_t b, const TypeInfo_t *type) +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) { - for (int64_t i = 0; i < Table$length(*t); i++) { + for (int64_t i = 0; i < Tableヽlength(*t); i++) { void *key = GET_ENTRY(*t, i); - Table$set(&result, key, key + offset, type); + 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++) { + for (int64_t i = 0; i < Tableヽlength(*t); i++) { void *key = GET_ENTRY(*t, i); - Table$set(&result, key, key + offset, type); + Tableヽset(&result, key, key + offset, type); } } return result; } // 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++) { + 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++) { + 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); for (Table_t *t = &a; t; t = t->fallback) { - for (int64_t i = 0; i < Table$length(*t); i++) { + for (int64_t i = 0; i < Tableヽlength(*t); i++) { void *key = GET_ENTRY(*t, i); void *a_value = key + offset; - void *b_value = Table$get(b, key, type); + void *b_value = Tableヽget(b, key, type); if (!b_value || !generic_equal(a_value, b_value, type->TableInfo.value)) - Table$set(&result, key, a_value, type); + Tableヽset(&result, key, a_value, 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; @@ -723,66 +723,66 @@ 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) +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); + for (int64_t i = 0; i < Tableヽlength(a); i++) { + void *found = Tableヽget_raw(b, GET_ENTRY(a, i), type); if (!found) return false; } 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); + 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); + 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); + 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); + return Tableヽreserve(t, &key, &value, &CStrToVoidStarTable); } -public void Table$str_set(Table_t *t, const char *key, const void *value) +public void Tableヽstr_set(Table_t *t, const char *key, const void *value) { - Table$set(t, &key, &value, &CStrToVoidStarTable); + Tableヽset(t, &key, &value, &CStrToVoidStarTable); } -public void Table$str_remove(Table_t *t, const char *key) +public void Tableヽstr_remove(Table_t *t, const char *key) { - return Table$remove(t, &key, &CStrToVoidStarTable); + return Tableヽremove(t, &key, &CStrToVoidStarTable); } -CONSTFUNC public void *Table$str_entry(Table_t t, int64_t n) +CONSTFUNC public void *Tableヽstr_entry(Table_t t, int64_t n) { - return Table$entry(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; } -public void Table$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) +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); + Int64ヽserialize(&len, out, pointers, &Int64ヽinfo); size_t offset = value_offset(type); for (int64_t i = 0; i < len; i++) { @@ -793,17 +793,17 @@ public void Table$serialize(const void *obj, FILE *out, Table_t *pointers, const assert(fputc(t->fallback != NULL ? 1 : 0, out) != EOF); if (t->fallback) - Table$serialize(t->fallback, out, pointers, type); + 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); + Int64ヽdeserialize(in, &len, pointers, &Intヽinfo); Table_t t = {}; for (int64_t i = 0; i < len; i++) { @@ -812,12 +812,12 @@ public void Table$deserialize(FILE *in, void *outval, List_t *pointers, const Ty char value[type->TableInfo.value->size]; if (type->TableInfo.value->size > 0) _deserialize(in, value, pointers, type->TableInfo.value); - Table$set(&t, key, value, type); + Tableヽset(&t, key, value, type); } if (fgetc(in) != 0) { t.fallback = GC_MALLOC(sizeof(Table_t)); - Table$deserialize(in, t.fallback, pointers, type); + Tableヽdeserialize(in, t.fallback, pointers, type); } *(Table_t*)outval = t; diff --git a/src/stdlib/tables.h b/src/stdlib/tables.h index f80c16c3..eac8c7d8 100644 --- a/src/stdlib/tables.h +++ b/src/stdlib/tables.h @@ -13,94 +13,94 @@ #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){ \ + 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ヽ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){ \ + 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ヽ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) ({ \ +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); \ + 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) ({ \ +#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) ({ \ + 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); \ + val_t *v = Tableヽget(t, &k, info_expr); \ v ? *v : default_expr; }) -#define Table$has_value(table_expr, key_expr, info_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); }) -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); }) + (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); }) +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); }) -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); -Table_t Table$without(Table_t a, Table_t b, const TypeInfo_t *type); -Table_t Table$xor(Table_t a, Table_t b, const TypeInfo_t *type); -Table_t Table$with_fallback(Table_t t, OptionalTable_t fallback); -PUREFUNC bool Table$is_subset_of(Table_t a, Table_t b, bool strict, const TypeInfo_t *type); -PUREFUNC bool Table$is_superset_of(Table_t a, Table_t b, bool strict, const TypeInfo_t *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); +Table_t Tableヽwithout(Table_t a, Table_t b, const TypeInfo_t *type); +Table_t Tableヽxor(Table_t a, Table_t b, const TypeInfo_t *type); +Table_t Tableヽwith_fallback(Table_t t, OptionalTable_t fallback); +PUREFUNC bool Tableヽis_subset_of(Table_t a, Table_t b, bool strict, const TypeInfo_t *type); +PUREFUNC bool Tableヽis_superset_of(Table_t a, Table_t b, bool strict, const TypeInfo_t *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); +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; }) -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 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*); -CONSTFUNC void *Table$str_entry(Table_t t, int64_t n); -PUREFUNC void *Table$str_get(Table_t t, const char *key); -PUREFUNC void *Table$str_get_raw(Table_t t, const char *key); -void Table$str_set(Table_t *t, const char *key, const void *value); -void *Table$str_reserve(Table_t *t, const char *key, const void *value); -void Table$str_remove(Table_t *t, const char *key); -void Table$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type); -void Table$deserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *type); +CONSTFUNC void *Tableヽstr_entry(Table_t t, int64_t n); +PUREFUNC void *Tableヽstr_get(Table_t t, const char *key); +PUREFUNC void *Tableヽstr_get_raw(Table_t t, const char *key); +void Tableヽstr_set(Table_t *t, const char *key, const void *value); +void *Tableヽstr_reserve(Table_t *t, const char *key, const void *value); +void Tableヽstr_remove(Table_t *t, const char *key); +void Tableヽserialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type); +void Tableヽdeserialize(FILE *in, void *outval, List_t *pointers, const TypeInfo_t *type); -#define Table$length(t) ((t).entries.length) +#define Tableヽlength(t) ((t).entries.length) 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 8ef0874e..ec444bfe 100644 --- a/src/stdlib/text.c +++ b/src/stdlib/text.c @@ -195,8 +195,8 @@ public int32_t get_synthetic_grapheme(const ucs4_t *codepoints, int64_t utf32_le 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); - int32_t *found = Table$get(grapheme_ids_by_codepoints, &ptr, &GraphemeIDLookupTableInfo); + TypeInfo_t GraphemeIDLookupTableInfo = *Tableヽinfo(&GraphemeClusterInfo, &Int32ヽinfo); + int32_t *found = Tableヽget(grapheme_ids_by_codepoints, &ptr, &GraphemeIDLookupTableInfo); if (found) return *found; // New synthetic grapheme: @@ -266,7 +266,7 @@ public int32_t get_synthetic_grapheme(const ucs4_t *codepoints, int64_t utf32_le // Cleanup from unicode API: if (u8 != u8_buf) free(u8); - Table$set(&grapheme_ids_by_codepoints, &codepoint_copy, &grapheme_id, &GraphemeIDLookupTableInfo); + Tableヽset(&grapheme_ids_by_codepoints, &codepoint_copy, &grapheme_id, &GraphemeIDLookupTableInfo); last_grapheme = grapheme_id; return grapheme_id; @@ -275,7 +275,7 @@ 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; @@ -321,8 +321,8 @@ public int Text$print(FILE *stream, Text_t t) return written; } case TEXT_CONCAT: { - int written = Text$print(stream, *t.left); - written += Text$print(stream, *t.right); + int written = Textヽprint(stream, *t.left); + written += Textヽprint(stream, *t.right); return written; } default: return 0; @@ -478,8 +478,8 @@ 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 first_b = Text$get_grapheme(b, 0); + 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: static const int32_t LOWEST_CODEPOINT_TO_CHECK = 0x300; // COMBINING GRAVE ACCENT @@ -525,7 +525,7 @@ static Text_t concat2(Text_t a, Text_t b) 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); @@ -533,16 +533,16 @@ static Text_t concat2(Text_t a, Text_t b) 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))); + 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); + 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))); + 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; @@ -554,35 +554,35 @@ public Text_t Text$_concat(int n, Text_t items[n]) return ret; } -public Text_t Text$repeat(Text_t text, Int_t count) +public Text_t Textヽrepeat(Text_t text, Int_t count) { - if (text.length == 0 || Int$is_negative(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) + 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!"); - int64_t count64 = Int64$from_int(count, false); + int64_t count64 = Int64ヽfrom_int(count, false); Text_t ret = text; for (int64_t c = 1; c < count64; c++) ret = concat2(ret, text); return ret; } -public Int_t Text$width(Text_t text, Text_t 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); + 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) +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); + 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); Text_t repeated = EMPTY_TEXT; int64_t repeated_width = 0; while (repeated_width + width <= target_width) { @@ -592,10 +592,10 @@ 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 = concat2(repeated, Textヽrepeat(Text(" "), I(target_width - repeated_width))); repeated_width = target_width; break; } @@ -607,37 +607,37 @@ 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) +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); + 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) +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)); + 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) +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)); + 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)); } -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); + 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"); if (last == 0) return EMPTY_TEXT; @@ -660,8 +660,8 @@ public Text_t Text$slice(Text_t text, Int_t first_int, Int_t last_int) last -= text.left->length; 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))); + return concat2_assuming_safe(Textヽslice(*text.left, I(first), I(text.length)), + Textヽslice(*text.right, I(1), I(last-text.left->length))); } } @@ -694,17 +694,17 @@ 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) +public Text_t Textヽfrom(Text_t text, Int_t first) { - return Text$slice(text, first, I_small(-1)); + return Textヽslice(text, first, I_small(-1)); } -public Text_t Text$to(Text_t text, Int_t last) +public Text_t Textヽto(Text_t text, Int_t last) { - return Text$slice(text, I_small(1), 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: { @@ -739,19 +739,19 @@ public Text_t Text$reversed(Text_t text) return ret; } case TEXT_CONCAT: { - return concat2_assuming_safe(Text$reversed(*text.right), Text$reversed(*text.left)); + return concat2_assuming_safe(Textヽreversed(*text.right), Textヽreversed(*text.left)); } default: errx(1, "Invalid tag"); } return EMPTY_TEXT; } -public PUREFUNC Text_t Text$cluster(Text_t text, Int_t index) +public PUREFUNC Text_t Textヽcluster(Text_t text, Int_t index) { - return Text$slice(text, index, index); + return Textヽslice(text, index, index); } -static Text_t Text$from_components(List_t graphemes, Table_t unique_clusters) +static Text_t Textヽfrom_components(List_t graphemes, Table_t unique_clusters) { struct { int32_t map[unique_clusters.entries.length]; @@ -771,7 +771,7 @@ static Text_t Text$from_components(List_t graphemes, Table_t unique_clusters) } for (int64_t i = 0; i < graphemes.length; i++) { int32_t g = *(int32_t*)(graphemes.data + i*graphemes.stride); - uint8_t *byte = Table$get(unique_clusters, &g, Table$info(&Int32$info, &Byte$info)); + uint8_t *byte = Tableヽget(unique_clusters, &g, Tableヽinfo(&Int32ヽinfo, &Byteヽinfo)); assert(byte); blob->bytes[i] = *byte; } @@ -787,7 +787,7 @@ static Text_t Text$from_components(List_t graphemes, Table_t unique_clusters) } } -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++) @@ -820,23 +820,23 @@ public OptionalText_t Text$from_strn(const char *str, size_t len) 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)); + 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)); 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(next, (size_t)(end-next))); + return concat2_assuming_safe(Textヽfrom_components(graphemes, unique_clusters), Textヽfrom_strn(next, (size_t)(end-next))); } } - return Text$from_components(graphemes, unique_clusters); + return Textヽfrom_components(graphemes, unique_clusters); } -public OptionalText_t Text$from_str(const char *str) +public OptionalText_t Textヽfrom_str(const char *str) { - return str ? Text$from_strn(str, strlen(str)) : Text(""); + 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) @@ -924,7 +924,7 @@ 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); @@ -939,7 +939,7 @@ 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; @@ -983,12 +983,12 @@ PUREFUNC public uint64_t Text$hash(const void *obj, const TypeInfo_t *info) 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[0] = Textヽget_grapheme_fast(&state, i); + 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"); @@ -996,7 +996,7 @@ 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; @@ -1047,13 +1047,13 @@ 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); + 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; @@ -1064,8 +1064,8 @@ PUREFUNC public int32_t Text$compare(const void *va, const void *vb, const TypeI int64_t len = MAX(a.length, b.length); TextIter_t a_state = NEW_TEXT_ITER_STATE(a), b_state = NEW_TEXT_ITER_STATE(b); for (int64_t i = 0; i < len; i++) { - int32_t ai = Text$get_grapheme_fast(&a_state, i); - int32_t bi = Text$get_grapheme_fast(&b_state, i); + int32_t ai = Textヽget_grapheme_fast(&a_state, i); + int32_t bi = Textヽget_grapheme_fast(&b_state, i); if (ai == bi) continue; int32_t cmp; if (ai > 0 && bi > 0) { @@ -1095,20 +1095,20 @@ PUREFUNC public int32_t Text$compare(const void *va, const void *vb, const TypeI 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); + int32_t text_i = Textヽget_grapheme_fast(text_state, pos + i); + int32_t prefix_i = Textヽget_grapheme_fast(target_state, i); if (text_i != prefix_i) return false; } return true; } -PUREFUNC public bool Text$starts_with(Text_t text, Text_t prefix, Text_t *remainder) +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)); + if (remainder) *remainder = Textヽfrom(text, Intヽfrom_int64(prefix.length + 1)); return true; } else { if (remainder) *remainder = text; @@ -1116,13 +1116,13 @@ 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) +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)); + if (remainder) *remainder = Textヽto(text, Intヽfrom_int64(text.length - suffix.length)); return true; } else { if (remainder) *remainder = text; @@ -1130,45 +1130,45 @@ 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, false) ? Text$slice(text, I(prefix.length + 1), I(text.length)) : text; + return Textヽstarts_with(text, prefix, false) ? 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, false) ? Text$slice(text, I(1), I(text.length - suffix.length)) : text; + return Textヽends_with(text, suffix, false) ? Textヽslice(text, I(1), I(text.length - suffix.length)) : text; } 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)) { + if (g == Textヽget_grapheme_fast(text, t)) { return true; } } 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) { - while (first < text.length && _has_grapheme(&trim_state, Text$get_grapheme_fast(&text_state, first))) { + while (first < text.length && _has_grapheme(&trim_state, Textヽget_grapheme_fast(&text_state, first))) { first += 1; } } int64_t last = text.length-1; if (right) { - while (last >= first && _has_grapheme(&trim_state, Text$get_grapheme_fast(&text_state, last))) { + 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; @@ -1180,7 +1180,7 @@ public Text_t Text$translate(Text_t text, Table_t translations) 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))); + result = concat2(result, Textヽslice(text, I(span_start+1), I(i))); result = concat2(result, entry->replacement); i += entry->target.length; @@ -1192,11 +1192,11 @@ public Text_t Text$translate(Text_t text, Table_t translations) found_match: continue; } if (span_start < text.length) - result = concat2(result, Text$slice(text, I(span_start+1), I(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; @@ -1204,7 +1204,7 @@ public Text_t Text$replace(Text_t text, Text_t target, Text_t replacement) 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))); + result = concat2(result, Textヽslice(text, I(span_start+1), I(i))); result = concat2(result, replacement); i += target.length; @@ -1214,11 +1214,11 @@ public Text_t Text$replace(Text_t text, Text_t target, Text_t replacement) } } if (span_start < text.length) - result = concat2(result, Text$slice(text, I(span_start+1), I(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++) { @@ -1228,10 +1228,10 @@ public PUREFUNC bool Text$has(Text_t text, Text_t target) return false; } -public List_t Text$split(Text_t text, Text_t delimiters) +public List_t Textヽsplit(Text_t text, Text_t delimiters) { if (delimiters.length == 0) - return Text$clusters(text); + return Textヽclusters(text); TextIter_t text_state = NEW_TEXT_ITER_STATE(text), delim_state = NEW_TEXT_ITER_STATE(delimiters); List_t splits = {}; @@ -1240,18 +1240,18 @@ public List_t Text$split(Text_t text, Text_t delimiters) 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)); - List$insert(&splits, &slice, I(0), sizeof(slice)); + 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) { Text_t empty = Text(""); - List$insert(&splits, &empty, I(0), sizeof(empty)); + Listヽinsert(&splits, &empty, I(0), sizeof(empty)); } } return splits; } -public List_t Text$split_any(Text_t text, Text_t delimiters) +public List_t Textヽsplit_any(Text_t text, Text_t delimiters) { if (delimiters.length == 0) return List(text); @@ -1260,19 +1260,19 @@ public List_t Text$split_any(Text_t text, Text_t delimiters) List_t splits = {}; 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)); - List$insert(&splits, &slice, I(0), sizeof(slice)); + 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))) { + while (i < text.length && _has_grapheme(&delim_state, Textヽget_grapheme_fast(&text_state, i))) { i += 1; } if (i >= text.length && trailing_delim) { Text_t empty = Text(""); - List$insert(&splits, &empty, I(0), sizeof(empty)); + Listヽinsert(&splits, &empty, I(0), sizeof(empty)); } } return splits; @@ -1306,12 +1306,12 @@ 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, @@ -1331,7 +1331,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; } @@ -1339,19 +1339,19 @@ 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))) { + while (i < text.length && _has_grapheme(&delim_state, Textヽget_grapheme_fast(&state->state, i))) { i += 1; } state->i = i; 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, @@ -1359,7 +1359,7 @@ public Closure_t Text$by_split_any(Text_t text, Text_t delimiters) }; } -PUREFUNC public bool Text$equal_values(Text_t a, Text_t b) +PUREFUNC public bool Textヽequal_values(Text_t a, Text_t b) { if (a.length != b.length) return false; @@ -1367,30 +1367,30 @@ PUREFUNC public bool Text$equal_values(Text_t a, Text_t b) TextIter_t a_state = NEW_TEXT_ITER_STATE(a), b_state = NEW_TEXT_ITER_STATE(b); // TODO: make this smarter and more efficient for (int64_t i = 0; i < len; i++) { - int32_t ai = Text$get_grapheme_fast(&a_state, i); - int32_t bi = Text$get_grapheme_fast(&b_state, i); + int32_t ai = Textヽget_grapheme_fast(&a_state, i); + int32_t bi = Textヽget_grapheme_fast(&b_state, i); if (ai != bi) return false; } 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) +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); + const char *uc_language = Textヽas_c_string(language); for (int64_t i = 0; i < len; i++) { - int32_t ai = Text$get_grapheme_fast(&a_state, i); - int32_t bi = Text$get_grapheme_fast(&b_state, i); + 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); int64_t a_len = ai >= 0 ? 1 : NUM_GRAPHEME_CODEPOINTS(ai); @@ -1407,54 +1407,54 @@ PUREFUNC public bool Text$equal_ignoring_case(Text_t a, Text_t b, Text_t languag 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); + 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); + 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); + 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) +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); + 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))); \ + ret = concat2_assuming_safe(ret, Textヽslice(text, I(i-unquoted_span+1), I(i))); \ unquoted_span = 0; \ } }) #define add_escaped(str) ({ \ @@ -1466,7 +1466,7 @@ public Text_t Text$quoted(Text_t text, bool colorize, Text_t quotation_mark) int64_t unquoted_span = 0; int64_t i = 0; for (i = 0; i < text.length; i++) { - int32_t g = Text$get_grapheme_fast(&state, i); + int32_t g = Textヽget_grapheme_fast(&state, i); switch (g) { case '\a': add_escaped("a"); break; case '\b': add_escaped("b"); break; @@ -1494,7 +1494,7 @@ public Text_t Text$quoted(Text_t text, bool colorize, Text_t quotation_mark) (g & 15) > 9 ? 'a' + (g & 15) - 10 : '0' + (g & 15), '\0', }; - ret = concat2_assuming_safe(ret, Text$from_strn(tmp, 2)); + ret = concat2_assuming_safe(ret, Textヽfrom_strn(tmp, 2)); if (colorize) ret = concat2_assuming_safe(ret, Text("\x1b[0;35m")); break; @@ -1524,10 +1524,10 @@ public Text_t Text$quoted(Text_t text, bool colorize, Text_t quotation_mark) 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"); + if (!vtext) return info && info->TextInfo.lang ? Textヽfrom_str(info->TextInfo.lang) : Text("Text"); Text_t text = *(Text_t*)vtext; // Figure out the best quotation mark to use: @@ -1535,7 +1535,7 @@ public Text_t Text$as_text(const void *vtext, bool colorize, const TypeInfo_t *i 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); + int32_t g = Textヽget_grapheme_fast(&state, i); if (g == '"') { has_double_quote = true; } else if (g == '`') { @@ -1560,58 +1560,58 @@ public Text_t Text$as_text(const void *vtext, bool colorize, const TypeInfo_t *i else quote = Text("\""); - Text_t as_text = Text$quoted(text, colorize, quote); - if (info && info->TextInfo.lang && info != &Text$info) - as_text = Text$concat( + 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(""), + Textヽfrom_str(info->TextInfo.lang), + colorize ? Text("\x1b[0m") : EMPTY_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; 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)); - List$insert(&clusters, &cluster, I_small(0), sizeof(Text_t)); + Text_t cluster = Textヽslice(text, I(i), I(i)); + Listヽinsert(&clusters, &cluster, I_small(0), sizeof(Text_t)); } return clusters; } -public List_t Text$utf32_codepoints(Text_t text) +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); + int32_t grapheme = Textヽget_grapheme_fast(&state, i); if (grapheme < 0) { for (int64_t c = 0; c < NUM_GRAPHEME_CODEPOINTS(grapheme); c++) { ucs4_t subg = GRAPHEME_CODEPOINTS(grapheme)[c]; - List$insert(&codepoints, &subg, I_small(0), sizeof(ucs4_t)); + Listヽinsert(&codepoints, &subg, I_small(0), sizeof(ucs4_t)); } } else { - List$insert(&codepoints, &grapheme, I_small(0), sizeof(ucs4_t)); + Listヽinsert(&codepoints, &grapheme, I_small(0), sizeof(ucs4_t)); } } 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); + const char *str = Textヽas_c_string(text); return (List_t){.length=(int64_t)strlen(str), .stride=1, .atomic=1, .data=(void*)str}; } @@ -1625,31 +1625,31 @@ static INLINE const char *codepoint_name(ucs4_t c) 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++) { - int32_t grapheme = Text$get_grapheme_fast(&state, i); + int32_t grapheme = Textヽget_grapheme_fast(&state, i); if (grapheme < 0) { for (int64_t c = 0; c < NUM_GRAPHEME_CODEPOINTS(grapheme); c++) { const char *name = codepoint_name(GRAPHEME_CODEPOINTS(grapheme)[c]); - Text_t name_text = Text$from_str(name); - List$insert(&names, &name_text, I_small(0), sizeof(Text_t)); + Text_t name_text = Textヽfrom_str(name); + Listヽinsert(&names, &name_text, I_small(0), sizeof(Text_t)); } } else { const char *name = codepoint_name((ucs4_t)grapheme); - Text_t name_text = Text$from_str(name); - List$insert(&names, &name_text, I_small(0), sizeof(Text_t)); + Text_t name_text = Textヽfrom_str(name); + Listヽinsert(&names, &name_text, I_small(0), sizeof(Text_t)); } } return names; } -public Text_t Text$from_codepoints(List_t codepoints) +public Text_t Textヽfrom_codepoints(List_t codepoints) { if (codepoints.stride != sizeof(uint32_t)) - List$compact(&codepoints, sizeof(uint32_t)); + Listヽcompact(&codepoints, sizeof(uint32_t)); List_t graphemes = {}; Table_t unique_clusters = {}; @@ -1663,10 +1663,10 @@ public Text_t Text$from_codepoints(List_t codepoints) 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( + 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ヽinfo(&Int32ヽinfo, &Byteヽinfo)); if (u32s_normalized != buf) free(u32s_normalized); @@ -1676,52 +1676,52 @@ public Text_t Text$from_codepoints(List_t codepoints) .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); + 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)); - const char *name_str = Text$as_c_string(*name); + const char *name_str = Textヽas_c_string(*name); ucs4_t codepoint = unicode_name_character(name_str); if (codepoint == UNINAME_INVALID) return NONE_TEXT; - List$insert(&codepoints, &codepoint, I_small(0), sizeof(ucs4_t)); + Listヽinsert(&codepoints, &codepoint, I_small(0), sizeof(ucs4_t)); } - return Text$from_codepoints(codepoints); + return Textヽfrom_codepoints(codepoints); } -public OptionalText_t Text$from_bytes(List_t bytes) +public OptionalText_t Textヽfrom_bytes(List_t bytes) { if (bytes.stride != sizeof(int8_t)) - List$compact(&bytes, sizeof(int8_t)); + Listヽcompact(&bytes, sizeof(int8_t)); - return Text$from_strn(bytes.data, (size_t)bytes.length); + 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)); - List$insert(&lines, &line, I_small(0), sizeof(Text_t)); + 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)); + 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)); - List$insert(&lines, &line, I_small(0), sizeof(Text_t)); + 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)); - List$insert(&lines, &line, I_small(0), sizeof(Text_t)); + Text_t line = Textヽslice(text, I(line_start+1), I(i+1)); + Listヽinsert(&lines, &line, I_small(0), sizeof(Text_t)); } } return lines; @@ -1736,17 +1736,17 @@ 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)); + 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)); 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)); + Text_t line = Textヽslice(text, I(state->i+1), I(i+1)); state->i = i + 1; return line; } @@ -1754,7 +1754,7 @@ 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, @@ -1762,73 +1762,73 @@ public Closure_t Text$by_line(Text_t text) }; } -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; } -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])); + 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])); + 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: ", 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(")")); + 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(")")); + 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(")")); + 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(")")); + return Texts(Text("Concat("), Textヽlayout(*text.left), Text(", "), Textヽlayout(*text.right), Text(")")); default: errx(1, "Invalid text tag: ", 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); + 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); + 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); + *(Text_t*)out = Textヽfrom_strn(buf, (size_t)len); } -public const TypeInfo_t Text$info = { +public const TypeInfo_t Textヽinfo = { .size=sizeof(Text_t), .align=__alignof__(Text_t), .tag=TextInfo, .TextInfo={.lang="Text"}, - .metamethods=Text$metamethods, + .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 637a3db7..87e7dcb5 100644 --- a/src/stdlib/text.h +++ b/src/stdlib/text.h @@ -35,82 +35,82 @@ 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 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); -Text_t Text$from(Text_t text, Int_t first); -Text_t Text$to(Text_t text, Int_t last); -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 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*); -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); -Text_t Text$as_text(const void *text, bool colorize, const TypeInfo_t *info); -Text_t Text$quoted(Text_t str, bool colorize, Text_t quotation_mark); -PUREFUNC bool Text$starts_with(Text_t text, Text_t prefix, Text_t *remainder); -PUREFUNC bool Text$ends_with(Text_t text, Text_t suffix, Text_t *remainder); -Text_t Text$without_prefix(Text_t text, Text_t prefix); -Text_t Text$without_suffix(Text_t text, Text_t suffix); -Text_t Text$replace(Text_t text, Text_t target, Text_t replacement); -Text_t Text$translate(Text_t text, Table_t translations); -PUREFUNC bool Text$has(Text_t text, Text_t target); -List_t Text$split(Text_t text, Text_t delimiter); -List_t Text$split_any(Text_t text, Text_t delimiters); -Closure_t Text$by_split(Text_t text, Text_t delimiter); -Closure_t Text$by_split_any(Text_t text, Text_t delimiters); -Text_t Text$trim(Text_t text, Text_t to_trim, bool left, bool right); -char *Text$as_c_string(Text_t text); -List_t Text$clusters(Text_t text); -List_t Text$utf32_codepoints(Text_t text); -List_t Text$utf8_bytes(Text_t text); -List_t Text$codepoint_names(Text_t text); -Text_t Text$from_codepoints(List_t codepoints); -OptionalText_t Text$from_codepoint_names(List_t codepoint_names); -OptionalText_t Text$from_bytes(List_t bytes); -List_t Text$lines(Text_t text); -Closure_t Text$by_line(Text_t text); -Text_t Text$join(Text_t glue, List_t pieces); -Text_t Text$repeat(Text_t text, Int_t count); -Int_t Text$width(Text_t text, Text_t language); -Text_t Text$left_pad(Text_t text, Int_t width, Text_t padding, Text_t language); -Text_t Text$right_pad(Text_t text, Int_t width, Text_t padding, Text_t language); -Text_t Text$middle_pad(Text_t text, Int_t width, Text_t padding, Text_t language); -int32_t Text$get_grapheme_fast(TextIter_t *state, int64_t index); -uint32_t Text$get_main_grapheme_fast(TextIter_t *state, int64_t index); -Int_t Text$memory_size(Text_t text); -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 *); +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 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); +Text_t Textヽfrom(Text_t text, Int_t first); +Text_t Textヽto(Text_t text, Int_t last); +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 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*); +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); +Text_t Textヽas_text(const void *text, bool colorize, const TypeInfo_t *info); +Text_t Textヽquoted(Text_t str, bool colorize, Text_t quotation_mark); +PUREFUNC bool Textヽstarts_with(Text_t text, Text_t prefix, Text_t *remainder); +PUREFUNC bool Textヽends_with(Text_t text, Text_t suffix, Text_t *remainder); +Text_t Textヽwithout_prefix(Text_t text, Text_t prefix); +Text_t Textヽwithout_suffix(Text_t text, Text_t suffix); +Text_t Textヽreplace(Text_t text, Text_t target, Text_t replacement); +Text_t Textヽtranslate(Text_t text, Table_t translations); +PUREFUNC bool Textヽhas(Text_t text, Text_t target); +List_t Textヽsplit(Text_t text, Text_t delimiter); +List_t Textヽsplit_any(Text_t text, Text_t delimiters); +Closure_t Textヽby_split(Text_t text, Text_t delimiter); +Closure_t Textヽby_split_any(Text_t text, Text_t delimiters); +Text_t Textヽtrim(Text_t text, Text_t to_trim, bool left, bool right); +char *Textヽas_c_string(Text_t text); +List_t Textヽclusters(Text_t text); +List_t Textヽutf32_codepoints(Text_t text); +List_t Textヽutf8_bytes(Text_t text); +List_t Textヽcodepoint_names(Text_t text); +Text_t Textヽfrom_codepoints(List_t codepoints); +OptionalText_t Textヽfrom_codepoint_names(List_t codepoint_names); +OptionalText_t Textヽfrom_bytes(List_t bytes); +List_t Textヽlines(Text_t text); +Closure_t Textヽby_line(Text_t text); +Text_t Textヽjoin(Text_t glue, List_t pieces); +Text_t Textヽrepeat(Text_t text, Int_t count); +Int_t Textヽwidth(Text_t text, Text_t language); +Text_t Textヽleft_pad(Text_t text, Int_t width, Text_t padding, Text_t language); +Text_t Textヽright_pad(Text_t text, Int_t width, Text_t padding, Text_t language); +Text_t Textヽmiddle_pad(Text_t text, Int_t width, Text_t padding, Text_t language); +int32_t Textヽget_grapheme_fast(TextIter_t *state, int64_t index); +uint32_t Textヽget_main_grapheme_fast(TextIter_t *state, int64_t index); +Int_t Textヽmemory_size(Text_t text); +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); + return Textヽget_grapheme_fast(&state, index); } -extern const TypeInfo_t Text$info; +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 0f51d6ea..f12bcaa1 100644 --- a/src/stdlib/types.c +++ b/src/stdlib/types.c @@ -12,20 +12,20 @@ #include "text.h" #include "types.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( + return Textヽconcat( Text("\x1b[36;1m"), - Text$from_str(type->TypeInfoInfo.type_str), + Textヽfrom_str(type->TypeInfoInfo.type_str), Text("\x1b[m")); else - return Text$from_str(type->TypeInfoInfo.type_str); + 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..c890f07e 100644 --- a/src/stdlib/types.h +++ b/src/stdlib/types.h @@ -78,15 +78,15 @@ struct TypeInfo_s { }; }; -extern const TypeInfo_t Void$info; -extern const TypeInfo_t Abort$info; +extern const TypeInfo_t Voidヽinfo; +extern const TypeInfo_t Abortヽinfo; #define Void_t void -Text_t Type$as_text(const void *typeinfo, bool colorize, const TypeInfo_t *type); +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), \ +#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}}) + .metamethods={.serialize=cannot_serialize, .deserialize=cannot_deserialize, .as_text=Typeヽas_text}}) #define DEFINE_OPTIONAL_TYPE(t, unpadded_size, name) \ typedef struct { \ diff --git a/src/stdlib/util.h b/src/stdlib/util.h index 3b00e6e9..499f89cc 100644 --- a/src/stdlib/util.h +++ b/src/stdlib/util.h @@ -19,7 +19,7 @@ #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"))) |