Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-foundation

Source of release 0.6.0

0.6.0 / src / ak / string_1.lucb

#==============================================================================================
#
#   string_1 - String: creation from UTF-8, UTF-16, streams, builders and code points
#
#   DESCRIPTION:
#       Port of AK/String.h (lines 1-289) and AK/String.cpp (lines 1-201): String's
#       constructors and static creators, in the stub's (the header's) order.
#
#       String is a strongly owned sequence of Unicode code points encoded as UTF-8. The data
#       may or may not be heap-allocated. There is no guarantee that the underlying bytes are
#       null-terminated. Strings of up to seven bytes are stored inline (string_base).
#       `==` on String does not compile (its StringBase holds a union): compare with
#       string_equals or string_base_eq.
#
#==============================================================================================

# mark: Construction ============================================================================

## `String {}`: the empty string (a zero-initialized String is the empty string too).
pub func string_new() -> String:
    return String(string_base = string_base_new())

## `"text"_string`: a String of a literal or any other `str` (DESIGN.md §2.6's `ak.string`; a
## module function named `string` would collide with the many parameters named `string`).
pub func string_from_str(text: str) -> String:
    return literalstring(text.bytes.data, text.length)

## Ported from AK/String.cpp:62 AK::String::from_utf8: a String of `view`, failing when it is
## not valid UTF-8.
pub func string_from_utf8(view: StringView) -> String!:
    let utf8 = Utf8View(m_string = view)
    if not utf8_view_validate_allow_lonely_surrogates(&utf8):
        error(ak_error, "String::from_utf8: Input was not valid UTF-8")

    var result = string_new()
    var copy = CopyBytesToBuffer(source = string_view_bytes(&view))
    try string_base_replace_with_new_string_usize(&result.string_base, string_view_length(&view), &copy)
    return result

## Ported from AK/String.cpp:25 AK::String::from_utf8_with_replacement_character: a String of
## `view` with lonely surrogates and invalid bytes replaced by U+FFFD.
pub func string_from_utf8_with_replacement_character(view: StringView, with_bom_handling: StringWithBomHandling = StringWithBomHandling.yes) -> String:
    var input = view
    let bytes = string_view_bytes(&view)
    if with_bom_handling == StringWithBomHandling.yes and bytes.length >= 3 and bytes[0] == 0xef and bytes[1] == 0xbb and bytes[2] == 0xbf:
        input = string_view_substring_view(&view, 3)

    let utf8_view = Utf8View(m_string = input)

    if utf8_view_validate_allow_lonely_surrogates(&utf8_view, AllowLonelySurrogates.no):
        return string_from_utf8_without_validation(string_view_bytes(&input))

    var builder = string_builder_new_usize(string_view_length(&input))

    var it = utf8_view_begin(&utf8_view)
    while not utf8_code_point_iterator_done(&it):
        let code_point = utf8_code_point_iterator_deref(&it)
        if is_unicode_surrogate(code_point):
            string_builder_append_code_point(&builder, unicode_utils_replacement_code_point)
        else:
            string_builder_append_code_point(&builder, code_point)
        utf8_code_point_iterator_inc(&it)

    return string_builder_to_string_without_validation(&builder)

## Ported from AK/String.cpp:47 AK::String::from_utf8_without_validation.
pub func string_from_utf8_without_validation(bytes: const u8[]) -> String:
    var result = string_new()
    var copy = CopyBytesToBuffer(source = bytes)
    string_base_replace_with_new_string_usize(&result.string_base, bytes.length, &copy) else trap("MUST: from_utf8_without_validation")
    return result

## Ported from AK/String.cpp:57 AK::String::from_ascii_without_validation.
pub func string_from_ascii_without_validation(bytes: const u8[]) -> String:
    return string_from_utf8_without_validation(bytes)

## Ported from AK/String.h:60 AK::String::from_ascii_short_string_without_validation.
pub func string_from_ascii_short_string_without_validation(data: const u8[]) -> String:
    assert(data.length <= max_short_string_byte_count)
    var short_string = short_string_create_with_byte_count(data.length)
    for i in 0..<data.length:
        short_string.storage[i] = data[i]
    var result = String(string_base = StringBase())
    string_base_construct_short_string(&result.string_base, short_string)
    return result

## Ported from AK/String.cpp:145 AK::String::from_string_builder.
pub func string_from_string_builder(builder: StringBuilder*) -> String!:
    let view = string_builder_string_view(builder)
    let utf8 = Utf8View(m_string = view)
    if not utf8_view_validate_allow_lonely_surrogates(&utf8):
        error(ak_error, "String::from_string_builder: Input was not valid UTF-8")

    var result = string_new()
    string_base_replace_with_string_builder(&result.string_base, builder)
    return result

## Ported from AK/String.cpp:155 AK::String::from_string_builder_without_validation.
pub func string_from_string_builder_without_validation(builder: StringBuilder*) -> String:
    var result = string_new()
    string_base_replace_with_string_builder(&result.string_base, builder)
    return result

