package core:text/match

Source

Capture :: struct {
	init: int,
	len:  int,
}

Error :: enum int {
	OK, 
	OOB, 
	Invalid_Capture_Index, 
	Invalid_Pattern_Capture, 
	Unfinished_Capture, 
	Malformed_Pattern, 
	Rune_Error, 
	Match_Invalid, 
}

Gsub_Proc :: proc(data: rawptr, word: string, haystack: string, captures: []Match)

Match :: struct {
	byte_start: int,
	byte_end:   int,
}

Match_State :: struct {
	src:     string,
	pattern: string,
	level:   int,
	capture: [32]Capture,
}

Matcher :: struct {
	haystack:        string,
	pattern:         string,
	captures:        [32]Match,
	captures_length: int,
	offset:          int,
	err:             Error,
	// changing content for iterators
	iter:            string,
	iter_index:      int,
}

CAP_POSITION :: -2

CAP_UNFINISHED :: -1

INVALID :: -1

L_ESC :: '%'

MAX_CAPTURES :: 32

SPECIALS_TABLE: [256]bool = …

capture_to_close :: proc(ms: ^Match_State) -> (int, Error) {…}

check_capture :: proc(ms: ^Match_State, l: rune) -> (int, Error) {…}

class_end :: proc(ms: ^Match_State, p: int) -> (step: int, err: Error) {…}

end_capture :: proc(ms: ^Match_State, s, p: int) -> (res: int, err: Error) {…}

find_aux :: proc(haystack: string, pattern: string, offset: int, allow_memfind: bool, matches: ^[32]Match) -> (captures: int, err: Error) {…}

gfind :: proc(haystack: ^string, pattern: string, captures: ^[32]Match) -> (res: string, ok: bool) {…}

gmatch :: proc(haystack: ^string, pattern: string, captures: ^[32]Match) -> (res: string, ok: bool) {…}

gsub_allocator :: proc(haystack: string, pattern: string, replace: string, allocator := context.allocator) -> string {…}

gsub_builder :: proc(builder: ^strings.Builder, haystack: string, pattern: string, replace: string) -> string {…}

gsub_with :: proc(haystack: string, pattern: string, data: rawptr, call: Gsub_Proc) {…}

index_special :: proc(text: string) -> int {…}

is_alnum :: proc(c: rune) -> bool {…}

is_cont :: proc(b: u8) -> bool {…}

is_graph :: proc(c: rune) -> bool {…}

is_xdigit :: proc(c: rune) -> bool {…}

lmem_find :: proc(s1: string, s2: string) -> int {…}

match :: proc(ms: ^Match_State, s, p: int) -> (unused: int, err: Error) {…}

match_balance :: proc(ms: ^Match_State, s, p: int) -> (unused: int, err: Error) {…}

match_bracket_class :: proc(ms: ^Match_State, c: rune, p, ec: int) -> (sig: bool, err: Error) {…}

match_capture :: proc(ms: ^Match_State, s: int, char: rune) -> (res: int, err: Error) {…}

match_class :: proc(c: rune, cl: rune) -> (res: bool) {…}

match_default :: proc(ms: ^Match_State, s, p: int) -> (unused: int, err: Error) {…}

matcher_capture :: proc(matcher: ^Matcher, index: int, loc := #caller_location) -> string {…}

matcher_capture_raw :: proc(matcher: ^Matcher, index: int, loc := #caller_location) -> Match {…}

matcher_captures_slice :: proc(matcher: ^Matcher) -> []Match {…}

matcher_find :: proc(matcher: ^Matcher) -> (start, end: int, ok: bool) {…}

matcher_gmatch :: matcher_match_iter

matcher_init :: proc(haystack, pattern: string, offset: int = 0) -> (res: Matcher) {…}

matcher_match :: proc(matcher: ^Matcher) -> (word: string, ok: bool) {…}

matcher_match_iter :: proc(matcher: ^Matcher) -> (res: string, index: int, ok: bool) {…}

max_expand :: proc(ms: ^Match_State, s, p, ep: int) -> (res: int, err: Error) {…}

min_expand :: proc(ms: ^Match_State, s, p, ep: int) -> (res: int, err: Error) {…}

pattern_case_insensitive_allocator :: proc(pattern: string, cap: int = 256, allocator := context.allocator) -> (res: string) {…}

pattern_case_insensitive_builder :: proc(builder: ^strings.Builder, pattern: string) -> (res: string) {…}

push_captures :: proc(ms: ^Match_State, s: int, e: int, matches: []Match) -> (nlevels: int, err: Error) {…}

push_onecapture :: proc(ms: ^Match_State, i: int, s: int, e: int, matches: []Match) -> (err: Error) {…}

single_match :: proc(ms: ^Match_State, s, p, ep: int) -> (matched: bool, schar_size: int, err: Error) {…}

start_capture :: proc(ms: ^Match_State, s, p, what: int) -> (res: int, err: Error) {…}

utf8_advance :: proc(bytes: string, index: ^int) -> (c: rune, err: Error) {…}

utf8_next :: proc(bytes: string, a: int) -> int {…}

utf8_peek :: proc(bytes: string) -> (c: rune, size: int, err: Error) {…}

utf8_prev :: proc(bytes: string, a, b: int) -> int {…}

gsub :: proc{
	gsub_builder,
	gsub_allocator,
}

pattern_case_insensitive :: proc{
	pattern_case_insensitive_builder,
	pattern_case_insensitive_allocator,
}