package core:unicode/utf8

Source

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

Grapheme :: struct {
	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:                  untyped 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,
}

HICB: int : 0b1011_1111

LOCB: int : 0b1000_0000

MASK2: int : 0b0001_1111

MASK3: int : 0b0000_1111

MASK4: int : 0b0000_0111

MASKX: int : 0b0011_1111

MAX_RUNE :: '\U0010ffff'

RUNE1_MAX: int : 1 << 7 - 1

RUNE2_MAX: int : 1 << 11 - 1

RUNE3_MAX: int : 1 << 16 - 1

RUNE_BOM: int : 0xfeff

RUNE_EOF :: ~rune(0)

RUNE_ERROR :: '\ufffd'

RUNE_SELF: int : 0x80

SURROGATE_HIGH_MAX: int : 0xdbff

SURROGATE_LOW_MIN: int : 0xdc00

SURROGATE_MAX: int : 0xdfff

SURROGATE_MIN: int : 0xd800

T1: int : 0b0000_0000

T2: int : 0b1100_0000

T3: int : 0b1110_0000

T4: int : 0b1111_0000

T5: int : 0b1111_1000

TX: int : 0b1000_0000

UTF_MAX: int : 4

ZERO_WIDTH_JOINER :: unicode.ZERO_WIDTH_JOINER

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 :: proc(it: ^Grapheme_Iterator) -> (text: string, grapheme: Grapheme, ok: bool) {…}

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

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

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

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

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

encode_rune :: proc "contextless" (c: untyped 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) {…}

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

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

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

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

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

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

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

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

runes_to_string :: proc(runes: []untyped rune, allocator := context.allocator) -> string {…}

string_to_runes :: proc(s: string, allocator := context.allocator) -> (runes: []untyped rune) {…}

valid_rune :: proc "contextless" (r: untyped 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,
}