## The lambda of String::from_utf16_le/be_with_replacement_character: transcodes the
## well-formed UTF-16 into the new string.
struct StringFromUtf16Transcode: BytesCallback:
    var utf16_data: const u16[]

    func call(buffer: u8[]) -> !:
        let result = simdutf_convert_utf16_to_utf8(self.utf16_data, buffer)
        assert(result == buffer.length)

## The shared body of from_utf16_le/be_with_replacement_character.
func string_from_utf16_with_replacement_character(bytes: const u8[], big_endian: bool) -> String!:
    if bytes.length == 0:
        return string_new()

    # simdutf reads the bytes in the stated order; the well-formed copy is in host order.
    let well_formed_utf16 = simdutf_to_well_formed_utf16_bytes(bytes, big_endian)

    let utf8_length = simdutf_utf8_length_from_utf16(well_formed_utf16)

    var result = string_new()
    var transcode = StringFromUtf16Transcode(utf16_data = well_formed_utf16)
    try string_base_replace_with_new_string_usize(&result.string_base, utf8_length, &transcode)

    return result

## Ported from AK/String.cpp:75 AK::String::from_utf16_le_with_replacement_character: a String
## of little-endian UTF-16 bytes, lonely surrogates replaced by U+FFFD.
pub func string_from_utf16_le_with_replacement_character(bytes: const u8[]) -> String!:
    # The C++ copies into a well-formed buffer only when validate_utf16_le fails; converting a
    # host-order copy always gives the same bytes.
    return try string_from_utf16_with_replacement_character(bytes, false)

## Ported from AK/String.cpp:104 AK::String::from_utf16_be_with_replacement_character.
pub func string_from_utf16_be_with_replacement_character(bytes: const u8[]) -> String!:
    return try string_from_utf16_with_replacement_character(bytes, true)

## The lambda of String::from_stream: fills the buffer from the stream and validates it.
struct StringFromStreamRead: BytesCallback:
    var stream: Stream*

    func call(buffer: u8[]) -> !:
        try stream_read_until_filled(self.stream, buffer)
        let utf8 = Utf8View(m_string = string_view_from_bytes(buffer))
        if not utf8_view_validate_allow_lonely_surrogates(&utf8):
            error(ak_error, "String::from_stream: Input was not valid UTF-8")

## Ported from AK/String.cpp:133 AK::String::from_stream: a String of the next `byte_count`
## UTF-8 bytes of `stream`.
pub func string_from_stream(stream: Stream*, byte_count: usize) -> String!:
    var result = string_new()
    var read = StringFromStreamRead(stream = stream)
    try string_base_replace_with_new_string_usize(&result.string_base, byte_count, &read)
    return result

## The lambdas of String::from_code_point: encode the code point into the short string.
struct StringFromCodePointEncode: ShortStringBytesCallback:
    var code_point: u32

    func call(buffer: u8[]):
        var utf8 = CodePointAsUtf8()
        _ = unicode_utils_code_point_to_utf8(self.code_point, &utf8)
        copy_bytes(buffer, utf8.bytes[..<utf8.length])

## Ported from AK/String.h:80 AK::String::from_code_point: a String of a single code point.
pub func string_from_code_point(code_point: u32) -> String:
    assert(is_unicode(code_point))

    var string = string_new()
    var encode = StringFromCodePointEncode(code_point = code_point)
    string_base_replace_with_new_short_string(&string.string_base, (usize)unicode_utils_bytes_to_store_code_point_in_utf8(code_point), &encode)

    return string

## The lambda of String::repeated(u32, size_t).
struct StringRepeatedCodePoint: BytesCallback:
    var code_point_as_utf8: const u8[]
    var count: usize

    func call(buffer: u8[]) -> !:
        let code_point_byte_length = self.code_point_as_utf8.length
        if code_point_byte_length == 1:
            memory.set(buffer, self.code_point_as_utf8[0])
        else:
            for i in 0..<self.count:
                copy_bytes(buffer[(i * code_point_byte_length)..], self.code_point_as_utf8)

## Ported from AK/String.cpp:162 AK::String::repeated(u32, size_t): a String of one code point
## repeated `count` times.
pub func string_repeated_u32(code_point: u32, count: usize) -> String!:
    assert(is_unicode(code_point))

    var code_point_as_utf8 = CodePointAsUtf8()
    let code_point_byte_length = (usize)unicode_utils_code_point_to_utf8(code_point, &code_point_as_utf8)

    let total_byte_count = code_point_byte_length * count

    var result = string_new()
    var repeat = StringRepeatedCodePoint(code_point_as_utf8 = code_point_as_utf8.bytes[..<code_point_byte_length], count = count)
    try string_base_replace_with_new_string_usize(&result.string_base, total_byte_count, &repeat)
    return result

## The lambda of String::repeated(String const&, size_t).
struct StringRepeatedString: BytesCallback:
    var input: const u8[]
    var count: usize

    func call(buffer: u8[]) -> !:
        let input_size = self.input.length
        if input_size == 1:
            memory.set(buffer, self.input[0])
        else:
            for i in 0..<self.count:
                copy_bytes(buffer[(i * input_size)..<(i * input_size + input_size)], self.input)

