441 lines
12 KiB
C
441 lines
12 KiB
C
/* regex.c
|
|
* Copyright 2023 Anon Anonson, Ognjen 'xolatile' Milan Robovic, Emil Williams
|
|
* SPDX Identifier: GPL-3.0-only / NO WARRANTY / NO GUARANTEE */
|
|
|
|
#include "regex.h"
|
|
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
|
|
// ------------------
|
|
// ### Char tests ###
|
|
// ------------------
|
|
static bool is_quantifier(const char c) {
|
|
for (const char * s = "+*?"; *s != '\00'; s++) {
|
|
if (*s == c) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool is_magic(const char c) {
|
|
if (is_quantifier(c)) {
|
|
return true;
|
|
}
|
|
for (const char * s = "\\[]"; *s != '\00'; s++) {
|
|
if (*s == c) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
// ----------------------
|
|
// ### Internal Types ###
|
|
// ----------------------
|
|
typedef struct {
|
|
int in;
|
|
char input;
|
|
int to;
|
|
} delta_t;
|
|
|
|
typedef struct {
|
|
int in;
|
|
int to;
|
|
} offshoot_t;
|
|
|
|
|
|
|
|
// ----------------------------------
|
|
// ### Regex creation/destruction ###
|
|
// ----------------------------------
|
|
static int escape_1_to_1(const char c, char * whitelist) {
|
|
switch (c) {
|
|
case 't': {
|
|
strcat(whitelist, "\t");
|
|
} return 1;
|
|
case 'n': {
|
|
strcat(whitelist, "\n");
|
|
} return 1;
|
|
case 'r': {
|
|
strcat(whitelist, "\r");
|
|
} return 1;
|
|
case 'b': {
|
|
strcat(whitelist, "\b");
|
|
} return 1;
|
|
case '[': {
|
|
strcat(whitelist, "[");
|
|
} return 1;
|
|
case ']': {
|
|
strcat(whitelist, "]");
|
|
} return 1;
|
|
case '.': {
|
|
strcat(whitelist, ".");
|
|
} return 1;
|
|
case '?': {
|
|
strcat(whitelist, "?");
|
|
} return 1;
|
|
case '+': {
|
|
strcat(whitelist, "+");
|
|
} return 1;
|
|
case '*': {
|
|
strcat(whitelist, "*");
|
|
} return 1;
|
|
case '\\': {
|
|
strcat(whitelist, "\\");
|
|
} return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int escape_1_to_N(const char c, char * whitelist) {
|
|
switch(c) {
|
|
case 'i': {
|
|
const char identifier_chars[] = "@0123456789_"
|
|
"\300\301\302\303\304"
|
|
"\305\306\307\310\311"
|
|
"\312\313\314\315\316"
|
|
"\317\320\321\322\323"
|
|
"\324\325\326\327\330"
|
|
"\331\332\333\334\335"
|
|
"\336\337";
|
|
strcpy(whitelist, identifier_chars);
|
|
return sizeof(identifier_chars)-1;
|
|
};
|
|
case 'I': {
|
|
const char identifier_chars[] = "@_"
|
|
"\300\301\302\303\304"
|
|
"\305\306\307\310\311"
|
|
"\312\313\314\315\316"
|
|
"\317\320\321\322\323"
|
|
"\324\325\326\327\330"
|
|
"\331\332\333\334\335"
|
|
"\336\337";
|
|
strcpy(whitelist, identifier_chars);
|
|
return sizeof(identifier_chars)-1;
|
|
};
|
|
case 'k': {
|
|
const char keyword_chars[] = "@0123456789_"
|
|
"\300\301\302\303\304"
|
|
"\305\306\307\310\311"
|
|
"\312\313\314\315\316"
|
|
"\317\320\321\322\323"
|
|
"\324\325\326\327\330"
|
|
"\331\332\333\334\335"
|
|
"\336\337";
|
|
strcpy(whitelist, keyword_chars);
|
|
return sizeof(keyword_chars)-1;
|
|
};
|
|
case 'K': {
|
|
const char keyword_chars[] = "@_"
|
|
"\300\301\302\303\304"
|
|
"\305\306\307\310\311"
|
|
"\312\313\314\315\316"
|
|
"\317\320\321\322\323"
|
|
"\324\325\326\327\330"
|
|
"\331\332\333\334\335"
|
|
"\336\337";
|
|
strcpy(whitelist, keyword_chars);
|
|
return sizeof(keyword_chars)-1;
|
|
};
|
|
case 'f': {
|
|
const char filename_chars[] = "@0123456789/.-_+,#$%~=";
|
|
strcpy(whitelist, filename_chars);
|
|
return sizeof(filename_chars)-1;
|
|
};
|
|
case 'F': {
|
|
const char filename_chars[] = "@/.-_+,#$%~=";
|
|
strcpy(whitelist, filename_chars);
|
|
return sizeof(filename_chars)-1;
|
|
};
|
|
case 'p': {
|
|
const char printable_chars[] = "@"
|
|
"\241\242\243\244\245"
|
|
"\246\247\250\251\252"
|
|
"\253\254\255\256\257"
|
|
"\260\261\262\263\264"
|
|
"\265\266\267\270\271"
|
|
"\272\273\274\275\276"
|
|
"\277"
|
|
"\300\301\302\303\304"
|
|
"\305\306\307\310\311"
|
|
"\312\313\314\315\316"
|
|
"\317\320\321\322\323"
|
|
"\324\325\326\327\330"
|
|
"\331\332\333\334\335"
|
|
"\336\337";
|
|
strcpy(whitelist, printable_chars);
|
|
return sizeof(printable_chars)-1;
|
|
};
|
|
case 'P': {
|
|
const char printable_chars[] = "@"
|
|
"\241\242\243\244\245"
|
|
"\246\247\250\251\252"
|
|
"\253\254\255\256\257"
|
|
"\260\261\262\263\264"
|
|
"\265\266\267\270\271"
|
|
"\272\273\274\275\276"
|
|
"\277"
|
|
"\300\301\302\303\304"
|
|
"\305\306\307\310\311"
|
|
"\312\313\314\315\316"
|
|
"\317\320\321\322\323"
|
|
"\324\325\326\327\330"
|
|
"\331\332\333\334\335"
|
|
"\336\337";
|
|
strcpy(whitelist, printable_chars);
|
|
return sizeof(printable_chars)-1;
|
|
};
|
|
case 's': {
|
|
const char whitespace_chars[] = " \t\v\n";
|
|
strcpy(whitelist, whitespace_chars);
|
|
return sizeof(whitespace_chars)-1;
|
|
};
|
|
case 'd': {
|
|
const char digit_chars[] = "0123456789";
|
|
strcpy(whitelist, digit_chars);
|
|
return sizeof(digit_chars)-1;
|
|
};
|
|
case 'x': {
|
|
const char hex_chars[] = "0123456789"
|
|
"abcdef"
|
|
"ABCDEF";
|
|
strcpy(whitelist, hex_chars);
|
|
return sizeof(hex_chars)-1;
|
|
};
|
|
case 'o': {
|
|
const char oct_chars[] = "01234567";
|
|
strcpy(whitelist, oct_chars);
|
|
return sizeof(oct_chars)-1;
|
|
};
|
|
case 'w': {
|
|
const char word_chars[] = "0123456789"
|
|
"abcdefghijklmnopqrstuwxyz"
|
|
"ABCDEFGHIJKLMNOPQRSTUWXYZ"
|
|
"_";
|
|
strcpy(whitelist, word_chars);
|
|
return sizeof(word_chars)-1;
|
|
};
|
|
case 'h': {
|
|
const char very_word_chars[] = "abcdefghijklmnopqrstuwxyz"
|
|
"ABCDEFGHIJKLMNOPQRSTUWXYZ"
|
|
"_";
|
|
strcpy(whitelist, very_word_chars);
|
|
return sizeof(very_word_chars)-1;
|
|
};
|
|
case 'a': {
|
|
const char alpha_chars[] = "abcdefghijklmnopqrstuwxyz"
|
|
"ABCDEFGHIJKLMNOPQRSTUWXYZ";
|
|
strcpy(whitelist, alpha_chars);
|
|
return sizeof(alpha_chars)-1;
|
|
};
|
|
case 'l': {
|
|
const char lower_alpha_chars[] = "abcdefghijklmnopqrstuwxyz";
|
|
strcpy(whitelist, lower_alpha_chars);
|
|
return sizeof(lower_alpha_chars)-1;
|
|
};
|
|
case 'u': {
|
|
const char upper_alpha_chars[] = "ABCDEFGHIJKLMNOPQRSTUWXYZ";
|
|
strcpy(whitelist, upper_alpha_chars);
|
|
return sizeof(upper_alpha_chars)-1;
|
|
};
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int compile_range(const char * const range,
|
|
char * whitelist,
|
|
bool * is_negative) {
|
|
assert(range[0] == '[' && "Not a range.");
|
|
|
|
int r = 0;
|
|
const char * s;
|
|
if (range[1] == '^') {
|
|
*is_negative = true;
|
|
s = range + 2;
|
|
} else {
|
|
s = range + 1;
|
|
}
|
|
for (; *s != ']'; s++) {
|
|
assert(*s != '\00' && "Unclosed range.");
|
|
char c = *s;
|
|
if (escape_1_to_1(c, whitelist)
|
|
|| escape_1_to_N(c, whitelist)) {
|
|
;
|
|
} else if (*(s+1) == '-') {
|
|
char end = *(s+2);
|
|
assert(c < end && "Endless range.");
|
|
for (char cc = c; cc < end+1; cc++) {
|
|
strncat(whitelist, &cc, 1);
|
|
strncat(whitelist, "\00", 1);
|
|
}
|
|
s += 2;
|
|
} else {
|
|
++r;
|
|
strncat(whitelist, &c, 1);
|
|
strncat(whitelist, "\00", 1);
|
|
}
|
|
}
|
|
|
|
return ((s - range) + 1);
|
|
}
|
|
|
|
static bool catch_(const regex_t * const regex,
|
|
int * const state) {
|
|
|
|
for (int i = 0; i < regex->catch_table.element_size; i++){
|
|
const offshoot_t * const offshoot = (vector_get(®ex->catch_table, i));
|
|
if (offshoot->in == *state) {
|
|
*state = offshoot->to;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#define HALT_AND_CATCH_FIRE -1
|
|
|
|
#define HOOK_ALL(from, str, to) do { \
|
|
int hook_to = (is_negative) ? -1 : state + to; \
|
|
for (char * s = str; *s != '\00'; s++) { \
|
|
vector_push(®ex->delta_table, \
|
|
&(delta_t){state + from, *s, hook_to} \
|
|
); \
|
|
} \
|
|
if (do_catch) { \
|
|
vector_push(®ex->catch_table, \
|
|
&(offshoot_t){state + from, hook_to} \
|
|
); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define EAT(n) do { \
|
|
s += n; \
|
|
} while (0)
|
|
|
|
regex_t * regex_compile(const char * const pattern) {
|
|
regex_t * regex = (regex_t *)malloc(sizeof(regex_t));
|
|
regex->str = strdup(pattern);
|
|
vector_init(®ex->delta_table, sizeof(delta_t), 32);
|
|
vector_init(®ex->catch_table, sizeof(offshoot_t), 16);
|
|
|
|
int state = 0;
|
|
|
|
char whitelist[64];
|
|
bool do_catch;
|
|
bool is_negative;
|
|
for (const char * s = pattern; *s != '\00';) {
|
|
// Get token
|
|
assert(!is_quantifier(*pattern) && "Pattern starts with quantifier.");
|
|
whitelist[0] = '\00';
|
|
do_catch = false;
|
|
|
|
switch (*s) {
|
|
case '.': {
|
|
do_catch = true;
|
|
} break;
|
|
case '\\': {
|
|
EAT(1);
|
|
if(escape_1_to_1(*s, whitelist)
|
|
|| escape_1_to_N(*s, whitelist)){
|
|
;
|
|
} else {
|
|
assert(!"Unknown escape.");
|
|
}
|
|
} break;
|
|
case '[': {
|
|
EAT(compile_range(s, whitelist, &is_negative)-1);
|
|
} break;
|
|
default: {
|
|
whitelist[0] = *s;
|
|
whitelist[1] = '\00';
|
|
} break;
|
|
}
|
|
|
|
EAT(1);
|
|
|
|
// Get quantifier
|
|
switch (*s) {
|
|
case '?': {
|
|
HOOK_ALL(0, whitelist, +1);
|
|
EAT(1);
|
|
} break;
|
|
case '*': {
|
|
HOOK_ALL(0, whitelist, 0);
|
|
EAT(1);
|
|
} break;
|
|
case '+': {
|
|
HOOK_ALL(0, whitelist, +1);
|
|
state += 1;
|
|
HOOK_ALL(0, whitelist, 0);
|
|
EAT(1);
|
|
} break;
|
|
default: { // Literal
|
|
HOOK_ALL(0, whitelist, +1);
|
|
state += 1;
|
|
} break;
|
|
}
|
|
}
|
|
|
|
regex->accepting_state = state;
|
|
|
|
return regex;
|
|
}
|
|
|
|
int regex_free(regex_t * const regex) {
|
|
free(regex->str);
|
|
vector_free(®ex->delta_table);
|
|
vector_free(®ex->catch_table);
|
|
free(regex);
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
// -----------------
|
|
// ### Searching ###
|
|
// -----------------
|
|
static bool regex_assert(const regex_t * const regex,
|
|
const char * const string,
|
|
int state) {
|
|
|
|
for (const char * s = string; *s != '\00'; s++) {
|
|
// delta
|
|
for (int i = 0; i < regex->delta_table.element_count; i++) {
|
|
const delta_t * const delta = (delta_t *)(vector_get(®ex->delta_table, i));
|
|
if ((delta->in == state)
|
|
&& (delta->input == *s)) {
|
|
if(regex_assert(regex, s+1, delta->to)){
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (catch_(regex, &state)) {
|
|
continue;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
return (state == regex->accepting_state);
|
|
}
|
|
|
|
bool regex_search( regex_t * regex,
|
|
const char * const string) {
|
|
|
|
if (regex == NULL) {
|
|
return false;
|
|
}
|
|
if (string == NULL) {
|
|
return true;
|
|
}
|
|
|
|
return regex_assert(regex, string, 0);
|
|
}
|