vieter-v
/
v
2
0
Fork 0
Code Issues Pull Requests Releases Activity
v/vlib/regex/regex.v

2546 lines
66 KiB
V
Raw Blame History

/*
regex 1.0 alpha
Copyright (c) 2019-2022 Dario Deledda. All rights reserved.
Use of this source code is governed by an MIT license
that can be found in the LICENSE file.
This file contains regex module
Know limitation:
- find is implemented in a trivial way
- not full compliant PCRE
- not compliant POSIX ERE
*/
module regex
import strings
pub const (
v_regex_version = '1.0 alpha' // regex module version
max_code_len = 256 // default small base code len for the regex programs
max_quantifier = 1073741824 // default max repetitions allowed for the quantifiers = 2^30
// spaces chars (here only westerns!!) TODO: manage all the spaces from unicode
spaces = [` `, `\t`, `\n`, `\r`, `\v`, `\f`]
// new line chars for now only '\n'
new_line_list = [`\n`, `\r`]
// Results
no_match_found = -1
// Errors
compile_ok = 0 // the regex string compiled, all ok
err_char_unknown = -2 // the char used is unknow to the system
err_undefined = -3 // the compiler symbol is undefined
err_internal_error = -4 // Bug in the regex system!!
err_cc_alloc_overflow = -5 // memory for char class full!!
err_syntax_error = -6 // syntax error in regex compiling
err_groups_overflow = -7 // max number of groups reached
err_groups_max_nested = -8 // max number of nested group reached
err_group_not_balanced = -9 // group not balanced
err_group_qm_notation = -10 // group invalid notation
err_invalid_or_with_cc = -11 // invalid or on two consecutive char class
err_neg_group_quantifier = -12 // negation groups can not have quantifier
err_consecutive_dots = -13 // two consecutive dots is an error
)
const (
//*************************************
// regex program instructions
//*************************************
ist_simple_char = u32(0x7FFFFFFF) // single char instruction, 31 bit available to char
// char class 11 0100 AA xxxxxxxx
// AA = 00 regular class
// AA = 01 Negated class ^ char
ist_char_class = 0xD1000000 // MASK
ist_char_class_pos = 0xD0000000 // char class normal [abc]
ist_char_class_neg = 0xD1000000 // char class negate [^abc]
// dot char 10 0110 xx xxxxxxxx
ist_dot_char = 0x98000000 // match any char except \n
// backslash chars 10 0100 xx xxxxxxxx
ist_bsls_char = 0x90000000 // backslash char
// OR | 10 010Y xx xxxxxxxx
ist_or_branch = 0x91000000 // OR case
// groups 10 010Y xx xxxxxxxx
ist_group_start = 0x92000000 // group start (
ist_group_end = 0x94000000 // group end )
// control instructions
ist_prog_end = u32(0x88000000) // 10 0010 xx xxxxxxxx
//*************************************
)
/*
General Utilities
*/
// utf8util_char_len calculate the length in bytes of a utf8 char
[inline]
fn utf8util_char_len(b byte) int {
return ((0xe5000000 >> ((b >> 3) & 0x1e)) & 3) + 1
}
// get_char get a char from position i and return an u32 with the unicode code
[direct_array_access; inline]
fn (re RE) get_char(in_txt string, i int) (u32, int) {
ini := unsafe { in_txt.str[i] }
// ascii 8 bit
if (re.flag & regex.f_bin) != 0 || ini & 0x80 == 0 {
return u32(ini), 1
}
// unicode char
char_len := utf8util_char_len(ini)
mut tmp := 0
mut ch := u32(0)
for tmp < char_len {
ch = (ch << 8) | unsafe { in_txt.str[i + tmp] }
tmp++
}
return ch, char_len
}
// get_charb get a char from position i and return an u32 with the unicode code
[direct_array_access; inline]
fn (re RE) get_charb(in_txt &byte, i int) (u32, int) {
// ascii 8 bit
if (re.flag & regex.f_bin) != 0 || unsafe { in_txt[i] } & 0x80 == 0 {
return u32(unsafe { in_txt[i] }), 1
}
// unicode char
char_len := utf8util_char_len(unsafe { in_txt[i] })
mut tmp := 0
mut ch := u32(0)
for tmp < char_len {
ch = (ch << 8) | unsafe { in_txt[i + tmp] }
tmp++
}
return ch, char_len
}
[inline]
fn is_alnum(in_char byte) bool {
mut tmp := in_char - `A`
if tmp <= 25 {
return true
}
tmp = in_char - `a`
if tmp <= 25 {
return true
}
tmp = in_char - `0`
if tmp <= 9 {
return true
}
if in_char == `_` {
return true
}
return false
}
[inline]
fn is_not_alnum(in_char byte) bool {
return !is_alnum(in_char)
}
[inline]
fn is_space(in_char byte) bool {
return in_char in regex.spaces
}
[inline]
fn is_not_space(in_char byte) bool {
return !is_space(in_char)
}
[inline]
fn is_digit(in_char byte) bool {
tmp := in_char - `0`
return tmp <= 0x09
}
[inline]
fn is_not_digit(in_char byte) bool {
return !is_digit(in_char)
}
/*
[inline]
fn is_wordchar(in_char byte) bool {
return is_alnum(in_char) || in_char == `_`
}
[inline]
fn is_not_wordchar(in_char byte) bool {
return !is_alnum(in_char)
}
*/
[inline]
fn is_lower(in_char byte) bool {
tmp := in_char - `a`
return tmp <= 25
}
[inline]
fn is_upper(in_char byte) bool {
tmp := in_char - `A`
return tmp <= 25
}
pub fn (re RE) get_parse_error_string(err int) string {
match err {
regex.compile_ok { return 'compile_ok' }
regex.no_match_found { return 'no_match_found' }
regex.err_char_unknown { return 'err_char_unknown' }
regex.err_undefined { return 'err_undefined' }
regex.err_internal_error { return 'err_internal_error' }
regex.err_cc_alloc_overflow { return 'err_cc_alloc_overflow' }
regex.err_syntax_error { return 'err_syntax_error' }
regex.err_groups_overflow { return 'err_groups_overflow' }
regex.err_groups_max_nested { return 'err_groups_max_nested' }
regex.err_group_not_balanced { return 'err_group_not_balanced' }
regex.err_group_qm_notation { return 'err_group_qm_notation' }
regex.err_invalid_or_with_cc { return 'err_invalid_or_with_cc' }
regex.err_neg_group_quantifier { return 'err_neg_group_quantifier' }
regex.err_consecutive_dots { return 'err_consecutive_dots' }
else { return 'err_unknown' }
}
}
// utf8_str convert and utf8 sequence to a printable string
[inline]
fn utf8_str(ch rune) string {
mut i := 4
mut res := ''
for i > 0 {
v := byte((ch >> ((i - 1) * 8)) & 0xFF)
if v != 0 {
res += '${v:1c}'
}
i--
}
return res
}
// simple_log default log function
fn simple_log(txt string) {
print(txt)
}
/******************************************************************************
*
* Token Structs
*
******************************************************************************/
pub type FnValidator = fn (byte) bool
struct Token {
mut:
ist rune
// char
ch rune // char of the token if any
ch_len byte // char len
// Quantifiers / branch
rep_min int // used also for jump next in the OR branch [no match] pc jump
rep_max int // used also for jump next in the OR branch [ match] pc jump
greedy bool // greedy quantifier flag
// Char class
cc_index int = -1
// counters for quantifier check (repetitions)
rep int
// validator function pointer
validator FnValidator
// groups variables
group_neg bool // negation flag for the group, 0 => no negation > 0 => negataion
group_rep int // repetition of the group
group_id int = -1 // id of the group
goto_pc int = -1 // jump to this PC if is needed
// OR flag for the token
next_is_or bool // true if the next token is an OR
// dot_char token variables
dot_check_pc int = -1 // pc of the next token to check for dots
bsls_check_pc int = -1 // pc of the next token to check for bsls
last_dot_flag bool // if true indicate that is the last dot_char in the regex
// debug fields
source_index int
}
[inline]
fn (mut tok Token) reset() {
tok.rep = 0
}
/******************************************************************************
*
* Regex struct
*
******************************************************************************/
pub const (
f_nl = 0x00000001 // end the match when find a new line symbol
f_ms = 0x00000002 // match true only if the match is at the start of the string
f_me = 0x00000004 // match true only if the match is at the end of the string
f_efm = 0x00000100 // exit on first token matched, used by search
f_bin = 0x00000200 // work only on bytes, ignore utf-8
// behaviour modifier flags
f_src = 0x00020000 // search mode enabled
)
// Log function prototype
pub type FnLog = fn (string)
pub struct RE {
pub mut:
prog []Token
prog_len int // regex program len
// char classes storage
cc []CharClass // char class list
cc_index int // index
// groups
group_count int // number of groups in this regex struct
groups []int // groups index results
group_max_nested int = 3 // max nested group
group_max int = 8 // max allowed number of different groups
state_list []StateObj
group_csave_flag bool // flag to enable continuous saving
group_csave []int //= []int{} // groups continuous save list
group_map map[string]int // groups names map
group_stack []int
group_data []int
// flags
flag int // flag for optional parameters
// Debug/log
debug int // enable in order to have the unroll of the code 0 = NO_DEBUG, 1 = LIGHT 2 = VERBOSE
log_func FnLog = simple_log // log function, can be customized by the user
query string // query string
}
// Reset RE object
[direct_array_access; inline]
fn (mut re RE) reset() {
re.cc_index = 0
mut i := 0
for i < re.prog_len {
re.prog[i].group_rep = 0 // clear repetition of the group
re.prog[i].rep = 0 // clear repetition of the token
i++
}
// init groups array
if re.group_count > 0 {
if re.groups.len == 0 {
// first run alloc memory
re.groups = []int{len: re.group_count * 2, init: -1}
} else {
// subsequent executions, only clean up the memory
i = 0
for i < re.groups.len {
re.groups[i] = -1
i++
}
}
}
// reset group_csave
if re.group_csave_flag == true {
re.group_csave.clear() // = []int{}
}
// reset state list
re.state_list.clear()
re.group_stack.clear()
}
// reset for search mode fail
// gcc bug, dont use [inline] or go 5 time slower
//[inline]
[direct_array_access]
fn (mut re RE) reset_src() {
mut i := 0
for i < re.prog_len {
re.prog[i].group_rep = 0 // clear repetition of the group
re.prog[i].rep = 0 // clear repetition of the token
i++
}
}
/******************************************************************************
*
* Backslashes chars
*
******************************************************************************/
struct BslsStruct {
ch rune // meta char
validator FnValidator // validator function pointer
}
const (
bsls_validator_array = [
BslsStruct{`w`, is_alnum},
BslsStruct{`W`, is_not_alnum},
BslsStruct{`s`, is_space},
BslsStruct{`S`, is_not_space},
BslsStruct{`d`, is_digit},
BslsStruct{`D`, is_not_digit},
BslsStruct{`a`, is_lower},
BslsStruct{`A`, is_upper},
]
// these chars are escape if preceded by a \
bsls_escape_list = [`\\`, `|`, `.`, `:`, `*`, `+`, `-`, `{`, `}`, `[`, `]`, `(`, `)`, `?`,
`^`, `!`]
)
enum BSLS_parse_state {
start
bsls_found
bsls_char
normal_char
}
// parse_bsls return (index, str_len) bsls_validator_array index, len of the backslash sequence if present
fn (re RE) parse_bsls(in_txt string, in_i int) (int, int) {
mut status := BSLS_parse_state.start
mut i := in_i
for i < in_txt.len {
// get our char
char_tmp, char_len := re.get_char(in_txt, i)
ch := byte(char_tmp)
if status == .start && ch == `\\` {
status = .bsls_found
i += char_len
continue
}
// check if is our bsls char, for now only one length sequence
if status == .bsls_found {
for c, x in regex.bsls_validator_array {
if x.ch == ch {
return c, i - in_i + 1
}
}
status = .normal_char
continue
}
// no BSLS validator, manage as normal escape char char
if status == .normal_char {
if ch in regex.bsls_escape_list {
return regex.no_match_found, i - in_i + 1
}
return regex.err_syntax_error, i - in_i + 1
}
// at the present time we manage only one char after the \
break
}
// not our bsls return KO
return regex.err_syntax_error, i
}
/******************************************************************************
*
* Char class
*
******************************************************************************/
const (
cc_null = 0 // empty cc token
cc_char = 1 // simple char: a
cc_int = 2 // char interval: a-z
cc_bsls = 3 // backslash char
cc_end = 4 // cc sequence terminator
)
struct CharClass {
mut:
cc_type int = regex.cc_null // type of cc token
ch0 rune // first char of the interval a-b a in this case
ch1 rune // second char of the interval a-b b in this case
validator FnValidator // validator function pointer
}
enum CharClass_parse_state {
start
in_char
in_bsls
separator
finish
}
fn (re RE) get_char_class(pc int) string {
buf := []byte{len: (re.cc.len)}
mut buf_ptr := unsafe { &byte(&buf) }
mut cc_i := re.prog[pc].cc_index
mut i := 0
mut tmp := 0
for cc_i >= 0 && cc_i < re.cc.len && re.cc[cc_i].cc_type != regex.cc_end {
if re.cc[cc_i].cc_type == regex.cc_bsls {
unsafe {
buf_ptr[i] = `\\`
i++
buf_ptr[i] = byte(re.cc[cc_i].ch0)
i++
}
} else if re.cc[cc_i].ch0 == re.cc[cc_i].ch1 {
tmp = 3
for tmp >= 0 {
x := byte((re.cc[cc_i].ch0 >> (tmp * 8)) & 0xFF)
if x != 0 {
unsafe {
buf_ptr[i] = x
i++
}
}
tmp--
}
} else {
tmp = 3
for tmp >= 0 {
x := byte((re.cc[cc_i].ch0 >> (tmp * 8)) & 0xFF)
if x != 0 {
unsafe {
buf_ptr[i] = x
i++
}
}
tmp--
}
unsafe {
buf_ptr[i] = `-`
i++
}
tmp = 3
for tmp >= 0 {
x := byte((re.cc[cc_i].ch1 >> (tmp * 8)) & 0xFF)
if x != 0 {
unsafe {
buf_ptr[i] = x
i++
}
}
tmp--
}
}
cc_i++
}
unsafe {
buf_ptr[i] = byte(0)
}
return unsafe { tos_clone(buf_ptr) }
}
fn (re RE) check_char_class(pc int, ch rune) bool {
mut cc_i := re.prog[pc].cc_index
for cc_i >= 0 && cc_i < re.cc.len && re.cc[cc_i].cc_type != regex.cc_end {
if re.cc[cc_i].cc_type == regex.cc_bsls {
if re.cc[cc_i].validator(byte(ch)) {
return true
}
} else if ch >= re.cc[cc_i].ch0 && ch <= re.cc[cc_i].ch1 {
return true
}
cc_i++
}
return false
}
// parse_char_class return (index, str_len, cc_type) of a char class [abcm-p], char class start after the [ char
fn (mut re RE) parse_char_class(in_txt string, in_i int) (int, int, rune) {
mut status := CharClass_parse_state.start
mut i := in_i
mut tmp_index := re.cc_index
res_index := re.cc_index
mut cc_type := u32(regex.ist_char_class_pos)
for i < in_txt.len {
// check if we are out of memory for char classes
if tmp_index >= re.cc.len {
return regex.err_cc_alloc_overflow, 0, u32(0)
}
// get our char
char_tmp, char_len := re.get_char(in_txt, i)
ch := byte(char_tmp)
// println("CC #${i:3d} ch: ${ch:c}")
// negation
if status == .start && ch == `^` {
cc_type = u32(regex.ist_char_class_neg)
i += char_len
continue
}
// minus symbol
if status == .start && ch == `-` {
re.cc[tmp_index].cc_type = regex.cc_char
re.cc[tmp_index].ch0 = char_tmp
re.cc[tmp_index].ch1 = char_tmp
i += char_len
tmp_index++
continue
}
// bsls
if (status == .start || status == .in_char) && ch == `\\` {
// println("CC bsls.")
status = .in_bsls
i += char_len
continue
}
if status == .in_bsls {
// println("CC bsls validation.")
for c, x in regex.bsls_validator_array {
if x.ch == ch {
// println("CC bsls found [${ch:c}]")
re.cc[tmp_index].cc_type = regex.cc_bsls
re.cc[tmp_index].ch0 = regex.bsls_validator_array[c].ch
re.cc[tmp_index].ch1 = regex.bsls_validator_array[c].ch
re.cc[tmp_index].validator = regex.bsls_validator_array[c].validator
i += char_len
tmp_index++
status = .in_char
break
}
}
if status == .in_bsls {
// manage as a simple char
// println("CC bsls not found [${ch:c}]")
re.cc[tmp_index].cc_type = regex.cc_char
re.cc[tmp_index].ch0 = char_tmp
re.cc[tmp_index].ch1 = char_tmp
i += char_len
tmp_index++
status = .in_char
continue
} else {
continue
}
}
// simple char
if (status == .start || status == .in_char) && ch != `-` && ch != `]` {
status = .in_char
re.cc[tmp_index].cc_type = regex.cc_char
re.cc[tmp_index].ch0 = char_tmp
re.cc[tmp_index].ch1 = char_tmp
i += char_len
tmp_index++
continue
}
// check range separator
if status == .in_char && ch == `-` {
status = .separator
i += char_len
continue
}
// check range end
if status == .separator && ch != `]` && ch != `-` {
status = .in_char
re.cc[tmp_index - 1].cc_type = regex.cc_int
re.cc[tmp_index - 1].ch1 = char_tmp
i += char_len
continue
}
// char class end
if status == .in_char && ch == `]` {
re.cc[tmp_index].cc_type = regex.cc_end
re.cc[tmp_index].ch0 = 0
re.cc[tmp_index].ch1 = 0
re.cc_index = tmp_index + 1
return res_index, i - in_i + 2, cc_type
}
i++
}
return regex.err_syntax_error, 0, u32(0)
}
/******************************************************************************
*
* Re Compiler
*
******************************************************************************/
//
// Quantifier
//
enum Quant_parse_state {
start
min_parse
comma_checked
max_parse
greedy
gredy_parse
finish
}
// parse_quantifier return (min, max, str_len, greedy_flag) of a {min,max}? quantifier starting after the { char
fn (re RE) parse_quantifier(in_txt string, in_i int) (int, int, int, bool) {
mut status := Quant_parse_state.start
mut i := in_i
mut q_min := 0 // default min in a {} quantifier is 1
mut q_max := 0 // deafult max in a {} quantifier is max_quantifier
mut ch := byte(0)
for i < in_txt.len {
unsafe {
ch = in_txt.str[i]
}
// println("${ch:c} status: $status")
// exit on no compatible char with {} quantifier
if utf8util_char_len(ch) != 1 {
return regex.err_syntax_error, i, 0, false
}
// min parsing skip if comma present
if status == .start && ch == `,` {
q_min = 0 // default min in a {} quantifier is 0
status = .comma_checked
i++
continue
}
if status == .start && is_digit(ch) {
status = .min_parse
q_min *= 10
q_min += int(ch - `0`)
i++
continue
}
if status == .min_parse && is_digit(ch) {
q_min *= 10
q_min += int(ch - `0`)
i++
continue
}
// we have parsed the min, now check the max
if status == .min_parse && ch == `,` {
status = .comma_checked
i++
continue
}
// single value {4}
if status == .min_parse && ch == `}` {
q_max = q_min
status = .greedy
continue
}
// end without max
if status == .comma_checked && ch == `}` {
q_max = regex.max_quantifier
status = .greedy
continue
}
// start max parsing
if status == .comma_checked && is_digit(ch) {
status = .max_parse
q_max *= 10
q_max += int(ch - `0`)
i++
continue
}
// parse the max
if status == .max_parse && is_digit(ch) {
q_max *= 10
q_max += int(ch - `0`)
i++
continue
}
// finished the quantifier
if status == .max_parse && ch == `}` {
status = .greedy
continue
}
// check if greedy flag char ? is present
if status == .greedy {
if i + 1 < in_txt.len {
i++
status = .gredy_parse
continue
}
return q_min, q_max, i - in_i + 2, false
}
// check the greedy flag
if status == .gredy_parse {
if ch == `?` {
return q_min, q_max, i - in_i + 2, true
} else {
i--
return q_min, q_max, i - in_i + 2, false
}
}
// not a {} quantifier, exit
return regex.err_syntax_error, i, 0, false
}
// not a conform {} quantifier
return regex.err_syntax_error, i, 0, false
}
//
// Groups
//
enum Group_parse_state {
start
q_mark // (?
q_mark1 // (?:|P checking
p_status // (?P
p_start // (?P<
p_end // (?P<...>
p_in_name // (?P<...
finish
}
// parse_groups parse a group for ? (question mark) syntax, if found, return (error, capture_flag, negate_flag, name_of_the_group, next_index)
fn (re RE) parse_groups(in_txt string, in_i int) (int, bool, bool, string, int) {
mut status := Group_parse_state.start
mut i := in_i
mut name := ''
for i < in_txt.len && status != .finish {
// get our char
char_tmp, char_len := re.get_char(in_txt, i)
ch := byte(char_tmp)
// start
if status == .start && ch == `(` {
status = .q_mark
i += char_len
continue
}
// check for question marks
if status == .q_mark && ch == `?` {
status = .q_mark1
i += char_len
continue
}
// negate group
if status == .q_mark1 && ch == `!` {
i += char_len
return 0, false, true, name, i
}
// non capturing group
if status == .q_mark1 && ch == `:` {
i += char_len
return 0, false, false, name, i
}
// enter in P section
if status == .q_mark1 && ch == `P` {
status = .p_status
i += char_len
continue
}
// not a valid q mark found
if status == .q_mark1 {
// println("NO VALID Q MARK")
return -2, true, false, name, i
}
if status == .p_status && ch == `<` {
status = .p_start
i += char_len
continue
}
if status == .p_start && ch != `>` {
status = .p_in_name
name += '${ch:1c}' // TODO: manage utf8 chars
i += char_len
continue
}
// colect name
if status == .p_in_name && ch != `>` && is_alnum(ch) {
name += '${ch:1c}' // TODO: manage utf8 chars
i += char_len
continue
}
// end name
if status == .p_in_name && ch == `>` {
i += char_len
return 0, true, false, name, i
}
// error on name group
if status == .p_in_name {
return -2, true, false, name, i
}
// normal group, nothig to do, exit
return 0, true, false, name, i
}
// UNREACHABLE
// println("ERROR!! NOT MEANT TO BE HERE!!1")
return -2, true, false, name, i
}
const (
quntifier_chars = [rune(`+`), `*`, `?`, `{`]
)
//
// main compiler
//
// compile return (return code, index) where index is the index of the error in the query string if return code is an error code
fn (mut re RE) impl_compile(in_txt string) (int, int) {
mut i := 0 // input string index
mut pc := 0 // program counter
// group management variables
mut group_count := -1
mut group_stack := []int{len: re.group_max_nested, init: 0}
mut group_stack_txt_index := []int{len: re.group_max_nested, init: -1}
mut group_stack_index := -1
re.query = in_txt // save the query string
i = 0
for i < in_txt.len {
mut char_tmp := u32(0)
mut char_len := 0
// println("i: ${i:3d} ch: ${in_txt.str[i]:c}")
char_tmp, char_len = re.get_char(in_txt, i)
//
// check special cases: $ ^
//
if char_len == 1 && i == 0 && byte(char_tmp) == `^` {
re.flag = regex.f_ms
i = i + char_len
continue
}
if char_len == 1 && i == (in_txt.len - 1) && byte(char_tmp) == `$` {
re.flag = regex.f_me
i = i + char_len
continue
}
// ist_group_start
if char_len == 1 && pc >= 0 && byte(char_tmp) == `(` {
// check max groups allowed
if group_count > re.group_max {
return regex.err_groups_overflow, i + 1
}
group_stack_index++
// check max nested groups allowed
if group_stack_index > re.group_max_nested {
return regex.err_groups_max_nested, i + 1
}
tmp_res, cgroup_flag, negate_flag, cgroup_name, next_i := re.parse_groups(in_txt,
i)
// manage question mark format error
if tmp_res < -1 {
return regex.err_group_qm_notation, next_i
}
// println("Parse group: [$tmp_res, $cgroup_flag, ($i,$next_i), '${in_txt[i..next_i]}' ]")
i = next_i
if cgroup_flag == true {
group_count++
}
// calculate the group id
// if it is a named group, recycle the group id
// NOTE: **** the group index is +1 because map return 0 when not found!! ****
mut group_id := group_count
if cgroup_name.len > 0 {
// println("GROUP NAME: ${cgroup_name}")
if cgroup_name in re.group_map {
group_id = re.group_map[cgroup_name] - 1
group_count--
} else {
re.group_map[cgroup_name] = group_id + 1
}
}
group_stack_txt_index[group_stack_index] = i
group_stack[group_stack_index] = pc
re.prog[pc].ist = u32(0) | regex.ist_group_start
re.prog[pc].rep_min = 1
re.prog[pc].rep_max = 1
// manage negation groups
if negate_flag == true {
re.prog[pc].group_neg = true
re.prog[pc].rep_min = 0 // may be not catched, but it is ok
}
// set the group id
if cgroup_flag == false {
// println("NO CAPTURE GROUP")
re.prog[pc].group_id = -1
} else {
re.prog[pc].group_id = group_id
}
pc = pc + 1
continue
}
// ist_group_end
if char_len == 1 && pc > 0 && byte(char_tmp) == `)` {
if group_stack_index < 0 {
return regex.err_group_not_balanced, i + 1
}
goto_pc := group_stack[group_stack_index]
group_stack_index--
re.prog[pc].ist = u32(0) | regex.ist_group_end
re.prog[pc].rep_min = 1
re.prog[pc].rep_max = 1
re.prog[pc].goto_pc = goto_pc // PC where to jump if a group need
re.prog[pc].group_id = re.prog[goto_pc].group_id // id of this group, used for storing data
re.prog[goto_pc].goto_pc = pc // start goto point to the end group pc
// re.prog[goto_pc].group_id = group_count // id of this group, used for storing data
// duplicate the negation group info and settings
if re.prog[goto_pc].group_neg == true {
re.prog[pc].group_neg = re.prog[goto_pc].group_neg
re.prog[pc].rep_min = re.prog[goto_pc].rep_min
}
pc = pc + 1
i = i + char_len
continue
}
// ist_dot_char match any char except the following token
if char_len == 1 && pc >= 0 && byte(char_tmp) == `.` {
// consecutive ist_dot_char is a syntax error
if pc > 0 && re.prog[pc - 1].ist == regex.ist_dot_char {
return regex.err_consecutive_dots, i
}
re.prog[pc].ist = u32(0) | regex.ist_dot_char
re.prog[pc].rep_min = 1
re.prog[pc].rep_max = 1
pc = pc + 1
i = i + char_len
continue
}
// OR branch
if char_len == 1 && pc > 0 && byte(char_tmp) == `|` {
if pc > 0 && re.prog[pc - 1].ist == regex.ist_or_branch {
return regex.err_syntax_error, i
}
re.prog[pc].ist = u32(0) | regex.ist_or_branch
re.prog[pc].source_index = i
pc = pc + 1
i = i + char_len
continue
}
// Quantifiers
if char_len == 1 && pc > 0 {
mut char_next := rune(0)
mut char_next_len := 0
if (char_len + i) < in_txt.len {
char_next, char_next_len = re.get_char(in_txt, i + char_len)
}
mut quant_flag := true
// negation groups can not have quantifiers
if re.prog[pc - 1].group_neg == true && char_tmp in [`?`, `+`, `*`, `{`] {
return regex.err_neg_group_quantifier, i
}
match byte(char_tmp) {
`?` {
// println("q: ${char_tmp:c}")
// check illegal quantifier sequences
if char_next_len == 1 && char_next in regex.quntifier_chars {
return regex.err_syntax_error, i
}
re.prog[pc - 1].rep_min = 0
re.prog[pc - 1].rep_max = 1
}
`+` {
// println("q: ${char_tmp:c}")
// check illegal quantifier sequences
if char_next_len == 1 && char_next in regex.quntifier_chars {
return regex.err_syntax_error, i
}
re.prog[pc - 1].rep_min = 1
re.prog[pc - 1].rep_max = regex.max_quantifier
}
`*` {
// println("q: ${char_tmp:c}")
// check illegal quantifier sequences
if char_next_len == 1 && char_next in regex.quntifier_chars {
return regex.err_syntax_error, i
}
re.prog[pc - 1].rep_min = 0
re.prog[pc - 1].rep_max = regex.max_quantifier
}
`{` {
min, max, tmp, greedy := re.parse_quantifier(in_txt, i + 1)
// it is a quantifier
if min >= 0 {
// println("{$min,$max}\n str:[${in_txt[i..i+tmp]}] greedy:$greedy")
i = i + tmp
re.prog[pc - 1].rep_min = min
re.prog[pc - 1].rep_max = max
re.prog[pc - 1].greedy = greedy
// check illegal quantifier sequences
if i <= in_txt.len {
char_next, char_next_len = re.get_char(in_txt, i)
if char_next_len == 1 && char_next in regex.quntifier_chars {
return regex.err_syntax_error, i
}
}
continue
} else {
return min, i
}
// TODO: decide if the open bracket can be conform without the close bracket
/*
// no conform, parse as normal char
else {
quant_flag = false
}
*/
}
else {
quant_flag = false
}
}
if quant_flag {
i = i + char_len
continue
}
}
// IST_CHAR_CLASS_*
if char_len == 1 && pc >= 0 {
if byte(char_tmp) == `[` {
cc_index, tmp, cc_type := re.parse_char_class(in_txt, i + 1)
if cc_index >= 0 {
// println("index: $cc_index str:${in_txt[i..i+tmp]}")
i = i + tmp
re.prog[pc].ist = u32(0) | cc_type
re.prog[pc].cc_index = cc_index
re.prog[pc].rep_min = 1
re.prog[pc].rep_max = 1
pc = pc + 1
continue
}
// cc_class vector memory full
else if cc_index < 0 {
return cc_index, i
}
}
}
// ist_bsls_char
if char_len == 1 && pc >= 0 {
if byte(char_tmp) == `\\` {
bsls_index, tmp := re.parse_bsls(in_txt, i)
// println("index: $bsls_index str:${in_txt[i..i+tmp]}")
if bsls_index >= 0 {
i = i + tmp
re.prog[pc].ist = u32(0) | regex.ist_bsls_char
re.prog[pc].rep_min = 1
re.prog[pc].rep_max = 1
re.prog[pc].validator = regex.bsls_validator_array[bsls_index].validator
re.prog[pc].ch = regex.bsls_validator_array[bsls_index].ch
pc = pc + 1
continue
}
// this is an escape char, skip the bsls and continue as a normal char
else if bsls_index == regex.no_match_found {
i += char_len
char_tmp, char_len = re.get_char(in_txt, i)
// continue as simple char
}
// if not an escape or a bsls char then it is an error (at least for now!)
else {
return bsls_index, i + tmp
}
}
}
// ist_simple_char
re.prog[pc].ist = regex.ist_simple_char
re.prog[pc].ch = char_tmp
re.prog[pc].ch_len = byte(char_len)
re.prog[pc].rep_min = 1
re.prog[pc].rep_max = 1
// println("char: ${char_tmp:c}")
pc = pc + 1
i += char_len
}
// add end of the program
re.prog[pc].ist = regex.ist_prog_end
re.prog_len = pc
// check for unbalanced groups
if group_stack_index != -1 {
return regex.err_group_not_balanced, group_stack_txt_index[group_stack_index] + 1
}
// check for OR at the end of the program
if pc > 0 && re.prog[pc - 1].ist == regex.ist_or_branch {
return regex.err_syntax_error, in_txt.len - 1
}
// store the number of groups in the query
re.group_count = group_count + 1
//******************************************
// Post processing
//******************************************
//
// manage ist_dot_char
//
// find the checks for dot chars, if any...
mut pc1 := 0
mut dot_char_count := 0
mut last_dot_char_pc := -1
for pc1 < pc {
if re.prog[pc1].ist == regex.ist_dot_char {
// println("Dot_char pc: $pc1")
last_dot_char_pc = pc1
dot_char_count++
mut pc2 := pc1 + 1
for pc2 < pc {
// consecutive dot chars is an error
if re.prog[pc2].ist == regex.ist_dot_char {
return regex.err_syntax_error, 0
}
if re.prog[pc2].ist !in [rune(regex.ist_prog_end), regex.ist_group_end,
regex.ist_group_start] {
// println("Next dot char check is PC: ${pc2}")
re.prog[pc1].dot_check_pc = pc2
break
}
pc2++
}
}
pc1++
}
// println("last_dot_char_pc: $last_dot_char_pc")
if last_dot_char_pc >= 0 {
pc1 = last_dot_char_pc + 1
mut is_last_dot := true
for pc1 < pc {
if re.prog[pc1].ist !in [rune(regex.ist_prog_end), regex.ist_group_end] {
is_last_dot = false
break
}
pc1++
}
if is_last_dot {
re.prog[last_dot_char_pc].last_dot_flag = true
}
}
//
// manage bsls_char
//
// find the checks for bsls, if any...
pc1 = 0
mut bsls_char_count := 0
mut last_bsls_char_pc := -1
for pc1 < pc {
if re.prog[pc1].ist == regex.ist_bsls_char {
// println("bsls_char pc: $pc1")
last_bsls_char_pc = pc1
bsls_char_count++
mut pc2 := pc1 + 1
for pc2 < pc {
if re.prog[pc2].ist !in [rune(regex.ist_prog_end), regex.ist_group_end,
regex.ist_group_start] {
// println("Next bsls check is PC: ${pc2}")
re.prog[pc1].bsls_check_pc = pc2
break
}
pc2++
}
}
pc1++
}
// println("last_bsls_char_pc: $last_bsls_char_pc")
if last_bsls_char_pc >= 0 {
pc1 = last_bsls_char_pc + 1
mut is_last_bsls := true
for pc1 < pc {
if re.prog[pc1].ist !in [rune(regex.ist_prog_end), regex.ist_group_end] {
is_last_bsls = false
break
}
pc1++
}
if is_last_bsls {
re.prog[last_bsls_char_pc].last_dot_flag = true
}
}
//******************************************
// OR branch
// a|b|cd
// d exit point
// a,b,c branches
// set the jump in the right places
pc1 = 0
for pc1 < pc - 2 {
// println("Here $pc1 ${pc-2}")
// println("source index: ${pc1 + 1} => ${re.prog[pc1+1].source_index}")
if re.prog[pc1 + 1].ist == regex.ist_or_branch {
// two consecutive OR are a syntax error
if re.prog[pc1 + 2].ist == regex.ist_or_branch {
return regex.err_syntax_error, i
}
// check for []|[] errors
if re.prog[pc1].ist == regex.ist_char_class_pos
&& re.prog[pc1 + 2].ist == regex.ist_char_class_pos {
return regex.err_invalid_or_with_cc, re.prog[pc1 + 1].source_index
}
}
// manange a|b chains like a|(b)|c|d...
// standard solution
if re.prog[pc1].ist != regex.ist_or_branch && re.prog[pc1 + 1].ist == regex.ist_or_branch
&& re.prog[pc1 + 2].ist != regex.ist_or_branch {
re.prog[pc1].next_is_or = true // set that the next token is an OR
re.prog[pc1 + 1].rep_min = pc1 + 2 // failed match jump
// match jump, if an OR chain the next token will be an OR token
mut pc2 := pc1 + 2
for pc2 < pc - 1 {
ist := re.prog[pc2].ist
if ist == regex.ist_group_start {
re.prog[pc1 + 1].rep_max = re.prog[pc2].goto_pc + 1
break
}
if ist != regex.ist_or_branch {
re.prog[pc1 + 1].rep_max = pc2 + 1
break
}
pc2++
}
// special case query of few chars, the true can't go on the first instruction
if re.prog[pc1 + 1].rep_max == pc1 {
re.prog[pc1 + 1].rep_max = 3
}
// println("Compile OR postproc. [$pc1,OR ${pc1+1},$pc2]")
pc1 = pc2
continue
}
pc1++
}
//******************************************
// DEBUG PRINT REGEX GENERATED CODE
//******************************************
if re.debug > 0 {
gc := re.get_code()
re.log_func(gc)
}
//******************************************
return regex.compile_ok, 0
}
// get_code return the compiled code as regex string, note: may be different from the source!
pub fn (re RE) get_code() string {
mut pc1 := 0
mut res := strings.new_builder(re.cc.len * 2 * re.prog.len)
res.write_string('========================================\nv RegEx compiler v $regex.v_regex_version output:\n')
mut stop_flag := false
for pc1 <= re.prog.len {
tk := re.prog[pc1]
res.write_string('PC:${pc1:3d}')
res.write_string(' ist: ')
res.write_string('${tk.ist:8x}'.replace(' ', '0'))
res.write_string(' ')
ist := tk.ist
if ist == regex.ist_bsls_char {
res.write_string('[\\${tk.ch:1c}] BSLS')
} else if ist == regex.ist_prog_end {
res.write_string('PROG_END')
stop_flag = true
} else if ist == regex.ist_or_branch {
res.write_string('OR ')
} else if ist == regex.ist_char_class_pos {
res.write_string('[${re.get_char_class(pc1)}] CHAR_CLASS_POS')
} else if ist == regex.ist_char_class_neg {
res.write_string('[^${re.get_char_class(pc1)}] CHAR_CLASS_NEG')
} else if ist == regex.ist_dot_char {
res.write_string('. DOT_CHAR nx chk: $tk.dot_check_pc')
if tk.last_dot_flag == true {
res.write_string(' last!')
}
} else if ist == regex.ist_group_start {
res.write_string('( GROUP_START #:$tk.group_id')
if tk.group_id == -1 {
res.write_string(' ?:')
} else {
for x in re.group_map.keys() {
if re.group_map[x] == (tk.group_id + 1) {
res.write_string(' ?P<$x>')
break
}
}
}
} else if ist == regex.ist_group_end {
res.write_string(') GROUP_END #:$tk.group_id')
} else if ist == regex.ist_simple_char {
res.write_string('[${tk.ch:1c}] query_ch')
}
if tk.rep_max == regex.max_quantifier {
res.write_string(' {${tk.rep_min:3d},MAX}')
} else {
if ist == regex.ist_or_branch {
res.write_string(' if false go: ${tk.rep_min:3d} if true go: ${tk.rep_max:3d}')
} else {
res.write_string(' {${tk.rep_min:3d},${tk.rep_max:3d}}')
}
if tk.greedy == true {
res.write_string('?')
}
}
res.write_string('\n')
if stop_flag {
break
}
pc1++
}
res.write_string('========================================\n')
return res.str()
}
// get_query return a string with a reconstruction of the query starting from the regex program code
pub fn (re RE) get_query() string {
mut res := strings.new_builder(re.query.len * 2)
if (re.flag & regex.f_ms) != 0 {
res.write_string('^')
}
mut i := 0
for i < re.prog.len && re.prog[i].ist != regex.ist_prog_end && re.prog[i].ist != 0 {
tk := unsafe { &re.prog[i] }
ch := tk.ist
// GROUP start
if ch == regex.ist_group_start {
if re.debug > 0 {
res.write_string('#$tk.group_id')
}
res.write_string('(')
if tk.group_neg == true {
res.write_string('?!') // negation group
} else if tk.group_id == -1 {
res.write_string('?:') // non capturing group
}
for x in re.group_map.keys() {
if re.group_map[x] == (tk.group_id + 1) {
res.write_string('?P<$x>')
break
}
}
i++
continue
}
// GROUP end
if ch == regex.ist_group_end {
res.write_string(')')
}
// OR branch
if ch == regex.ist_or_branch {
res.write_string('|')
if re.debug > 0 {
res.write_string('{$tk.rep_min,$tk.rep_max}')
}
i++
continue
}
// char class
if ch == regex.ist_char_class_neg || ch == regex.ist_char_class_pos {
res.write_string('[')
if ch == regex.ist_char_class_neg {
res.write_string('^')
}
res.write_string('${re.get_char_class(i)}')
res.write_string(']')
}
// bsls char
if ch == regex.ist_bsls_char {
res.write_string('\\${tk.ch:1c}')
}
// ist_dot_char
if ch == regex.ist_dot_char {
res.write_string('.')
}
// char alone
if ch == regex.ist_simple_char {
if byte(ch) in regex.bsls_escape_list {
res.write_string('\\')
}
res.write_string('${tk.ch:c}')
}
// quantifier
if !(tk.rep_min == 1 && tk.rep_max == 1) && tk.group_neg == false {
if tk.rep_min == 0 && tk.rep_max == 1 {
res.write_string('?')
} else if tk.rep_min == 1 && tk.rep_max == regex.max_quantifier {
res.write_string('+')
} else if tk.rep_min == 0 && tk.rep_max == regex.max_quantifier {
res.write_string('*')
} else {
if tk.rep_max == regex.max_quantifier {
res.write_string('{$tk.rep_min,MAX}')
} else {
res.write_string('{$tk.rep_min,$tk.rep_max}')
}
if tk.greedy == true {
res.write_string('?')
}
}
}
i++
}
if (re.flag & regex.f_me) != 0 {
res.write_string('$')
}
return res.str()
}
/******************************************************************************
*
* Groups saving utilities
*
******************************************************************************/
[direct_array_access]
fn (mut re RE) group_continuous_save(g_index int) {
if re.group_csave_flag == true {
// continuous save, save until we have space
// init the first element as counter
if re.group_csave.len == 0 {
re.group_csave << 0
}
gi := g_index >> 1
start := re.groups[g_index]
end := re.groups[g_index + 1]
// check if we are simply increasing the size ot the found group
if re.group_csave.len >= 4 && gi == re.group_csave[re.group_csave.len - 3]
&& start == re.group_csave[re.group_csave.len - 2] {
re.group_csave[re.group_csave.len - 1] = end
return
}
// otherwise append a new group to the list
// increment counter
re.group_csave[0]++
// save the record
re.group_csave << (g_index >> 1) // group id
re.group_csave << re.groups[g_index] // start
re.group_csave << re.groups[g_index + 1] // end
}
}
/******************************************************************************
*
* Matching
*
******************************************************************************/
enum Match_state {
start = 0
stop
end
new_line
ist_load // load and execute instruction
ist_next // go to next instruction
ist_next_ks // go to next instruction without clenaning the state
ist_quant_p // match positive ,quantifier check
ist_quant_n // match negative, quantifier check
ist_quant_pg // match positive ,group quantifier check
ist_quant_ng // match negative ,group quantifier check
}
fn state_str(s Match_state) string {
match s {
.start { return 'start' }
.stop { return 'stop' }
.end { return 'end' }
.new_line { return 'new line' }
.ist_load { return 'ist_load' }
.ist_next { return 'ist_next' }
.ist_next_ks { return 'ist_next_ks' }
.ist_quant_p { return 'ist_quant_p' }
.ist_quant_n { return 'ist_quant_n' }
.ist_quant_pg { return 'ist_quant_pg' }
.ist_quant_ng { return 'ist_quant_ng' }
}
}
struct StateObj {
pub mut:
group_index int = -1 // group id used to know how many groups are open
match_flag bool // indicate if we are in a match condition
match_index int = -1 // index of the last match
first_match int = -1 // index of the first match
pc int = -1 // program counter
i int = -1 // source string index
char_len int // last char legth
last_dot_pc int = -1 // last dot chat pc
}
[direct_array_access]
pub fn (mut re RE) match_base(in_txt &byte, in_txt_len int) (int, int) {
// result status
mut result := regex.no_match_found // function return
mut ch := rune(0) // examinated char
mut char_len := 0 // utf8 examinated char len
mut m_state := Match_state.start // start point for the matcher FSM
mut src_end := false
mut last_fnd_pc := -1
mut state := StateObj{} // actual state
mut ist := rune(0) // actual instruction
mut l_ist := rune(0) // last matched instruction
mut step_count := 0 // stats for debug
mut dbg_line := 0 // count debug line printed
re.reset()
if re.debug > 0 {
// print header
mut h_buf := strings.new_builder(32)
h_buf.write_string('flags: ')
h_buf.write_string('${re.flag:8x}'.replace(' ', '0'))
h_buf.write_string('\n')
sss := h_buf.str()
re.log_func(sss)
}
for m_state != .end {
if state.pc >= 0 && state.pc < re.prog.len {
ist = re.prog[state.pc].ist
} else if state.pc >= re.prog.len {
// println("ERROR!! PC overflow!!")
return regex.err_internal_error, state.i
}
//******************************************
// DEBUG LOG
//******************************************
if re.debug > 0 {
mut buf2 := strings.new_builder(re.cc.len + 128)
// print all the instructions
// end of the input text
if state.i >= in_txt_len {
buf2.write_string('# ${step_count:3d} END OF INPUT TEXT\n')
sss := buf2.str()
re.log_func(sss)
} else {
// print only the exe instruction
if (re.debug == 1 && m_state == .ist_load) || re.debug == 2 {
if ist == regex.ist_prog_end {
buf2.write_string('# ${step_count:3d} PROG_END\n')
} else if ist == 0 || m_state in [.start, .ist_next, .stop] {
buf2.write_string('# ${step_count:3d} s: ${state_str(m_state):12s} PC: NA\n')
} else {
ch, char_len = re.get_charb(in_txt, state.i)
buf2.write_string('# ${step_count:3d} s: ${state_str(m_state):12s} PC: ${state.pc:3d}=>')
buf2.write_string('${ist:8x}'.replace(' ', '0'))
buf2.write_string(" i,ch,len:[${state.i:3d},'${utf8_str(ch)}',$char_len] f.m:[${state.first_match:3d},${state.match_index:3d}] ")
if ist == regex.ist_simple_char {
buf2.write_string('query_ch: [${re.prog[state.pc].ch:1c}]')
} else {
if ist == regex.ist_bsls_char {
buf2.write_string('BSLS [\\${re.prog[state.pc].ch:1c}]')
} else if ist == regex.ist_prog_end {
buf2.write_string('PROG_END')
} else if ist == regex.ist_or_branch {
buf2.write_string('OR')
} else if ist == regex.ist_char_class_pos {
buf2.write_string('CHAR_CLASS_POS[${re.get_char_class(state.pc)}]')
} else if ist == regex.ist_char_class_neg {
buf2.write_string('CHAR_CLASS_NEG[${re.get_char_class(state.pc)}]')
} else if ist == regex.ist_dot_char {
buf2.write_string('DOT_CHAR')
} else if ist == regex.ist_group_start {
tmp_gi := re.prog[state.pc].group_id
tmp_gr := re.prog[re.prog[state.pc].goto_pc].group_rep
buf2.write_string('GROUP_START #:$tmp_gi rep:$tmp_gr ')
} else if ist == regex.ist_group_end {
buf2.write_string('GROUP_END #:${re.prog[state.pc].group_id} deep:$state.group_index')
}
}
if re.prog[state.pc].rep_max == regex.max_quantifier {
buf2.write_string('{${re.prog[state.pc].rep_min},MAX}:${re.prog[state.pc].rep}')
} else {
buf2.write_string('{${re.prog[state.pc].rep_min},${re.prog[state.pc].rep_max}}:${re.prog[state.pc].rep}')
}
if re.prog[state.pc].greedy == true {
buf2.write_string('?')
}
buf2.write_string(' (#$state.group_index)')
if ist == regex.ist_dot_char {
buf2.write_string(' last!')
}
buf2.write_string('\n')
}
sss2 := buf2.str()
re.log_func(sss2)
}
}
step_count++
dbg_line++
}
//******************************************
if ist == regex.ist_prog_end {
// println("HERE we end!")
break
}
// we're out of text, manage it
if state.i >= in_txt_len || m_state == .new_line {
// println("Finished text!!")
src_end = true
// manage groups
if state.group_index >= 0 && state.match_index >= 0 {
// println("End text with open groups!")
// close the groups
for state.group_index >= 0 {
tmp_pc := re.group_data[state.group_index]
re.prog[tmp_pc].group_rep++
// println("Closing group $state.group_index {${re.prog[tmp_pc].rep_min},${re.prog[tmp_pc].rep_max}}:${re.prog[tmp_pc].group_rep}")
if re.prog[tmp_pc].group_rep >= re.prog[tmp_pc].rep_min
&& re.prog[tmp_pc].group_id >= 0 {
start_i := re.group_stack[state.group_index]
re.group_stack[state.group_index] = -1
// save group results
g_index := re.prog[tmp_pc].group_id * 2
if start_i >= 0 {
re.groups[g_index] = start_i
} else {
re.groups[g_index] = 0
}
// we have fished the text, we must manage out pf bound indexes
if state.i >= in_txt_len {
state.i = in_txt_len - 1
}
re.groups[g_index + 1] = state.i
if re.groups[g_index + 1] >= in_txt_len {
// println("clamp group on stop!")
re.groups[g_index + 1] = in_txt_len - 1
}
// continuous save, save until we have space
re.group_continuous_save(g_index)
}
state.group_index--
}
}
// the text is finished and the groups closed and we are the last group, ok exit
if ist == regex.ist_group_end && re.prog[state.pc + 1].ist == regex.ist_prog_end {
// println("Last group end")
return state.first_match, state.i
}
if state.pc == -1 {
state.pc = last_fnd_pc
}
// println("Finished text!!")
// println("Instruction: ${ist:08x} pc: $state.pc")
// println("min_rep: ${re.prog[state.pc].rep_min} max_rep: ${re.prog[state.pc].rep_max} rep: ${re.prog[state.pc].rep}")
// program end
if ist == regex.ist_prog_end {
// println("Program end on end of text!")
return state.first_match, state.i
}
// we are in a last dot_ char case
if l_ist == regex.ist_dot_char {
// println("***** We have a last dot_char")
// println("PC: ${state.pc} last_dot_flag:${re.prog[state.pc].last_dot_flag}")
// println("rep: ${re.prog[state.pc].group_rep} min: ${re.prog[state.pc].rep_min} max: ${re.prog[state.pc].rep_max}")
// println("first match: ${state.first_match}")
if re.prog[state.pc].last_dot_flag == true
&& re.prog[state.pc].rep >= re.prog[state.pc].rep_min
&& re.prog[state.pc].rep <= re.prog[state.pc].rep_max {
return state.first_match, state.i
}
// println("Not fitted!!")
}
// m_state = .end
// break
// no groups open, check the last token quantifier
if ist != regex.ist_group_end && re.prog[state.pc + 1].ist == regex.ist_prog_end {
if re.prog[state.pc].rep >= re.prog[state.pc].rep_min
&& re.prog[state.pc].rep <= re.prog[state.pc].rep_max {
// println("We are in good repetition")
return state.first_match, state.i
}
}
// print("No good exit!!")
return regex.no_match_found, state.i
}
// starting and init
if m_state == .start {
state.pc = -1
state.i = 0
m_state = .ist_next
continue
}
// ist_next, next instruction reseting its state
else if m_state == .ist_next {
state.pc = state.pc + 1
re.prog[state.pc].reset()
// check if we are in the program bounds
if state.pc < 0 || state.pc > re.prog.len {
// println("ERROR!! PC overflow!!")
return regex.err_internal_error, state.i
}
m_state = .ist_load
continue
}
// ist_next_ks, next instruction keeping its state
else if m_state == .ist_next_ks {
state.pc = state.pc + 1
// check if we are in the program bounds
if state.pc < 0 || state.pc > re.prog.len {
// println("ERROR!! PC overflow!!")
return regex.err_internal_error, state.i
}
m_state = .ist_load
continue
}
// load the char
ch, char_len = re.get_charb(in_txt, state.i)
// check new line if flag f_nl enabled
if (re.flag & regex.f_nl) != 0 && char_len == 1 && byte(ch) in regex.new_line_list {
m_state = .new_line
continue
}
// check if stop
else if m_state == .stop {
// we are in search mode, don't exit until the end
if ((re.flag & regex.f_src) != 0) && (ist != regex.ist_prog_end) {
last_fnd_pc = state.pc
state.pc = -1
state.i += char_len
m_state = .ist_next
re.reset_src()
state.match_index = -1
state.first_match = -1
// reset state list
re.reset()
continue
}
if ist == regex.ist_prog_end {
return state.first_match, state.i
}
// manage here dot char
if re.state_list.len > 0 {
// println("Here we are, with stop: state buffer: [${re.state_list.len}]")
state = re.state_list.pop()
state.match_flag = true
l_ist = u32(regex.ist_dot_char)
if state.first_match < 0 {
state.first_match = state.i
}
state.match_index = state.i
re.prog[state.pc].rep++ // increase repetitions
state.i += char_len
m_state = .ist_quant_p
continue
}
// exit on no match
return result, state.i
}
// ist_load
else if m_state == .ist_load {
// program end
if ist == regex.ist_prog_end {
// if we are in match exit well
if state.group_index >= 0 && state.match_index >= 0 {
state.group_index = -1
}
m_state = .stop
continue
}
// check GROUP start, no quantifier is checkd for this token!!
else if ist == regex.ist_group_start {
state.group_index++
re.group_data[state.group_index] = re.prog[state.pc].goto_pc // save where is ist_group_end, we will use it for escape
re.group_stack[state.group_index] = state.i // index where we start to manage
// println("group_index $state.group_index rep ${re.prog[re.prog[state.pc].goto_pc].group_rep}")
m_state = .ist_next
continue
}
// check GROUP end
else if ist == regex.ist_group_end {
// we are in matching streak
// println("Group END!! last ist: ${l_ist:08x}")
if state.match_index >= 0 {
// restore txt index stack and save the group data
// println("g.id: ${re.prog[state.pc].group_id} group_index: ${state.group_index}")
if state.group_index >= 0 && re.prog[state.pc].group_id >= 0 {
start_i := re.group_stack[state.group_index]
// save group results
g_index := re.prog[state.pc].group_id * 2
if start_i >= 0 {
re.groups[g_index] = start_i
} else {
re.groups[g_index] = 0
}
re.groups[g_index + 1] = state.i
if g_index > 0 && re.groups[g_index] <= re.groups[g_index - 1] {
re.groups[g_index] = re.groups[g_index - 1]
}
if re.groups[g_index + 1] >= in_txt_len {
// println("clamp group!")
re.groups[g_index + 1] = in_txt_len - 1
}
// println("GROUP ${re.prog[state.pc].group_id} END [${re.groups[g_index]}, ${re.groups[g_index+1]}] i: $state.i in_txt_len: $in_txt_len")
// continuous save, save until we have space
re.group_continuous_save(g_index)
}
re.prog[state.pc].group_rep++ // increase repetitions
// println("GROUP $group_index END ${re.prog[state.pc].group_rep}")
if re.prog[state.pc].group_rep > in_txt_len - 1 {
m_state = .ist_quant_ng
continue
}
m_state = .ist_quant_pg
continue
}
m_state = .ist_quant_ng
continue
}
// check OR
else if ist == regex.ist_or_branch {
if state.match_index >= 0 {
state.pc = re.prog[state.pc].rep_max
// println("ist_or_branch True pc: $state.pc")
} else {
state.pc = re.prog[state.pc].rep_min
// println("ist_or_branch False pc: $state.pc")
}
re.prog[state.pc].reset()
m_state = .ist_load
continue
}
// check ist_dot_char
else if ist == regex.ist_dot_char {
// println("ist_dot_char rep: ${re.prog[state.pc].rep}")
// check next token to be false
mut next_check_flag := false
// if we are done with max go on dot char are dedicated case!!
if re.prog[state.pc].rep >= re.prog[state.pc].rep_max {
re.state_list.pop()
m_state = .ist_next
continue
}
if re.prog[state.pc].dot_check_pc >= 0
&& re.prog[state.pc].rep >= re.prog[state.pc].rep_min {
// load the char
// ch_t, _ := re.get_charb(in_txt, state.i+char_len)
ch_t := ch
chk_pc := re.prog[state.pc].dot_check_pc
// simple char
if re.prog[chk_pc].ist == regex.ist_simple_char {
if re.prog[chk_pc].ch == ch_t {
next_check_flag = true
}
// println("Check [ist_simple_char] [${re.prog[chk_pc].ch}]==[${ch_t:c}] => $next_check_flag")
}
// char char_class
else if re.prog[chk_pc].ist == regex.ist_char_class_pos
|| re.prog[chk_pc].ist == regex.ist_char_class_neg {
mut cc_neg := false
if re.prog[chk_pc].ist == regex.ist_char_class_neg {
cc_neg = true
}
mut cc_res := re.check_char_class(chk_pc, ch_t)
if cc_neg {
cc_res = !cc_res
}
next_check_flag = cc_res
// println("Check [ist_char_class] => $next_check_flag")
}
// check bsls
else if re.prog[chk_pc].ist == regex.ist_bsls_char {
next_check_flag = re.prog[chk_pc].validator(byte(ch_t))
// println("Check [ist_bsls_char] => $next_check_flag")
}
}
// check if we must continue or pass to the next IST
if next_check_flag == true && re.prog[state.pc + 1].ist != regex.ist_prog_end {
// println("save the state!!")
mut dot_state := StateObj{
group_index: state.group_index
match_flag: state.match_flag
match_index: state.match_index
first_match: state.first_match
pc: state.pc
i: state.i + char_len
char_len: char_len
last_dot_pc: state.pc
}
// if we are mananging a .* stay on the same char on return
if re.prog[state.pc].rep_min == 0 {
dot_state.i -= char_len
}
re.state_list << dot_state
m_state = .ist_quant_n
// println("dot_char stack len: ${re.state_list.len}")
continue
}
state.match_flag = true
l_ist = u32(regex.ist_dot_char)
if state.first_match < 0 {
state.first_match = state.i
}
state.match_index = state.i
re.prog[state.pc].rep++ // increase repetitions
state.i += char_len
m_state = .ist_quant_p
continue
}
// char class IST
else if ist == regex.ist_char_class_pos || ist == regex.ist_char_class_neg {
state.match_flag = false
mut cc_neg := false
if ist == regex.ist_char_class_neg {
cc_neg = true
}
mut cc_res := re.check_char_class(state.pc, ch)
if cc_neg {
cc_res = !cc_res
}
if cc_res {
state.match_flag = true
l_ist = u32(regex.ist_char_class_pos)
if state.first_match < 0 {
state.first_match = state.i
}
state.match_index = state.i
re.prog[state.pc].rep++ // increase repetitions
state.i += char_len // next char
m_state = .ist_quant_p
continue
}
m_state = .ist_quant_n
continue
}
// check bsls
else if ist == regex.ist_bsls_char {
// println("ist_bsls_char rep: ${re.prog[state.pc].rep}")
// check next token to be false
mut next_check_flag := false
// if we are done with max go on dot char are dedicated case!!
if re.prog[state.pc].rep >= re.prog[state.pc].rep_max {
re.state_list.pop()
m_state = .ist_next
continue
}
if re.prog[state.pc].bsls_check_pc >= 0
&& re.prog[state.pc].rep >= re.prog[state.pc].rep_min {
// load the char
// ch_t, _ := re.get_charb(in_txt, state.i+char_len)
ch_t := ch
chk_pc := re.prog[state.pc].bsls_check_pc
// simple char
if re.prog[chk_pc].ist == regex.ist_simple_char {
if re.prog[chk_pc].ch == ch_t {
next_check_flag = true
}
// println("Check [ist_simple_char] [${re.prog[chk_pc].ch}]==[${ch_t:c}] => $next_check_flag")
}
// char char_class
else if re.prog[chk_pc].ist == regex.ist_char_class_pos
|| re.prog[chk_pc].ist == regex.ist_char_class_neg {
mut cc_neg := false
if re.prog[chk_pc].ist == regex.ist_char_class_neg {
cc_neg = true
}
mut cc_res := re.check_char_class(chk_pc, ch_t)
if cc_neg {
cc_res = !cc_res
}
next_check_flag = cc_res
// println("Check [ist_char_class] => $next_check_flag")
}
// check bsls
else if re.prog[chk_pc].ist == regex.ist_bsls_char {
next_check_flag = re.prog[chk_pc].validator(byte(ch_t))
// println("Check [ist_bsls_char] => $next_check_flag")
}
}
// check if we must continue or pass to the next IST
if next_check_flag == true && re.prog[state.pc + 1].ist != regex.ist_prog_end {
// println("save the state!!")
mut dot_state := StateObj{
group_index: state.group_index
match_flag: state.match_flag
match_index: state.match_index
first_match: state.first_match
pc: state.pc
i: state.i + char_len
char_len: char_len
last_dot_pc: state.pc
}
// if we are mananging a .* stay on the same char on return
if re.prog[state.pc].rep_min == 0 {
dot_state.i -= char_len
}
re.state_list << dot_state
m_state = .ist_quant_n
// println("dot_char stack len: ${re.state_list.len}")
continue
}
tmp_res := re.prog[state.pc].validator(byte(ch))
if tmp_res == false {
m_state = .ist_quant_n
continue
}
// println("${ch} => ${tmp_res}")
state.match_flag = true
l_ist = u32(regex.ist_dot_char)
if state.first_match < 0 {
state.first_match = state.i
}
state.match_index = state.i
re.prog[state.pc].rep++ // increase repetitions
state.i += char_len
m_state = .ist_quant_p
continue
}
// simple char IST
else if ist == regex.ist_simple_char {
// println("ist_simple_char")
state.match_flag = false
if re.prog[state.pc].ch == ch {
state.match_flag = true
l_ist = regex.ist_simple_char
if state.first_match < 0 {
state.first_match = state.i
}
// println("state.match_index: ${state.match_index}")
state.match_index = state.i
re.prog[state.pc].rep++ // increase repetitions
state.i += char_len // next char
m_state = .ist_quant_p
continue
}
m_state = .ist_quant_n
continue
}
// UNREACHABLE
// println("PANIC2!! state: $m_state")
return regex.err_internal_error, state.i
}
/***********************************
* Quantifier management
***********************************/
// ist_quant_ng => quantifier negative test on group
else if m_state == .ist_quant_ng {
// we are finished here
if state.group_index < 0 {
// println("Early stop!")
result = regex.no_match_found
m_state = .stop
continue
}
tmp_pc := re.group_data[state.group_index] // PC to the end of the group token
rep := re.prog[tmp_pc].group_rep // use a temp variable
re.prog[tmp_pc].group_rep = 0 // clear the repetitions
// println(".ist_quant_ng group_pc_end: $tmp_pc rep: $rep")
if rep >= re.prog[tmp_pc].rep_min {
// println("ist_quant_ng GROUP CLOSED OK group_index: $state.group_index")
state.i = re.group_stack[state.group_index]
state.pc = tmp_pc
state.group_index--
m_state = .ist_next
continue
} else if re.prog[tmp_pc].next_is_or {
// println("ist_quant_ng OR Negative branch")
state.i = re.group_stack[state.group_index]
state.pc = re.prog[tmp_pc + 1].rep_min - 1
state.group_index--
m_state = .ist_next
continue
} else if rep > 0 && rep < re.prog[tmp_pc].rep_min {
// println("ist_quant_ng UNDER THE MINIMUM g.i: $state.group_index")
// check if we are inside a group, if yes exit from the nested groups
if state.group_index > 0 {
state.group_index--
state.pc = tmp_pc
m_state = .ist_quant_ng //.ist_next
continue
}
if state.group_index == 0 {
state.group_index--
state.pc = tmp_pc // TEST
m_state = .ist_next
continue
}
result = regex.no_match_found
m_state = .stop
continue
} else if rep == 0 && rep < re.prog[tmp_pc].rep_min {
// println("ist_quant_ng c_zero UNDER THE MINIMUM g.i: $state.group_index")
if state.group_index > 0 {
state.group_index--
state.pc = tmp_pc
m_state = .ist_quant_ng //.ist_next
continue
}
result = regex.no_match_found
m_state = .stop
continue
}
// println("DO NOT STAY HERE!! {${re.prog[tmp_pc].rep_min},${re.prog[tmp_pc].rep_max}}:$rep")
// UNREACHABLE
return regex.err_internal_error, state.i
}
// ist_quant_pg => quantifier positive test on group
else if m_state == .ist_quant_pg {
// println(".ist_quant_pg")
mut tmp_pc := state.pc
if state.group_index >= 0 {
tmp_pc = re.group_data[state.group_index]
}
if re.prog[tmp_pc].group_neg == true {
// println("***** Negation of the group")
result = regex.no_match_found
m_state = .stop
continue
}
rep := re.prog[tmp_pc].group_rep
if rep < re.prog[tmp_pc].rep_min {
// println("ist_quant_pg UNDER RANGE")
state.pc = re.prog[tmp_pc].goto_pc
m_state = .ist_next
continue
} else if rep == re.prog[tmp_pc].rep_max {
// println("ist_quant_pg MAX RANGE")
re.prog[tmp_pc].group_rep = 0 // clear the repetitions
state.group_index--
m_state = .ist_next
continue
} else if rep >= re.prog[tmp_pc].rep_min {
// println("ist_quant_pg IN RANGE group_index:$state.group_index")
// check greedy flag, if true exit on minimum
if re.prog[tmp_pc].greedy == true {
re.prog[tmp_pc].group_rep = 0 // clear the repetitions
state.group_index--
m_state = .ist_next
continue
}
state.pc = re.prog[tmp_pc].goto_pc - 1
state.group_index--
m_state = .ist_next
continue
}
// UNREACHABLE
// println("PANIC3!! state: $m_state")
return regex.err_internal_error, state.i
}
// ist_quant_n => quantifier negative test on token
else if m_state == .ist_quant_n {
rep := re.prog[state.pc].rep
// println("Here!! PC $state.pc is_next_or: ${re.prog[state.pc].next_is_or}")
// zero quantifier * or ?
if rep == 0 && re.prog[state.pc].rep_min == 0 {
// println("ist_quant_n c_zero RANGE MIN")
m_state = .ist_next // go to next ist
continue
}
// match + or *
else if rep >= re.prog[state.pc].rep_min {
// println("ist_quant_n MATCH RANGE")
m_state = .ist_next
continue
}
// check the OR if present
if re.prog[state.pc].next_is_or {
// println("OR present on failing")
state.match_index = -1
m_state = .ist_next
continue
}
// we are in a group manage no match from here
if state.group_index >= 0 {
// println("ist_quant_n FAILED insied a GROUP group_index:$state.group_index")
m_state = .ist_quant_ng
continue
}
// no other options
// println("ist_quant_n no_match_found")
result = regex.no_match_found
m_state = .stop
continue
// return no_match_found, 0
}
// ist_quant_p => quantifier positive test on token
else if m_state == .ist_quant_p {
// println("Here .ist_quant_p")
// exit on first match
if (re.flag & regex.f_efm) != 0 {
return state.i, state.i + 1
}
rep := re.prog[state.pc].rep
// println(rep)
// under range
if rep > 0 && rep < re.prog[state.pc].rep_min {
// println("ist_quant_p UNDER RANGE")
m_state = .ist_load // continue the loop
continue
}
// range ok, continue loop
else if rep >= re.prog[state.pc].rep_min && rep < re.prog[state.pc].rep_max {
// println("ist_quant_p IN RANGE")
// check greedy flag, if true exit on minimum
if re.prog[state.pc].greedy == true {
m_state = .ist_next
continue
}
m_state = .ist_load
continue
}
// max reached
else if rep == re.prog[state.pc].rep_max {
// println("ist_quant_p MAX RANGE")
m_state = .ist_next
continue
}
}
// UNREACHABLE
// println("PANIC4!! state: $m_state")
return regex.err_internal_error, state.i
}
// println("Check end of text!")
// Check the results
if state.match_index >= 0 {
if state.group_index < 0 {
if re.prog[state.pc].ist == regex.ist_prog_end {
// println("program ended!!")
if (re.flag & regex.f_src) != 0 {
// println("find return")
return state.first_match, state.i
} else {
// println("Here!!")
return 0, state.i
}
}
// println("No Group here, natural end [$state.first_match,$state.i] state: ${state_str(m_state)} ist: $ist pgr_end: $re.prog.len")
if re.prog[state.pc + 1].ist == regex.ist_prog_end
|| re.prog[state.pc].ist == regex.ist_prog_end {
rep := re.prog[state.pc].rep
// println("rep: $rep re.prog[state.pc].rep_min: ${re.prog[state.pc].rep_min} re.prog[state.pc].rep_max: ${re.prog[state.pc].rep_max}")
if rep >= re.prog[state.pc].rep_min && rep <= re.prog[state.pc].rep_max {
return state.first_match, state.i
}
// println("Program not finished! ")
return regex.no_match_found, state.i
}
if src_end {
// println("program end")
return state.first_match, state.i
}
// print("No match found!!")
return regex.no_match_found, state.i
} else {
// println("Group match! OK")
// println("first_match: $state.first_match, i: $state.i")
// println("Skip last group")
return state.first_match, state.i
// return state.first_match,re.group_stack[state.group_index--]
}
}
// println("no_match_found, natural end")
return regex.no_match_found, state.i
}
Reference in New Issue View Git Blame Copy Permalink