package core:text/regex/parser

Source

Error :: union {
	Expected_Token, 
	Invalid_Repetition, 
	Invalid_Token, 
	Invalid_Unicode, 
	Too_Many_Capture_Groups, 
	Unexpected_EOF, 
}

Expected_Token :: struct {
	pos:  int,
	kind: regex_tokenizer.Token_Kind,
}

Invalid_Repetition :: struct {
	pos: int,
}

Invalid_Token :: struct {
	pos:  int,
	kind: regex_tokenizer.Token_Kind,
}

Invalid_Unicode :: struct {
	pos: int,
}

Node :: union {
	^Node_Rune, 
	^Node_Rune_Class, 
	^Node_Wildcard, 
	^Node_Concatenation, 
	^Node_Alternation, 
	^Node_Repeat_Zero, 
	^Node_Repeat_Zero_Non_Greedy, 
	^Node_Repeat_One, 
	^Node_Repeat_One_Non_Greedy, 
	^Node_Repeat_N, 
	^Node_Optional, 
	^Node_Optional_Non_Greedy, 
	^Node_Group, 
	^Node_Anchor, 
	^Node_Word_Boundary, 
	^Node_Match_All_And_Escape, 
}

Node_Alternation :: struct {
	left:  Node,
	right: Node,
}

Node_Anchor :: struct {
	start: bool,
}

Node_Concatenation :: struct {
	nodes: [dynamic]Node,
}

Node_Group :: struct {
	inner:      Node,
	capture_id: int,
	capture:    bool,
}

Node_Match_All_And_Escape :: struct {}

Node_Optional :: struct {
	inner: Node,
}

Node_Optional_Non_Greedy :: struct {
	inner: Node,
}

Node_Repeat_N :: struct {
	inner: Node,
	lower: int,
	upper: int,
}

Node_Repeat_One :: struct {
	inner: Node,
}

Node_Repeat_One_Non_Greedy :: struct {
	inner: Node,
}

Node_Repeat_Zero :: struct {
	inner: Node,
}

Node_Repeat_Zero_Non_Greedy :: struct {
	inner: Node,
}

Node_Rune :: struct {
	data: rune,
}

Node_Rune_Class :: struct {
	negating: bool,
	using data: Rune_Class_Data,
}

Node_Wildcard :: struct {}

Node_Word_Boundary :: struct {
	non_word: bool,
}

Parser :: struct {
	flags:     bit_set[regex_common.Flag; u8],
	t:         regex_tokenizer.Tokenizer,
	cur_token: regex_tokenizer.Token,
	groups:    int,
}

Rune_Class_Data :: struct {
	runes:  [dynamic]rune,
	ranges: [dynamic]Rune_Class_Range,
}

Rune_Class_Range :: struct {
	lower: rune,
	upper: rune,
}

Token :: regex_tokenizer.Token

Token_Kind :: regex_tokenizer.Token_Kind

Tokenizer :: regex_tokenizer.Tokenizer

Too_Many_Capture_Groups :: struct {
	pos: int,
}

Unexpected_EOF :: struct {
	pos: int,
}

@(require_results)
advance :: proc(p: ^Parser) -> Error {…}

expect :: proc(p: ^Parser, kind: regex_tokenizer.Token_Kind) -> (err: Error) {…}

left_binding_power :: proc(kind: regex_tokenizer.Token_Kind) -> int {…}

left_denotation :: proc(p: ^Parser, token: regex_tokenizer.Token, left: Node) -> (result: Node, err: Error) {…}

null_denotation :: proc(p: ^Parser, token: regex_tokenizer.Token) -> (result: Node, err: Error) {…}

parse :: proc(str: string, flags: bit_set[regex_common.Flag; u8]) -> (result: Node, err: Error) {…}

parse_expression :: proc(p: ^Parser, rbp: int) -> (result: Node, err: Error) {…}

write_node :: proc(w: io.Stream, node: Node) {…}