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

@(rodata)
SPECIALS_TABLE: [256]bool = …

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

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

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

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

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

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

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

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

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

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

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

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

is_alpha :: unicode.is_letter

is_cntrl :: unicode.is_control

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

is_digit :: unicode.is_digit

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

is_lower :: unicode.is_lower

is_punct :: unicode.is_punct

is_space :: unicode.is_space

is_upper :: unicode.is_upper

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

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

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

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

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

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

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

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

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

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

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

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

matcher_gmatch :: matcher_match_iter

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@(require_results)
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,
}