anon/jeger
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

it works

Browse Source
This commit is contained in:
anon 2023-09-09 12:10:07 +02:00
parent c7af36dbb0
commit 9e8eb4f2e2
1 changed files with 83 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

133
source/regex.c
View File

@ -1,12 +1,4 @@
/* XXX:
* as it turns out returning a range of match objects is a
* high profile performance issue regarding regex, especially when highlighting.
* now as it stands we search an array of tokens for every position on a string.
* which sounds ok, until one realizes that searching from any position revails a range,
* where (future) matches can or cannot be found. meaning we are computing the same thing
* repeatedly, practically resulting in a bruteforcing situation where instead of eliminating
* certain non-matches, we blindly hammer character by character.
*/
#pragma GCC diagnostic ignored "-Wc++20-extensions"
#include "regex.h"
@ -89,14 +81,14 @@ typedef struct {
int in;
char input;
int to;
int width;
int pattern_width;
int match_width;
} delta_t;
typedef struct {
int in;
int to;
int width;
int pattern_width;
int match_width;
} offshoot_t;
@ -133,26 +125,31 @@ void HOOK_ALL(const int from,
regex_t * regex) {
for (const char * s = str; *s != '\0'; s++) {
delta_t * delta = (delta_t *)malloc(sizeof(delta_t));
delta->in = cs->state + from;
delta->input = *s;
delta->to = ASSERT_HALT(to);
delta->width = cs->width;
*delta = (delta_t){
.in = cs->state + from,
.input = *s,
.to = ASSERT_HALT(to),
.pattern_width = cs->width,
.match_width = 1,
};
vector_push(&regex->delta_table,
&delta);
}
}
static
void ABSOLUTE_OFFSHOOT(const int from,
const int to,
const int width,
const int match_width,
regex_t * regex) {
void ABSOLUTE_OFFSHOOT(const int from,
const int to,
const int width,
const int match_width,
regex_t * regex) {
offshoot_t * offshoot = (offshoot_t *)malloc(sizeof(offshoot_t));
offshoot->in = from;
offshoot->to = to;
offshoot->width = width;
offshoot->match_width = match_width;
*offshoot = (offshoot_t){
.in = from,
.to = to,
.pattern_width = width,
.match_width = match_width,
};
vector_push(&regex->catch_table,
&offshoot);
}
@ -361,7 +358,7 @@ int escape_to_negative(const char c,
}
static inline
int compile_dot(compiler_state * cs) {
int compile_dot(compiler_state * const cs) {
cs->flags |= DO_CATCH;
return true;
}
@ -371,9 +368,9 @@ int compile_escape(const char c,
compiler_state * const cs) {
return escape_1_to_1(c, cs)
|| escape_1_to_N(c, cs)
|| escape_to_negative(c, cs)
;
|| escape_1_to_N(c, cs)
|| escape_to_negative(c, cs)
;
}
static
@ -441,7 +438,6 @@ regex_t * regex_compile(const char * const pattern) {
compiler_state cs = {
.flags = IS_AT_THE_BEGINNING,
.state = JEGER_INIT_STATE,
.width = 0,
.whitelist = whitelist,
.blacklist = blacklist,
};
@ -451,7 +447,7 @@ regex_t * regex_compile(const char * const pattern) {
// Reset the compiler
whitelist[0] = '\0';
blacklist[0] = '\0';
cs.flags &= IS_AT_THE_BEGINNING;
cs.flags &= (IS_AT_THE_BEGINNING | FORCE_START_OF_STRING);
cs.width = 1;
// Translate char
@ -566,7 +562,7 @@ regex_t * regex_compile(const char * const pattern) {
++cs.state;
}
cs.flags &= !(IS_AT_THE_BEGINNING);
cs.flags &= (~IS_AT_THE_BEGINNING);
}
// Init state hookups
@ -648,10 +644,9 @@ bool regex_assert(const regex_t * const regex,
if ((delta->in == state)
&& (delta->input == *s)) {
was_found = true;
const int r = regex_assert(regex, s + delta->width, delta->to, match);
const int r = regex_assert(regex, s + delta->pattern_width, delta->to, match);
if(r){
if ((match->position != -1)
&& (delta->match_width)) {
if (match->position == -1) {
match->position = (s - string);
}
match->width += delta->match_width;
@ -664,9 +659,9 @@ bool regex_assert(const regex_t * const regex,
PERFORM_CATCH_LOOKUP: {
if (!was_found) {
const offshoot_t * const my_catch = catch_table_lookup(regex, &state);
if (my_catch && (!my_catch->width || !last_stand)) {
if (my_catch && (!my_catch->pattern_width || !last_stand)) {
state = my_catch->to;
s += my_catch->width;
s += my_catch->pattern_width;
match->width += my_catch->match_width;
goto LOOP;
}
@ -679,30 +674,68 @@ bool regex_assert(const regex_t * const regex,
match_t * regex_match(const regex_t * const regex,
const char * const string,
const bool is_start_of_string) {
if (regex == NULL) {
return NULL;
}
vector_t matches;
vector_init(&matches, sizeof(match_t), 0);
match_t * match = (match_t *)malloc(sizeof(match_t));
if (string == NULL) {
match->position = -1;
match->width = 0;
return match;
/* Non-existent regex does not match anything.
* Not to be confused with an empty regex.
*/
if (regex == NULL) {
goto FINISH;
}
const int initial_state = (int)(!is_start_of_string);
// Find all matches
{
const char * s = string;
do {
int initial_state;
initial_state = (int)(!(is_start_of_string && (s == string)));
// XXX: this should be called in a loop, always restarting from the last char of the last match
if (regex_assert(regex, string, initial_state, match)) {
return match;
} else {
return NULL;
*match = (match_t){
.position = -1,
.width = 0,
};
if (regex_assert(regex, s, initial_state, match)) {
match->position = (s - string);
vector_push(&matches, match);
s += ((match->width > 0) ? match->width : 1);
match = (match_t *)malloc(sizeof(match_t));
} else {
++s;
}
} while (*s != '\0');
}
FINISH:
// Insert sentinel
*match = (match_t){
.position = -1,
.width = -1,
};
vector_push(&matches, match);
// Hide internal vector usage
const size_t data_size = matches.element_size * matches.element_count;
match_t * r = (match_t *)malloc(data_size);
memcpy(r, matches.data, data_size);
vector_free(&matches);
return r;
}
bool regex_search(const regex_t * const regex,
const char * const string) {
return (bool)regex_match(regex, string, true);
match_t * m = regex_match(regex, string, true);
const bool r = (m->position != -1);
free(m);
return r;
}