X-Git-Url: http://mj.ucw.cz/gitweb/?a=blobdiff_plain;f=lib%2Fregex.c;h=270fb590b5e7fc8873afefc2d5c898c97a1d1287;hb=4cd590195cb23a667ff5f329a721b6f4ce2e6dc3;hp=888f36b918bb4a422f234647ae891596674f936a;hpb=ac9212c1d03bd23f6322bef39a4a0384b5afcc5d;p=libucw.git diff --git a/lib/regex.c b/lib/regex.c index 888f36b9..270fb590 100644 --- a/lib/regex.c +++ b/lib/regex.c @@ -1,17 +1,224 @@ /* - * Sherlock Library -- Regular Expressions + * UCW Library -- Interface to Regular Expression Libraries * - * (c) 1997 Martin Mares, + * (c) 1997--2004 Martin Mares + * (c) 2001 Robert Spalek + * + * This software may be freely distributed and used according to the terms + * of the GNU Lesser General Public License. */ +#include "lib/lib.h" +#include "lib/chartype.h" +#include "lib/hashfunc.h" + #include #include -#include + +#if defined(CONFIG_OWN_REGEX) || defined(CONFIG_POSIX_REGEX) + +/* POSIX regular expression library */ + +#ifdef CONFIG_OWN_REGEX +#include "lib/regex/regex-sh.h" +#else #include +#endif + +struct regex { + regex_t rx; + regmatch_t matches[10]; +}; + +regex * +rx_compile(const char *p, int icase) +{ + regex *r = xmalloc_zero(sizeof(regex)); + + int err = regcomp(&r->rx, p, REG_EXTENDED | (icase ? REG_ICASE : 0)); + if (err) + { + char msg[256]; + regerror(err, &r->rx, msg, sizeof(msg)-1); + /* regfree(&r->rx) not needed */ + die("Error parsing regular expression `%s': %s", p, msg); + } + return r; +} -#include "lib.h" +void +rx_free(regex *r) +{ + regfree(&r->rx); + xfree(r); +} + +int +rx_match(regex *r, const char *s) +{ + int err = regexec(&r->rx, s, 10, r->matches, 0); + if (!err) + { + /* regexec doesn't support anchored expressions, so we have to check ourselves that the full string is matched */ + return !(r->matches[0].rm_so || s[r->matches[0].rm_eo]); + } + else if (err == REG_NOMATCH) + return 0; + else if (err == REG_ESPACE) + die("Regex matching ran out of memory"); + else + die("Regex matching failed with unknown error %d", err); +} + +int +rx_subst(regex *r, const char *by, const char *src, char *dest, uns destlen) +{ + char *end = dest + destlen - 1; + + if (!rx_match(r, src)) + return 0; + + while (*by) + { + if (*by == '\\') + { + by++; + if (*by >= '0' && *by <= '9') /* \0 gets replaced by entire pattern */ + { + uns j = *by++ - '0'; + if (j <= r->rx.re_nsub && r->matches[j].rm_so >= 0) + { + const char *s = src + r->matches[j].rm_so; + uns i = r->matches[j].rm_eo - r->matches[j].rm_so; + if (dest + i >= end) + return -1; + memcpy(dest, s, i); + dest += i; + continue; + } + } + } + if (dest < end) + *dest++ = *by++; + else + return -1; + } + *dest = 0; + return 1; +} + +#elif defined(CONFIG_PCRE) + +/* PCRE library */ + +#include + +struct regex { + pcre *rx; + pcre_extra *extra; + uns match_array_size; + uns real_matches; + int matches[0]; /* (max_matches+1) pairs (pos,len) plus some workspace */ +}; + +regex * +rx_compile(const char *p, int icase) +{ + const char *err; + int errpos, match_array_size, eno; + + pcre *rx = pcre_compile(p, PCRE_ANCHORED | PCRE_EXTRA | (icase ? PCRE_CASELESS : 0), &err, &errpos, NULL); + if (!rx) + die("Error parsing regular expression `%s': %s at position %d", p, err, errpos); + eno = pcre_fullinfo(rx, NULL, PCRE_INFO_CAPTURECOUNT, &match_array_size); + if (eno) + die("Internal error: pcre_fullinfo() failed with error %d", eno); + match_array_size = 3*(match_array_size+1); + regex *r = xmalloc_zero(sizeof(regex) + match_array_size * sizeof(int)); + r->rx = rx; + r->match_array_size = match_array_size; + r->extra = pcre_study(r->rx, 0, &err); + if (err) + die("Error studying regular expression `%s': %s", p, err); + return r; +} + +void +rx_free(regex *r) +{ + xfree(r->rx); + xfree(r->extra); + xfree(r); +} + +int +rx_match(regex *r, const char *s) +{ + int len = str_len(s); + int err = pcre_exec(r->rx, r->extra, s, len, 0, 0, r->matches, r->match_array_size); + if (err >= 0) + { + r->real_matches = err; + /* need to check that the full string matches */ + return !(r->matches[0] || s[r->matches[1]]); + } + else if (err == PCRE_ERROR_NOMATCH) + return 0; + else if (err == PCRE_ERROR_NOMEMORY) + die("Regex matching ran out of memory"); + else + die("Regex matching failed with unknown error %d", err); +} + +int +rx_subst(regex *r, const char *by, const char *src, char *dest, uns destlen) +{ + char *end = dest + destlen - 1; + + if (!rx_match(r, src)) + return 0; + + while (*by) + { + if (*by == '\\') + { + by++; + if (*by >= '0' && *by <= '9') /* \0 gets replaced by entire pattern */ + { + uns j = *by++ - '0'; + if (j < r->real_matches && r->matches[2*j] >= 0) + { + char *s = src + r->matches[2*j]; + uns i = r->matches[2*j+1] - r->matches[2*j]; + if (dest + i >= end) + return -1; + memcpy(dest, s, i); + dest += i; + continue; + } + } + } + if (dest < end) + *dest++ = *by++; + else + return -1; + } + *dest = 0; + return 1; +} + +#else + +/* BSD regular expression library */ + +#ifdef CONFIG_OWN_BSD_REGEX +#include "lib/regex/regex-sh.h" +#else +#include +#endif #define INITIAL_MEM 1024 /* Initial space allocated for each pattern */ +#define CHAR_SET_SIZE 256 /* How many characters in the character set. */ struct regex { struct re_pattern_buffer buf; @@ -20,14 +227,24 @@ struct regex { }; regex * -rx_compile(byte *p) +rx_compile(const char *p, int icase) { - regex *r = xmalloc(sizeof(regex)); + regex *r = xmalloc_zero(sizeof(regex)); const char *msg; - bzero(r, sizeof(struct regex)); r->buf.buffer = xmalloc(INITIAL_MEM); r->buf.allocated = INITIAL_MEM; + if (icase) + { + unsigned i; + r->buf.translate = xmalloc (CHAR_SET_SIZE); + /* Map uppercase characters to corresponding lowercase ones. */ + for (i = 0; i < CHAR_SET_SIZE; i++) + r->buf.translate[i] = Cupcase(i); + } + else + r->buf.translate = NULL; + re_set_syntax(RE_SYNTAX_POSIX_EXTENDED); msg = re_compile_pattern(p, strlen(p), &r->buf); if (!msg) return r; @@ -37,12 +254,14 @@ rx_compile(byte *p) void rx_free(regex *r) { - free(r->buf.buffer); - free(r); + xfree(r->buf.buffer); + if (r->buf.translate) + xfree(r->buf.translate); + xfree(r); } int -rx_match(regex *r, byte *s) +rx_match(regex *r, const char *s) { int len = strlen(s); @@ -55,9 +274,9 @@ rx_match(regex *r, byte *s) } int -rx_subst(regex *r, byte *by, byte *src, byte *dest, uns destlen) +rx_subst(regex *r, const char *by, const char *src, char *dest, uns destlen) { - byte *end = dest + destlen - 1; + char *end = dest + destlen - 1; if (!rx_match(r, src)) return 0; @@ -72,7 +291,7 @@ rx_subst(regex *r, byte *by, byte *src, byte *dest, uns destlen) uns j = *by++ - '0'; if (j < r->regs.num_regs) { - byte *s = src + r->regs.start[j]; + const char *s = src + r->regs.start[j]; uns i = r->regs.end[j] - r->regs.start[j]; if (r->regs.start[j] > r->len_cache || r->regs.end[j] > r->len_cache) return -1; @@ -93,14 +312,23 @@ rx_subst(regex *r, byte *by, byte *src, byte *dest, uns destlen) return 1; } +#endif + #ifdef TEST -void main(int argc, char **argv) +int main(int argc, char **argv) { regex *r; - byte buf1[256], buf2[256]; + char buf1[4096], buf2[4096]; + int opt_i = 0; - r = rx_compile(argv[1]); + if (!strcmp(argv[1], "-i")) + { + opt_i = 1; + argv++; + argc--; + } + r = rx_compile(argv[1], opt_i); while (fgets(buf1, sizeof(buf1), stdin)) { char *p = strchr(buf1, '\n');