Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-foundation

Source of release 0.6.1

0.6.1 / src / ak / format_builder.lucb

#==============================================================================================
#
#   format_builder - FormatBuilder: padding, literals, strings, integers and fixed point
#
#   DESCRIPTION:
#       Port of AK/Format.cpp lines 218-485: FormatBuilder::put_padding, put_literal,
#       put_string, put_u64 (with its put_prefix and put_digits lambdas as helpers), put_i64,
#       put_fixed_point and round_up_digits. Every function writes through the StringBuilder the
#       FormatBuilder wraps; the arithmetic keeps C++'s unsigned wrapping where it can wrap.
#
#==============================================================================================

# mark: Padding, literals and strings ===========================================================

## Ported from AK/Format.cpp:218 AK::FormatBuilder::put_padding.
pub func format_builder_put_padding(this: FormatBuilder*, fill: u8, amount: usize) -> !:
    for _ in 0..<amount:
        try string_builder_try_append_u8(this.m_builder, fill)

## Ported from AK/Format.cpp:224 AK::FormatBuilder::put_literal: appends `value`, collapsing
## each escaped `{{` and `}}` to one brace.
pub func format_builder_put_literal(this: FormatBuilder*, value: StringView) -> !:
    var i: usize = 0
    while i < string_view_length(&value):
        let ch = string_view_at(&value, i)
        try string_builder_try_append_u8(this.m_builder, ch)
        if ch == '{' or ch == '}':
            i += 1
        i += 1

## Ported from AK/Format.cpp:234 AK::FormatBuilder::put_string.
pub func format_builder_put_string(this: FormatBuilder*, value: StringView, align: FormatBuilderAlign = FormatBuilderAlign.left, min_width: usize = 0, max_width: usize = usize_max, fill: u8 = ' ') -> !:
    let used_by_string = max_width if max_width < string_view_length(&value) else string_view_length(&value)
    let used_by_padding = (min_width if min_width > used_by_string else used_by_string) - used_by_string

    var string = value
    if used_by_string < string_view_length(&value):
        string = string_view_substring_view_usize(&value, 0, used_by_string)

    if align == FormatBuilderAlign.left or align == FormatBuilderAlign.default:
        try string_builder_try_append_string_view(this.m_builder, string)
        try format_builder_put_padding(this, fill, used_by_padding)
    elif align == FormatBuilderAlign.center:
        let used_by_left_padding = used_by_padding // 2
        # ceil_div<size_t, size_t>(used_by_padding, 2)
        let used_by_right_padding = used_by_padding // 2 + (1 if used_by_padding % 2 != 0 else 0)

        try format_builder_put_padding(this, fill, used_by_left_padding)
        try string_builder_try_append_string_view(this.m_builder, string)
        try format_builder_put_padding(this, fill, used_by_right_padding)
    elif align == FormatBuilderAlign.right:
        try format_builder_put_padding(this, fill, used_by_padding)
        try string_builder_try_append_string_view(this.m_builder, string)

# mark: Integers ================================================================================

## put_u64's `put_prefix` lambda (AK/Format.cpp:307).
func format_builder_put_u64_prefix(this: FormatBuilder*, base_: u8, prefix: bool, upper_case: bool, sign_mode: FormatBuilderSignMode, is_negative: bool) -> !:
    if is_negative:
        try string_builder_try_append_u8(this.m_builder, '-')
    elif sign_mode == FormatBuilderSignMode.always:
        try string_builder_try_append_u8(this.m_builder, '+')
    elif sign_mode == FormatBuilderSignMode.reserved:
        try string_builder_try_append_u8(this.m_builder, ' ')

    if prefix:
        if base_ == 2:
            if upper_case:
                try string_builder_try_append_string_view(this.m_builder, sv("0B"))
            else:
                try string_builder_try_append_string_view(this.m_builder, sv("0b"))
        elif base_ == 8:
            try string_builder_try_append_string_view(this.m_builder, sv("0"))
        elif base_ == 16:
            if upper_case:
                try string_builder_try_append_string_view(this.m_builder, sv("0X"))
            else:
                try string_builder_try_append_string_view(this.m_builder, sv("0x"))

## put_u64's `put_digits` lambda (AK/Format.cpp:332).
func format_builder_put_u64_digits(this: FormatBuilder*, buffer: const (u8[128])*, used_by_digits: usize) -> !:
    for i in 0..<used_by_digits:
        try string_builder_try_append_u8(this.m_builder, (*buffer)[i])

