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

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

Token :: regex_tokenizer.Token

Token_Kind :: regex_tokenizer.Token_Kind

Tokenizer :: regex_tokenizer.Tokenizer

JUMP_SIZE :: size_of(Opcode) + 1 * size_of(u16)

SPLIT_SIZE :: size_of(Opcode) + 2 * size_of(u16)

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

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

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) {…}

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) {…}