12#include "ruby/internal/config.h"
19#include "internal/encoding.h"
20#include "internal/hash.h"
21#include "internal/imemo.h"
22#include "internal/re.h"
23#include "internal/string.h"
24#include "internal/object.h"
25#include "internal/ractor.h"
26#include "internal/variable.h"
31#include "ractor_core.h"
35typedef char onig_errmsg_buffer[ONIG_MAX_ERROR_MESSAGE_LEN];
36#define errcpy(err, msg) strlcpy((err), (msg), ONIG_MAX_ERROR_MESSAGE_LEN)
38#define BEG(no) (regs->beg[(no)])
39#define END(no) (regs->end[(no)])
42static const char casetable[] = {
43 '\000',
'\001',
'\002',
'\003',
'\004',
'\005',
'\006',
'\007',
44 '\010',
'\011',
'\012',
'\013',
'\014',
'\015',
'\016',
'\017',
45 '\020',
'\021',
'\022',
'\023',
'\024',
'\025',
'\026',
'\027',
46 '\030',
'\031',
'\032',
'\033',
'\034',
'\035',
'\036',
'\037',
48 '\040',
'\041',
'\042',
'\043',
'\044',
'\045',
'\046',
'\047',
50 '\050',
'\051',
'\052',
'\053',
'\054',
'\055',
'\056',
'\057',
52 '\060',
'\061',
'\062',
'\063',
'\064',
'\065',
'\066',
'\067',
54 '\070',
'\071',
'\072',
'\073',
'\074',
'\075',
'\076',
'\077',
56 '\100',
'\141',
'\142',
'\143',
'\144',
'\145',
'\146',
'\147',
58 '\150',
'\151',
'\152',
'\153',
'\154',
'\155',
'\156',
'\157',
60 '\160',
'\161',
'\162',
'\163',
'\164',
'\165',
'\166',
'\167',
62 '\170',
'\171',
'\172',
'\133',
'\134',
'\135',
'\136',
'\137',
64 '\140',
'\141',
'\142',
'\143',
'\144',
'\145',
'\146',
'\147',
66 '\150',
'\151',
'\152',
'\153',
'\154',
'\155',
'\156',
'\157',
68 '\160',
'\161',
'\162',
'\163',
'\164',
'\165',
'\166',
'\167',
70 '\170',
'\171',
'\172',
'\173',
'\174',
'\175',
'\176',
'\177',
71 '\200',
'\201',
'\202',
'\203',
'\204',
'\205',
'\206',
'\207',
72 '\210',
'\211',
'\212',
'\213',
'\214',
'\215',
'\216',
'\217',
73 '\220',
'\221',
'\222',
'\223',
'\224',
'\225',
'\226',
'\227',
74 '\230',
'\231',
'\232',
'\233',
'\234',
'\235',
'\236',
'\237',
75 '\240',
'\241',
'\242',
'\243',
'\244',
'\245',
'\246',
'\247',
76 '\250',
'\251',
'\252',
'\253',
'\254',
'\255',
'\256',
'\257',
77 '\260',
'\261',
'\262',
'\263',
'\264',
'\265',
'\266',
'\267',
78 '\270',
'\271',
'\272',
'\273',
'\274',
'\275',
'\276',
'\277',
79 '\300',
'\301',
'\302',
'\303',
'\304',
'\305',
'\306',
'\307',
80 '\310',
'\311',
'\312',
'\313',
'\314',
'\315',
'\316',
'\317',
81 '\320',
'\321',
'\322',
'\323',
'\324',
'\325',
'\326',
'\327',
82 '\330',
'\331',
'\332',
'\333',
'\334',
'\335',
'\336',
'\337',
83 '\340',
'\341',
'\342',
'\343',
'\344',
'\345',
'\346',
'\347',
84 '\350',
'\351',
'\352',
'\353',
'\354',
'\355',
'\356',
'\357',
85 '\360',
'\361',
'\362',
'\363',
'\364',
'\365',
'\366',
'\367',
86 '\370',
'\371',
'\372',
'\373',
'\374',
'\375',
'\376',
'\377',
89# error >>> "You lose. You will need a translation table for your character set." <<<
93rb_hrtime_t rb_reg_match_time_limit = 0;
96rb_memcicmp(
const void *x,
const void *y,
long len)
98 const unsigned char *p1 = x, *p2 = y;
102 if ((tmp = casetable[(
unsigned)*p1++] - casetable[(
unsigned)*p2++]))
110rb_memsearch_ss(
const unsigned char *xs,
long m,
const unsigned char *ys,
long n)
112 const unsigned char *y;
114 if ((y = memmem(ys, n, xs, m)) != NULL)
121rb_memsearch_ss(
const unsigned char *xs,
long m,
const unsigned char *ys,
long n)
123 const unsigned char *x = xs, *xe = xs + m;
124 const unsigned char *y = ys, *ye = ys + n;
125#define VALUE_MAX ((VALUE)~(VALUE)0)
129 rb_bug(
"!!too long pattern string!!");
131 if (!(y = memchr(y, *x, n - m + 1)))
135 for (hx = *x++, hy = *y++; x < xe; ++x, ++y) {
155rb_memsearch_qs(
const unsigned char *xs,
long m,
const unsigned char *ys,
long n)
157 const unsigned char *x = xs, *xe = xs + m;
158 const unsigned char *y = ys;
159 VALUE i, qstable[256];
162 for (i = 0; i < 256; ++i)
165 qstable[*x] = xe - x;
167 for (; y + m <= ys + n; y += *(qstable + y[m])) {
168 if (*xs == *y && memcmp(xs, y, m) == 0)
174static inline unsigned int
175rb_memsearch_qs_utf8_hash(
const unsigned char *x)
177 register const unsigned int mix = 8353;
178 register unsigned int h = *x;
203 return (
unsigned char)h;
207rb_memsearch_qs_utf8(
const unsigned char *xs,
long m,
const unsigned char *ys,
long n)
209 const unsigned char *x = xs, *xe = xs + m;
210 const unsigned char *y = ys;
211 VALUE i, qstable[512];
214 for (i = 0; i < 512; ++i) {
217 for (; x < xe; ++x) {
218 qstable[rb_memsearch_qs_utf8_hash(x)] = xe - x;
221 for (; y + m <= ys + n; y += qstable[rb_memsearch_qs_utf8_hash(y+m)]) {
222 if (*xs == *y && memcmp(xs, y, m) == 0)
229rb_memsearch_with_char_size(
const unsigned char *xs,
long m,
const unsigned char *ys,
long n,
int char_size)
231 const unsigned char *x = xs, x0 = *xs, *y = ys;
233 for (n -= m; n >= 0; n -= char_size, y += char_size) {
234 if (x0 == *y && memcmp(x+1, y+1, m-1) == 0)
241rb_memsearch_wchar(
const unsigned char *xs,
long m,
const unsigned char *ys,
long n)
243 return rb_memsearch_with_char_size(xs, m, ys, n, 2);
247rb_memsearch_qchar(
const unsigned char *xs,
long m,
const unsigned char *ys,
long n)
249 return rb_memsearch_with_char_size(xs, m, ys, n, 4);
255 const unsigned char *x = x0, *y = y0;
257 if (m > n)
return -1;
259 return memcmp(x0, y0, m) == 0 ? 0 : -1;
265 const unsigned char *ys = memchr(y, *x, n);
272 else if (LIKELY(rb_enc_mbminlen(enc) == 1)) {
274 return rb_memsearch_ss(x0, m, y0, n);
276 else if (enc == rb_utf8_encoding()){
277 return rb_memsearch_qs_utf8(x0, m, y0, n);
280 else if (LIKELY(rb_enc_mbminlen(enc) == 2)) {
281 return rb_memsearch_wchar(x0, m, y0, n);
283 else if (LIKELY(rb_enc_mbminlen(enc) == 4)) {
284 return rb_memsearch_qchar(x0, m, y0, n);
286 return rb_memsearch_qs(x0, m, y0, n);
289#define REG_ENCODING_NONE FL_USER6
291#define KCODE_FIXED FL_USER4
300 val = ONIG_OPTION_IGNORECASE;
303 val = ONIG_OPTION_EXTEND;
306 val = ONIG_OPTION_MULTILINE;
315enum { OPTBUF_SIZE = 4 };
318option_to_str(
char str[OPTBUF_SIZE],
int options)
321 if (options & ONIG_OPTION_MULTILINE) *p++ =
'm';
322 if (options & ONIG_OPTION_IGNORECASE) *p++ =
'i';
323 if (options & ONIG_OPTION_EXTEND) *p++ =
'x';
335 *kcode = rb_ascii8bit_encindex();
336 return (*option = ARG_ENCODING_NONE);
338 *kcode = ENCINDEX_EUC_JP;
341 *kcode = ENCINDEX_Windows_31J;
344 *kcode = rb_utf8_encindex();
348 return (*option = char_to_option(c));
350 *option = ARG_ENCODING_FIXED;
355rb_reg_check(
VALUE re)
363rb_reg_expr_str(
VALUE str,
const char *s,
long len,
366 const char *p, *pend;
371 p = s; pend = p +
len;
375 c = rb_enc_ascget(p, pend, &clen, enc);
378 p += mbclen(p, pend, enc);
402 int unicode_p = rb_enc_unicode_p(enc);
405 c = rb_enc_ascget(p, pend, &clen, enc);
406 if (c ==
'\\' && p+clen < pend) {
407 int n = clen + mbclen(p+clen, pend, enc);
413 clen = rb_enc_precise_mbclen(p, pend, enc);
415 c = (
unsigned char)*p;
420 unsigned int c = rb_enc_mbc_to_codepoint(p, pend, enc);
421 rb_str_buf_cat_escaped_char(str, c, unicode_p);
428 else if (c == term) {
436 else if (!rb_enc_isspace(c, enc)) {
440 snprintf(b,
sizeof(b),
"\\x%02X", c);
456 rb_encoding *resenc = rb_default_internal_encoding();
457 if (resenc == NULL) resenc = rb_default_external_encoding();
459 if (re && rb_enc_asciicompat(enc)) {
460 rb_enc_copy(str, re);
463 rb_enc_associate(str, rb_usascii_encoding());
467 rb_reg_expr_str(str, RSTRING_PTR(src_str), RSTRING_LEN(src_str), enc, resenc,
'/');
472 char opts[OPTBUF_SIZE];
474 if (*option_to_str(opts,
RREGEXP_PTR(re)->options))
476 if (
RBASIC(re)->flags & REG_ENCODING_NONE)
502rb_reg_source(
VALUE re)
523rb_reg_inspect(
VALUE re)
528 return rb_reg_desc(re);
531static VALUE rb_reg_str_with_term(
VALUE re,
int term);
563 return rb_reg_str_with_term(re,
'/');
567rb_reg_str_with_term(
VALUE re,
int term)
570 const int embeddable = ONIG_OPTION_MULTILINE|ONIG_OPTION_IGNORECASE|ONIG_OPTION_EXTEND;
572 char optbuf[OPTBUF_SIZE + 1];
577 rb_enc_copy(str, re);
580 const UChar *ptr = (UChar *)RSTRING_PTR(src_str);
581 long len = RSTRING_LEN(src_str);
583 if (
len >= 4 && ptr[0] ==
'(' && ptr[1] ==
'?') {
586 if ((
len -= 2) > 0) {
588 opt = char_to_option((
int )*ptr);
598 if (
len > 1 && *ptr ==
'-') {
602 opt = char_to_option((
int )*ptr);
617 if (*ptr ==
':' && ptr[
len-1] ==
')') {
624 err = onig_new(&rp, ptr, ptr +
len, options,
625 enc, OnigDefaultSyntax, NULL);
638 if ((options & embeddable) != embeddable) {
640 option_to_str(optbuf + 1, ~options);
645 if (rb_enc_asciicompat(enc)) {
646 rb_reg_expr_str(str, (
char*)ptr,
len, enc, NULL, term);
654 rb_enc_associate(str, rb_usascii_encoding());
658 s = RSTRING_PTR(str);
664 rb_str_resize(str, RSTRING_LEN(str) - n);
666 rb_reg_expr_str(str, (
char*)ptr,
len, enc, NULL, term);
669 rb_enc_copy(str, re);
676NORETURN(
static void rb_reg_raise(
const char *err,
VALUE re));
679rb_reg_raise(
const char *err,
VALUE re)
681 VALUE desc = rb_reg_desc(re);
687rb_enc_reg_error_desc(
const char *s,
long len,
rb_encoding *enc,
int options,
const char *err)
689 char opts[OPTBUF_SIZE + 1];
691 rb_encoding *resenc = rb_default_internal_encoding();
692 if (resenc == NULL) resenc = rb_default_external_encoding();
694 rb_enc_associate(desc, enc);
696 rb_reg_expr_str(desc, s,
len, enc, resenc,
'/');
698 option_to_str(opts + 1, options);
703NORETURN(
static void rb_enc_reg_raise(
const char *s,
long len,
rb_encoding *enc,
int options,
const char *err));
706rb_enc_reg_raise(
const char *s,
long len,
rb_encoding *enc,
int options,
const char *err)
712rb_reg_error_desc(
VALUE str,
int options,
const char *err)
714 return rb_enc_reg_error_desc(RSTRING_PTR(str), RSTRING_LEN(str),
715 rb_enc_get(str), options, err);
718NORETURN(
static void rb_reg_raise_str(
VALUE str,
int options,
const char *err));
721rb_reg_raise_str(
VALUE str,
int options,
const char *err)
741rb_reg_casefold_p(
VALUE re)
744 return RBOOL(
RREGEXP_PTR(re)->options & ONIG_OPTION_IGNORECASE);
786rb_reg_options_m(
VALUE re)
793reg_names_iter(
const OnigUChar *name,
const OnigUChar *name_end,
794 int back_num,
int *back_refs,
OnigRegex regex,
void *arg)
797 rb_ary_push(ary, rb_enc_str_new((
const char *)name, name_end-name, regex->enc));
815rb_reg_names(
VALUE re)
820 onig_foreach_name(
RREGEXP_PTR(re), reg_names_iter, (
void*)ary);
825reg_named_captures_iter(
const OnigUChar *name,
const OnigUChar *name_end,
826 int back_num,
int *back_refs,
OnigRegex regex,
void *arg)
832 for (i = 0; i < back_num; i++)
835 rb_hash_aset(hash,
rb_str_new((
const char*)name, name_end-name),ary);
859rb_reg_named_captures(
VALUE re)
862 VALUE hash = rb_hash_new_with_size(onig_number_of_names(reg));
863 onig_foreach_name(reg, reg_named_captures_iter, (
void*)hash);
868onig_new_with_source(
regex_t** reg,
const UChar* pattern,
const UChar* pattern_end,
870 OnigErrorInfo* einfo,
const char *sourcefile,
int sourceline)
875 if (IS_NULL(*reg))
return ONIGERR_MEMORY;
877 r = onig_reg_init(*reg, option, ONIGENC_CASE_FOLD_DEFAULT, enc, syntax);
880 r = onig_compile_ruby(*reg, pattern, pattern_end, einfo, sourcefile, sourceline);
890make_regexp(
const char *s,
long len,
rb_encoding *enc,
int flags, onig_errmsg_buffer err,
891 const char *sourcefile,
int sourceline)
904 r = onig_new_with_source(&rp, (UChar*)s, (UChar*)(s +
len), flags,
905 enc, OnigDefaultSyntax, &einfo, sourcefile, sourceline);
907 onig_error_code_to_str((UChar*)err, r, &einfo);
966match_alloc(
VALUE klass)
970 NEWOBJ_OF(match,
struct RMatch, klass, flags, alloc_size, 0);
983 if (to->allocated)
return 0;
986 if (to->allocated)
return 0;
987 return ONIGERR_MEMORY;
996pair_byte_cmp(
const void *pair1,
const void *pair2)
998 long diff = ((
pair_t*)pair1)->byte_pos - ((
pair_t*)pair2)->byte_pos;
999#if SIZEOF_LONG > SIZEOF_INT
1000 return diff ? diff > 0 ? 1 : -1 : 0;
1007update_char_offset(
VALUE match)
1011 int i, num_regs, num_pos;
1021 num_regs = rm->
regs.num_regs;
1028 enc = rb_enc_get(
RMATCH(match)->str);
1030 for (i = 0; i < num_regs; i++) {
1039 for (i = 0; i < num_regs; i++) {
1042 pairs[num_pos++].byte_pos = BEG(i);
1043 pairs[num_pos++].byte_pos = END(i);
1045 qsort(pairs, num_pos,
sizeof(
pair_t), pair_byte_cmp);
1047 s = p = RSTRING_PTR(
RMATCH(match)->str);
1049 for (i = 0; i < num_pos; i++) {
1050 q = s + pairs[i].byte_pos;
1052 pairs[i].char_pos = c;
1056 for (i = 0; i < num_regs; i++) {
1064 key.byte_pos = BEG(i);
1065 found = bsearch(&key, pairs, num_pos,
sizeof(
pair_t), pair_byte_cmp);
1068 key.byte_pos = END(i);
1069 found = bsearch(&key, pairs, num_pos,
sizeof(
pair_t), pair_byte_cmp);
1075match_check(
VALUE match)
1077 if (!
RMATCH(match)->regexp) {
1094 rm = RMATCH_EXT(obj);
1098 if (RMATCH_EXT(orig)->char_offset_num_allocated) {
1124match_regexp(
VALUE match)
1128 regexp =
RMATCH(match)->regexp;
1129 if (
NIL_P(regexp)) {
1159match_names(
VALUE match)
1164 return rb_reg_names(
RMATCH(match)->regexp);
1180match_size(
VALUE match)
1186static int name_to_backref_number(
struct re_registers *,
VALUE,
const char*,
const char*);
1187NORETURN(
static void name_to_backref_error(
VALUE name));
1190name_to_backref_error(
VALUE name)
1192 rb_raise(
rb_eIndexError,
"undefined group name reference: % "PRIsVALUE,
1199 if (i < 0 || regs->num_regs <= i)
1204match_backref_number(
VALUE match,
VALUE backref)
1221 num = name_to_backref_number(regs, regexp, name, name + RSTRING_LEN(backref));
1224 name_to_backref_error(backref);
1233 return match_backref_number(match, backref);
1248 int i = match_backref_number(match, n);
1252 backref_number_check(regs, i);
1257 update_char_offset(match);
1259 LONG2NUM(RMATCH_EXT(match)->char_offset[i].end));
1283 int i = match_backref_number(match, n);
1287 backref_number_check(regs, i);
1307 int i = match_backref_number(match, n);
1311 backref_number_check(regs, i);
1331 int i = match_backref_number(match, n);
1335 backref_number_check(regs, i);
1355 int i = match_backref_number(match, n);
1359 backref_number_check(regs, i);
1364 update_char_offset(match);
1365 return LONG2NUM(RMATCH_EXT(match)->char_offset[i].beg);
1381 int i = match_backref_number(match, n);
1385 backref_number_check(regs, i);
1390 update_char_offset(match);
1391 return LONG2NUM(RMATCH_EXT(match)->char_offset[i].end);
1423 int i = match_backref_number(match, n);
1426 backref_number_check(regs, i);
1428 long start = BEG(i), end = END(i);
1467 int i = match_backref_number(match, n);
1471 backref_number_check(regs, i);
1476 update_char_offset(match);
1478 &RMATCH_EXT(match)->char_offset[i];
1482#define MATCH_BUSY FL_USER2
1487 FL_SET(match, MATCH_BUSY);
1491rb_match_unbusy(
VALUE match)
1497rb_match_count(
VALUE match)
1500 if (
NIL_P(match))
return -1;
1502 if (!regs)
return -1;
1503 return regs->num_regs;
1514 int err = onig_region_resize(&rmatch->
regs, 1);
1515 if (err) rb_memerror();
1516 rmatch->
regs.beg[0] = pos;
1517 rmatch->
regs.end[0] = pos +
len;
1521rb_backref_set_string(
VALUE string,
long pos,
long len)
1527 match_set_string(match,
string, pos,
len);
1562rb_reg_fixed_encoding_p(
VALUE re)
1564 return RBOOL(
FL_TEST(re, KCODE_FIXED));
1568rb_reg_preprocess(
const char *p,
const char *end,
rb_encoding *enc,
1569 rb_encoding **fixed_enc, onig_errmsg_buffer err,
int options);
1577 "incompatible encoding regexp match (%s regexp with %s string)",
1578 rb_enc_inspect_name(rb_enc_get(re)),
1579 rb_enc_inspect_name(rb_enc_get(
str)));
1596 int cr = str_coderange(
str);
1599 rb_raise(rb_eArgError,
1600 "invalid byte sequence in %s",
1601 rb_enc_name(rb_enc_get(
str)));
1605 enc = rb_enc_get(
str);
1612 else if (!rb_enc_asciicompat(enc)) {
1613 reg_enc_error(re,
str);
1615 else if (rb_reg_fixed_encoding_p(re)) {
1618 reg_enc_error(re,
str);
1622 else if (warn && (
RBASIC(re)->flags & REG_ENCODING_NONE) &&
1623 enc != rb_ascii8bit_encoding() &&
1625 rb_warn(
"historical binary regexp match /.../n against %s string",
1641 if (reg->enc == enc)
return reg;
1646 const char *pattern = RSTRING_PTR(src_str);
1648 onig_errmsg_buffer err =
"";
1649 unescaped = rb_reg_preprocess(
1650 pattern, pattern + RSTRING_LEN(src_str), enc,
1651 &fixed_enc, err, 0);
1653 if (
NIL_P(unescaped)) {
1654 rb_raise(rb_eArgError,
"regexp preprocess failed: %s", err);
1658 rb_hrtime_t timelimit = reg->timelimit;
1665 if (ruby_single_main_ractor &&
RREGEXP(re)->usecnt == 0) {
1667 r = onig_new_without_alloc(&tmp_reg, (UChar *)ptr, (UChar *)(ptr +
len),
1669 OnigDefaultSyntax, &einfo);
1673 onig_free_body(&tmp_reg);
1676 onig_free_body(reg);
1682 r = onig_new(®, (UChar *)ptr, (UChar *)(ptr +
len),
1684 OnigDefaultSyntax, &einfo);
1688 onig_error_code_to_str((UChar*)err, r, &einfo);
1689 rb_reg_raise(err, re);
1692 reg->timelimit = timelimit;
1707 if (!tmpreg)
RREGEXP(re)->usecnt++;
1709 OnigPosition result = match(reg,
str, regs, args);
1711 if (!tmpreg)
RREGEXP(re)->usecnt--;
1717 onig_region_free(regs, 0);
1722 case ONIGERR_TIMEOUT:
1723 rb_raise(rb_eRegexpTimeoutError,
"regexp match timeout");
1725 onig_errmsg_buffer err =
"";
1726 onig_error_code_to_str((UChar*)err, (
int)result);
1727 rb_reg_raise(err, re);
1742 enc = rb_reg_prepare_enc(re,
str, 0);
1748 range = RSTRING_LEN(
str) - pos;
1751 if (pos > 0 && ONIGENC_MBC_MAXLEN(enc) != 1 && pos < RSTRING_LEN(
str)) {
1752 string = (UChar*)RSTRING_PTR(
str);
1755 p = onigenc_get_right_adjust_char_head(enc,
string,
string + pos,
string + RSTRING_LEN(
str));
1758 p = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc,
string,
string + pos,
string + RSTRING_LEN(
str));
1782 (UChar *)(ptr +
len),
1783 (UChar *)(ptr + args->pos),
1784 (UChar *)(ptr + args->range),
1791rb_reg_search_set_match(
VALUE re,
VALUE str,
long pos,
int reverse,
int set_backref_str,
VALUE *set_match)
1793 long len = RSTRING_LEN(str);
1794 if (pos >
len || pos < 0) {
1801 .range = reverse ? 0 :
len,
1805 OnigPosition result =
rb_reg_onig_match(re, str, reg_onig_search, &args, ®s);
1807 if (result == ONIG_MISMATCH) {
1809 return ONIG_MISMATCH;
1829 onig_region_free(&RMATCH_EXT(match)->regs,
false);
1835 if (set_backref_str) {
1849 if (set_match) *set_match = match;
1855rb_reg_search0(
VALUE re,
VALUE str,
long pos,
int reverse,
int set_backref_str,
VALUE *match)
1857 return rb_reg_search_set_match(re, str, pos, reverse, set_backref_str, match);
1863 return rb_reg_search_set_match(re, str, pos, reverse, 1, NULL);
1876 (UChar *)(ptr +
len),
1911 if (nth >= regs->num_regs) {
1915 nth += regs->num_regs;
1916 if (nth <= 0)
return Qnil;
1918 return RBOOL(BEG(nth) != -1);
1925 long start, end,
len;
1931 if (nth >= regs->num_regs) {
1935 nth += regs->num_regs;
1936 if (nth <= 0)
return Qnil;
1939 if (start == -1)
return Qnil;
1979 if (BEG(0) == -1)
return Qnil;
2013 if (BEG(0) == -1)
return Qnil;
2014 str =
RMATCH(match)->str;
2021match_last_index(
VALUE match)
2026 if (
NIL_P(match))
return -1;
2029 if (BEG(0) == -1)
return -1;
2031 for (i=regs->num_regs-1; BEG(i) == -1 && i > 0; i--)
2039 int i = match_last_index(match);
2040 if (i <= 0)
return Qnil;
2046rb_reg_last_defined(
VALUE match)
2048 int i = match_last_index(match);
2049 if (i < 0)
return Qnil;
2054last_match_getter(
ID _x,
VALUE *_y)
2060prematch_getter(
ID _x,
VALUE *_y)
2066postmatch_getter(
ID _x,
VALUE *_y)
2072last_paren_match_getter(
ID _x,
VALUE *_y)
2078match_array(
VALUE match,
int start)
2088 target =
RMATCH(match)->str;
2090 for (i=start; i<regs->num_regs; i++) {
2091 if (regs->beg[i] == -1) {
2118match_to_a(
VALUE match)
2120 return match_array(match, 0);
2140match_captures(
VALUE match)
2142 return match_array(match, 1);
2146name_to_backref_number(
struct re_registers *regs,
VALUE regexp,
const char* name,
const char* name_end)
2148 if (
NIL_P(regexp))
return -1;
2149 return onig_name_to_backref_number(
RREGEXP_PTR(regexp),
2150 (
const unsigned char *)name, (
const unsigned char *)name_end, regs);
2153#define NAME_TO_NUMBER(regs, re, name, name_ptr, name_end) \
2155 !rb_enc_compatible(RREGEXP_SRC(re), (name)) ? 0 : \
2156 name_to_backref_number((regs), (re), (name_ptr), (name_end)))
2169 num = NAME_TO_NUMBER(regs, re, name,
2172 name_to_backref_error(name);
2178match_ary_subseq(
VALUE match,
long beg,
long len,
VALUE result)
2181 long j, end = olen < beg+
len ? olen : beg+
len;
2183 if (
len == 0)
return result;
2185 for (j = beg; j < end; j++) {
2188 if (beg +
len > j) {
2209 return match_ary_subseq(match, beg,
len, result);
2252match_aref(
int argc,
VALUE *argv,
VALUE match)
2259 if (
NIL_P(length)) {
2264 int num = namev_to_backref_number(
RMATCH_REGS(match),
RMATCH(match)->regexp, idx);
2269 return match_ary_aref(match, idx,
Qnil);
2282 if (beg < 0)
return Qnil;
2284 else if (beg > num_regs) {
2287 if (beg+
len > num_regs) {
2288 len = num_regs - beg;
2290 return match_ary_subseq(match, beg,
len,
Qnil);
2321match_values_at(
int argc,
VALUE *argv,
VALUE match)
2329 for (i=0; i<argc; i++) {
2334 int num = namev_to_backref_number(
RMATCH_REGS(match),
RMATCH(match)->regexp, argv[i]);
2339 match_ary_aref(match, argv[i], result);
2366match_to_s(
VALUE match)
2375match_named_captures_iter(
const OnigUChar *name,
const OnigUChar *name_end,
2376 int back_num,
int *back_refs,
OnigRegex regex,
void *arg)
2378 struct MEMO *memo = MEMO_CAST(arg);
2379 VALUE hash = memo->v1;
2380 VALUE match = memo->v2;
2381 long symbolize = memo->u3.state;
2383 VALUE key = rb_enc_str_new((
const char *)name, name_end-name, regex->enc);
2385 if (symbolize > 0) {
2394 for (i = 0; i < back_num; i++) {
2397 rb_hash_aset(hash, key, value);
2403 rb_hash_aset(hash, key,
Qnil);
2442match_named_captures(
int argc,
VALUE *argv,
VALUE match)
2449 return rb_hash_new();
2452 VALUE symbolize_names = 0;
2457 static ID keyword_ids[1];
2459 VALUE symbolize_names_val;
2461 if (!keyword_ids[0]) {
2464 rb_get_kwargs(opt, keyword_ids, 0, 1, &symbolize_names_val);
2465 if (!UNDEF_P(symbolize_names_val) &&
RTEST(symbolize_names_val)) {
2466 symbolize_names = 1;
2470 hash = rb_hash_new();
2471 memo = MEMO_NEW(hash, match, symbolize_names);
2473 onig_foreach_name(
RREGEXP(
RMATCH(match)->regexp)->ptr, match_named_captures_iter, (
void*)memo);
2495match_deconstruct_keys(
VALUE match,
VALUE keys)
2503 return rb_hash_new_with_size(0);
2507 h = rb_hash_new_with_size(onig_number_of_names(
RREGEXP_PTR(
RMATCH(match)->regexp)));
2510 memo = MEMO_NEW(h, match, 1);
2512 onig_foreach_name(
RREGEXP_PTR(
RMATCH(match)->regexp), match_named_captures_iter, (
void*)memo);
2520 return rb_hash_new_with_size(0);
2561match_string(
VALUE match)
2564 return RMATCH(match)->str;
2573match_inspect_name_iter(
const OnigUChar *name,
const OnigUChar *name_end,
2574 int back_num,
int *back_refs,
OnigRegex regex,
void *arg0)
2579 for (i = 0; i < back_num; i++) {
2580 arg[back_refs[i]].name = name;
2581 arg[back_refs[i]].len = name_end - name;
2608match_inspect(
VALUE match)
2614 int num_regs = regs->num_regs;
2619 return rb_sprintf(
"#<%"PRIsVALUE
":%p>", cname, (
void*)match);
2621 else if (
NIL_P(regexp)) {
2622 return rb_sprintf(
"#<%"PRIsVALUE
": %"PRIsVALUE
">",
2630 match_inspect_name_iter, names);
2635 for (i = 0; i < num_regs; i++) {
2642 rb_str_catf(str,
"%d", i);
2660read_escaped_byte(
const char **pp,
const char *end, onig_errmsg_buffer err)
2662 const char *p = *pp;
2664 int meta_prefix = 0, ctrl_prefix = 0;
2667 if (p == end || *p++ !=
'\\') {
2668 errcpy(err,
"too short escaped multibyte character");
2674 errcpy(err,
"too short escape sequence");
2678 case '\\': code =
'\\';
break;
2679 case 'n': code =
'\n';
break;
2680 case 't': code =
'\t';
break;
2681 case 'r': code =
'\r';
break;
2682 case 'f': code =
'\f';
break;
2683 case 'v': code =
'\013';
break;
2684 case 'a': code =
'\007';
break;
2685 case 'e': code =
'\033';
break;
2688 case '0':
case '1':
case '2':
case '3':
2689 case '4':
case '5':
case '6':
case '7':
2698 errcpy(err,
"invalid hex escape");
2706 errcpy(err,
"duplicate meta escape");
2710 if (p+1 < end && *p++ ==
'-' && (*p & 0x80) == 0) {
2720 errcpy(err,
"too short meta escape");
2724 if (p == end || *p++ !=
'-') {
2725 errcpy(err,
"too short control escape");
2730 errcpy(err,
"duplicate control escape");
2734 if (p < end && (*p & 0x80) == 0) {
2744 errcpy(err,
"too short control escape");
2748 errcpy(err,
"unexpected escape sequence");
2751 if (code < 0 || 0xff < code) {
2752 errcpy(err,
"invalid escape code");
2766unescape_escaped_nonascii(
const char **pp,
const char *end,
rb_encoding *enc,
2769 const char *p = *pp;
2771 unsigned char *area =
ALLOCA_N(
unsigned char, chmaxlen);
2772 char *chbuf = (
char *)area;
2777 memset(chbuf, 0, chmaxlen);
2779 byte = read_escaped_byte(&p, end, err);
2784 area[chlen++] = byte;
2785 while (chlen < chmaxlen &&
2787 byte = read_escaped_byte(&p, end, err);
2791 area[chlen++] = byte;
2794 l = rb_enc_precise_mbclen(chbuf, chbuf+chlen, enc);
2796 errcpy(err,
"invalid multibyte escape");
2799 if (1 < chlen || (area[0] & 0x80)) {
2804 else if (*encp != enc) {
2805 errcpy(err,
"escaped non ASCII character in UTF-8 regexp");
2811 snprintf(escbuf,
sizeof(escbuf),
"\\x%02X", area[0]&0xff);
2819check_unicode_range(
unsigned long code, onig_errmsg_buffer err)
2821 if ((0xd800 <= code && code <= 0xdfff) ||
2823 errcpy(err,
"invalid Unicode range");
2830append_utf8(
unsigned long uv,
2833 if (check_unicode_range(uv, err) != 0)
2837 snprintf(escbuf,
sizeof(escbuf),
"\\x%02X", (
int)uv);
2847 *encp = rb_utf8_encoding();
2848 else if (*encp != rb_utf8_encoding()) {
2849 errcpy(err,
"UTF-8 character in non UTF-8 regexp");
2857unescape_unicode_list(
const char **pp,
const char *end,
2860 const char *p = *pp;
2861 int has_unicode = 0;
2865 while (p < end &&
ISSPACE(*p)) p++;
2868 code = ruby_scan_hex(p, end-p, &
len);
2872 errcpy(err,
"invalid Unicode range");
2876 if (append_utf8(code, buf, encp, err) != 0)
2880 while (p < end &&
ISSPACE(*p)) p++;
2883 if (has_unicode == 0) {
2884 errcpy(err,
"invalid Unicode list");
2894unescape_unicode_bmp(
const char **pp,
const char *end,
2897 const char *p = *pp;
2902 errcpy(err,
"invalid Unicode escape");
2905 code = ruby_scan_hex(p, 4, &
len);
2907 errcpy(err,
"invalid Unicode escape");
2910 if (append_utf8(code, buf, encp, err) != 0)
2917unescape_nonascii0(
const char **pp,
const char *end,
rb_encoding *enc,
2919 onig_errmsg_buffer err,
int options,
int recurse)
2921 const char *p = *pp;
2924 int in_char_class = 0;
2926 int extended_mode = options & ONIG_OPTION_EXTEND;
2930 int chlen = rb_enc_precise_mbclen(p, end, enc);
2933 errcpy(err,
"invalid multibyte character");
2937 if (1 < chlen || (*p & 0x80)) {
2943 else if (*encp != enc) {
2944 errcpy(err,
"non ASCII character in UTF-8 regexp");
2953 errcpy(err,
"too short escape sequence");
2956 chlen = rb_enc_precise_mbclen(p, end, enc);
2958 goto invalid_multibyte;
2967 case '1':
case '2':
case '3':
2968 case '4':
case '5':
case '6':
case '7':
2970 size_t len = end-(p-1), octlen;
2971 if (ruby_scan_oct(p-1,
len < 3 ?
len : 3, &octlen) <= 0177) {
2987 if (rb_is_usascii_enc(enc)) {
2988 const char *pbeg = p;
2989 int byte = read_escaped_byte(&p, end, err);
2990 if (
byte == -1)
return -1;
2995 if (unescape_escaped_nonascii(&p, end, enc, buf, encp, err) != 0)
3002 errcpy(err,
"too short escape sequence");
3008 if (unescape_unicode_list(&p, end, buf, encp, err) != 0)
3010 if (p == end || *p++ !=
'}') {
3011 errcpy(err,
"invalid Unicode list");
3018 if (unescape_unicode_bmp(&p, end, buf, encp, err) != 0)
3040 if (extended_mode && !in_char_class) {
3042 while ((p < end) && ((c = *p++) !=
'\n')) {
3043 if ((c & 0x80) && !*encp && enc == rb_utf8_encoding()) {
3056 if (in_char_class) {
3063 if (!in_char_class && recurse) {
3064 if (--parens == 0) {
3071 if (!in_char_class && p + 1 < end && *p ==
'?') {
3072 if (*(p+1) ==
'#') {
3074 const char *orig_p = p;
3077 while (cont && (p < end)) {
3080 if (!(c & 0x80))
break;
3081 if (!*encp && enc == rb_utf8_encoding()) {
3087 chlen = rb_enc_precise_mbclen(p, end, enc);
3089 goto invalid_multibyte;
3110 int local_extend = 0;
3117 for (s = p+1; s < end; s++) {
3120 local_extend = invert ? -1 : 1;
3127 if (local_extend == 0 ||
3128 (local_extend == -1 && !extended_mode) ||
3129 (local_extend == 1 && extended_mode)) {
3136 int local_options = options;
3137 if (local_extend == 1) {
3138 local_options |= ONIG_OPTION_EXTEND;
3141 local_options &= ~ONIG_OPTION_EXTEND;
3145 int ret = unescape_nonascii0(&p, end, enc, buf, encp,
3148 if (ret < 0)
return ret;
3153 extended_mode = local_extend == 1;
3170 else if (!in_char_class && recurse) {
3188unescape_nonascii(
const char *p,
const char *end,
rb_encoding *enc,
3190 onig_errmsg_buffer err,
int options)
3192 return unescape_nonascii0(&p, end, enc, buf, encp, has_property,
3197rb_reg_preprocess(
const char *p,
const char *end,
rb_encoding *enc,
3198 rb_encoding **fixed_enc, onig_errmsg_buffer err,
int options)
3201 int has_property = 0;
3205 if (rb_enc_asciicompat(enc))
3209 rb_enc_associate(buf, enc);
3212 if (unescape_nonascii(p, end, enc, buf, fixed_enc, &has_property, err, options) != 0)
3215 if (has_property && !*fixed_enc) {
3220 rb_enc_associate(buf, *fixed_enc);
3227rb_reg_check_preprocess(
VALUE str)
3230 onig_errmsg_buffer err =
"";
3236 p = RSTRING_PTR(str);
3237 end = p + RSTRING_LEN(str);
3238 enc = rb_enc_get(str);
3240 buf = rb_reg_preprocess(p, end, enc, &fixed_enc, err, 0);
3244 return rb_reg_error_desc(str, 0, err);
3250rb_reg_preprocess_dregexp(
VALUE ary,
int options)
3254 onig_errmsg_buffer err =
"";
3260 rb_raise(rb_eArgError,
"no arguments given");
3269 src_enc = rb_enc_get(str);
3270 if (options & ARG_ENCODING_NONE &&
3271 src_enc != ascii8bit) {
3273 rb_raise(
rb_eRegexpError,
"/.../n has a non escaped non ASCII character in non ASCII-8BIT script");
3275 src_enc = ascii8bit;
3279 p = RSTRING_PTR(str);
3280 end = p + RSTRING_LEN(str);
3282 buf = rb_reg_preprocess(p, end, src_enc, &fixed_enc, err, options);
3285 rb_raise(rb_eArgError,
"%s", err);
3287 if (fixed_enc != 0) {
3288 if (regexp_enc != 0 && regexp_enc != fixed_enc) {
3289 rb_raise(
rb_eRegexpError,
"encoding mismatch in dynamic regexp : %s and %s",
3290 rb_enc_name(regexp_enc), rb_enc_name(fixed_enc));
3292 regexp_enc = fixed_enc;
3301 rb_enc_associate(result, regexp_enc);
3308rb_reg_initialize_check(
VALUE obj)
3310 rb_check_frozen(obj);
3318 int options, onig_errmsg_buffer err,
3319 const char *sourcefile,
int sourceline)
3326 rb_reg_initialize_check(obj);
3328 if (rb_enc_dummy_p(enc)) {
3329 errcpy(err,
"can't make regexp with dummy encoding");
3333 unescaped = rb_reg_preprocess(s, s+
len, enc, &fixed_enc, err, options);
3334 if (
NIL_P(unescaped))
3338 if ((fixed_enc != enc && (options & ARG_ENCODING_FIXED)) ||
3339 (fixed_enc != a_enc && (options & ARG_ENCODING_NONE))) {
3340 errcpy(err,
"incompatible character encoding");
3343 if (fixed_enc != a_enc) {
3344 options |= ARG_ENCODING_FIXED;
3348 else if (!(options & ARG_ENCODING_FIXED)) {
3349 enc = rb_usascii_encoding();
3352 rb_enc_associate((
VALUE)re, enc);
3353 if ((options & ARG_ENCODING_FIXED) || fixed_enc) {
3356 if (options & ARG_ENCODING_NONE) {
3360 re->
ptr = make_regexp(RSTRING_PTR(unescaped), RSTRING_LEN(unescaped), enc,
3361 options & ARG_REG_OPTION_MASK, err,
3362 sourcefile, sourceline);
3363 if (!re->
ptr)
return -1;
3372 if (regenc != enc) {
3373 str = rb_enc_associate(
rb_str_dup(str), enc = regenc);
3379rb_reg_initialize_str(
VALUE obj,
VALUE str,
int options, onig_errmsg_buffer err,
3380 const char *sourcefile,
int sourceline)
3383 rb_encoding *str_enc = rb_enc_get(str), *enc = str_enc;
3384 if (options & ARG_ENCODING_NONE) {
3386 if (enc != ascii8bit) {
3388 errcpy(err,
"/.../n has a non escaped non ASCII character in non ASCII-8BIT script");
3394 ret = rb_reg_initialize(obj, RSTRING_PTR(str), RSTRING_LEN(str), enc,
3395 options, err, sourcefile, sourceline);
3396 if (ret == 0) reg_set_source(obj, str, str_enc);
3401rb_reg_s_alloc(
VALUE klass)
3421 return rb_reg_init_str(rb_reg_alloc(), s, options);
3425rb_reg_init_str(
VALUE re,
VALUE s,
int options)
3427 onig_errmsg_buffer err =
"";
3429 if (rb_reg_initialize_str(re, s, options, err, NULL, 0) != 0) {
3430 rb_reg_raise_str(s, options, err);
3439 onig_errmsg_buffer err =
"";
3441 if (rb_reg_initialize(re, RSTRING_PTR(s), RSTRING_LEN(s),
3442 enc, options, err, NULL, 0) != 0) {
3443 rb_reg_raise_str(s, options, err);
3445 reg_set_source(re, s, enc);
3451rb_reg_new_ary(
VALUE ary,
int opt)
3461 VALUE re = rb_reg_alloc();
3462 onig_errmsg_buffer err =
"";
3464 if (rb_reg_initialize(re, s,
len, enc, options, err, NULL, 0) != 0) {
3465 rb_enc_reg_raise(s,
len, enc, options, err);
3479rb_reg_compile(
VALUE str,
int options,
const char *sourcefile,
int sourceline)
3481 VALUE re = rb_reg_alloc();
3482 onig_errmsg_buffer err =
"";
3485 if (rb_reg_initialize_str(re, str, options, err, sourcefile, sourceline) != 0) {
3486 rb_set_errinfo(rb_reg_error_desc(str, options, err));
3493static VALUE reg_cache;
3498 if (rb_ractor_main_p()) {
3501 && memcmp(
RREGEXP_SRC_PTR(reg_cache), RSTRING_PTR(str), RSTRING_LEN(str)) == 0)
3511static st_index_t reg_hash(
VALUE re);
3523rb_reg_hash(
VALUE re)
3525 st_index_t hashval = reg_hash(re);
3558 if (re1 == re2)
return Qtrue;
3560 rb_reg_check(re1); rb_reg_check(re2);
3580match_hash(
VALUE match)
3587 hashval =
rb_hash_uint(hashval, reg_hash(match_regexp(match)));
3610 if (match1 == match2)
return Qtrue;
3614 if (!rb_reg_equal(match_regexp(match1), match_regexp(match2)))
return Qfalse;
3617 if (regs1->num_regs != regs2->num_regs)
return Qfalse;
3618 if (memcmp(regs1->beg, regs2->beg, regs1->num_regs *
sizeof(*regs1->beg)))
return Qfalse;
3619 if (memcmp(regs1->end, regs2->end, regs1->num_regs *
sizeof(*regs1->end)))
return Qfalse;
3624reg_operand(
VALUE s,
int check)
3646 *strp = str = reg_operand(str, TRUE);
3657 return rb_reg_search_set_match(re, str, pos, 0, 1, set_match);
3719 long pos = reg_match_pos(re, &str, 0, NULL);
3720 if (pos < 0)
return Qnil;
3750 str = reg_operand(str, FALSE);
3756 return RBOOL(start >= 0);
3833rb_reg_match_m(
int argc,
VALUE *argv,
VALUE re)
3838 if (
rb_scan_args(argc, argv,
"11", &str, &initpos) == 2) {
3845 pos = reg_match_pos(re, &str, pos, &result);
3874rb_reg_match_m_p(
int argc,
VALUE *argv,
VALUE re)
3877 return rb_reg_match_p(re, argv[0], pos);
3888 if (pos < 0)
return Qfalse;
3894 pos = beg - RSTRING_PTR(str);
3900 .range = RSTRING_LEN(str),
3913str_to_option(
VALUE str)
3919 if (
NIL_P(str))
return -1;
3921 for (
long i = 0; i <
len; ++i) {
3922 int f = char_to_option(ptr[i]);
3924 rb_raise(rb_eArgError,
"unknown regexp option: %"PRIsVALUE, str);
3932set_timeout(rb_hrtime_t *hrt,
VALUE timeout)
3934 double timeout_d =
NIL_P(timeout) ? 0.0 :
NUM2DBL(timeout);
3935 if (!
NIL_P(timeout) && timeout_d <= 0) {
3936 rb_raise(rb_eArgError,
"invalid timeout: %"PRIsVALUE, timeout);
3938 double2hrtime(hrt, timeout_d);
3947 rb_reg_initialize_check(copy);
3948 if ((r = onig_reg_copy(&re,
RREGEXP_PTR(orig))) != 0) {
3955 rb_enc_copy(copy, orig);
3970void rb_warn_deprecated_to_remove(
const char *removal,
const char *fmt,
const char *suggest, ...);
4027rb_reg_initialize_m(
int argc,
VALUE *argv,
VALUE self)
4030 VALUE re = reg_extract_args(argc, argv, &args);
4039 set_timeout(&
RREGEXP_PTR(self)->timelimit, args.timeout);
4054 args->timeout =
Qnil;
4055 if (!
NIL_P(kwargs)) {
4056 static ID keywords[1];
4077 else if ((f = str_to_option(opts)) >= 0) flags = f;
4078 else if (rb_bool_expected(opts,
"ignorecase", FALSE))
4079 flags = ONIG_OPTION_IGNORECASE;
4085 args->flags = flags;
4092 if (enc && rb_enc_get(str) != enc)
4093 rb_reg_init_str_enc(self, str, enc, flags);
4095 rb_reg_init_str(self, str, flags);
4108 s = RSTRING_PTR(str);
4109 send = s + RSTRING_LEN(str);
4111 c = rb_enc_ascget(s, send, &clen, enc);
4113 s += mbclen(s, send, enc);
4117 case '[':
case ']':
case '{':
case '}':
4118 case '(':
case ')':
case '|':
case '-':
4119 case '*':
case '.':
case '\\':
4120 case '?':
case '+':
case '^':
case '$':
4122 case '\t':
case '\f':
case '\v':
case '\n':
case '\r':
4129 rb_enc_associate(tmp, rb_usascii_encoding());
4136 rb_enc_associate(tmp, rb_usascii_encoding());
4139 rb_enc_copy(tmp, str);
4141 t = RSTRING_PTR(tmp);
4143 const char *p = RSTRING_PTR(str);
4144 memcpy(t, p, s - p);
4148 c = rb_enc_ascget(s, send, &clen, enc);
4150 int n = mbclen(s, send, enc);
4158 case '[':
case ']':
case '{':
case '}':
4159 case '(':
case ')':
case '|':
case '-':
4160 case '*':
case '.':
case '\\':
4161 case '?':
case '+':
case '^':
case '$':
4163 t += rb_enc_mbcput(
'\\', t, enc);
4166 t += rb_enc_mbcput(
'\\', t, enc);
4167 t += rb_enc_mbcput(
' ', t, enc);
4170 t += rb_enc_mbcput(
'\\', t, enc);
4171 t += rb_enc_mbcput(
't', t, enc);
4174 t += rb_enc_mbcput(
'\\', t, enc);
4175 t += rb_enc_mbcput(
'n', t, enc);
4178 t += rb_enc_mbcput(
'\\', t, enc);
4179 t += rb_enc_mbcput(
'r', t, enc);
4182 t += rb_enc_mbcput(
'\\', t, enc);
4183 t += rb_enc_mbcput(
'f', t, enc);
4186 t += rb_enc_mbcput(
'\\', t, enc);
4187 t += rb_enc_mbcput(
'v', t, enc);
4190 t += rb_enc_mbcput(c, t, enc);
4192 rb_str_resize(tmp, t - RSTRING_PTR(tmp));
4225 options =
RREGEXP_PTR(re)->options & ARG_REG_OPTION_MASK;
4226 if (
RBASIC(re)->flags & KCODE_FIXED) options |= ARG_ENCODING_FIXED;
4227 if (
RBASIC(re)->flags & REG_ENCODING_NONE) options |= ARG_ENCODING_NONE;
4232rb_check_regexp_type(
VALUE re)
4258 return rb_check_regexp_type(re);
4271 else if (argc == 1) {
4273 VALUE re = rb_check_regexp_type(arg);
4278 quoted = rb_reg_s_quote(
Qnil, arg);
4287 int has_asciionly = 0;
4291 for (i = 0; i < argc; i++) {
4298 v = rb_check_regexp_type(e);
4301 if (!rb_enc_asciicompat(enc)) {
4302 if (!has_ascii_incompat)
4303 has_ascii_incompat = enc;
4304 else if (has_ascii_incompat != enc)
4305 rb_raise(rb_eArgError,
"incompatible encodings: %s and %s",
4306 rb_enc_name(has_ascii_incompat), rb_enc_name(enc));
4308 else if (rb_reg_fixed_encoding_p(v)) {
4309 if (!has_ascii_compat_fixed)
4310 has_ascii_compat_fixed = enc;
4311 else if (has_ascii_compat_fixed != enc)
4312 rb_raise(rb_eArgError,
"incompatible encodings: %s and %s",
4313 rb_enc_name(has_ascii_compat_fixed), rb_enc_name(enc));
4318 v = rb_reg_str_with_term(v, -1);
4323 enc = rb_enc_get(e);
4324 if (!rb_enc_asciicompat(enc)) {
4325 if (!has_ascii_incompat)
4326 has_ascii_incompat = enc;
4327 else if (has_ascii_incompat != enc)
4328 rb_raise(rb_eArgError,
"incompatible encodings: %s and %s",
4329 rb_enc_name(has_ascii_incompat), rb_enc_name(enc));
4335 if (!has_ascii_compat_fixed)
4336 has_ascii_compat_fixed = enc;
4337 else if (has_ascii_compat_fixed != enc)
4338 rb_raise(rb_eArgError,
"incompatible encodings: %s and %s",
4339 rb_enc_name(has_ascii_compat_fixed), rb_enc_name(enc));
4341 v = rb_reg_s_quote(
Qnil, e);
4343 if (has_ascii_incompat) {
4344 if (has_asciionly) {
4345 rb_raise(rb_eArgError,
"ASCII incompatible encoding: %s",
4346 rb_enc_name(has_ascii_incompat));
4348 if (has_ascii_compat_fixed) {
4349 rb_raise(rb_eArgError,
"incompatible encodings: %s and %s",
4350 rb_enc_name(has_ascii_incompat), rb_enc_name(has_ascii_compat_fixed));
4355 rb_enc_copy(source, v);
4360 if (has_ascii_incompat) {
4361 result_enc = has_ascii_incompat;
4363 else if (has_ascii_compat_fixed) {
4364 result_enc = has_ascii_compat_fixed;
4367 result_enc = rb_ascii8bit_encoding();
4370 rb_enc_associate(source, result_enc);
4415 return rb_reg_s_union(self, v);
4417 return rb_reg_s_union(self, args);
4442rb_reg_s_linear_time_p(
int argc,
VALUE *argv,
VALUE self)
4445 VALUE re = reg_extract_args(argc, argv, &args);
4448 re =
reg_init_args(rb_reg_alloc(), args.str, args.enc, args.flags);
4451 return RBOOL(onig_check_linear_time(
RREGEXP_PTR(re)));
4460 return reg_copy(copy, re);
4471 int acompat = rb_enc_asciicompat(str_enc);
4473#define ASCGET(s,e,cl) (acompat ? (*(cl)=1,ISASCII((s)[0])?(s)[0]:-1) : rb_enc_ascget((s), (e), (cl), str_enc))
4480 int c = ASCGET(s, e, &clen);
4484 s += mbclen(s, e, str_enc);
4490 if (c !=
'\\' || s == e)
continue;
4497 c = ASCGET(s, e, &clen);
4499 s += mbclen(s, e, str_enc);
4508 case '1':
case '2':
case '3':
case '4':
4509 case '5':
case '6':
case '7':
case '8':
case '9':
4510 if (!
NIL_P(regexp) && onig_noname_group_capture_is_active(
RREGEXP_PTR(regexp))) {
4519 if (s < e && ASCGET(s, e, &clen) ==
'<') {
4520 char *name, *name_end;
4522 name_end = name = s + clen;
4523 while (name_end < e) {
4524 c = ASCGET(name_end, e, &clen);
4525 if (c ==
'>')
break;
4526 name_end += c == -1 ? mbclen(name_end, e, str_enc) : clen;
4530 (
long)(name_end - name));
4531 if ((no = NAME_TO_NUMBER(regs, regexp, n, name, name_end)) < 1) {
4532 name_to_backref_error(n);
4534 p = s = name_end + clen;
4559 no = regs->num_regs-1;
4560 while (BEG(no) == -1 && no > 0) no--;
4561 if (no == 0)
continue;
4574 if (no >= regs->num_regs)
continue;
4575 if (BEG(no) == -1)
continue;
4580 if (!val)
return str;
4589ignorecase_getter(
ID _x,
VALUE *_y)
4612get_LAST_MATCH_INFO(
ID _x,
VALUE *_y)
4614 return match_getter();
4665rb_reg_s_last_match(
int argc,
VALUE *argv,
VALUE _)
4671 n = match_backref_number(match, argv[0]);
4674 return match_getter();
4678re_warn(
const char *s)
4685rb_reg_timeout_p(
regex_t *reg,
void *end_time_)
4687 rb_hrtime_t *end_time = (rb_hrtime_t *)end_time_;
4689 if (*end_time == 0) {
4693 rb_hrtime_t timelimit = reg->timelimit;
4697 timelimit = rb_reg_match_time_limit;
4701 *end_time = rb_hrtime_add(timelimit, rb_hrtime_now());
4705 *end_time = RB_HRTIME_MAX;
4709 if (*end_time < rb_hrtime_now()) {
4727rb_reg_s_timeout_get(
VALUE dummy)
4729 double d = hrtime2double(rb_reg_match_time_limit);
4730 if (d == 0.0)
return Qnil;
4748rb_reg_s_timeout_set(
VALUE dummy,
VALUE timeout)
4750 rb_ractor_ensure_main_ractor(
"can not access Regexp.timeout from non-main Ractors");
4752 set_timeout(&rb_reg_match_time_limit, timeout);
4773rb_reg_timeout_get(
VALUE re)
4776 double d = hrtime2double(
RREGEXP_PTR(re)->timelimit);
4777 if (d == 0.0)
return Qnil;
4804 onigenc_set_default_encoding(ONIG_ENCODING_ASCII);
4805 onig_set_warn_func(re_warn);
4806 onig_set_verb_warn_func(re_warn);
4814 rb_gvar_ractor_local(
"$~");
4815 rb_gvar_ractor_local(
"$&");
4816 rb_gvar_ractor_local(
"$`");
4817 rb_gvar_ractor_local(
"$'");
4818 rb_gvar_ractor_local(
"$+");
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
static bool rb_enc_isprint(OnigCodePoint c, rb_encoding *enc)
Identical to rb_isprint(), except it additionally takes an encoding.
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
void rb_undef_method(VALUE klass, const char *name)
Defines an undef of a method.
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Retrieves argument from argc and argv to given VALUE references according to the format string.
int rb_block_given_p(void)
Determines if the current method is given a block.
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
Keyword argument deconstructor.
#define rb_str_new2
Old name of rb_str_new_cstr.
#define ENC_CODERANGE_7BIT
Old name of RUBY_ENC_CODERANGE_7BIT.
#define rb_str_buf_cat2
Old name of rb_usascii_str_new_cstr.
#define REALLOC_N
Old name of RB_REALLOC_N.
#define OBJ_INIT_COPY(obj, orig)
Old name of RB_OBJ_INIT_COPY.
#define ISSPACE
Old name of rb_isspace.
#define T_STRING
Old name of RUBY_T_STRING.
#define ENC_CODERANGE_CLEAN_P(cr)
Old name of RB_ENC_CODERANGE_CLEAN_P.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define rb_str_buf_new2
Old name of rb_str_buf_new_cstr.
#define ENC_CODERANGE(obj)
Old name of RB_ENC_CODERANGE.
#define CLASS_OF
Old name of rb_class_of.
#define ENC_CODERANGE_UNKNOWN
Old name of RUBY_ENC_CODERANGE_UNKNOWN.
#define ENCODING_GET(obj)
Old name of RB_ENCODING_GET.
#define LONG2FIX
Old name of RB_INT2FIX.
#define FIX2INT
Old name of RB_FIX2INT.
#define NUM2DBL
Old name of rb_num2dbl.
#define rb_str_new3
Old name of rb_str_new_shared.
#define MBCLEN_CHARFOUND_LEN(ret)
Old name of ONIGENC_MBCLEN_CHARFOUND_LEN.
#define FL_TEST_RAW
Old name of RB_FL_TEST_RAW.
#define FL_SET
Old name of RB_FL_SET.
#define LONG2NUM
Old name of RB_LONG2NUM.
#define rb_exc_new3
Old name of rb_exc_new_str.
#define MBCLEN_INVALID_P(ret)
Old name of ONIGENC_MBCLEN_INVALID_P.
#define Qtrue
Old name of RUBY_Qtrue.
#define ST2FIX
Old name of RB_ST2FIX.
#define MBCLEN_NEEDMORE_P(ret)
Old name of ONIGENC_MBCLEN_NEEDMORE_P.
#define NUM2INT
Old name of RB_NUM2INT.
#define INT2NUM
Old name of RB_INT2NUM.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define ENC_CODERANGE_BROKEN
Old name of RUBY_ENC_CODERANGE_BROKEN.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
#define scan_hex(s, l, e)
Old name of ruby_scan_hex.
#define NIL_P
Old name of RB_NIL_P.
#define MBCLEN_CHARFOUND_P(ret)
Old name of ONIGENC_MBCLEN_CHARFOUND_P.
#define FL_WB_PROTECTED
Old name of RUBY_FL_WB_PROTECTED.
#define T_SYMBOL
Old name of RUBY_T_SYMBOL.
#define DBL2NUM
Old name of rb_float_new.
#define T_MATCH
Old name of RUBY_T_MATCH.
#define FL_TEST
Old name of RB_FL_TEST.
#define NUM2LONG
Old name of RB_NUM2LONG.
#define FL_UNSET
Old name of RB_FL_UNSET.
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define scan_oct(s, l, e)
Old name of ruby_scan_oct.
#define rb_ary_new2
Old name of rb_ary_new_capa.
#define FL_SET_RAW
Old name of RB_FL_SET_RAW.
#define rb_str_new4
Old name of rb_str_new_frozen.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
#define T_REGEXP
Old name of RUBY_T_REGEXP.
void rb_category_warn(rb_warning_category_t category, const char *fmt,...)
Identical to rb_category_warning(), except it reports unless $VERBOSE is nil.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
VALUE rb_eStandardError
StandardError exception.
VALUE rb_eRegexpError
RegexpError exception.
#define ruby_verbose
This variable controls whether the interpreter is in debug mode.
VALUE rb_eTypeError
TypeError exception.
VALUE rb_eEncCompatError
Encoding::CompatibilityError exception.
VALUE rb_eRuntimeError
RuntimeError exception.
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
VALUE rb_eIndexError
IndexError exception.
@ RB_WARN_CATEGORY_DEPRECATED
Warning is for deprecated features.
VALUE rb_obj_reveal(VALUE obj, VALUE klass)
Make a hidden object visible again.
VALUE rb_check_convert_type(VALUE val, int type, const char *name, const char *mid)
Identical to rb_convert_type(), except it returns RUBY_Qnil instead of raising exceptions,...
VALUE rb_any_to_s(VALUE obj)
Generates a textual representation of the given object.
VALUE rb_class_new_instance(int argc, const VALUE *argv, VALUE klass)
Allocates, then initialises an instance of the given class.
VALUE rb_cMatch
MatchData class.
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
VALUE rb_class_new_instance_pass_kw(int argc, const VALUE *argv, VALUE klass)
Identical to rb_class_new_instance(), except it passes the passed keywords if any to the #initialize ...
VALUE rb_cRegexp
Regexp class.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_obj_freeze(VALUE obj)
Just calls rb_obj_freeze_inline() inside.
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
static char * rb_enc_left_char_head(const char *s, const char *p, const char *e, rb_encoding *enc)
Queries the left boundary of a character.
int rb_char_to_option_kcode(int c, int *option, int *kcode)
Converts a character option to its encoding.
static int rb_enc_mbmaxlen(rb_encoding *enc)
Queries the maximum number of bytes that the passed encoding needs to represent a character.
VALUE rb_enc_reg_new(const char *ptr, long len, rb_encoding *enc, int opts)
Identical to rb_reg_new(), except it additionally takes an encoding.
int rb_enc_str_coderange(VALUE str)
Scans the passed string to collect its code range.
long rb_memsearch(const void *x, long m, const void *y, long n, rb_encoding *enc)
Looks for the passed string in the passed buffer.
long rb_enc_strlen(const char *head, const char *tail, rb_encoding *enc)
Counts the number of characters of the passed string, according to the passed encoding.
VALUE rb_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *enc)
Identical to rb_str_cat(), except it additionally takes an encoding.
int rb_enc_str_asciionly_p(VALUE str)
Queries if the passed string is "ASCII only".
long rb_str_coderange_scan_restartable(const char *str, const char *end, rb_encoding *enc, int *cr)
Scans the passed string until it finds something odd.
VALUE rb_str_encode(VALUE str, VALUE to, int ecflags, VALUE ecopts)
Converts the contents of the passed string from its encoding to the passed one.
#define RGENGC_WB_PROTECTED_MATCH
This is a compile-time flag to enable/disable write barrier for struct RMatch.
#define RGENGC_WB_PROTECTED_REGEXP
This is a compile-time flag to enable/disable write barrier for struct RRegexp.
VALUE rb_check_array_type(VALUE obj)
Try converting an object to its array representation using its to_ary method, if any.
VALUE rb_ary_new_capa(long capa)
Identical to rb_ary_new(), except it additionally specifies how many rooms of objects it should alloc...
VALUE rb_ary_resize(VALUE ary, long len)
Expands or shrinks the passed array to the passed length.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
VALUE rb_ary_entry(VALUE ary, long off)
Queries an element of an array.
VALUE rb_assoc_new(VALUE car, VALUE cdr)
Identical to rb_ary_new_from_values(), except it expects exactly two parameters.
void rb_ary_store(VALUE ary, long key, VALUE val)
Destructively stores the passed value to the passed array's passed index.
int rb_uv_to_utf8(char buf[6], unsigned long uv)
Encodes a Unicode codepoint into its UTF-8 representation.
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
VALUE rb_backref_get(void)
Queries the last match, or Regexp.last_match, or the $~.
VALUE rb_lastline_get(void)
Queries the last line, or the $_.
void rb_backref_set(VALUE md)
Updates $~.
VALUE rb_range_beg_len(VALUE range, long *begp, long *lenp, long len, int err)
Deconstructs a numerical range.
int rb_reg_backref_number(VALUE match, VALUE backref)
Queries the index of the given named capture.
int rb_reg_options(VALUE re)
Queries the options of the passed regular expression.
VALUE rb_reg_last_match(VALUE md)
This just returns the argument, stringified.
VALUE rb_reg_match(VALUE re, VALUE str)
This is the match operator.
void rb_match_busy(VALUE md)
Asserts that the given MatchData is "occupied".
VALUE rb_reg_nth_match(int n, VALUE md)
Queries the nth captured substring.
VALUE rb_reg_match_post(VALUE md)
The portion of the original string after the given match.
VALUE rb_reg_nth_defined(int n, VALUE md)
Identical to rb_reg_nth_match(), except it just returns Boolean.
VALUE rb_reg_match_pre(VALUE md)
The portion of the original string before the given match.
VALUE rb_reg_new_str(VALUE src, int opts)
Identical to rb_reg_new(), except it takes the expression in Ruby's string instead of C's.
VALUE rb_reg_match_last(VALUE md)
The portion of the original string that captured at the very last.
VALUE rb_reg_match2(VALUE re)
Identical to rb_reg_match(), except it matches against rb_lastline_get() (or, the $_).
VALUE rb_reg_new(const char *src, long len, int opts)
Creates a new Regular expression.
#define rb_hash_uint(h, i)
Just another name of st_hash_uint.
#define rb_hash_end(h)
Just another name of st_hash_end.
VALUE rb_str_append(VALUE dst, VALUE src)
Identical to rb_str_buf_append(), except it converts the right hand side before concatenating.
long rb_str_offset(VALUE str, long pos)
"Inverse" of rb_str_sublen().
VALUE rb_str_subseq(VALUE str, long beg, long len)
Identical to rb_str_substr(), except the numbers are interpreted as byte offsets instead of character...
st_index_t rb_memhash(const void *ptr, long len)
This is a universal hash function.
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
#define rb_str_buf_cat
Just another name of rb_str_cat.
VALUE rb_str_dup(VALUE str)
Duplicates a string.
st_index_t rb_str_hash(VALUE str)
Calculates a hash value of a string.
char * rb_str_subpos(VALUE str, long beg, long *len)
Identical to rb_str_substr(), except it returns a C's string instead of Ruby's.
VALUE rb_str_buf_append(VALUE dst, VALUE src)
Identical to rb_str_cat_cstr(), except it takes Ruby's string instead of C's.
long rb_str_sublen(VALUE str, long pos)
Byte offset to character offset conversion.
VALUE rb_str_equal(VALUE str1, VALUE str2)
Equality of two strings.
st_index_t rb_hash_start(st_index_t i)
Starts a series of hashing.
VALUE rb_str_inspect(VALUE str)
Generates a "readable" version of the receiver.
VALUE rb_str_buf_cat_ascii(VALUE dst, const char *src)
Identical to rb_str_cat_cstr(), except it additionally assumes the source string be a NUL terminated ...
VALUE rb_check_string_type(VALUE obj)
Try converting an object to its stringised representation using its to_str method,...
VALUE rb_str_buf_new(long capa)
Allocates a "string buffer".
VALUE rb_str_length(VALUE)
Identical to rb_str_strlen(), except it returns the value in rb_cInteger.
VALUE rb_str_intern(VALUE str)
Identical to rb_to_symbol(), except it assumes the receiver being an instance of RString.
VALUE rb_class_path(VALUE mod)
Identical to rb_mod_name(), except it returns #<Class: ...> style inspection for anonymous modules.
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
VALUE rb_sym2str(VALUE symbol)
Obtain a frozen string representation of a symbol (not including the leading colon).
int len
Length of the buffer.
long rb_reg_search(VALUE re, VALUE str, long pos, int dir)
Runs the passed regular expression over the passed string.
regex_t * rb_reg_prepare_re(VALUE re, VALUE str)
Exercises various checks and preprocesses so that the given regular expression can be applied to the ...
long rb_reg_adjust_startpos(VALUE re, VALUE str, long pos, int dir)
Tell us if this is a wrong idea, but it seems this function has no usage at all.
OnigPosition rb_reg_onig_match(VALUE re, VALUE str, OnigPosition(*match)(regex_t *reg, VALUE str, struct re_registers *regs, void *args), void *args, struct re_registers *regs)
Runs a regular expression match using function match.
VALUE rb_reg_regcomp(VALUE str)
Creates a new instance of rb_cRegexp.
VALUE rb_reg_quote(VALUE str)
Escapes any characters that would have special meaning in a regular expression.
VALUE rb_reg_regsub(VALUE repl, VALUE src, struct re_registers *regs, VALUE rexp)
Substitution.
int rb_reg_region_copy(struct re_registers *dst, const struct re_registers *src)
Duplicates a match data.
VALUE rb_yield(VALUE val)
Yields the block.
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
#define ALLOCA_N(type, n)
#define MEMZERO(p, type, n)
Handy macro to erase a region of memory.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
void rb_define_virtual_variable(const char *q, type *w, void_type *e)
Define a function-backended global variable.
#define RARRAY_LEN
Just another name of rb_array_len.
#define RARRAY_AREF(a, i)
#define RBASIC(obj)
Convenient casting macro.
#define RMATCH(obj)
Convenient casting macro.
static struct re_registers * RMATCH_REGS(VALUE match)
Queries the raw re_registers.
#define RREGEXP(obj)
Convenient casting macro.
static VALUE RREGEXP_SRC(VALUE rexp)
Convenient getter function.
#define RREGEXP_PTR(obj)
Convenient accessor macro.
static long RREGEXP_SRC_LEN(VALUE rexp)
Convenient getter function.
static char * RREGEXP_SRC_PTR(VALUE rexp)
Convenient getter function.
#define StringValue(v)
Ensures that the parameter object is a String.
static char * RSTRING_END(VALUE str)
Queries the end of the contents pointer of the string.
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Convenient macro to obtain the contents and length at once.
VALUE rb_str_to_str(VALUE obj)
Identical to rb_check_string_type(), except it raises exceptions in case of conversion failures.
#define StringValueCStr(v)
Identical to StringValuePtr, except it additionally checks for the contents for viability as a C stri...
#define RTEST
This is an old name of RB_TEST.
#define _(args)
This was a transition path from K&R to ANSI.
VALUE flags
Per-object flags.
Regular expression execution context.
VALUE regexp
The expression of this match.
VALUE str
The target string that the match was made against.
Ruby's regular expression.
struct RBasic basic
Basic part, including flags and class.
const VALUE src
Source code of this expression.
unsigned long usecnt
Reference count.
struct re_pattern_buffer * ptr
The pattern buffer.
struct rmatch_offset * char_offset
Capture group offsets, in C array.
int char_offset_num_allocated
Number of rmatch_offset that ::rmatch::char_offset holds.
struct re_registers regs
"Registers" of a match.
Represents the region of a capture group.
long beg
Beginning of a group.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
#define SIZEOF_VALUE
Identical to sizeof(VALUE), except it is a macro that can also be used inside of preprocessor directi...
uintptr_t VALUE
Type that represents a Ruby object.
static void Check_Type(VALUE v, enum ruby_value_type t)
Identical to RB_TYPE_P(), except it raises exceptions on predication failure.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.