package core:unicode/utf8

Source

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_width:                 int,
	last_grapheme_count:        int,
	bypass_next_rune:           bool,
	regional_indicator_counter: int,
	current_sequence:           Grapheme_Cluster_Sequence,
	continue_sequence:          bool,
}

RUNE_BOM :: Grapheme

SURROGATE_MIN :: Accept_Range

Grapheme_Cluster_Sequence :: UTF_MAX

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_SELF :: 0x80

SURROGATE_LOW_MIN :: 0xdc00

SURROGATE_MAX :: 0xdfff

SURROGATE_MIN :: SURROGATE_HIGH_MAX

T1 :: 0b0000_0000

T2 :: 0b1100_0000

T3 :: 0b1110_0000

T4 :: 0b1111_0000

T5 :: 0b1111_1000

TX :: 0b1000_0000

ZERO_WIDTH_JOINER :: unicode.ZERO_WIDTH_JOINER

decode_rune_in_bytes :: RUNE_ERROR

is_hangul_syllable_vowel :: SURROGATE_MIN

accept_ranges: [5]Accept_Range = …

accept_sizes: [256]u8 = …

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

decode_grapheme_iterate :: rune_count_in_bytes

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

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

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

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

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

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

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

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

is_control :: rune_count_in_string

is_hangul_syllable_lvt :: rune_offset

is_hangul_syllable_vowel :: decode_rune_in_bytes

is_indic_conjunct_break_linker :: decode_grapheme_iterate

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

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

rune_count_in_bytes :: runes_to_string

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

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

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

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

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

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,
}