## Ported from AK/Format.cpp:264 AK::FormatBuilder::put_u64.
pub func format_builder_put_u64(this: FormatBuilder*, value: u64, base_: u8 = 10, prefix: bool = false, upper_case: bool = false, zero_pad: bool = false, use_separator: bool = false, align: FormatBuilderAlign = FormatBuilderAlign.right, min_width: usize = 0, fill: u8 = ' ', sign_mode: FormatBuilderSignMode = FormatBuilderSignMode.only_if_needed, is_negative: bool = false) -> !:
    var alignment = align
    if alignment == FormatBuilderAlign.default:
        alignment = FormatBuilderAlign.right

    var buffer: u8[128]

    let used_by_digits = convert_unsigned_to_string(value, &buffer, base_, upper_case, use_separator)

    var used_by_prefix: usize = 0
    if alignment == FormatBuilderAlign.right and zero_pad:
        # We want ByteString::formatted("{:#08x}", 32) to produce '0x00000020' instead of '0x000020'. This
        # behavior differs from both fmtlib and printf, but is more intuitive.
        used_by_prefix = 0
    else:
        if is_negative or sign_mode != FormatBuilderSignMode.only_if_needed:
            used_by_prefix += 1

        if prefix:
            if base_ == 8:
                used_by_prefix += 1
            elif base_ == 16:
                used_by_prefix += 2
            elif base_ == 2:
                used_by_prefix += 2

    let used_by_field = used_by_prefix + used_by_digits
    let used_by_padding = (used_by_field if used_by_field > min_width else min_width) - used_by_field

    if alignment == FormatBuilderAlign.left:
        let used_by_right_padding = used_by_padding

        try format_builder_put_u64_prefix(this, base_, prefix, upper_case, sign_mode, is_negative)
        try format_builder_put_u64_digits(this, &buffer, used_by_digits)
        try format_builder_put_padding(this, fill, used_by_right_padding)
    elif alignment == FormatBuilderAlign.center:
        let used_by_left_padding = used_by_padding // 2
        let used_by_right_padding = used_by_padding - used_by_left_padding

        try format_builder_put_padding(this, fill, used_by_left_padding)
        try format_builder_put_u64_prefix(this, base_, prefix, upper_case, sign_mode, is_negative)
        try format_builder_put_u64_digits(this, &buffer, used_by_digits)
        try format_builder_put_padding(this, fill, used_by_right_padding)
    elif alignment == FormatBuilderAlign.right:
        let used_by_left_padding = used_by_padding

        if zero_pad:
            try format_builder_put_u64_prefix(this, base_, prefix, upper_case, sign_mode, is_negative)
            try format_builder_put_padding(this, '0', used_by_left_padding)
            try format_builder_put_u64_digits(this, &buffer, used_by_digits)
        else:
            try format_builder_put_padding(this, fill, used_by_left_padding)
            try format_builder_put_u64_prefix(this, base_, prefix, upper_case, sign_mode, is_negative)
            try format_builder_put_u64_digits(this, &buffer, used_by_digits)

## Ported from AK/Format.cpp:368 AK::FormatBuilder::put_i64.
pub func format_builder_put_i64(this: FormatBuilder*, value: i64, base_: u8 = 10, prefix: bool = false, upper_case: bool = false, zero_pad: bool = false, use_separator: bool = false, align: FormatBuilderAlign = FormatBuilderAlign.right, min_width: usize = 0, fill: u8 = ' ', sign_mode: FormatBuilderSignMode = FormatBuilderSignMode.only_if_needed) -> !:
    let is_negative = value < 0
    var positive_value: u64
    if value == -9223372036854775808:
        positive_value = (u64)9223372036854775807 + 1
    else:
        positive_value = (u64)(-value if is_negative else value)

    try format_builder_put_u64(this, positive_value, base_, prefix, upper_case, zero_pad, use_separator, align, min_width, fill, sign_mode, is_negative)

# mark: Fixed point =============================================================================

