Pattern
new_pattern(const char *pattern, int case_matters)
{
int tpatlen = -1;
const char *tpattern = translate_pattern(pattern, &tpatlen);
regexp_t buf = mymalloc(sizeof(*buf), M_PATTERN);
Pattern p;
init_casefold_once();
buf->buffer = 0;
buf->allocated = 0;
buf->translate = case_matters ? 0 : casefold;
re_set_syntax(MOO_SYNTAX);
if (tpattern
&& !re_compile_pattern((void *) tpattern, tpatlen, buf)) {
buf->fastmap = mymalloc(256 * sizeof(char), M_PATTERN);
re_compile_fastmap(buf);
p.ptr = buf;
} else {
if (buf->buffer)
free(buf->buffer);
myfree(buf, M_PATTERN);
p.ptr = 0;
}
return p;
}
static int
run_test_backwards (const char *expr, const char *mem, size_t memlen,
int icase, int expected)
{
regex_t re;
const char *err;
size_t offset;
int cnt;
re_set_syntax ((RE_SYNTAX_POSIX_BASIC & ~RE_DOT_NEWLINE)
| RE_HAT_LISTS_NOT_NEWLINE
| (icase ? RE_ICASE : 0));
memset (&re, 0, sizeof (re));
re.fastmap = malloc (256);
if (re.fastmap == NULL)
error (EXIT_FAILURE, errno, "cannot allocate fastmap");
err = re_compile_pattern (expr, strlen (expr), &re);
if (err != NULL)
error (EXIT_FAILURE, 0, "cannot compile expression: %s", err);
if (re_compile_fastmap (&re))
error (EXIT_FAILURE, 0, "couldn't compile fastmap");
cnt = 0;
offset = memlen;
assert (mem[memlen] == '\0');
while (offset <= memlen)
{
int start;
const char *sp;
const char *ep;
start = re_search (&re, mem, memlen, offset, -offset, NULL);
if (start == -1)
break;
if (start == -2)
error (EXIT_FAILURE, 0, "internal error in re_search");
sp = mem + start;
while (sp > mem && sp[-1] != '\n')
--sp;
ep = mem + start;
while (*ep != '\0' && *ep != '\n')
++ep;
printf ("match %d: \"%.*s\"\n", ++cnt, (int) (ep - sp), sp);
offset = sp - 1 - mem;
}
regfree (&re);
/* Return an error if the number of matches found is not match we
expect. */
return cnt != expected;
}
bool
Regexp::compile(vespalib::stringref re, Flags flags)
{
re_set_syntax(flags.flags());
regex_t *preg = (regex_t *)_data;
preg->translate = NULL;
preg->fastmap = static_cast<char *>(malloc(256));
preg->buffer = NULL;
preg->allocated = 0;
const char * error = re_compile_pattern(re.data(), re.size(), preg);
if (error != 0) {
LOG(warning, "invalid regexp '%s': %s", vespalib::string(re).c_str(), error);
return false;
}
if (re_compile_fastmap(preg) != 0) {
LOG(warning, "re_compile_fastmap failed for regexp '%s'", vespalib::string(re).c_str());
return false;
}
return true;
}
void
set_word_regexp (const char *regexp)
{
const char *msg;
struct re_pattern_buffer new_word_regexp;
if (!*regexp || STREQ (regexp, DEFAULT_WORD_REGEXP))
{
default_word_regexp = true;
return;
}
/* Dry run to see whether the new expression is compilable. */
init_pattern_buffer (&new_word_regexp, NULL);
msg = re_compile_pattern (regexp, strlen (regexp), &new_word_regexp);
regfree (&new_word_regexp);
if (msg != NULL)
{
M4ERROR ((warning_status, 0,
"bad regular expression `%s': %s", regexp, msg));
return;
}
/* If compilation worked, retry using the word_regexp struct. We
can't rely on struct assigns working, so redo the compilation.
The fastmap can be reused between compilations, and will be freed
by the final regfree. */
if (!word_regexp.fastmap)
word_regexp.fastmap = xcharalloc (UCHAR_MAX + 1);
msg = re_compile_pattern (regexp, strlen (regexp), &word_regexp);
assert (!msg);
re_set_registers (&word_regexp, ®s, regs.num_regs, regs.start, regs.end);
if (re_compile_fastmap (&word_regexp))
assert (false);
default_word_regexp = false;
}
int re_search(regexp_t bufp, unsigned char *string, int size, int pos,
int range, regexp_registers_t regs)
{
unsigned char *fastmap;
unsigned char *translate;
unsigned char *text;
unsigned char *partstart;
unsigned char *partend;
int dir;
int ret;
unsigned char anchor;
assert(size >= 0 && pos >= 0);
assert(pos + range >= 0 && pos + range <= size); /* Bugfix by ylo */
fastmap = bufp->fastmap;
translate = bufp->translate;
if (fastmap && !bufp->fastmap_accurate) {
re_compile_fastmap(bufp);
if (PyErr_Occurred()) return -2;
}
anchor = bufp->anchor;
if (bufp->can_be_null == 1) /* can_be_null == 2: can match null at eob */
fastmap = NULL;
if (range < 0)
{
dir = -1;
range = -range;
}
else
dir = 1;
if (anchor == 2) {
if (pos != 0)
return -1;
else
range = 0;
}
for (; range >= 0; range--, pos += dir)
{
if (fastmap)
{
if (dir == 1)
{ /* searching forwards */
text = string + pos;
partend = string + size;
partstart = text;
if (translate)
while (text != partend &&
!fastmap[(unsigned char) translate[(unsigned char)*text]])
text++;
else
while (text != partend && !fastmap[(unsigned char)*text])
text++;
pos += text - partstart;
range -= text - partstart;
if (pos == size && bufp->can_be_null == 0)
return -1;
}
else
{ /* searching backwards */
text = string + pos;
partstart = string + pos - range;
partend = text;
if (translate)
while (text != partstart &&
!fastmap[(unsigned char)
translate[(unsigned char)*text]])
text--;
else
while (text != partstart &&
!fastmap[(unsigned char)*text])
text--;
pos -= partend - text;
range -= partend - text;
}
}
if (anchor == 1)
{ /* anchored to begline */
if (pos > 0 && (string[pos - 1] != '\n'))
continue;
}
assert(pos >= 0 && pos <= size);
ret = re_match(bufp, string, size, pos, regs);
if (ret >= 0)
return pos;
if (ret == -2)
return -2;
}
return -1;
}