package core:text/regex/compiler

Source

Compiler :: struct {
	flags:      bit_set[regex_common.Flag; u8],
	class_data: [dynamic]regex_parser.Rune_Class_Data,
}

Error :: enum int {
	None, 
	Program_Too_Big, 
	Too_Many_Classes, 
}

Jump :: regex_vm.Jump

Node :: regex_parser.Node

Node_Alternation :: regex_parser.Node_Alternation

Node_Anchor :: regex_parser.Node_Anchor

Node_Concatenation :: regex_parser.Node_Concatenation

Node_Group :: regex_parser.Node_Group

Node_Match_All_And_Escape :: regex_parser.Node_Match_All_And_Escape

Node_Optional :: regex_parser.Node_Optional

Node_Optional_Non_Greedy :: regex_parser.Node_Optional_Non_Greedy

Node_Repeat_N :: regex_parser.Node_Repeat_N

Node_Repeat_One :: regex_parser.Node_Repeat_One

Node_Repeat_One_Non_Greedy :: regex_parser.Node_Repeat_One_Non_Greedy

Node_Repeat_Zero :: regex_parser.Node_Repeat_Zero

Node_Repeat_Zero_Non_Greedy :: regex_parser.Node_Repeat_Zero_Non_Greedy

Node_Rune :: regex_parser.Node_Rune

Node_Rune_Class :: regex_parser.Node_Rune_Class

Node_Wildcard :: regex_parser.Node_Wildcard

Node_Word_Boundary :: regex_parser.Node_Word_Boundary

Opcode :: regex_vm.Opcode

Program :: [dynamic]regex_vm.Opcode

Rune_Class_Data :: regex_parser.Rune_Class_Data

Rune_Class_Range :: regex_parser.Rune_Class_Range

Save :: regex_vm.Save

Split :: regex_vm.Split

Token :: regex_tokenizer.Token

Token_Kind :: regex_tokenizer.Token_Kind

Tokenizer :: regex_tokenizer.Tokenizer

Wait_For_Byte :: regex_vm.Wait_For_Byte

Wait_For_Rune :: regex_vm.Wait_For_Rune

Wait_For_Rune_Class :: regex_vm.Wait_For_Rune_Class

Wait_For_Rune_Class_Negated :: regex_vm.Wait_For_Rune_Class_Negated

JUMP_SIZE :: size_of(Jump)

SPLIT_SIZE :: size_of(Split)

append_raw :: proc(code: ^[dynamic]regex_vm.Opcode, data: $T) {…}

classes_are_exact :: proc(q, w: ^regex_parser.Rune_Class_Data) -> bool {…}

@(require_results)
compile :: proc(
	tree:  regex_parser.Node, 
	flags: bit_set[regex_common.Flag; u8], 
) -> (code: [dynamic]regex_vm.Opcode, class_data: [dynamic]regex_parser.Rune_Class_Data, err: Error) {…}

@(require_results)
generate_code :: proc(
	c:    ^Compiler, 
	node: regex_parser.Node, 
) -> (code: [dynamic]regex_vm.Opcode) {…}

get_jump_targets :: proc(code: []regex_vm.Opcode) -> (jump_targets: map[int]int) {…}

inject_raw :: proc(code: ^[dynamic]regex_vm.Opcode, start: int, data: $T) {…}

map_all_classes :: proc(
	tree:       regex_parser.Node, 
	collection: ^[dynamic]regex_parser.Rune_Class_Data, 
) {…}

trace :: proc(w: io.Stream, code: []regex_vm.Opcode) {…}