// Called with the individual regexp lock held.
regex_t* Regexp::maybe_recompile(STATE, String* string) {
const UChar *pat;
const UChar *end;
OnigEncoding enc;
OnigErrorInfo err_info;
int err;
if(fixed_encoding_) return onig_source_data(state);
Encoding* string_enc = string->encoding(state);
regex_t* onig_encoded = onig_data_encoded(state, string_enc);
if(onig_encoded) return onig_encoded;
enc = string_enc->get_encoding();
Encoding* source_enc = source()->encoding(state);
String* converted = source()->convert_escaped(state, source_enc, fixed_encoding_);
pat = (UChar*)converted->byte_address();
end = pat + converted->byte_size();
int options = onig_source_data(state)->options;
OnigEncoding orig_enc = onig_source_data(state)->enc;
regex_t* reg;
err = onig_new(®, pat, end, options,
enc, ONIG_SYNTAX_RUBY, &err_info);
// If it doesn't work out, then abort and reset the encoding back
// and say that it's forced.
if(err != ONIG_NORMAL) {
err = onig_new(®, pat, end, options,
orig_enc, ONIG_SYNTAX_RUBY, &err_info);
// Ok, wtf. Well, no way to proceed now.
if(err != ONIG_NORMAL) {
UChar onig_err_buf[ONIG_MAX_ERROR_MESSAGE_LEN];
char err_buf[REGEXP_ONIG_ERROR_MESSAGE_LEN];
onig_error_code_to_str(onig_err_buf, err, &err_info);
snprintf(err_buf, REGEXP_ONIG_ERROR_MESSAGE_LEN, "%s: %s", onig_err_buf, pat);
Exception::regexp_error(state, err_buf);
return NULL;
}
string_enc = source_enc;
fixed_encoding_ = true;
}
return make_managed(state, string_enc, reg);
}
cell AMX_NATIVE_CALL pawn_regex_set(AMX* amx, cell* params)
{
const char *rexp = NULL;
amx_StrParam(amx, params[1], rexp);
if(rexp)
{
int aidi=(int)params[2];
//logprintf("aidi %d", aidi);
if(aidi>=0 && aidi<TotalExpressions)
{
onig_free(rexpression[aidi].RegExpr);
onig_region_free(rexpression[aidi].zreg, 1);
UChar* pattern = (UChar* )rexp;
OnigErrorInfo einfo;
rexpression[aidi].id = onig_new(&rexpression[aidi].RegExpr, pattern, pattern + strlen(rexp), ONIG_OPTION_NONE, ONIG_ENCODING_UTF8, ONIG_SYNTAX_DEFAULT, &einfo);
if(rexpression[aidi].id != ONIG_NORMAL)
{
UChar s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, rexpression[aidi].id, &einfo);
logprintf("[REGEX ERROR]: %s | at index %d. regex_set aborted.", s, aidi);
onig_free(rexpression[aidi].RegExpr);
return -1;
}
rexpression[aidi].zreg = onig_region_new();
//logprintf("aidi %d", aidi);
return 1;
}
logprintf("[REGEX ERROR]: Call regex_set with undefined parameter at index %d", aidi);
return -1;
}
return -1337;
}
/* {{{ php_mbregex_compile_pattern */
static php_mb_regex_t *php_mbregex_compile_pattern(const char *pattern, size_t patlen, OnigOptionType options, OnigEncoding enc, OnigSyntaxType *syntax)
{
int err_code = 0;
php_mb_regex_t *retval = NULL, *rc = NULL;
OnigErrorInfo err_info;
OnigUChar err_str[ONIG_MAX_ERROR_MESSAGE_LEN];
rc = zend_hash_str_find_ptr(&MBREX(ht_rc), (char *)pattern, patlen);
if (!rc || onig_get_options(rc) != options || onig_get_encoding(rc) != enc || onig_get_syntax(rc) != syntax) {
if ((err_code = onig_new(&retval, (OnigUChar *)pattern, (OnigUChar *)(pattern + patlen), options, enc, syntax, &err_info)) != ONIG_NORMAL) {
onig_error_code_to_str(err_str, err_code, &err_info);
php_error_docref(NULL, E_WARNING, "mbregex compile err: %s", err_str);
retval = NULL;
goto out;
}
if (rc == MBREX(search_re)) {
/* reuse the new rc? see bug #72399 */
MBREX(search_re) = NULL;
}
zend_hash_str_update_ptr(&MBREX(ht_rc), (char *)pattern, patlen, retval);
} else {
retval = rc;
}
out:
return retval;
}
extern int
regcomp(regex_t* reg, const char* pattern, int posix_options)
{
int r, len;
OnigSyntaxType* syntax = OnigDefaultSyntax;
OnigOptionType options;
if ((posix_options & REG_EXTENDED) == 0)
syntax = ONIG_SYNTAX_POSIX_BASIC;
options = syntax->options;
if ((posix_options & REG_ICASE) != 0)
ONIG_OPTION_ON(options, ONIG_OPTION_IGNORECASE);
if ((posix_options & REG_NEWLINE) != 0) {
ONIG_OPTION_ON( options, ONIG_OPTION_NEGATE_SINGLELINE);
ONIG_OPTION_OFF(options, ONIG_OPTION_SINGLELINE);
}
reg->comp_options = posix_options;
ENC_STRING_LEN(OnigEncDefaultCharEncoding, pattern, len);
r = onig_new(PONIG_C(reg), (UChar* )pattern, (UChar* )(pattern + len),
options, OnigEncDefaultCharEncoding, syntax,
(OnigErrorInfo* )NULL);
if (r != ONIG_NORMAL) {
return onig2posix_error_code(r);
}
reg->re_nsub = ONIG_C(reg)->num_mem;
return 0;
}
int NewOnigRegex(char *pattern, int pattern_length, int option,
OnigRegex *regex, OnigRegion **region, OnigEncoding *encoding, OnigErrorInfo **error_info, char **error_buffer) {
int ret = ONIG_NORMAL;
int error_msg_len = 0;
OnigUChar *pattern_start = (OnigUChar *) pattern;
OnigUChar *pattern_end = (OnigUChar *) (pattern + pattern_length);
*error_info = (OnigErrorInfo *) malloc(sizeof(OnigErrorInfo));
memset(*error_info, 0, sizeof(OnigErrorInfo));
*encoding = (void*)ONIG_ENCODING_UTF8;
*error_buffer = (char*) malloc(ONIG_MAX_ERROR_MESSAGE_LEN * sizeof(char));
memset(*error_buffer, 0, ONIG_MAX_ERROR_MESSAGE_LEN * sizeof(char));
*region = onig_region_new();
ret = onig_new(regex, pattern_start, pattern_end, (OnigOptionType)(option), *encoding, OnigDefaultSyntax, *error_info);
if (ret != ONIG_NORMAL) {
error_msg_len = onig_error_code_to_str((unsigned char*)(*error_buffer), ret, *error_info);
if (error_msg_len >= ONIG_MAX_ERROR_MESSAGE_LEN) {
error_msg_len = ONIG_MAX_ERROR_MESSAGE_LEN - 1;
}
(*error_buffer)[error_msg_len] = '\0';
}
return ret;
}
cell AMX_NATIVE_CALL pawn_regex_match(AMX* amx, cell* params)
{
regex_t* RegExpr;
const char *rexp = NULL, *string = NULL;
amx_StrParam(amx, params[1], string);
amx_StrParam(amx, params[2], rexp);
if(string && rexp)
{
int r=NULL;
UChar* pattern = (UChar* )rexp;
OnigErrorInfo einfo;
r = onig_new(&RegExpr, pattern, pattern + strlen((char* )pattern), ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, ONIG_SYNTAX_PERL, &einfo);
//logprintf("[REGEX DEBUG]: rexp %s",pattern);
if(r != ONIG_NORMAL)
{
UChar s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, r, &einfo);
logprintf("[REGEX ERROR]: %s", s);
onig_free(RegExpr);
return -1;
}
UChar* str = (UChar* )string;
OnigRegion *region;
region = onig_region_new();
r = onig_match(RegExpr, str, str+strlen((char*) str), str, region, ONIG_OPTION_NONE);
//logprintf("[REGEX DEBUG]: string %s",str);
onig_region_free(region, 1);
onig_free(RegExpr);
//logprintf("[REGEX DEBUG]: return %d",r);
return r;
}
return -1337;
}
regexp_match::regexp_match(const std::string& regexp)
: reg_(NULL) {
const UChar* pattern = reinterpret_cast<const UChar*>(regexp.c_str());
if (ONIG_NORMAL != onig_new(®_, pattern, pattern + regexp.size(),
ONIG_OPTION_DEFAULT, ONIG_ENCODING_UTF8, ONIG_SYNTAX_PERL, NULL)) {
throw JUBATUS_EXCEPTION(converter_exception("invalid regular expression"));
}
}
/*
* This is a primitive so #initialize_copy can work.
*/
Regexp* Regexp::initialize(STATE, String* pattern, Fixnum* options) {
const UChar *pat;
const UChar *end;
OnigErrorInfo err_info;
OnigOptionType opts;
OnigEncoding enc;
int err, num_names, kcode;
pat = (UChar*)pattern->byte_address();
end = pat + pattern->size();
opts = options->to_native();
kcode = opts & KCODE_MASK;
opts &= OPTION_MASK;
if(kcode == 0) {
enc = current_encoding(state);
} else {
// Don't attempt to fix the encoding later, it's been specified by the
// user.
enc = get_enc_from_kcode(kcode);
forced_encoding_ = true;
}
thread::Mutex::LockGuard lg(state->shared().onig_lock());
err = onig_new(&this->onig_data, pat, end, opts, enc, ONIG_SYNTAX_RUBY, &err_info);
if(err != ONIG_NORMAL) {
UChar onig_err_buf[ONIG_MAX_ERROR_MESSAGE_LEN];
char err_buf[1024];
onig_error_code_to_str(onig_err_buf, err, &err_info);
snprintf(err_buf, 1024, "%s: %s", onig_err_buf, pat);
Exception::regexp_error(state, err_buf);
return 0;
}
this->source(state, pattern);
num_names = onig_number_of_names(this->onig_data);
if(num_names == 0) {
this->names(state, nil<LookupTable>());
} else {
struct _gather_data gd;
gd.state = state;
LookupTable* tbl = LookupTable::create(state);
gd.tbl = tbl;
onig_foreach_name(this->onig_data, (int (*)(const OnigUChar*, const OnigUChar*,int,int*,OnigRegex,void*))_gather_names, (void*)&gd);
this->names(state, tbl);
}
make_managed(state);
return this;
}
static OnigRegex
regexp_compile(grn_ctx *ctx,
const char *pattern,
unsigned int pattern_len,
OnigSyntaxType *syntax)
{
OnigRegex regex;
OnigEncoding onig_encoding;
int onig_result;
OnigErrorInfo onig_error_info;
if (ctx->encoding == GRN_ENC_NONE) {
return NULL;
}
switch (ctx->encoding) {
case GRN_ENC_EUC_JP :
onig_encoding = ONIG_ENCODING_EUC_JP;
break;
case GRN_ENC_UTF8 :
onig_encoding = ONIG_ENCODING_UTF8;
break;
case GRN_ENC_SJIS :
onig_encoding = ONIG_ENCODING_CP932;
break;
case GRN_ENC_LATIN1 :
onig_encoding = ONIG_ENCODING_ISO_8859_1;
break;
case GRN_ENC_KOI8R :
onig_encoding = ONIG_ENCODING_KOI8_R;
break;
default :
return NULL;
}
onig_result = onig_new(®ex,
pattern,
pattern + pattern_len,
ONIG_OPTION_ASCII_RANGE |
ONIG_OPTION_MULTILINE,
onig_encoding,
syntax,
&onig_error_info);
if (onig_result != ONIG_NORMAL) {
char message[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(message, onig_result, onig_error_info);
ERR(GRN_INVALID_ARGUMENT,
"[operator][regexp] "
"failed to create regular expression object: <%.*s>: %s",
pattern_len, pattern,
message);
return NULL;
}
return regex;
}
cell AMX_NATIVE_CALL pawn_regex_search(AMX* amx, cell* params)
{
regex_t* RegExpr;
const char *rexp = NULL, *string = NULL;
cell* addr[2] = {NULL, NULL};
amx_GetAddr(amx, params[3], &addr[0]);
amx_GetAddr(amx, params[4], &addr[1]);
amx_StrParam(amx, params[1], string);
amx_StrParam(amx, params[2], rexp);
if(string && rexp)
{
int r=NULL;
UChar* pattern = (UChar* )rexp;
OnigErrorInfo einfo;
r = onig_new(&RegExpr, pattern, pattern + strlen((char* )pattern), ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, ONIG_SYNTAX_PERL, &einfo);
//logprintf("[REGEX DEBUG]: rexp %s",pattern);
if(r != ONIG_NORMAL)
{
UChar s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, r, &einfo);
logprintf("[REGEX ERROR]: %s", s);
onig_free(RegExpr);
return -1;
}
UChar* str = (UChar* )string;
OnigRegion *region;
region = onig_region_new();
r = onig_search(RegExpr, str, str+strlen((char*) str), str, str+strlen((char*) str), region, ONIG_OPTION_NONE);
if(r>=0)
{
*addr[0]=r;
*addr[1]=region->end[region->num_regs-1]-1;
}
else if(r==ONIG_MISMATCH)
{
*addr[0]=-1;
*addr[1]=-1;
}
else
{
UChar s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, r);
logprintf("[REGEX ERROR]: %s\n", s);
onig_region_free(region, 1);
onig_free(RegExpr);
return -1;
}
//logprintf("[REGEX DEBUG]: string %s",str);
onig_region_free(region, 1);
onig_free(RegExpr);
//logprintf("[REGEX DEBUG]: return %d",r);
return 1;
}
return -1337;
}
// Called with the onig_lock held.
void Regexp::maybe_recompile(STATE, String* string) {
const UChar *pat;
const UChar *end;
OnigEncoding enc;
OnigErrorInfo err_info;
int err;
if(fixed_encoding_) return;
enc = string->get_encoding_kcode_fallback(state);
if(enc == onig_data->enc) return;
pat = (UChar*)source()->byte_address();
end = pat + source()->byte_size();
int options = onig_data->options;
OnigEncoding orig_enc = onig_data->enc;
err = onig_new(&this->onig_data, pat, end, options,
enc, ONIG_SYNTAX_RUBY, &err_info);
// If it doesn't work out, then abort and reset the encoding back
// and say that it's forced.
if(err != ONIG_NORMAL) {
err = onig_new(&this->onig_data, pat, end, options,
orig_enc, ONIG_SYNTAX_RUBY, &err_info);
// Ok, wtf. Well, no way to proceed now.
if(err != ONIG_NORMAL) {
OnigUChar buf[1024];
onig_error_code_to_str((UChar*)buf, err, &err_info);
std::cout << "Fatal ONIG error: " << buf << "\n";
assert(err == ONIG_NORMAL);
}
fixed_encoding_ = true;
}
make_managed(state);
}
extern int ex(unsigned char* str, unsigned char* pattern,
OnigSyntaxType* syntax)
{
int r;
unsigned char *start, *range, *end;
regex_t* reg;
OnigErrorInfo einfo;
OnigRegion *region;
r = onig_new(®, pattern, pattern + strlen((char* )pattern),
ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, syntax, &einfo);
if (r != ONIG_NORMAL) {
char s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, r, &einfo);
fprintf(stderr, "ERROR: %s\n", s);
return -1;
}
fprintf(stderr, "number of captures: %d\n", onig_number_of_captures(reg));
fprintf(stderr, "number of capture histories: %d\n",
onig_number_of_capture_histories(reg));
region = onig_region_new();
end = str + strlen((char* )str);
start = str;
range = end;
r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE);
if (r >= 0) {
int i;
fprintf(stderr, "match at %d\n", r);
for (i = 0; i < region->num_regs; i++) {
fprintf(stderr, "%d: (%ld-%ld)\n", i, region->beg[i], region->end[i]);
}
fprintf(stderr, "\n");
r = onig_capture_tree_traverse(region, ONIG_TRAVERSE_CALLBACK_AT_FIRST,
node_callback, (void* )0);
}
else if (r == ONIG_MISMATCH) {
fprintf(stderr, "search fail\n");
}
else { /* error */
char s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, r);
return -1;
}
onig_region_free(region, 1 /* 1:free self, 0:free contents only */);
onig_free(reg);
return 0;
}
static int
regexp_main(char *pat0, char *str0)
{
int r;
unsigned char *start, *range, *end;
regex_t* reg;
OnigErrorInfo einfo;
OnigRegion *region;
static UChar* pattern;
static UChar* str;
int i;
pattern = (UChar* )pat0;
str = (UChar* )str0;
strcpy(data_str, str);
for (i = 0; i NAMES; i ++) {
data_rslt[i].n[0] = 0;
}
r = onig_new(®, pattern, pattern + strlen((char* )pattern),
ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, ONIG_SYNTAX_DEFAULT, &einfo);
if (r != ONIG_NORMAL) {
char s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, r, &einfo);
return -1;
}
region = onig_region_new();
end = str + strlen((char* )str);
start = str;
range = end;
r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE);
if (r = 0) {
r = onig_foreach_name(reg, name_callback, (void* )region);
}
else if (r == ONIG_MISMATCH) {
return 1;
}
else { /* error */
char s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, r);
return -1;
}
onig_region_free(region, 1);
/* 1:free self, 0:free contents only */
onig_free(reg);
onig_end();
return 0;
}
static int
x0(int no, char* pattern_arg, char* str_arg,
int start_offset, int expected_from, int expected_to, int backward)
{
int r;
unsigned char *start, *range, *end;
regex_t* reg;
OnigErrorInfo einfo;
OnigRegion *region;
UChar *pattern, *str;
pattern = (UChar* )pattern_arg;
str = (UChar* )str_arg;
r = onig_new(®, pattern, pattern + strlen((char* )pattern),
ONIG_OPTION_NEWLINE_CRLF, ONIG_ENCODING_UTF8, ONIG_SYNTAX_DEFAULT, &einfo);
if (r != ONIG_NORMAL) {
char s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, r, &einfo);
fprintf(stderr, "ERROR: %s\n", s);
return -1;
}
region = onig_region_new();
end = str + strlen((char* )str);
if (backward) {
start = end + start_offset;
range = str;
}
else {
start = str + start_offset;
range = end;
}
r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE);
if (r >= 0) {
result(no, region->beg[0], region->end[0], expected_from, expected_to);
}
else if (r == ONIG_MISMATCH) {
result(no, r, -1, expected_from, expected_to);
}
else { /* error */
char s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, r);
fprintf(stderr, "ERROR: %s\n", s);
return -1;
}
onig_region_free(region, 1 /* 1:free self, 0:free contents only */);
onig_free(reg);
return 0;
}
extern int main(int argc, char* argv[])
{
int r;
unsigned char *start, *range, *end;
regex_t* reg;
OnigErrorInfo einfo;
OnigRegion *region;
static UChar* pattern = (UChar* )"a(.*)b|[e-f]+";
static UChar* str = (UChar* )"zzzzaffffffffb";
r = onig_new(®, pattern, pattern + strlen((char* )pattern),
ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, ONIG_SYNTAX_DEFAULT, &einfo);
if (r != ONIG_NORMAL) {
char s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, r, &einfo);
fprintf(stderr, "ERROR: %s\n", s);
return -1;
}
region = onig_region_new();
end = str + strlen((char* )str);
start = str;
range = end;
r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE);
if (r >= 0) {
int i;
fprintf(stderr, "match at %d\n", r);
for (i = 0; i < region->num_regs; i++) {
fprintf(stderr, "%d: (%ld-%ld)\n", i, region->beg[i], region->end[i]);
}
r = 0;
}
else if (r == ONIG_MISMATCH) {
fprintf(stderr, "search fail\n");
r = -1;
}
else { /* error */
char s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, r);
fprintf(stderr, "ERROR: %s\n", s);
return -1;
}
onig_region_free(region, 1 /* 1:free self, 0:free contents only */);
onig_free(reg);
onig_end();
return r;
}
static void get_thread(un2ch_t *get, unarray_t *tl, int board_no, MYSQL *mysql)
{
unstr_t *data = 0;
unstr_t *moto = 0;
nich_t *nich = 0;
size_t i = 0;
regex_t *reg;
OnigErrorInfo einfo;
int r;
if(get == NULL || tl == NULL){
return;
}
pthread_mutex_lock(&g_onig_mutex);
r = onig_new(®, (UChar *)g_pattern, (UChar *)(g_pattern + strlen(g_pattern)),
ONIG_OPTION_NONE, ONIG_ENCODING_SJIS, ONIG_SYNTAX_PERL, &einfo);
pthread_mutex_unlock(&g_onig_mutex);
if(r != ONIG_NORMAL){
UChar s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, r, &einfo);
printf("ERROR: %s\n", s);
return;
}
for(i = 0; i < tl->length; i++){
nich = unarray_at(tl, i);
un2ch_set_info(get, nich->server, nich->board, nich->thread);
moto = unstr_file_get_contents(get->logfile);
data = un2ch_get_data(get);
if(unstr_empty(data)){
printf("error %ld %s/%s/%s\n", get->code, nich->server->data,
nich->board->data, nich->thread->data);
} else {
printf("code:%ld OK %s/%s/%s\n", get->code, nich->server->data,
nich->board->data, nich->thread->data);
if((board_no >= 0) && (mysql != NULL)){
nich->reg = reg;
nich->board_no = board_no;
set_mysql_res(data, moto, nich, mysql);
}
}
nich = NULL;
unstr_delete(2, moto, data);
/* 4秒止める */
sleep(4);
}
pthread_mutex_lock(&g_onig_mutex);
onig_free(reg);
pthread_mutex_unlock(&g_onig_mutex);
}
extern int main(int argc, char* argv[])
{
int r;
unsigned char *start, *range, *end;
regex_t* reg;
OnigErrorInfo einfo;
OnigRegion *region;
static UChar* pattern = (UChar* )"(?<foo>a*)(?<bar>b*)(?<foo>c*)";
static UChar* str = (UChar* )"aaabbbbcc";
OnigEncoding use_encs[] = { ONIG_ENCODING_ASCII };
onig_initialize(use_encs, sizeof(use_encs)/sizeof(use_encs[0]));
r = onig_new(®, pattern, pattern + strlen((char* )pattern),
ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, ONIG_SYNTAX_DEFAULT, &einfo);
if (r != ONIG_NORMAL) {
char s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, r, &einfo);
fprintf(stderr, "ERROR: %s\n", s);
return -1;
}
fprintf(stderr, "number of names: %d\n", onig_number_of_names(reg));
region = onig_region_new();
end = str + strlen((char* )str);
start = str;
range = end;
r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE);
if (r >= 0) {
fprintf(stderr, "match at %d\n\n", r);
r = onig_foreach_name(reg, name_callback, (void* )region);
}
else if (r == ONIG_MISMATCH) {
fprintf(stderr, "search fail\n");
}
else { /* error */
char s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, r);
return -1;
}
onig_region_free(region, 1 /* 1:free self, 0:free contents only */);
onig_free(reg);
onig_end();
return 0;
}
/// Constructs the OnigRegExp engine
/// @param pattern the regular expression pattern
/// @param caseSensitive is the regexp case senstitive
/// @param syntax the syntax to use
OnigRegExpEngine( const QString& pattern, bool caseSensitive, RegExp::Syntax syntax )
: reg_(0)
, region_(0)
, pattern_(pattern)
{
const QChar* patternChars = pattern.constData();
OnigSyntaxType* onigSyntax = ONIG_SYNTAX_DEFAULT;
if( syntax == RegExp::SyntaxFixedString ) { onigSyntax = ONIG_SYNTAX_ASIS; }
OnigOptionType onigOptions = ONIG_OPTION_NONE|ONIG_OPTION_CAPTURE_GROUP;
if( !caseSensitive ) { onigOptions = onigOptions | ONIG_OPTION_IGNORECASE;}
int result = onig_new(®_, (OnigUChar*)patternChars, (OnigUChar*)(patternChars + pattern.length()), onigOptions, ONIG_ENCODING_UTF16_LE, ONIG_SYNTAX_DEFAULT, &einfo_);
valid_ = result == ONIG_NORMAL;
fillError( result );
}
void onig_find_all(char* pattern, char* subject, int subject_len, int repeat)
{
regex_t* reg;
OnigRegion *region;
clock_t best_time = 0, time;
unsigned char *ptr;
int res, len, found;
res = onig_new(®, (unsigned char *)pattern, (unsigned char *)pattern + strlen((char* )pattern),
ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, ONIG_SYNTAX_DEFAULT, NULL);
if (res != ONIG_NORMAL) {
printf("Onig compilation failed\n");
return;
}
region = onig_region_new();
if (!region) {
printf("Cannot allocate region\n");
return;
}
do {
found = 0;
ptr = (unsigned char *)subject;
len = subject_len;
time = clock();
while (1) {
res = onig_search(reg, ptr, ptr + len, ptr, ptr + len, region, ONIG_OPTION_NONE);
if (res < 0)
break;
// printf("match: %d %d\n", (ptr - (unsigned char *)subject) + region->beg[0], (ptr - (unsigned char *)subject) + region->end[0]);
ptr += region->end[0];
len -= region->end[0];
found++;
}
time = clock() - time;
if (!best_time || time < best_time)
best_time = time;
} while (--repeat > 0);
printResult("onig", best_time * 1000 / CLOCKS_PER_SEC, found);
onig_region_free(region, 1);
onig_free(reg);
}
regexp_splitter::regexp_splitter(const std::string& regexp, int group)
: reg_(NULL),
group_(group) {
if (group < 0) {
throw JUBATUS_EXCEPTION(converter_exception("'group' must be positive"));
}
const UChar* pattern = reinterpret_cast<const UChar*>(regexp.data());
if (ONIG_NORMAL != onig_new(®_, pattern, pattern + regexp.size(),
ONIG_OPTION_DEFAULT, ONIG_ENCODING_UTF8, ONIG_SYNTAX_PERL, NULL)) {
throw JUBATUS_EXCEPTION(converter_exception("invalid regular expression"));
}
const int num_capture = onig_number_of_captures(reg_);
if (group > num_capture) {
std::string msg = "regexp '" + regexp + "' only contains "
+ lexical_cast<std::string>(num_capture)
+ " groups, but 'group' is " + lexical_cast<std::string>(group);
throw JUBATUS_EXCEPTION(converter_exception(msg));
}
}
static int compile_regex (lua_State *L, const TArgComp *argC, TOnig **pud) {
TOnig *ud;
int r;
ud = (TOnig*)lua_newuserdata (L, sizeof (TOnig));
memset (ud, 0, sizeof (TOnig)); /* initialize all members to 0 */
lua_pushvalue (L, LUA_ENVIRONINDEX);
lua_setmetatable (L, -2);
r = onig_new(&ud->reg, (CUC)argC->pattern, (CUC)argC->pattern + argC->patlen,
argC->cflags, (OnigEncoding)argC->locale, (OnigSyntaxType*)argC->syntax,
&ud->einfo);
if (r != ONIG_NORMAL)
return generate_error(L, ud, r);
if ((ud->region = onig_region_new()) == NULL)
return luaL_error(L, "`onig_region_new' failed");
if (pud) *pud = ud;
return 1;
}
cell AMX_NATIVE_CALL pawn_regex_build(AMX* amx, cell* params)
{
const char *rexp = NULL;
amx_StrParam(amx, params[1], rexp);
if(rexp)
{
UChar* pattern = (UChar* )rexp;
OnigErrorInfo einfo;
rexpression[TotalExpressions].id = onig_new(&rexpression[TotalExpressions].RegExpr, pattern, pattern + strlen(rexp), ONIG_OPTION_NONE, ONIG_ENCODING_UTF8, ONIG_SYNTAX_DEFAULT, &einfo);
if(rexpression[TotalExpressions].id != ONIG_NORMAL)
{
UChar s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, rexpression[TotalExpressions].id, &einfo);
logprintf("[REGEX ERROR]: %s | at index %d. regex_exbuild aborted.", s, TotalExpressions);
onig_free(rexpression[TotalExpressions].RegExpr);
return -1;
}
rexpression[TotalExpressions].zreg = onig_region_new();
return TotalExpressions++;
}
return -1337;
}
/* {{{ php_mbregex_compile_pattern */
static php_mb_regex_t *php_mbregex_compile_pattern(const char *pattern, int patlen, OnigOptionType options, OnigEncoding enc, OnigSyntaxType *syntax)
{
int err_code = 0;
php_mb_regex_t *retval = NULL, *rc = NULL;
OnigErrorInfo err_info;
OnigUChar err_str[ONIG_MAX_ERROR_MESSAGE_LEN];
rc = zend_hash_str_find_ptr(&MBREX(ht_rc), (char *)pattern, patlen);
if (!rc || rc->options != options || rc->enc != enc || rc->syntax != syntax) {
if ((err_code = onig_new(&retval, (OnigUChar *)pattern, (OnigUChar *)(pattern + patlen), options, enc, syntax, &err_info)) != ONIG_NORMAL) {
onig_error_code_to_str(err_str, err_code, err_info);
php_error_docref(NULL, E_WARNING, "mbregex compile err: %s", err_str);
retval = NULL;
goto out;
}
zend_hash_str_update_ptr(&MBREX(ht_rc), (char *)pattern, patlen, retval);
} else if (rc) {
retval = rc;
}
out:
return retval;
}
/* Usage: reg = onig_new (pattern, options, enc, syntax) */
static void do_onig_new (void)
{
const UChar* pattern;
const UChar* pattern_end;
OnigOptionType option;
OnigEncoding enc;
OnigSyntaxType *syntax;
OnigErrorInfo err_info;
Onig_Type *o;
int status;
syntax = ONIG_SYNTAX_PERL;
if (SLinterp_is_utf8_mode ())
enc = ONIG_ENCODING_UTF8;
else
enc = ONIG_ENCODING_ISO_8859_1;
option = ONIG_OPTION_DEFAULT;
switch (SLang_Num_Function_Args)
{
default:
SLang_verror (SL_Usage_Error, "Usage: r = onig_new (pattern [,options [,encoding [,syntax]]])");
return;
case 4:
if (NULL == (syntax = pop_onig_syntax ()))
return;
case 3:
if (NULL == (enc = pop_onig_encoding ()))
return;
case 2:
if (-1 == pop_onig_option (&option))
return;
case 1:
if (-1 == SLang_pop_slstring ((char **)&pattern))
return;
}
if (NULL == (o = (Onig_Type *) SLcalloc (1, sizeof (Onig_Type))))
{
SLfree ((char *)pattern);
return;
}
pattern_end = pattern + strlen ((char *)pattern);
status = onig_new (&o->re, pattern, pattern_end,
option, enc, syntax, &err_info);
if (status != ONIG_NORMAL)
{
throw_onig_error (status, &err_info);
SLang_free_slstring ((char *)pattern);
free_onig_type (o);
return;
}
if (NULL == (o->region = onig_region_new ()))
{
SLang_verror (slOnig_Error, "failed to allocate a region");
SLang_free_slstring ((char *)pattern);
free_onig_type (o);
return;
}
SLang_free_slstring ((char *)pattern);
(void) push_onig_type (o); /* frees it */
}
int qspArrayPos(QSPVariant *args, int argsCount, QSP_BOOL isRegExp)
{
int num, count, ind;
QSPVar *var;
QSPVariant *val;
QSP_CHAR *str;
OnigUChar *tempBeg, *tempEnd;
regex_t *onigExp;
OnigErrorInfo onigInfo;
QSP_BOOL isString;
if (qspConvertVariantTo(args, argsCount == 2))
{
qspSetError(QSP_ERR_TYPEMISMATCH);
return -1;
}
if (argsCount == 2)
{
str = QSP_STR(args[0]);
ind = 0;
val = args + 1;
}
else
{
qspConvertVariantTo(args + 1, QSP_TRUE);
str = QSP_STR(args[1]);
ind = QSP_NUM(args[0]);
val = args + 2;
if (ind < 0) ind = 0;
}
if (!(var = qspVarReferenceWithType(str, QSP_FALSE, &isString))) return -1;
if (qspConvertVariantTo(val, isRegExp || isString))
{
qspSetError(QSP_ERR_TYPEMISMATCH);
return -1;
}
if (isRegExp)
{
tempBeg = (OnigUChar *)QSP_PSTR(val);
tempEnd = (OnigUChar *)qspStrEnd(QSP_PSTR(val));
if (onig_new(&onigExp, tempBeg, tempEnd, ONIG_OPTION_DEFAULT, QSP_ONIG_ENC, ONIG_SYNTAX_PERL_NG, &onigInfo))
{
qspSetError(QSP_ERR_INCORRECTREGEXP);
return -1;
}
}
count = var->ValsCount;
if (ind > count) ind = count;
while (ind <= count)
{
if (val->IsStr)
{
if (!(ind < count && (str = var->Values[ind].Str))) str = QSP_FMT("");
if (isRegExp)
{
tempBeg = (OnigUChar *)str;
tempEnd = (OnigUChar *)qspStrEnd(str);
if (onig_match(onigExp, tempBeg, tempEnd, tempBeg, 0, ONIG_OPTION_NONE) == tempEnd - tempBeg)
{
onig_free(onigExp);
return ind;
}
}
else if (!qspStrsComp(str, QSP_PSTR(val)))
return ind;
}
else
{
num = (ind < count ? var->Values[ind].Num : 0);
if (num == QSP_PNUM(val)) return ind;
}
++ind;
}
if (isRegExp) onig_free(onigExp);
return -1;
}
extern int main(int argc, char* argv[])
{
static OnigSyntaxType SQLSyntax;
int r;
unsigned char *start, *range, *end;
regex_t* reg;
OnigErrorInfo einfo;
OnigRegion *region;
static UChar* pattern = (UChar* )"\\_%\\\\__zz";
static UChar* str = (UChar* )"a_abcabcabc\\ppzz";
onig_set_syntax_op (&SQLSyntax, ONIG_SYN_OP_VARIABLE_META_CHARACTERS);
onig_set_syntax_op2 (&SQLSyntax, 0);
onig_set_syntax_behavior(&SQLSyntax, 0);
onig_set_syntax_options (&SQLSyntax, ONIG_OPTION_MULTILINE);
onig_set_meta_char(&SQLSyntax, ONIG_META_CHAR_ESCAPE, (OnigCodePoint )'\\');
onig_set_meta_char(&SQLSyntax, ONIG_META_CHAR_ANYCHAR, (OnigCodePoint )'_');
onig_set_meta_char(&SQLSyntax, ONIG_META_CHAR_ANYTIME,
ONIG_INEFFECTIVE_META_CHAR);
onig_set_meta_char(&SQLSyntax, ONIG_META_CHAR_ZERO_OR_ONE_TIME,
ONIG_INEFFECTIVE_META_CHAR);
onig_set_meta_char(&SQLSyntax, ONIG_META_CHAR_ONE_OR_MORE_TIME,
ONIG_INEFFECTIVE_META_CHAR);
onig_set_meta_char(&SQLSyntax, ONIG_META_CHAR_ANYCHAR_ANYTIME,
(OnigCodePoint )'%');
r = onig_new(®, pattern, pattern + strlen((char* )pattern),
ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, &SQLSyntax, &einfo);
if (r != ONIG_NORMAL) {
char s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, r, &einfo);
fprintf(stderr, "ERROR: %s\n", s);
return -1;
}
region = onig_region_new();
end = str + strlen((char* )str);
start = str;
range = end;
r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE);
if (r >= 0) {
int i;
fprintf(stderr, "match at %d\n", r);
for (i = 0; i < region->num_regs; i++) {
fprintf(stderr, "%d: (%ld-%ld)\n", i, region->beg[i], region->end[i]);
}
}
else if (r == ONIG_MISMATCH) {
fprintf(stderr, "search fail\n");
}
else { /* error */
char s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(s, r);
fprintf(stderr, "ERROR: %s\n", s);
return -1;
}
onig_region_free(region, 1 /* 1:free self, 0:free contents only */);
onig_free(reg);
onig_end();
return 0;
}
bregonig *recompile_onig_ex(bregonig *rxold,
pattern_type type, const TCHAR *ptn,
const TCHAR *patternp, const TCHAR *patternendp,
const TCHAR *prerepp, const TCHAR *prerependp,
const TCHAR *optionp, const TCHAR *optionendp,
TCHAR *msg)
{
int flag, compare;
bregonig *rx;
OnigOptionType option;
OnigEncoding enc;
TRACE0(_T("recompile_onig_ex()\n"));
TRACE2(_T("patternp: %s, len: %d\n"), patternp, patternendp-patternp);
TRACE2(_T("prerepp: %s, len: %d\n"), prerepp, prerependp-prerepp);
TRACE2(_T("optionp: %s, len: %d\n"), optionp, optionendp-optionp);
compare = compare_pattern(rxold, type, patternp, patternendp,
prerepp, prerependp, optionp, optionendp);
TRACE1(_T("compare: %d\n"), compare);
if (compare < 0) {
// need to compile
delete rxold;
rxold = NULL;
if (patternp == NULL
|| ((type == PTN_SUBST || type == PTN_TRANS) && prerepp == NULL)) {
asc2tcs(msg, "invalid reg parameter", BREGEXP_MAX_ERROR_MESSAGE_LEN);
return NULL;
}
} else {
// no need to compile
if (rxold->outp) {
delete [] rxold->outp;
rxold->outp = NULL;
}
if (rxold->splitp) {
delete [] rxold->splitp;
rxold->splitp = NULL;
}
}
parse_option(optionp, optionendp, &option, &enc, &flag);
if (type == PTN_TRANS) {
if (compare == 0) {
// no need to compile
TRACE1(_T("rxold(1):0x%08x\n"), rxold);
return rxold;
}
rx = trcomp(patternp, patternendp, prerepp, prerependp, flag, msg);
if (rx == NULL) {
return NULL;
}
} else {
if (compare == 0) {
// no need to compile
TRACE1(_T("rxold(2):0x%08x\n"), rxold);
return rxold;
} else if (compare < 0) {
// pattern string needs to compile.
rx = new (std::nothrow) bregonig();
if (rx == NULL) {
asc2tcs(msg, "out of space regexp", BREGEXP_MAX_ERROR_MESSAGE_LEN);
return NULL;
}
OnigErrorInfo err_info;
int err_code = onig_new(&rx->reg,
(UChar*) patternp, (UChar*) patternendp,
option, enc, &OnigSyntaxPerl_NG_EX, &err_info);
if (err_code != ONIG_NORMAL) {
onig_err_to_bregexp_msg(err_code, &err_info, msg);
delete rx;
return NULL;
}
rx->nparens = onig_number_of_captures(rx->reg); //
rx->pmflags = flag;
} else {
// only replace string needs to compile.
rx = rxold;
}
if (rxold != NULL && rxold->repstr != NULL) {
delete rxold->repstr;
rxold->repstr = NULL;
}
if (type == PTN_SUBST) { // substitute
try {
rx->pmflags |= PMf_SUBSTITUTE;
rx->repstr = compile_rep(rx, prerepp, prerependp); // compile replace string
} catch (std::exception& ex) {
asc2tcs(msg, ex.what(), BREGEXP_MAX_ERROR_MESSAGE_LEN);
delete rx;
return NULL;
}
}
}
if (ptn != NULL) {
size_t plen = _tcslen(ptn);
delete [] rx->parap;
rx->parap = new (std::nothrow) TCHAR[plen+1]; // parameter copy
if (rx->parap == NULL) {
asc2tcs(msg, "precompile out of space", BREGEXP_MAX_ERROR_MESSAGE_LEN);
delete rx;
return NULL;
}
memcpy(rx->parap, ptn, (plen+1)*sizeof(TCHAR)); // copy include null
rx->paraendp = rx->parap + plen;
}
TCHAR *oldpatternp = rx->patternp;
if (patternp == NULL) {
patternp = rx->patternp;
patternendp = rx->patternendp;
optionp = rx->optionp;
optionendp = rx->optionendp;
}
/* save pattern, replace and option string */
ptrdiff_t len1 = patternendp - patternp;
ptrdiff_t len2 = prerependp - prerepp;
ptrdiff_t len3 = optionendp - optionp;
rx->patternp = new (std::nothrow) TCHAR[len1+1 + len2+1 + len3+1];
if (rx->patternp == NULL) {
delete rx;
delete [] oldpatternp;
return NULL;
}
memcpy(rx->patternp, patternp, len1*sizeof(TCHAR));
rx->patternp[len1] = 0;
rx->patternendp = rx->patternp + len1;
rx->prerepp = rx->patternp + len1 + 1;
memcpy(rx->prerepp, prerepp, len2*sizeof(TCHAR));
rx->prerepp[len2] = 0;
rx->prerependp = rx->prerepp + len2;
rx->optionp = rx->prerepp + len2 + 1;
memcpy(rx->optionp, optionp, len3*sizeof(TCHAR));
rx->optionp[len3] = 0;
rx->optionendp = rx->optionp + len3;
delete [] oldpatternp;
TRACE1(_T("rx:0x%08x\n"), rx);
return rx;
}
/**
Call the Oniguruma regex match API.
Same parameters as RegularExpressionMatch, except SyntaxType is required.
@param String A pointer to a NULL terminated string to match against the
regular expression string specified by Pattern.
@param Pattern A pointer to a NULL terminated string that represents the
regular expression.
@param SyntaxType A pointer to the EFI_REGEX_SYNTAX_TYPE that identifies the
regular expression syntax type to use. May be NULL in which
case the function will use its default regular expression
syntax type.
@param Result On return, points to TRUE if String fully matches against
the regular expression Pattern using the regular expression
SyntaxType. Otherwise, points to FALSE.
@param Captures A Pointer to an array of EFI_REGEX_CAPTURE objects to receive
the captured groups in the event of a match. The full
sub-string match is put in Captures[0], and the results of N
capturing groups are put in Captures[1:N]. If Captures is
NULL, then this function doesn't allocate the memory for the
array and does not build up the elements. It only returns the
number of matching patterns in CapturesCount. If Captures is
not NULL, this function returns a pointer to an array and
builds up the elements in the array. CapturesCount is also
updated to the number of matching patterns found. It is the
caller's responsibility to free the memory pool in Captures
and in each CapturePtr in the array elements.
@param CapturesCount On output, CapturesCount is the number of matching patterns
found in String. Zero means no matching patterns were found
in the string.
@retval EFI_SUCCESS Regex compilation and match completed successfully.
@retval EFI_DEVICE_ERROR Regex compilation failed.
**/
STATIC
EFI_STATUS
OnigurumaMatch (
IN CHAR16 *String,
IN CHAR16 *Pattern,
IN EFI_REGEX_SYNTAX_TYPE *SyntaxType,
OUT BOOLEAN *Result,
OUT EFI_REGEX_CAPTURE **Captures, OPTIONAL
OUT UINTN *CapturesCount
)
{
regex_t *OnigRegex;
OnigSyntaxType *OnigSyntax;
OnigRegion *Region;
INT32 OnigResult;
OnigErrorInfo ErrorInfo;
CHAR8 ErrorMessage[ONIG_MAX_ERROR_MESSAGE_LEN];
UINT32 Index;
OnigUChar *Start;
EFI_STATUS Status;
Status = EFI_SUCCESS;
//
// Detemine the internal syntax type
//
OnigSyntax = ONIG_SYNTAX_DEFAULT;
if (CompareGuid (SyntaxType, &gEfiRegexSyntaxTypePosixExtendedGuid)) {
OnigSyntax = ONIG_SYNTAX_POSIX_EXTENDED;
} else if (CompareGuid (SyntaxType, &gEfiRegexSyntaxTypePerlGuid)) {
OnigSyntax = ONIG_SYNTAX_PERL;
} else {
DEBUG ((DEBUG_ERROR, "Unsupported regex syntax - using default\n"));
return EFI_UNSUPPORTED;
}
//
// Compile pattern
//
Start = (OnigUChar*)Pattern;
OnigResult = onig_new (
&OnigRegex,
Start,
Start + onigenc_str_bytelen_null (CHAR16_ENCODING, Start),
ONIG_OPTION_DEFAULT,
CHAR16_ENCODING,
OnigSyntax,
&ErrorInfo
);
if (OnigResult != ONIG_NORMAL) {
onig_error_code_to_str (ErrorMessage, OnigResult, &ErrorInfo);
DEBUG ((DEBUG_ERROR, "Regex compilation failed: %a\n", ErrorMessage));
return EFI_DEVICE_ERROR;
}
//
// Try to match
//
Start = (OnigUChar*)String;
Region = onig_region_new ();
if (Region == NULL) {
onig_free (OnigRegex);
return EFI_OUT_OF_RESOURCES;
}
OnigResult = onig_search (
OnigRegex,
Start,
Start + onigenc_str_bytelen_null (CHAR16_ENCODING, Start),
Start,
Start + onigenc_str_bytelen_null (CHAR16_ENCODING, Start),
Region,
ONIG_OPTION_NONE
);
if (OnigResult >= 0) {
*Result = TRUE;
} else {
*Result = FALSE;
if (OnigResult != ONIG_MISMATCH) {
onig_error_code_to_str (ErrorMessage, OnigResult);
DEBUG ((DEBUG_ERROR, "Regex match failed: %a\n", ErrorMessage));
onig_region_free (Region, 1);
onig_free (OnigRegex);
return EFI_DEVICE_ERROR;
}
}
//
// If successful, copy out the region (capture) information
//
if (*Result && Captures != NULL) {
*CapturesCount = Region->num_regs;
*Captures = AllocateZeroPool (*CapturesCount * sizeof(**Captures));
if (*Captures != NULL) {
for (Index = 0; Index < *CapturesCount; ++Index) {
//
// Region beg/end values represent bytes, not characters
//
(*Captures)[Index].Length = (Region->end[Index] - Region->beg[Index]) / sizeof(CHAR16);
(*Captures)[Index].CapturePtr = AllocateCopyPool (
((*Captures)[Index].Length) * sizeof (CHAR16),
(CHAR16*)((UINTN)String + Region->beg[Index])
);
if ((*Captures)[Index].CapturePtr == NULL) {
Status = EFI_OUT_OF_RESOURCES;
break;
}
}
if (EFI_ERROR (Status)) {
for (Index = 0; Index < *CapturesCount; ++Index) {
if ((*Captures)[Index].CapturePtr != NULL) {
FreePool ((CHAR16*)(*Captures)[Index].CapturePtr);
}
}
FreePool (*Captures);
}
}
}
onig_region_free (Region, 1);
onig_free (OnigRegex);
return Status;
}
/*
* This is a primitive so #initialize_copy can work.
*/
Regexp* Regexp::initialize(STATE, String* pattern, Fixnum* options) {
const UChar *pat;
const UChar *end;
OnigErrorInfo err_info;
OnigEncoding enc;
OnigOptionType opts = options->to_native();
if(LANGUAGE_18_ENABLED(state)) {
int kcode = opts & KCODE_MASK;
pat = (UChar*)pattern->byte_address();
end = pat + pattern->byte_size();
if(kcode == 0) {
enc = pattern->get_encoding_kcode_fallback(state);
} else {
// Don't attempt to fix the encoding later, it's been specified by the
// user.
enc = get_enc_from_kcode(kcode);
fixed_encoding_ = true;
}
} else {
fixed_encoding_ = opts & OPTION_FIXEDENCODING;
no_encoding_ = opts & OPTION_NOENCODING;
Encoding* source_enc = pattern->encoding(state);
switch(opts & KCODE_MASK) {
case KCODE_NONE:
source_enc = 0;
no_encoding_ = true;
break;
case KCODE_EUC:
source_enc = Encoding::find(state, "EUC-JP");
fixed_encoding_ = true;
break;
case KCODE_SJIS:
source_enc = Encoding::find(state, "Windows-31J");
fixed_encoding_ = true;
break;
case KCODE_UTF8:
source_enc = Encoding::utf8_encoding(state);
fixed_encoding_ = true;
break;
}
String* converted = pattern->convert_escaped(state, source_enc, fixed_encoding_);
pat = (UChar*)converted->byte_address();
end = pat + converted->byte_size();
enc = source_enc->get_encoding();
pattern = pattern->string_dup(state);
pattern->encoding(state, source_enc);
}
utilities::thread::Mutex::LockGuard lg(state->shared().onig_lock());
int err = onig_new(&this->onig_data, pat, end, opts & OPTION_MASK, enc, ONIG_SYNTAX_RUBY, &err_info);
if(err != ONIG_NORMAL) {
UChar onig_err_buf[ONIG_MAX_ERROR_MESSAGE_LEN];
char err_buf[1024];
onig_error_code_to_str(onig_err_buf, err, &err_info);
snprintf(err_buf, 1024, "%s: %s", onig_err_buf, pat);
Exception::regexp_error(state, err_buf);
return 0;
}
this->source(state, pattern);
int num_names = onig_number_of_names(this->onig_data);
if(num_names == 0) {
this->names(state, nil<LookupTable>());
} else {
struct _gather_data gd;
gd.state = state;
LookupTable* tbl = LookupTable::create(state);
gd.tbl = tbl;
onig_foreach_name(this->onig_data, (int (*)(const OnigUChar*, const OnigUChar*,int,int*,OnigRegex,void*))_gather_names, (void*)&gd);
this->names(state, tbl);
}
make_managed(state);
return this;
}
static void xx(char* pattern, char* str, int from, int to, int mem, int not)
{
int r;
#ifdef POSIX_TEST
regex_t reg;
char buf[200];
regmatch_t pmatch[25];
r = regcomp(®, pattern, REG_EXTENDED | REG_NEWLINE);
if (r) {
regerror(r, ®, buf, sizeof(buf));
fprintf(err_file, "ERROR: %s\n", buf);
nerror++;
return ;
}
r = regexec(®, str, reg.re_nsub + 1, pmatch, 0);
if (r != 0 && r != REG_NOMATCH) {
regerror(r, ®, buf, sizeof(buf));
fprintf(err_file, "ERROR: %s\n", buf);
nerror++;
return ;
}
if (r == REG_NOMATCH) {
if (not) {
fprintf(stdout, "OK(N): /%s/ '%s'\n", pattern, str);
nsucc++;
}
else {
fprintf(stdout, "FAIL: /%s/ '%s'\n", pattern, str);
nfail++;
}
}
else {
if (not) {
fprintf(stdout, "FAIL(N): /%s/ '%s'\n", pattern, str);
nfail++;
}
else {
if (pmatch[mem].rm_so == from && pmatch[mem].rm_eo == to) {
fprintf(stdout, "OK: /%s/ '%s'\n", pattern, str);
nsucc++;
}
else {
fprintf(stdout, "FAIL: /%s/ '%s' %d-%d : %d-%d\n", pattern, str,
from, to, pmatch[mem].rm_so, pmatch[mem].rm_eo);
nfail++;
}
}
}
regfree(®);
#else
regex_t* reg;
OnigErrorInfo einfo;
r = onig_new(®, (UChar* )pattern, (UChar* )(pattern + strlen(pattern)),
ONIG_OPTION_DEFAULT, ONIG_ENCODING_EUC_JP, ONIG_SYNTAX_DEFAULT, &einfo);
if (r) {
char s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str((UChar* )s, r, &einfo);
fprintf(err_file, "ERROR: %s\n", s);
nerror++;
return ;
}
r = onig_search(reg, (UChar* )str, (UChar* )(str + strlen(str)),
(UChar* )str, (UChar* )(str + strlen(str)),
region, ONIG_OPTION_NONE);
if (r < ONIG_MISMATCH) {
char s[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str((UChar* )s, r);
fprintf(err_file, "ERROR: %s\n", s);
nerror++;
return ;
}
if (r == ONIG_MISMATCH) {
if (not) {
fprintf(stdout, "OK(N): /%s/ '%s'\n", pattern, str);
nsucc++;
}
else {
fprintf(stdout, "FAIL: /%s/ '%s'\n", pattern, str);
nfail++;
}
}
else {
if (not) {
fprintf(stdout, "FAIL(N): /%s/ '%s'\n", pattern, str);
nfail++;
}
else {
if (region->beg[mem] == from && region->end[mem] == to) {
fprintf(stdout, "OK: /%s/ '%s'\n", pattern, str);
nsucc++;
}
else {
fprintf(stdout, "FAIL: /%s/ '%s' %d-%d : %d-%d\n", pattern, str,
from, to, region->beg[mem], region->end[mem]);
nfail++;
}
}
}
onig_free(reg);
#endif
}
