text-regex-tre.c

   1 #include <stdlib.h>
   2 #include <string.h>
   3 #include <wchar.h>
   4 #include <errno.h>
   5
   6 #include "text-regex.h"
   7 #include "text-motions.h"
   8
   9 struct Regex {
  10         regex_t regex;
  11         tre_str_source str_source;
  12         Text *text;
  13         Iterator it;
  14         size_t end;
  15 };
  16
  17 size_t text_regex_nsub(Regex *r) {
  18        if (!r)
  19                return 0;
  20        return r->regex.re_nsub;
  21 }
  22
  23 static int str_next_char(tre_char_t *c, unsigned int *pos_add, void *context) {
  24         Regex *r = context;
  25         Iterator *it = &r->it;
  26         if (TRE_WCHAR) {
  27                 mbstate_t ps = { 0 };
  28                 bool eof = false;
  29                 size_t start = it->pos;
  30                 for (;;) {
  31                         if (it->pos >= r->end) {
  32                                 eof = true;
  33                                 break;
  34                         }
  35                         size_t rem = r->end - it->pos;
  36                         size_t plen = it->end - it->text;
  37                         size_t len = rem < plen ? rem : plen;
  38                         size_t wclen = mbrtowc(c, it->text, len, &ps);
  39                         if (wclen == (size_t)-1 && errno == EILSEQ) {
  40                                 ps = (mbstate_t){0};
  41                                 *c = L'\0';
  42                                 text_iterator_codepoint_next(it, NULL);
  43                                 break;
  44                         } else if (wclen == (size_t)-2) {
  45                                 if (!text_iterator_next(it)) {
  46                                         eof = true;
  47                                         break;
  48                                 }
  49                         } else if (wclen == 0) {
  50                                 text_iterator_byte_next(it, NULL);
  51                                 break;
  52                         } else {
  53                                 if (wclen < plen) {
  54                                         it->text += wclen;
  55                                         it->pos += wclen;
  56                                 } else {
  57                                         text_iterator_next(it);
  58                                 }
  59                                 break;
  60                         }
  61                 }
  62
  63                 if (eof) {
  64                         *c = L'\0';
  65                         *pos_add = 1;
  66                         return 1;
  67                 } else {
  68                         *pos_add = it->pos - start;
  69                         return 0;
  70                 }
  71         } else {
  72                 *pos_add = 1;
  73                 if (it->pos < r->end && text_iterator_byte_get(it, (char*)c)) {
  74                         text_iterator_byte_next(it, NULL);
  75                         return 0;
  76                 } else {
  77                         *c = '\0';
  78                         return 1;
  79                 }
  80         }
  81 }
  82
  83 static void str_rewind(size_t pos, void *context) {
  84         Regex *r = context;
  85         r->it = text_iterator_get(r->text, pos);
  86 }
  87
  88 static int str_compare(size_t pos1, size_t pos2, size_t len, void *context) {
  89         Regex *r = context;
  90         int ret = 1;
  91         void *buf1 = malloc(len), *buf2 = malloc(len);
  92         if (!buf1 || !buf2)
  93                 goto err;
  94         text_bytes_get(r->text, pos1, len, buf1);
  95         text_bytes_get(r->text, pos2, len, buf2);
  96         ret = memcmp(buf1, buf2, len);
  97 err:
  98         free(buf1);
  99         free(buf2);
 100         return ret;
 101 }
 102
 103 Regex *text_regex_new(void) {
 104         Regex *r = calloc(1, sizeof(*r));
 105         if (!r)
 106                 return NULL;
 107         r->str_source = (tre_str_source) {
 108                 .get_next_char = str_next_char,
 109                 .rewind = str_rewind,
 110                 .compare = str_compare,
 111                 .context = r,
 112         };
 113         return r;
 114 }
 115
 116 void text_regex_free(Regex *r) {
 117         if (!r)
 118                 return;
 119         tre_regfree(&r->regex);
 120         free(r);
 121 }
 122
 123 int text_regex_compile(Regex *regex, const char *string, int cflags) {
 124         int r = tre_regcomp(&regex->regex, string, cflags);
 125         if (r)
 126                 tre_regcomp(&regex->regex, "\0\0", 0);
 127         return r;
 128 }
 129
 130 int text_regex_match(Regex *r, const char *data, int eflags) {
 131         return tre_regexec(&r->regex, data, 0, NULL, eflags);
 132 }
 133
 134 int text_search_range_forward(Text *txt, size_t pos, size_t len, Regex *r, size_t nmatch, RegexMatch pmatch[], int eflags) {
 135         r->text = txt;
 136         r->it = text_iterator_get(txt, pos);
 137         r->end = pos+len;
 138
 139         regmatch_t match[nmatch];
 140         int ret = tre_reguexec(&r->regex, &r->str_source, nmatch, match, eflags);
 141         if (!ret) {
 142                 for (size_t i = 0; i < nmatch; i++) {
 143                         pmatch[i].start = match[i].rm_so == -1 ? EPOS : pos + match[i].rm_so;
 144                         pmatch[i].end = match[i].rm_eo == -1 ? EPOS : pos + match[i].rm_eo;
 145                 }
 146         }
 147         return ret;
 148 }
 149
 150 int text_search_range_backward(Text *txt, size_t pos, size_t len, Regex *r, size_t nmatch, RegexMatch pmatch[], int eflags) {
 151         int ret = REG_NOMATCH;
 152         size_t end = pos + len;
 153
 154         while (pos < end && !text_search_range_forward(txt, pos, len, r, nmatch, pmatch, eflags)) {
 155                 ret = 0;
 156                 // FIXME: assumes nmatch >= 1
 157                 size_t next = pmatch[0].end;
 158                 if (next == pos) {
 159                         next = text_line_next(txt, pos);
 160                         if (next == pos)
 161                                 break;
 162                 }
 163                 pos = next;
 164                 len = end - pos;
 165         }
 166
 167         return ret;
 168 }