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; } }