static void
run_engines(pcre *re, unsigned engine_types, int ncaps,
const char *input, size_t len)
{
int i, n;
int rc;
int *ovector;
size_t ovecsize;
pcre_extra *extra;
struct timespec begin, end;
double elapsed;
const char *errstr = NULL;
if (engine_types & ENGINE_DEFAULT) {
ovecsize = (ncaps + 1) * 3;
ovector = malloc(ovecsize * sizeof(int));
assert(ovector);
printf("pcre default ");
extra = pcre_study(re, 0, &errstr);
if (errstr != NULL) {
fprintf(stderr, "failed to study the regex: %s", errstr);
exit(2);
}
TIMER_START
rc = pcre_exec(re, extra, input, len, 0, 0, ovector, ovecsize);
TIMER_STOP
if (rc == 0) {
fprintf(stderr, "capture size too small");
exit(2);
}
if (rc == PCRE_ERROR_NOMATCH) {
printf("no match");
} else if (rc < 0) {
printf("error: %d", rc);
} else if (rc > 0) {
printf("match");
for (i = 0, n = 0; i < rc; i++, n += 2) {
printf(" (%d, %d)", ovector[n], ovector[n + 1]);
}
}
printf(": %.02lf ms elapsed.\n", elapsed);
if (extra) {
pcre_free_study(extra);
extra = NULL;
}
free(ovector);
}
void ParseSizeDeinit(void) {
if (parse_regex != NULL)
pcre_free(parse_regex);
if (parse_regex_study != NULL)
pcre_free_study(parse_regex_study);
}
FileScannerPCRE::~FileScannerPCRE()
{
#ifdef HAVE_LIBPCRE
pcre_free_study(m_pcre_extra);
pcre_free(m_pcre_regex);
#endif
}
void r3_tree_free(node * tree) {
for (int i = 0 ; i < tree->edge_len ; i++ ) {
if (tree->edges[i]) {
r3_edge_free(tree->edges[ i ]);
}
}
if (tree->edges) {
zfree(tree->edges);
}
if (tree->routes) {
zfree(tree->routes);
}
if (tree->pcre_pattern) {
pcre_free(tree->pcre_pattern);
}
#ifdef PCRE_STUDY_JIT_COMPILE
if (tree->pcre_extra) {
pcre_free_study(tree->pcre_extra);
}
#endif
if (tree->combined_pattern)
zfree(tree->combined_pattern);
if (tree->ov)
zfree(tree->ov);
zfree(tree);
tree = NULL;
}
static void
ngx_pcre_free_studies(void *data)
{
ngx_list_t *studies = data;
ngx_uint_t i;
ngx_list_part_t *part;
ngx_regex_elt_t *elts;
part = &studies->part;
elts = part->elts;
for (i = 0 ; /* void */ ; i++) {
if (i >= part->nelts) {
if (part->next == NULL) {
break;
}
part = part->next;
elts = part->elts;
i = 0;
}
if (elts[i].regex->extra != NULL) {
pcre_free_study(elts[i].regex->extra);
}
}
}
/*
* Backend interface routines
*/
static void closef(struct selabel_handle *rec)
{
struct saved_data *data = (struct saved_data *)rec->data;
struct spec *spec;
struct stem *stem;
unsigned int i;
for (i = 0; i < data->nspec; i++) {
spec = &data->spec_arr[i];
free(spec->regex_str);
free(spec->type_str);
free(spec->lr.ctx_raw);
free(spec->lr.ctx_trans);
if (spec->regcomp) {
pcre_free(spec->regex);
pcre_free_study(spec->sd);
}
}
for (i = 0; i < (unsigned int)data->num_stems; i++) {
stem = &data->stem_arr[i];
free(stem->buf);
}
if (data->spec_arr)
free(data->spec_arr);
if (data->stem_arr)
free(data->stem_arr);
free(data);
}
template <typename Traits> inline
branch<Traits>::~branch() {
for (std::list<regex_data>::iterator i = regex_matches_.begin(), end = regex_matches_.end(); i != end; ++i) {
pcre_free_study(i->second);
pcre_free(i->first);
}
}
static int regexp_gc(lua_State *L) {
cs_regexp_t *regexp = (cs_regexp_t *)luaL_checkudata(L, 1, RE_MTBL_NAME);
if (regexp->extra)
pcre_free_study(regexp->extra);
if (regexp->re)
pcre_free(regexp->re);
return 0;
}
static void
log_matcher_pcre_re_free(LogMatcher *s)
{
LogMatcherPcreRe *self = (LogMatcherPcreRe *) s;
pcre_free_study(self->extra);
pcre_free(self->pattern);
log_matcher_free_method(s);
}
void pcre2_code_free_8(pcre2_code_8 *code) {
if (code == NULL) {
return;
}
pcre_free(code->regex);
pcre_free_study(code->extra);
free(code);
}
void
sircc_highlighter_free(struct sircc_highlighter *highlighter) {
if (!highlighter)
return;
pcre_free(highlighter->regexp);
pcre_free_study(highlighter->regexp_extra);
c_free(highlighter->sequence);
}
int main(int argc, char *argv[])
{
pcre *r;
pcre_extra *re;
const char *error;
int erroffset;
int ovector[10];
char *buf, *q;
int l = 0;
int studyoption;
if (argc != 3) {
fprintf(stderr, "Usage: cat in.file | %s <regexp> <jitflag>\n", argv[0]);
return 0;
}
r = pcre_compile(argv[1], 0, &error, &erroffset, NULL);
if (r == NULL) {
fprintf(stderr, "PCRE compilation failed at offset %d: %s\n",
erroffset, error);
return 1;
}
if (!strcmp(argv[2], "1")) {
#ifdef PCRE_STUDY_JIT_COMPILE
studyoption = PCRE_STUDY_JIT_COMPILE;
#else
fprintf(stderr, "JIT unsupported in PCRE\n");
return 1;
#endif
} else {
studyoption = 0;
}
re = pcre_study(r, studyoption, &error);
if (re == NULL) {
fprintf(stderr, "PCRE study failed: %s\n", error);
return 1;
}
buf = calloc(BUF_SIZE, 1);
while (fgets(buf, BUF_SIZE - 1, stdin)) {
++l;
for (q = buf; *q; ++q); if (q > buf) *(q-1) = 0;
if (pcre_exec(r, re, buf, q - buf, 0, PCRE_CONFIG_UTF8,
ovector, sizeof(ovector) / sizeof(int)) == 0)
printf("%d:%s\n", l, buf);
}
#ifdef PCRE_STUDY_JIT_COMPILE
pcre_free_study(re);
#else
pcre_free(re);
#endif
pcre_free(r);
free(buf);
return 0;
}
/* Finalizing deallocation function for compiled regular expressions */
static void pcre_dealloc_regexp(value v_rex)
{
void *extra = get_extra(v_rex);
if (extra != NULL)
#ifdef PCRE_STUDY_JIT_COMPILE
pcre_free_study(extra);
#else
pcre_free(extra);
#endif
(pcre_free)(get_rex(v_rex));
}
void regex_data_free(struct regex_data *regex)
{
if (regex) {
if (regex->owned) {
if (regex->regex)
pcre_free(regex->regex);
if (regex->sd)
pcre_free_study(regex->sd);
}
free(regex);
}
}
static void
rspamd_regexp_dtor (rspamd_regexp_t *re)
{
if (re) {
if (re->raw_re && re->raw_re != re->re) {
#ifndef WITH_PCRE2
#ifdef HAVE_PCRE_JIT
if (re->raw_extra) {
pcre_free_study (re->raw_extra);
}
#endif
#else
if (re->mcontext) {
pcre2_match_context_free (re->mcontext);
}
#endif
PCRE_FREE (re->raw_re);
}
if (re->re) {
#ifndef WITH_PCRE2
#ifdef HAVE_PCRE_JIT
if (re->extra) {
pcre_free_study (re->extra);
}
#endif
#else
if (re->raw_mcontext) {
pcre2_match_context_free (re->raw_mcontext);
}
#endif
PCRE_FREE (re->re);
}
if (re->pattern) {
g_free (re->pattern);
}
g_free (re);
}
}
static void free_pcre1_regexp(struct grep_pat *p)
{
pcre_free(p->pcre1_regexp);
#ifdef GIT_PCRE1_USE_JIT
if (p->pcre1_jit_on) {
pcre_free_study(p->pcre1_extra_info);
pcre_jit_stack_free(p->pcre1_jit_stack);
} else
#endif
{
pcre_free(p->pcre1_extra_info);
}
pcre_free((void *)p->pcre1_tables);
}
static void
free_invalidate_t(invalidate_t *i)
{
if (i->regex_extra)
#ifndef PCRE_STUDY_JIT_COMPILE
pcre_free(i->regex_extra);
#else
pcre_free_study(i->regex_extra);
#endif
if (i->regex)
pcre_free(i->regex);
if (i->regex_text)
pcre_free_substring(i->regex_text);
TSfree(i);
}
static void
rspamd_regexp_dtor (rspamd_regexp_t *re)
{
if (re) {
if (re->raw_re && re->raw_re != re->re) {
pcre_free (re->raw_re);
#ifdef HAVE_PCRE_JIT
if (re->raw_extra) {
pcre_free_study (re->raw_extra);
}
if (re->raw_jstack) {
pcre_jit_stack_free (re->raw_jstack);
}
#else
pcre_free (re->raw_extra);
#endif
}
if (re->re) {
pcre_free (re->re);
#ifdef HAVE_PCRE_JIT
if (re->extra) {
pcre_free_study (re->extra);
}
if (re->jstack) {
pcre_jit_stack_free (re->jstack);
}
#else
pcre_free (re->extra);
#endif
}
if (re->pattern) {
g_free (re->pattern);
}
}
}
static void
ngx_http_lua_regex_free_study_data(ngx_pool_t *pool, pcre_extra *sd)
{
ngx_pool_t *old_pool;
old_pool = ngx_http_lua_pcre_malloc_init(pool);
#if LUA_HAVE_PCRE_JIT
pcre_free_study(sd);
#else
pcre_free(sd);
#endif
ngx_http_lua_pcre_malloc_done(old_pool);
}
void RegExp::Impl::invalidate ()
{
_isReady = false;
_errstr.clear();
_erroffset = -1;
if (_re) {
pcre_free(_re);
_re = nullptr;
}
if (_extra) {
pcre_free_study(_extra);
_extra = nullptr;
}
}
static void
pcre_RegexObject_dealloc(pcre_RegexObject* self)
{
free(self->pattern);
Py_XDECREF(self->groupindex);
if (self->re != NULL)
pcre_free(self->re);
if (self->study != NULL)
pcre_free_study(self->study);
if (self->jit_stack != NULL)
pcre_jit_stack_free(self->jit_stack);
self->ob_type->tp_free((PyObject*)self);
}
void
VRE_free(vre_t **vv)
{
vre_t *v = *vv;
*vv = NULL;
CHECK_OBJ(v, VRE_MAGIC);
if (v->re_extra != NULL) {
if (v->my_extra)
free(v->re_extra);
else
pcre_free_study(v->re_extra);
}
if (v->re != NULL)
pcre_free(v->re);
FREE_OBJ(v);
}
void
patable_release(struct patable *pat)
{
int i;
for (i = 0; i < pat->npat; i++) {
#ifdef PATABLE_USE_PCRE
pcre_free(pat->pat[i].re);
pat->pat[i].re = 0;
pcre_free_study(pat->pat[i].ext);
pat->pat[i].ext = 0;
#else
regfree(&pat->pat[i].re);
pat->pat[i].used = 0;
#endif
}
}
static void
free_cfg(struct config *cfg)
{
TSError("[url_sig] Cleaning up...");
TSfree(cfg->err_url);
if (cfg->regex_extra)
#ifndef PCRE_STUDY_JIT_COMPILE
pcre_free(cfg->regex_extra);
#else
pcre_free_study(cfg->regex_extra);
#endif
if (cfg->regex)
pcre_free(cfg->regex);
TSfree(cfg);
}
/*
* Backend interface routines
*/
static void closef(struct selabel_handle *rec)
{
struct saved_data *data = (struct saved_data *)rec->data;
struct mmap_area *area, *last_area;
struct spec *spec;
struct stem *stem;
unsigned int i;
for (i = 0; i < data->nspec; i++) {
spec = &data->spec_arr[i];
free(spec->lr.ctx_trans);
free(spec->lr.ctx_raw);
if (spec->from_mmap)
continue;
free(spec->regex_str);
free(spec->type_str);
if (spec->regcomp) {
pcre_free(spec->regex);
pcre_free_study(spec->sd);
}
}
for (i = 0; i < (unsigned int)data->num_stems; i++) {
stem = &data->stem_arr[i];
if (stem->from_mmap)
continue;
free(stem->buf);
}
if (data->spec_arr)
free(data->spec_arr);
if (data->stem_arr)
free(data->stem_arr);
area = data->mmap_areas;
while (area) {
munmap(area->addr, area->len);
last_area = area;
area = area->next;
free(last_area);
}
free(data);
}
/*
* Regex stuff
*/
void regex_free(tvh_regex_t *regex)
{
#if ENABLE_PCRE || ENABLE_PCRE2
if (regex->is_posix) {
#endif
regfree(®ex->re_posix_code);
regex->re_posix_text = NULL;
#if ENABLE_PCRE || ENABLE_PCRE2
} else {
#if ENABLE_PCRE
#ifdef PCRE_CONFIG_JIT
#if PCRE_STUDY_JIT_COMPILE
if (regex->re_jit_stack) {
pcre_jit_stack_free(regex->re_jit_stack);
regex->re_jit_stack = NULL;
}
#endif
pcre_free_study(regex->re_extra);
#else
pcre_free(regex->re_extra);
#endif
pcre_free(regex->re_code);
regex->re_extra = NULL;
regex->re_code = NULL;
regex->re_text = NULL;
#elif ENABLE_PCRE2
pcre2_jit_stack_free(regex->re_jit_stack);
pcre2_match_data_free(regex->re_match);
pcre2_code_free(regex->re_code);
pcre2_match_context_free(regex->re_mcontext);
regex->re_match = NULL;
regex->re_code = NULL;
regex->re_mcontext = NULL;
regex->re_jit_stack = NULL;
#endif
}
#endif
}
void DetectUrilenRegister(void)
{
sigmatch_table[DETECT_AL_URILEN].name = "urilen";
sigmatch_table[DETECT_AL_URILEN].desc = "match on the length of the HTTP uri";
sigmatch_table[DETECT_AL_URILEN].url = "https://redmine.openinfosecfoundation.org/projects/suricata/wiki/HTTP-keywords#Urilen";
sigmatch_table[DETECT_AL_URILEN].Match = NULL;
sigmatch_table[DETECT_AL_URILEN].alproto = ALPROTO_HTTP;
sigmatch_table[DETECT_AL_URILEN].AppLayerMatch = NULL /**< We handle this at detect-engine-uri.c now */;
sigmatch_table[DETECT_AL_URILEN].Setup = DetectUrilenSetup;
sigmatch_table[DETECT_AL_URILEN].Free = DetectUrilenFree;
sigmatch_table[DETECT_AL_URILEN].RegisterTests = DetectUrilenRegisterTests;
sigmatch_table[DETECT_AL_URILEN].flags |= SIGMATCH_PAYLOAD;
const char *eb;
int eo;
int opts = 0;
parse_regex = pcre_compile(PARSE_REGEX, opts, &eb, &eo, NULL);
if (parse_regex == NULL) {
SCLogDebug("pcre compile of \"%s\" failed at offset %" PRId32 ": %s",
PARSE_REGEX, eo, eb);
goto error;
}
parse_regex_study = pcre_study(parse_regex, 0, &eb);
if (eb != NULL) {
SCLogDebug("pcre study failed: %s", eb);
goto error;
}
return;
error:
if (parse_regex != NULL)
pcre_free(parse_regex);
if (parse_regex_study != NULL)
pcre_free_study(parse_regex_study);
return;
}
static void free_specs(struct saved_data *data)
{
struct spec *specs = data->spec_arr;
unsigned int num_entries = data->nspec;
unsigned int i;
for (i = 0; i < num_entries; i++) {
free(specs[i].lr.ctx_raw);
free(specs[i].lr.ctx_trans);
free(specs[i].regex_str);
free(specs[i].type_str);
pcre_free(specs[i].regex);
pcre_free_study(specs[i].sd);
}
free(specs);
num_entries = data->num_stems;
for (i = 0; i < num_entries; i++)
free(data->stem_arr[i].buf);
free(data->stem_arr);
memset(data, 0, sizeof(*data));
}
/**
* This function combines ['/foo', '/bar', '/{slug}'] into (/foo)|(/bar)|/([^/]+)}
*
*/
void r3_tree_compile_patterns(node * n) {
char * cpat;
char * p;
cpat = zcalloc(sizeof(char) * 128);
if (cpat==NULL)
return;
p = cpat;
strncat(p, "^", 1);
p++;
edge *e = NULL;
int opcode_cnt = 0;
for ( int i = 0 ; i < n->edge_len ; i++ ) {
e = n->edges[i];
if ( e->opcode )
opcode_cnt++;
if ( e->has_slug ) {
// compile "foo/{slug}" to "foo/[^/]+"
char * slug_pat = slug_compile(e->pattern, e->pattern_len);
strcat(p, slug_pat);
} else {
strncat(p++,"(", 1);
strncat(p, e->pattern, e->pattern_len);
p += e->pattern_len;
strncat(p++,")", 1);
}
if ( i + 1 < n->edge_len && n->edge_len > 1 ) {
strncat(p++,"|",1);
}
}
info("pattern: %s\n",cpat);
// if all edges use opcode, we should skip the combined_pattern.
if ( opcode_cnt == n->edge_len ) {
// zfree(cpat);
n->compare_type = NODE_COMPARE_OPCODE;
} else {
n->compare_type = NODE_COMPARE_PCRE;
}
n->combined_pattern = cpat;
const char *error;
int erroffset;
unsigned int option_bits = 0;
n->ov_cnt = (1 + n->edge_len) * 3;
if (n->pcre_pattern) {
pcre_free(n->pcre_pattern);
}
n->pcre_pattern = pcre_compile(
n->combined_pattern, /* the pattern */
option_bits, /* default options */
&error, /* for error message */
&erroffset, /* for error offset */
NULL); /* use default character tables */
if (n->pcre_pattern == NULL) {
printf("PCRE compilation failed at offset %d: %s, pattern: %s\n", erroffset, error, n->combined_pattern);
return;
}
#ifdef PCRE_STUDY_JIT_COMPILE
if (n->pcre_extra) {
pcre_free_study(n->pcre_extra);
}
n->pcre_extra = pcre_study(n->pcre_pattern, 0, &error);
if (n->pcre_extra == NULL) {
printf("PCRE study failed at offset %s\n", error);
return;
}
#endif
}
static int regression_tests(void)
{
struct regression_test_case *current = regression_test_cases;
const char *error;
const char *cpu_info;
int i, err_offs;
int is_successful, is_ascii_pattern, is_ascii_input;
int total = 0;
int successful = 0;
int counter = 0;
#ifdef SUPPORT_PCRE8
pcre *re8;
pcre_extra *extra8;
int ovector8_1[32];
int ovector8_2[32];
int return_value8_1, return_value8_2;
int utf8 = 0, ucp8 = 0;
int disabled_flags8 = 0;
#endif
#ifdef SUPPORT_PCRE16
pcre16 *re16;
pcre16_extra *extra16;
int ovector16_1[32];
int ovector16_2[32];
int return_value16_1, return_value16_2;
int utf16 = 0, ucp16 = 0;
int disabled_flags16 = 0;
int length16;
#endif
/* This test compares the behaviour of interpreter and JIT. Although disabling
utf or ucp may make tests fail, if the pcre_exec result is the SAME, it is
still considered successful from pcre_jit_test point of view. */
#ifdef SUPPORT_PCRE8
pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);
#else
pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);
#endif
printf("Running JIT regression tests\n");
printf(" target CPU of SLJIT compiler: %s\n", cpu_info);
#ifdef SUPPORT_PCRE8
pcre_config(PCRE_CONFIG_UTF8, &utf8);
pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp8);
if (!utf8)
disabled_flags8 |= PCRE_UTF8;
if (!ucp8)
disabled_flags8 |= PCRE_UCP;
printf(" in 8 bit mode with utf8 %s and ucp %s:\n", utf8 ? "enabled" : "disabled", ucp8 ? "enabled" : "disabled");
#endif
#ifdef SUPPORT_PCRE16
pcre16_config(PCRE_CONFIG_UTF16, &utf16);
pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp16);
if (!utf16)
disabled_flags16 |= PCRE_UTF8;
if (!ucp16)
disabled_flags16 |= PCRE_UCP;
printf(" in 16 bit mode with utf16 %s and ucp %s:\n", utf16 ? "enabled" : "disabled", ucp16 ? "enabled" : "disabled");
#endif
while (current->pattern) {
/* printf("\nPattern: %s :\n", current->pattern); */
total++;
if (current->start_offset & F_PROPERTY) {
is_ascii_pattern = 0;
is_ascii_input = 0;
} else {
is_ascii_pattern = check_ascii(current->pattern);
is_ascii_input = check_ascii(current->input);
}
error = NULL;
#ifdef SUPPORT_PCRE8
re8 = NULL;
if (!(current->start_offset & F_NO8))
re8 = pcre_compile(current->pattern,
current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | disabled_flags8),
&error, &err_offs, tables(0));
extra8 = NULL;
if (re8) {
error = NULL;
extra8 = pcre_study(re8, PCRE_STUDY_JIT_COMPILE, &error);
if (!extra8) {
printf("\n8 bit: Cannot study pattern: %s\n", current->pattern);
pcre_free(re8);
re8 = NULL;
}
if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);
pcre_free_study(extra8);
pcre_free(re8);
re8 = NULL;
}
} else if (((utf8 && ucp8) || is_ascii_pattern) && !(current->start_offset & F_NO8))
printf("\n8 bit: Cannot compile pattern: %s\n", current->pattern);
#endif
#ifdef SUPPORT_PCRE16
if ((current->flags & PCRE_UTF8) || (current->start_offset & F_FORCECONV))
convert_utf8_to_utf16(current->pattern, regtest_buf, NULL, REGTEST_MAX_LENGTH);
else
copy_char8_to_char16(current->pattern, regtest_buf, REGTEST_MAX_LENGTH);
re16 = NULL;
if (!(current->start_offset & F_NO16))
re16 = pcre16_compile(regtest_buf,
current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | disabled_flags16),
&error, &err_offs, tables(0));
extra16 = NULL;
if (re16) {
error = NULL;
extra16 = pcre16_study(re16, PCRE_STUDY_JIT_COMPILE, &error);
if (!extra16) {
printf("\n16 bit: Cannot study pattern: %s\n", current->pattern);
pcre16_free(re16);
re16 = NULL;
}
if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);
pcre16_free_study(extra16);
pcre16_free(re16);
re16 = NULL;
}
} else if (((utf16 && ucp16) || is_ascii_pattern) && !(current->start_offset & F_NO16))
printf("\n16 bit: Cannot compile pattern: %s\n", current->pattern);
#endif
counter++;
if ((counter & 0x3) != 0) {
#ifdef SUPPORT_PCRE8
setstack8(NULL);
#endif
#ifdef SUPPORT_PCRE16
setstack16(NULL);
#endif
}
#ifdef SUPPORT_PCRE8
return_value8_1 = -1000;
return_value8_2 = -1000;
for (i = 0; i < 32; ++i)
ovector8_1[i] = -2;
for (i = 0; i < 32; ++i)
ovector8_2[i] = -2;
if (re8) {
setstack8(extra8);
return_value8_1 = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector8_1, 32);
return_value8_2 = pcre_exec(re8, NULL, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector8_2, 32);
}
#endif
#ifdef SUPPORT_PCRE16
return_value16_1 = -1000;
return_value16_2 = -1000;
for (i = 0; i < 32; ++i)
ovector16_1[i] = -2;
for (i = 0; i < 32; ++i)
ovector16_2[i] = -2;
if (re16) {
setstack16(extra16);
if ((current->flags & PCRE_UTF8) || (current->start_offset & F_FORCECONV))
length16 = convert_utf8_to_utf16(current->input, regtest_buf, regtest_offsetmap, REGTEST_MAX_LENGTH);
else
length16 = copy_char8_to_char16(current->input, regtest_buf, REGTEST_MAX_LENGTH);
return_value16_1 = pcre16_exec(re16, extra16, regtest_buf, length16, current->start_offset & OFFSET_MASK,
current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector16_1, 32);
return_value16_2 = pcre16_exec(re16, NULL, regtest_buf, length16, current->start_offset & OFFSET_MASK,
current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector16_2, 32);
}
#endif
/* If F_DIFF is set, just run the test, but do not compare the results.
Segfaults can still be captured. */
is_successful = 1;
if (!(current->start_offset & F_DIFF)) {
#if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
if (utf8 == utf16 && !(current->start_offset & F_FORCECONV)) {
/* All results must be the same. */
if (return_value8_1 != return_value8_2 || return_value8_1 != return_value16_1 || return_value8_1 != return_value16_2) {
printf("\n8 and 16 bit: Return value differs(%d:%d:%d:%d): [%d] '%s' @ '%s'\n",
return_value8_1, return_value8_2, return_value16_1, return_value16_2,
total, current->pattern, current->input);
is_successful = 0;
} else if (return_value8_1 >= 0) {
return_value8_1 *= 2;
/* Transform back the results. */
if (current->flags & PCRE_UTF8) {
for (i = 0; i < return_value8_1; ++i) {
if (ovector16_1[i] >= 0)
ovector16_1[i] = regtest_offsetmap[ovector16_1[i]];
if (ovector16_2[i] >= 0)
ovector16_2[i] = regtest_offsetmap[ovector16_2[i]];
}
}
for (i = 0; i < return_value8_1; ++i)
if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector16_1[i] || ovector8_1[i] != ovector16_2[i]) {
printf("\n8 and 16 bit: Ovector[%d] value differs(%d:%d:%d:%d): [%d] '%s' @ '%s' \n",
i, ovector8_1[i], ovector8_2[i], ovector16_1[i], ovector16_2[i],
total, current->pattern, current->input);
is_successful = 0;
}
}
} else {
#endif /* SUPPORT_PCRE8 && SUPPORT_PCRE16 */
/* Only the 8 bit and 16 bit results must be equal. */
#ifdef SUPPORT_PCRE8
if (return_value8_1 != return_value8_2) {
printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
return_value8_1, return_value8_2, total, current->pattern, current->input);
is_successful = 0;
} else if (return_value8_1 >= 0) {
return_value8_1 *= 2;
for (i = 0; i < return_value8_1; ++i)
if (ovector8_1[i] != ovector8_2[i]) {
printf("\n8 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
i, ovector8_1[i], ovector8_2[i], total, current->pattern, current->input);
is_successful = 0;
}
}
#endif
#ifdef SUPPORT_PCRE16
if (return_value16_1 != return_value16_2) {
printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
return_value16_1, return_value16_2, total, current->pattern, current->input);
is_successful = 0;
} else if (return_value16_1 >= 0) {
return_value16_1 *= 2;
for (i = 0; i < return_value16_1; ++i)
if (ovector16_1[i] != ovector16_2[i]) {
printf("\n16 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
i, ovector16_1[i], ovector16_2[i], total, current->pattern, current->input);
is_successful = 0;
}
}
#endif
#if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
}
#endif /* SUPPORT_PCRE8 && SUPPORT_PCRE16 */
}
if (is_successful) {
#ifdef SUPPORT_PCRE8
if (!(current->start_offset & F_NO8) && ((utf8 && ucp8) || is_ascii_input)) {
if (return_value8_1 < 0 && !(current->start_offset & F_NOMATCH)) {
printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",
total, current->pattern, current->input);
is_successful = 0;
}
if (return_value8_1 >= 0 && (current->start_offset & F_NOMATCH)) {
printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",
total, current->pattern, current->input);
is_successful = 0;
}
}
#endif
#ifdef SUPPORT_PCRE16
if (!(current->start_offset & F_NO16) && ((utf16 && ucp16) || is_ascii_input)) {
if (return_value16_1 < 0 && !(current->start_offset & F_NOMATCH)) {
printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",
total, current->pattern, current->input);
is_successful = 0;
}
if (return_value16_1 >= 0 && (current->start_offset & F_NOMATCH)) {
printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",
total, current->pattern, current->input);
is_successful = 0;
}
}
#endif
}
if (is_successful)
successful++;
#ifdef SUPPORT_PCRE8
if (re8) {
pcre_free_study(extra8);
pcre_free(re8);
}
#endif
#ifdef SUPPORT_PCRE16
if (re16) {
pcre16_free_study(extra16);
pcre16_free(re16);
}
#endif
/* printf("[%d-%d|%d-%d]%s", ovector8_1[0], ovector8_1[1], ovector16_1[0], ovector16_1[1], (current->flags & PCRE_CASELESS) ? "C" : ""); */
printf(".");
fflush(stdout);
current++;
}
tables(1);
#ifdef SUPPORT_PCRE8
setstack8(NULL);
#endif
#ifdef SUPPORT_PCRE16
setstack16(NULL);
#endif
if (total == successful) {
printf("\nAll JIT regression tests are successfully passed.\n");
return 0;
} else {
printf("\nSuccessful test ratio: %d%% (%d failed)\n", successful * 100 / total, total - successful);
return 1;
}
}
