package core:unicode/utf8

Source

Accept_Range :: struct {
	lo: u8,
	hi: u8,
}

Grapheme :: struct {
	text:       string,
	// The text of the grapheme, a slice of the string it was decoded from.
	byte_index: int,
	rune_index: int,
	width:      int,
}

Grapheme_Cluster_Sequence :: enum int {
	None, 
	Indic, 
	Emoji, 
	Regional, 
}

Grapheme_Iterator :: struct {
	str:                        string,
	curr_offset:                int,
	grapheme_count:             int,
	// The number of graphemes in the string
	rune_count:                 int,
	// The number of runes in the string
	width:                      int,
	// The widrth of the string in number of monospace cells
	last_rune:                  rune,
	last_rune_breaks_forward:   bool,
	last_grapheme_count:        int,
	bypass_next_rune:           bool,
	regional_indicator_counter: int,
	current_sequence:           Grapheme_Cluster_Sequence,
	continue_sequence:          bool,
	current_grapheme:           Grapheme,
	continue_grapheme:          bool,
	current_cluster_width:      int,
	current_cluster_ri_count:   int,
}

HICB :: 0b1011_1111

LOCB :: 0b1000_0000

MASK2 :: 0b0001_1111

MASK3 :: 0b0000_1111

MASK4 :: 0b0000_0111

MASKX :: 0b0011_1111

MAX_RUNE :: '\U0010ffff'

RUNE1_MAX :: 1 << 7 - 1

RUNE2_MAX :: 1 << 11 - 1

RUNE3_MAX :: 1 << 16 - 1

RUNE_BOM :: 0xfeff

RUNE_EOF: rune : ~rune(0)

RUNE_ERROR :: '\ufffd'

RUNE_SELF :: 0x80

SURROGATE_HIGH_MAX :: 0xdbff

SURROGATE_LOW_MIN :: 0xdc00

SURROGATE_MAX :: 0xdfff

SURROGATE_MIN :: 0xd800

T1 :: 0b0000_0000

T2 :: 0b1100_0000

T3 :: 0b1110_0000

T4 :: 0b1111_0000

T5 :: 0b1111_1000

TX :: 0b1000_0000

UTF_MAX :: 4

ZERO_WIDTH_JOINER :: unicode.ZERO_WIDTH_JOINER

accept_ranges: [5]Accept_Range = …

accept_sizes: [256]u8 = …

@(require_results)
decode_grapheme_clusters :: proc(
	str:             string, 
	track_graphemes: bool = true, 
	allocator := context.allocator, 
) -> (graphemes: [dynamic]Grapheme, grapheme_count: int, rune_count: int, width: int) {…}

@(require_results)
decode_grapheme_iterate :: proc(it: ^Grapheme_Iterator) -> (text: string, grapheme: Grapheme, ok: bool) {…}

@(require_results)
decode_grapheme_iterator_make :: proc(str: string) -> (it: Grapheme_Iterator) {…}

@(require_results)
decode_last_rune_in_bytes :: proc "contextless" (s: []u8) -> (rune, int) {…}

@(require_results)
decode_last_rune_in_string :: proc "contextless" (s: string) -> (rune, int) {…}

@(require_results)
decode_rune_in_bytes :: proc "contextless" (s: []u8) -> (rune, int) {…}

@(require_results)
decode_rune_in_string :: proc "contextless" (s: string) -> (rune, int) {…}

@(require_results)
encode_rune :: proc "contextless" (c: rune) -> ([4]u8, int) {…}

@(require_results)
full_rune_in_bytes :: proc "contextless" (b: []u8) -> bool {…}

@(require_results)
full_rune_in_string :: proc "contextless" (s: string) -> bool {…}

@(require_results)
grapheme_count :: proc(str: string) -> (graphemes, runes, width: int) {…}

is_control :: unicode.is_control

is_emoji_extended_pictographic :: unicode.is_emoji_extended_pictographic

is_gcb_extend_class :: unicode.is_gcb_extend_class

is_gcb_prepend_class :: unicode.is_gcb_prepend_class

is_hangul_syllable_leading :: unicode.is_hangul_syllable_leading

is_hangul_syllable_lv :: unicode.is_hangul_syllable_lv

is_hangul_syllable_lvt :: unicode.is_hangul_syllable_lvt

is_hangul_syllable_trailing :: unicode.is_hangul_syllable_trailing

is_hangul_syllable_vowel :: unicode.is_hangul_syllable_vowel

is_indic_conjunct_break_consonant :: unicode.is_indic_conjunct_break_consonant

is_indic_conjunct_break_extend :: unicode.is_indic_conjunct_break_extend

is_indic_conjunct_break_linker :: unicode.is_indic_conjunct_break_linker

is_regional_indicator :: unicode.is_regional_indicator

is_spacing_mark :: unicode.is_spacing_mark

normalized_east_asian_width :: unicode.normalized_east_asian_width

@(require_results)
rune_at :: proc "contextless" (s: string, byte_index: int) -> rune {…}

@(require_results)
rune_at_pos :: proc "contextless" (s: string, pos: int) -> rune {…}

@(require_results)
rune_count_in_bytes :: proc "contextless" (s: []u8) -> int {…}

@(require_results)
rune_count_in_string :: proc(s: string) -> int {…}

@(require_results)
rune_offset :: proc "contextless" (s: string, pos: int, start: int = 0) -> int {…}

@(require_results)
rune_size :: proc "contextless" (r: rune) -> int {…}

@(require_results)
rune_start :: proc "contextless" (b: u8) -> bool {…}

@(require_results)
rune_string_at_pos :: proc "contextless" (s: string, pos: int) -> string {…}

@(require_results)
runes_to_string :: proc(
	runes:     []rune, 
	allocator := context.allocator, 
) -> (s: string, err: runtime.Allocator_Error) #optional_ok {…}

@(require_results)
string_to_runes :: proc(
	s:         string, 
	allocator := context.allocator, 
) -> (runes: []rune, err: runtime.Allocator_Error) #optional_ok {…}

@(require_results)
valid_rune :: proc "contextless" (r: rune) -> bool {…}

@(require_results)
valid_string :: proc "contextless" (s: string) -> bool {…}

decode_last_rune :: proc{
	decode_last_rune_in_string,
	decode_last_rune_in_bytes,
}

decode_rune :: proc{
	decode_rune_in_string,
	decode_rune_in_bytes,
}

full_rune :: proc{
	full_rune_in_bytes,
	full_rune_in_string,
}

rune_count :: proc{
	rune_count_in_string,
	rune_count_in_bytes,
}