## Ported from AK/String.cpp:451 AK::String::repeated(String const&, size_t): `input` repeated
## `count` times.
pub func string_repeated_string(input: const String*, count: usize) -> String!:
    let input_bytes = string_base_bytes(&input.string_base)
    let total = (u64)count *? (u64)input_bytes.length else error(ak_errno_error, "EOVERFLOW")
    if total > 0xffffffff:
        error(ak_errno_error, "EOVERFLOW")

    var result = string_new()
    let input_size = input_bytes.length
    var repeat = StringRepeatedString(input = input_bytes, count = count)
    try string_base_replace_with_new_string_usize(&result.string_base, count * input_size, &repeat)

    return result

## Ported from AK/String.cpp:471 AK::String::bijective_base_from: `value` + 1 in bijective
## base `base_` over `maybe_map` (default A-Z or a-z).
pub func string_bijective_base_from(value: usize, target_case: StringCase, base_: u32 = 26, maybe_map: StringView? = none) -> String:
    var remaining = value + 1
    let map = maybe_map else (sv("ABCDEFGHIJKLMNOPQRSTUVWXYZ") if target_case == StringCase.upper else sv("abcdefghijklmnopqrstuvwxyz"))

    assert(base_ >= 2 and (usize)base_ <= string_view_length(&map))

    # The '8 bits per byte' assumption may need to go?
    var buffer: u8[128]
    var i: usize = 0
    while true:
        var remainder = remaining % (usize)base_
        var new_value = remaining // (usize)base_
        if remainder == 0:
            new_value -= 1
            remainder = string_view_length(&map)

        buffer[i] = string_view_at(&map, remainder - 1)
        i += 1
        remaining = new_value
        if remaining == 0:
            break

    for j in 0..<(i // 2):
        let swapped = buffer[j]
        buffer[j] = buffer[i - j - 1]
        buffer[i - j - 1] = swapped

    return string_from_utf8(string_view_from_bytes(buffer[..<i])) else trap("MUST: bijective_base_from")

## Ported from AK/String.cpp:501 AK::String::greek_letter_from.
pub func string_greek_letter_from(value: usize) -> String:
    let map = sv("αβγδεζηθικλμνξοπρστυφχψω")
    let base_: usize = 24

    var builder = string_builder_new()
    var remaining = value
    while remaining > 0:
        remaining -= 1
        string_builder_append_string_view(&builder, string_view_substring_view_usize(&map, (remaining % base_) * 2, 2))
        remaining //= base_

    let letters = string_builder_to_string_without_validation(&builder)
    return string_reverse(&letters) else trap("MUST: greek_letter_from")

## The `target_case == Case::Upper ? upper : lower` of String::roman_number_from.
func string_roman_number_digits(builder: StringBuilder*, target_case: StringCase, upper: str, lower: str):
    string_builder_append_string_view(builder, sv(upper) if target_case == StringCase.upper else sv(lower))

## Ported from AK/String.cpp:516 AK::String::roman_number_from.
pub func string_roman_number_from(value: usize, target_case: StringCase) -> String:
    if value > 3999:
        return string_number_u64((u64)value)

    var builder = string_builder_new()

    var remaining = value
    while remaining > 0:
        if remaining >= 1000:
            string_roman_number_digits(&builder, target_case, "M", "m")
            remaining -= 1000
        elif remaining >= 900:
            string_roman_number_digits(&builder, target_case, "CM", "cm")
            remaining -= 900
        elif remaining >= 500:
            string_roman_number_digits(&builder, target_case, "D", "d")
            remaining -= 500
        elif remaining >= 400:
            string_roman_number_digits(&builder, target_case, "CD", "cd")
            remaining -= 400
        elif remaining >= 100:
            string_roman_number_digits(&builder, target_case, "C", "c")
            remaining -= 100
        elif remaining >= 90:
            string_roman_number_digits(&builder, target_case, "XC", "xc")
            remaining -= 90
        elif remaining >= 50:
            string_roman_number_digits(&builder, target_case, "L", "l")
            remaining -= 50
        elif remaining >= 40:
            string_roman_number_digits(&builder, target_case, "XL", "xl")
            remaining -= 40
        elif remaining >= 10:
            string_roman_number_digits(&builder, target_case, "X", "x")
            remaining -= 10
        elif remaining == 9:
            string_roman_number_digits(&builder, target_case, "IX", "ix")
            remaining -= 9
        elif remaining >= 5 and remaining <= 8:
            string_roman_number_digits(&builder, target_case, "V", "v")
            remaining -= 5
        elif remaining == 4:
            string_roman_number_digits(&builder, target_case, "IV", "iv")
            remaining -= 4
        elif remaining <= 3:
            string_roman_number_digits(&builder, target_case, "I", "i")
            remaining -= 1

    return string_builder_to_string_without_validation(&builder)