dymokomi/luce-browser-foundation
Source of release 0.6.0
0.6.0 / src / web_url / support.lucb
#==============================================================================================
#
# support - Helpers the LibURL port shares: literals, string equality, integer formatting
#
# DESCRIPTION:
# Not a donor file. The spellings the C++ gets from AK's operators and templates, written
# once for the module (DESIGN.md §2.6, §2.8): `"foo"sv` and `"foo"_string` literals,
# `String == String` / `String == StringView` (ak.String has no `==`, §3.3), the
# AK/Debug.h switches LibURL reads, the pattern-error slot (PatternErrorOr's ErrorInfo,
# §2.10), and the three integer formats LibURL passes to AK::Format (`{}`, `{:x}`,
# `{:02X}`), written out.
#
#==============================================================================================
# mark: Debug switches and errors ===============================================================
## AK/Debug.h URL_PARSER_DEBUG (0 in the donor build). The dbgln_if bodies are not ported while it is off.
pub let url_parser_debug: bool = false
## AK/Debug.h URL_PATTERN_DEBUG (0 in the donor build). The dbgln_if bodies are not ported while it is off.
pub let url_pattern_debug: bool = false
## The error code of a URL::Pattern::PatternErrorOr failure (a TypeError for web callers); the
## ErrorInfo is kept in a slot, read with `pattern_take_error_info` (DESIGN.md §2.10).
pub let pattern_error: ErrorCode = ErrorCode.package(501)
# The ErrorInfo of the last pattern failure. It is read right after the failure, before the next
# allocation can collect the message.
var s_pattern_error_info: ErrorInfo?
## `return ErrorInfo { "..."_string };` from a PatternErrorOr function: store the error and fail.
pub func pattern_throw(message: str) -> never!:
s_pattern_error_info = ErrorInfo(message = string_lit(message))
error(pattern_error, message)
## `return ErrorInfo { MUST(String::formatted(...)) };`: store the formatted message and fail.
pub func pattern_throw_string(message: ak.String) -> never!:
s_pattern_error_info = ErrorInfo(message = message)
error(pattern_error, "URLPattern TypeError")
## `return ErrorInfo { MUST(String::formatted(...)) };` with the message built in a StringBuilder.
pub func pattern_throw_builder(message: ak.StringBuilder*) -> never!:
let text = ak.string_builder_to_string(message) else trap("MUST: String::formatted")
try pattern_throw_string(text)
## The ErrorInfo of the last failure with `pattern_error` (the result of `release_error()`).
pub func pattern_take_error_info() -> ErrorInfo:
let info = s_pattern_error_info else trap("no pending URLPattern error")
s_pattern_error_info = none
return info
# mark: Literals and equality ===================================================================
## `"text"sv`.
pub func sv(text: str) -> ak.StringView:
return ak.sv(text)
## `"text"_string`.
pub func string_lit(text: str) -> ak.String:
return ak.string_from_str(text)
## `String {}`: the empty string (all-zero, DESIGN.md §2.3).
pub func empty_string() -> ak.String:
var result: ak.String
return result
## `a == b` for two Strings.
pub func string_equals(a: ak.String, b: ak.String) -> bool:
return ak.string_base_eq(&a.string_base, &b.string_base)
## `a == b` for a String and a StringView (AK compares the bytes).
pub func string_equals_view(a: ak.String, b: ak.StringView) -> bool:
let view = ak.string_bytes_as_string_view(&a)
return ak.string_view_eq_string_view(&view, b)
## `a == "literal"` for a String.
pub func string_is(a: ak.String, literal: str) -> bool:
return string_equals_view(a, sv(literal))
## `a == b` for two StringViews.
pub func view_equals(a: ak.StringView, b: ak.StringView) -> bool:
return ak.string_view_eq_string_view(&a, b)
## `a == "literal"` for a StringView.
pub func view_is(a: ak.StringView, literal: str) -> bool:
return view_equals(a, sv(literal))
## `a == b` for two Optional<String>s (both null, or both present and equal).
pub func optional_string_equals(a: ak.String?, b: ak.String?) -> bool:
if let x = a:
if let y = b:
return string_equals(x, y)
return false
return b == none
## `"characters"sv.contains(code_point)`: whether a code point is one of the given ASCII bytes.
pub func literal_contains(characters: str, code_point: u32) -> bool:
for byte in characters.bytes:
if (u32)byte == code_point:
return true
return false
## `builder.append(string)` for a String.
pub func append_string(builder: ak.StringBuilder*, string: ak.String):
ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&string))
## `builder.append("literal"sv)`.
pub func append_literal(builder: ak.StringBuilder*, literal: str):
ak.string_builder_append_string_view(builder, sv(literal))
## `string.bytes_as_string_view()` for a String value.
pub func view_of(string: ak.String) -> ak.StringView:
return ak.string_bytes_as_string_view(&string)
## `Utf8View(input)`.
pub func utf8_view_of(input: ak.StringView) -> ak.Utf8View:
var view: ak.Utf8View
ak.utf8_view_construct_string_view(&view, input)
return view
## `ByteString {}`: the empty ByteString.
pub func empty_byte_string() -> ak.ByteString:
let empty = sv("")
return ak.string_view_to_byte_string(&empty)
# mark: Integer formats =========================================================================
let hex_digits_upper: str = "0123456789ABCDEF"
let hex_digits_lower: str = "0123456789abcdef"
## `builder.appendff("%{:02X}", byte)`: a percent sign and two uppercase hex digits.
pub func append_percent_encoded_byte(builder: ak.StringBuilder*, byte: u32):
ak.string_builder_append_u8(builder, '%')
ak.string_builder_append_u8(builder, hex_digits_upper.bytes[(usize)((byte >> 4) & 0xf)])
ak.string_builder_append_u8(builder, hex_digits_upper.bytes[(usize)(byte & 0xf)])
## `builder.appendff("{:x}", value)`: the shortest lowercase hexadecimal representation.
pub func append_hex_lowercase(builder: ak.StringBuilder*, value: u64):
var digits: u8[16]
var count: usize = 0
var rest = value
while true:
digits[count] = hex_digits_lower.bytes[(usize)(rest & 0xf)]
count += 1
rest = rest >> 4
if rest == 0:
break
while count > 0:
count -= 1
ak.string_builder_append_u8(builder, digits[count])
## `builder.appendff("{}", value)` for an unsigned integer.
pub func append_decimal(builder: ak.StringBuilder*, value: u64):
var digits: u8[20]
var count: usize = 0
var rest = value
while true:
digits[count] = (u8)('0' + (u8)(rest % 10))
count += 1
rest = rest // 10
if rest == 0:
break
while count > 0:
count -= 1
ak.string_builder_append_u8(builder, digits[count])