## Ported from AK/Format.cpp:392 AK::FormatBuilder::put_fixed_point.
pub func format_builder_put_fixed_point(this: FormatBuilder*, is_negative: bool, integer_value: i64, fraction_value: u64, fraction_one: u64, precision: usize, base_: u8 = 10, upper_case: bool = false, zero_pad: bool = false, use_separator: bool = false, align: FormatBuilderAlign = FormatBuilderAlign.right, min_width: usize = 0, fraction_max_width: usize = 6, fill: u8 = ' ', sign_mode: FormatBuilderSignMode = FormatBuilderSignMode.only_if_needed) -> !:
    var string_builder: StringBuilder
    string_builder_construct(&string_builder)
    var format_builder = FormatBuilder(m_builder = &string_builder)

    var integer = integer_value
    if is_negative:
        integer = -integer

    try format_builder_put_u64(&format_builder, (u64)integer, base_, false, upper_case, false, use_separator, FormatBuilderAlign.right, 0, ' ', sign_mode, is_negative)

    var fraction_value_left = fraction_value
    if fraction_max_width != 0 and (zero_pad or fraction_value_left != 0):
        # FIXME: This is a terrible approximation but doing it properly would be a lot of work. If someone is up for that, a good
        # place to start would be the following video from CppCon 2019:
        # https://youtu.be/4P_kbF0EbZM (Stephan T. Lavavej “Floating-Point <charconv>: Making Your Code 10x Faster With C++17's Final Boss”)

        if is_negative and fraction_value_left != 0:
            fraction_value_left = fraction_one - fraction_value_left

        try string_builder_try_append_u8(&string_builder, '.')

        if base_ == 10:
            let scale = pow_integral_u64(5, (u64)precision)
            # FIXME: overflows (not before: fraction_value = (2^precision - 1) and precision >= 20) (use wider integer type)
            let fraction = scale *% fraction_value_left
            try format_builder_put_u64(&format_builder, fraction, base_, false, upper_case, true, use_separator, FormatBuilderAlign.right, precision)
        elif base_ == 16 or base_ == 8 or base_ == 2:
            let bits_per_character = (usize)log2_u8(base_)
            let fraction = fraction_value_left << (u64)((bits_per_character - (precision % bits_per_character)) % bits_per_character)
            let width = precision // bits_per_character + (1 if precision % bits_per_character != 0 else 0)
            try format_builder_put_u64(&format_builder, fraction, base_, false, upper_case, false, use_separator, FormatBuilderAlign.right, width, '0')
        else:
            trap("VERIFY_NOT_REACHED")

    var formatted_string = string_builder_string_view(&string_builder)
    if fraction_max_width != 0 and (zero_pad or fraction_value_left != 0):
        let point_index = (usize)(string_view_find_u8(&formatted_string, '.') else 0)
        if point_index == 0:
            trap("VERIFY_NOT_REACHED")

        let formatted_length = string_view_length(&formatted_string) - point_index - 1
        if formatted_length > fraction_max_width:
            formatted_string = string_view_substring_view_usize(&formatted_string, 0, 1 + point_index + fraction_max_width)
        else:
            string_builder_append_repeated_u8(&string_builder, '0', fraction_max_width - formatted_length)
            formatted_string = string_builder_string_view(&string_builder)

        if not zero_pad:
            formatted_string = string_view_trim(&formatted_string, sv("0"), TrimMode.right)

        if string_view_ends_with_u8(&formatted_string, '.'):
            formatted_string = string_view_trim(&formatted_string, sv("."), TrimMode.right)

    try format_builder_put_string(this, formatted_string, align, min_width, usize_max, fill)

# mark: round_up_digits =========================================================================

## Ported from AK/Format.cpp:464 AK::round_up_digits: adds one in the last place of the decimal
## digits in `digits_builder`, carrying through the digits and over the point.
func round_up_digits(digits_builder: StringBuilder*) -> !:
    var digits_buffer = try string_builder_to_byte_buffer(digits_builder)
    var current_position = (i32)byte_buffer_size(&digits_buffer) - 1

    while current_position >= 0:
        let digit = byte_buffer_at(&digits_buffer, (usize)current_position)
        if *digit == '.':
            current_position -= 1
            continue
        *digit += 1
        if *digit <= '9':
            break
        *digit = '0'
        current_position -= 1

    string_builder_clear(digits_builder)
    if current_position < 0:
        try string_builder_try_append_u8(digits_builder, '1')
    var digits: StringView
    string_view_construct_byte_buffer(&digits, &digits_buffer)
    try string_builder_try_append_string_view(digits_builder, digits)