core/text/match

text_match

Types

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

Source

Error :: enum int {
	OK                      = 0,
	OOB                     = 1,
	Invalid_Capture_Index   = 2,
	Invalid_Pattern_Capture = 3,
	Unfinished_Capture      = 4,
	Malformed_Pattern       = 5,
	Rune_Error              = 6,
	Match_Invalid           = 7,
}

Source

Gsub_Proc :: proc(
	// optional passed data
	data:     rawptr,
	// word match found
	word:     string,
	// current haystack for found captures
	haystack: string, 
	// found captures - empty for no captures
	captures: []Match,
)

Source

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

Source

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

Source

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

Source

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

Constants

CAP_POSITION :: -2Source

CAP_UNFINISHED :: -1Source

INVALID :: -1Source

L_ESC :: '%'Source

MAX_CAPTURES :: 32Source

is_alpha :: is_alphaSource

Variables

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

Source

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

Procedures

capture_to_close :: proc(ms: ^Match_State) -> (Error, int)Source

check_capture :: proc(ms: ^Match_State, l: rune) -> (Error, int)Source

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

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

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

Source

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

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

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

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

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 :: proc(haystack: string, pattern: string, replace: string, allocator: mem.Allocator = context.allocator) -> (string)

Source

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

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

gsub with builder, replace patterns found with the replace content

gsub_with :: proc(haystack: string, pattern: string, data: rawptr, call: Gsub_Proc)Source

call a procedure on every match in the haystack

index_special :: proc(text: string) -> (int)Source

helper call to quick search for special characters

is_alnum :: proc(c: rune) -> (bool)Source

is_cntrl :: proc(r: rune) -> (bool)Source

is_cont :: proc(b: u8) -> (bool)Source

continuation byte?

is_digit :: proc(r: rune) -> (bool)Source

is_graph :: proc(c: rune) -> (bool)Source

is_lower :: proc(r: rune) -> (bool)Source

is_punct :: proc(r: rune) -> (bool)Source

is_space :: proc(r: rune) -> (bool)Source

is_upper :: proc(r: rune) -> (bool)Source

is_xdigit :: proc(c: rune) -> (bool)Source

lmem_find :: proc(s1: string, s2: string) -> (int)Source

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

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

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

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

match_class :: proc(c: rune, cl: rune) -> (res: bool)Source

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

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

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

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

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

matcher_captures_slice :: proc(matcher: ^Matcher) -> ([]Match)Source

get a slice of all valid captures above the first match

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

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

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

alias

matcher_init :: proc(haystack: string, pattern: string, offset: int) -> (res: Matcher)Source

init using haystack & pattern and an optional byte offset

matcher_match :: proc(matcher: ^Matcher) -> (word: string, ok: bool)Source

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

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

iteratively match the haystack till it cant find any matches

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

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

pattern_case_insensitive_allocator :: proc(pattern: string, cap: int, allocator: mem.Allocator = context.allocator) -> (string)

Source

pattern_case_insensitive_builder :: proc(builder: ^strings.Builder, pattern: string) -> (string)Source

rebuilds a pattern into a case insensitive pattern

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

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

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

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

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

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

utf8_next :: proc(bytes: string, a: int) -> (int)Source

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

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

utf8_prev :: proc(bytes: string, a: int, b: int) -> (int)Source

Procedure Groups

gsub :: proc{gsub_builder, gsub_allocator}Source

pattern_case_insensitive :: proc{pattern_case_insensitive_builder, pattern_case_insensitive_allocator}Source

text_match

Types

Constants

Variables

Procedures

Procedure Groups

Find anything

Settings