core/text/match package | Odin Programming Language

Matcher helper struct that stores optional data you might want to use or not as lua is far more dynamic this helps dealing with too much data this also allows use of find/match/gmatch at through one struct

Procedures

capture_to_close #

Source

@(require_results)

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

check_capture #

Source

@(require_results)

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

class_end #

Source

@(require_results)

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

end_capture #

Source

@(require_results)

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

find_aux #

Source

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

find a pattern with in a haystack with an offset allow_memfind will speed up simple searches

gfind #

Source

@(require_results)

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

iterative find with zeroth capture only assumes captures is zeroed on first iteration resets captures to zero on last iteration

gmatch #

Source

@(require_results)

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

iterative matching which returns the 0th/1st match rest has to be used from captures assumes captures is zeroed on first iteration resets captures to zero on last iteration

gsub_allocator #

Source

@(require_results)

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

uses temp builder to build initial string - then allocates the result

gsub_builder #

Source

@(require_results)

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

gsub with builder, replace patterns found with the replace content

gsub_with #

Source

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

call a procedure on every match in the haystack

index_special #

Source

@(require_results)

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

helper call to quick search for special characters

is_alnum #

Source

@(require_results)

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

is_cont #

Source

@(require_results)

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

continuation byte?

is_graph #

Source

@(require_results)

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

is_xdigit #

Source

@(require_results)

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

lmem_find #

Source

@(require_results)

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

match #

Source

@(require_results)

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

match_balance #

Source

@(require_results)

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

match_bracket_class #

Source

@(require_results)

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

match_capture #

Source

@(require_results)

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

match_class #

Source

@(require_results)

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

match_default #

Source

@(require_results)

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

matcher_capture #

Source

@(require_results)

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

get the capture at the "correct" spot, as spot 0 is reserved for the first match

matcher_capture_raw #

Source

@(require_results)

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

get the raw match out of the captures, skipping spot 0

matcher_captures_slice #

Source

@(require_results)

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

get a slice of all valid captures above the first match

matcher_find #

Source

@(require_results)

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

find the first match and return the byte start / end position in the string, true on success

matcher_gmatch #

Source

@(require_results)

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

iteratively match the haystack till it cant find any matches

matcher_init #

Source

@(require_results)

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

init using haystack & pattern and an optional byte offset

matcher_match #

Source

@(require_results)

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

find the first match and return the matched word, true on success

matcher_match_iter #

Source

@(require_results)

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

iteratively match the haystack till it cant find any matches

max_expand #

Source

@(require_results)

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

min_expand #

Source

@(require_results)

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

pattern_case_insensitive_allocator #

Source

@(require_results)

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

pattern_case_insensitive_builder #

Source

@(require_results)

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

rebuilds a pattern into a case insensitive pattern

push_captures #

Source

@(require_results)

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

push_onecapture #

Source

@(require_results)

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

single_match #

Source

@(require_results)

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

start_capture #

Source

@(require_results)

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

utf8_advance #

Source

@(require_results)

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

find the first utf8 charater and its size and advance the index return an error if the character is an error

utf8_next #

Source

@(require_results)

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

utf8_peek #

Source

@(require_results)

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

find the first utf8 charater and its size, return an error if the character is an error

utf8_prev #

Source

@(require_results)

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

Procedure Groups

gsub #

Source

gsub :: proc{
	gsub_builder,
	gsub_allocator,
}

pattern_case_insensitive #

Source

pattern_case_insensitive :: proc{
	pattern_case_insensitive_builder,
	pattern_case_insensitive_allocator,
}

Variables

SPECIALS_TABLE #

Source

@(rodata)

SPECIALS_TABLE: [256]bool = [256]bool{'^' = true, '$' = true, '*' = true, '+' = true, '?' = true, '.' = true, '(' = true, '[' = true, '%' = true, '-' = true}

SPECIALS := "^$*+?.([%-" all special characters inside a small ascii array