12#include "ruby/internal/config.h"
19#include "internal/bignum.h"
20#include "internal/encoding.h"
21#include "internal/error.h"
22#include "internal/gc.h"
23#include "internal/hash.h"
24#include "internal/imemo.h"
25#include "internal/re.h"
26#include "internal/string.h"
27#include "internal/object.h"
28#include "internal/ractor.h"
29#include "internal/variable.h"
35#include "ractor_core.h"
54#define KCODE_FIXED FL_USER4
55#define REG_ENCODING_NONE FL_USER6
68#define MATCH_BUSY FL_USER0
72typedef char onig_errmsg_buffer[ONIG_MAX_ERROR_MESSAGE_LEN];
73#define errcpy(err, msg) strlcpy((err), (msg), ONIG_MAX_ERROR_MESSAGE_LEN)
76static const char casetable[] = {
77 '\000',
'\001',
'\002',
'\003',
'\004',
'\005',
'\006',
'\007',
78 '\010',
'\011',
'\012',
'\013',
'\014',
'\015',
'\016',
'\017',
79 '\020',
'\021',
'\022',
'\023',
'\024',
'\025',
'\026',
'\027',
80 '\030',
'\031',
'\032',
'\033',
'\034',
'\035',
'\036',
'\037',
82 '\040',
'\041',
'\042',
'\043',
'\044',
'\045',
'\046',
'\047',
84 '\050',
'\051',
'\052',
'\053',
'\054',
'\055',
'\056',
'\057',
86 '\060',
'\061',
'\062',
'\063',
'\064',
'\065',
'\066',
'\067',
88 '\070',
'\071',
'\072',
'\073',
'\074',
'\075',
'\076',
'\077',
90 '\100',
'\141',
'\142',
'\143',
'\144',
'\145',
'\146',
'\147',
92 '\150',
'\151',
'\152',
'\153',
'\154',
'\155',
'\156',
'\157',
94 '\160',
'\161',
'\162',
'\163',
'\164',
'\165',
'\166',
'\167',
96 '\170',
'\171',
'\172',
'\133',
'\134',
'\135',
'\136',
'\137',
98 '\140',
'\141',
'\142',
'\143',
'\144',
'\145',
'\146',
'\147',
100 '\150',
'\151',
'\152',
'\153',
'\154',
'\155',
'\156',
'\157',
102 '\160',
'\161',
'\162',
'\163',
'\164',
'\165',
'\166',
'\167',
104 '\170',
'\171',
'\172',
'\173',
'\174',
'\175',
'\176',
'\177',
105 '\200',
'\201',
'\202',
'\203',
'\204',
'\205',
'\206',
'\207',
106 '\210',
'\211',
'\212',
'\213',
'\214',
'\215',
'\216',
'\217',
107 '\220',
'\221',
'\222',
'\223',
'\224',
'\225',
'\226',
'\227',
108 '\230',
'\231',
'\232',
'\233',
'\234',
'\235',
'\236',
'\237',
109 '\240',
'\241',
'\242',
'\243',
'\244',
'\245',
'\246',
'\247',
110 '\250',
'\251',
'\252',
'\253',
'\254',
'\255',
'\256',
'\257',
111 '\260',
'\261',
'\262',
'\263',
'\264',
'\265',
'\266',
'\267',
112 '\270',
'\271',
'\272',
'\273',
'\274',
'\275',
'\276',
'\277',
113 '\300',
'\301',
'\302',
'\303',
'\304',
'\305',
'\306',
'\307',
114 '\310',
'\311',
'\312',
'\313',
'\314',
'\315',
'\316',
'\317',
115 '\320',
'\321',
'\322',
'\323',
'\324',
'\325',
'\326',
'\327',
116 '\330',
'\331',
'\332',
'\333',
'\334',
'\335',
'\336',
'\337',
117 '\340',
'\341',
'\342',
'\343',
'\344',
'\345',
'\346',
'\347',
118 '\350',
'\351',
'\352',
'\353',
'\354',
'\355',
'\356',
'\357',
119 '\360',
'\361',
'\362',
'\363',
'\364',
'\365',
'\366',
'\367',
120 '\370',
'\371',
'\372',
'\373',
'\374',
'\375',
'\376',
'\377',
123# error >>> "You lose. You will need a translation table for your character set." <<<
127rb_hrtime_t rb_reg_match_time_limit = 0;
132 const unsigned char *p1 = x, *p2 = y;
136 if ((tmp = casetable[(
unsigned)*p1++] - casetable[(
unsigned)*p2++]))
142#if defined(HAVE_MEMMEM) && !defined(__APPLE__)
144rb_memsearch_ss(
const unsigned char *xs,
rb_len_t m,
const unsigned char *ys,
rb_len_t n)
146 const unsigned char *y;
148 if ((y = memmem(ys, n, xs, m)) != NULL)
155rb_memsearch_ss(
const unsigned char *xs,
rb_len_t m,
const unsigned char *ys,
rb_len_t n)
157 const unsigned char *x = xs, *xe = xs + m;
158 const unsigned char *y = ys, *ye = ys + n;
159#define VALUE_MAX ((VALUE)~(VALUE)0)
163 rb_bug(
"!!too long pattern string!!");
165 if (!(y = memchr(y, *x, n - m + 1)))
169 for (hx = *x++, hy = *y++; x < xe; ++x, ++y) {
189rb_memsearch_qs(
const unsigned char *xs,
rb_len_t m,
const unsigned char *ys,
rb_len_t n)
191 const unsigned char *x = xs, *xe = xs + m;
192 const unsigned char *y = ys;
193 VALUE i, qstable[256];
196 for (i = 0; i < 256; ++i)
199 qstable[*x] = xe - x;
201 for (; y + m <= ys + n; y += *(qstable + y[m])) {
202 if (*xs == *y && memcmp(xs, y, m) == 0)
208static inline unsigned int
209rb_memsearch_qs_utf8_hash(
const unsigned char *x,
const unsigned char *e)
211 register const unsigned int mix = 8353;
212 register unsigned int h = *x;
216 else if (e - x < (h < 0xE0 ? 2 : h < 0xF0 ? 3 : 4)) {
240 return (
unsigned char)h;
244rb_memsearch_qs_utf8(
const unsigned char *xs,
rb_len_t m,
const unsigned char *ys,
rb_len_t n)
246 const unsigned char *x = xs, *xe = xs + m;
247 const unsigned char *y = ys;
248 VALUE i, qstable[512];
251 for (i = 0; i < 512; ++i) {
254 for (; x < xe; ++x) {
255 qstable[rb_memsearch_qs_utf8_hash(x, xe)] = xe - x;
258 for (; y + m <= ys + n; y += qstable[rb_memsearch_qs_utf8_hash(y+m, ys+n)]) {
259 if (*xs == *y && memcmp(xs, y, m) == 0)
266rb_memsearch_with_char_size(
const unsigned char *xs,
rb_len_t m,
const unsigned char *ys,
rb_len_t n,
int char_size)
268 const unsigned char *x = xs, x0 = *xs, *y = ys;
270 for (n -= m; n >= 0; n -= char_size, y += char_size) {
271 if (x0 == *y && memcmp(x+1, y+1, m-1) == 0)
278rb_memsearch_wchar(
const unsigned char *xs,
rb_len_t m,
const unsigned char *ys,
rb_len_t n)
280 return rb_memsearch_with_char_size(xs, m, ys, n, 2);
284rb_memsearch_qchar(
const unsigned char *xs,
rb_len_t m,
const unsigned char *ys,
rb_len_t n)
286 return rb_memsearch_with_char_size(xs, m, ys, n, 4);
292 const unsigned char *x = x0, *y = y0;
294 if (m > n)
return -1;
296 return memcmp(x0, y0, m) == 0 ? 0 : -1;
302 const unsigned char *ys = memchr(y, *x, n);
309 else if (LIKELY(rb_enc_mbminlen(enc) == 1)) {
311 return rb_memsearch_ss(x0, m, y0, n);
314 return rb_memsearch_qs_utf8(x0, m, y0, n);
317 else if (LIKELY(rb_enc_mbminlen(enc) == 2)) {
318 return rb_memsearch_wchar(x0, m, y0, n);
320 else if (LIKELY(rb_enc_mbminlen(enc) == 4)) {
321 return rb_memsearch_qchar(x0, m, y0, n);
323 return rb_memsearch_qs(x0, m, y0, n);
333 val = ONIG_OPTION_IGNORECASE;
336 val = ONIG_OPTION_EXTEND;
339 val = ONIG_OPTION_MULTILINE;
348enum { OPTBUF_SIZE = 4 };
351option_to_str(
char str[OPTBUF_SIZE],
int options)
354 if (options & ONIG_OPTION_MULTILINE) *p++ =
'm';
355 if (options & ONIG_OPTION_IGNORECASE) *p++ =
'i';
356 if (options & ONIG_OPTION_EXTEND) *p++ =
'x';
369 return (*option = ARG_ENCODING_NONE);
371 *kcode = ENCINDEX_EUC_JP;
374 *kcode = ENCINDEX_Windows_31J;
381 return (*option = char_to_option(c));
383 *option = ARG_ENCODING_FIXED;
388reg_initialized_p(
VALUE re)
394rb_reg_check(
VALUE re)
396 if (!reg_initialized_p(re)) {
403 rb_encoding *enc, rb_encoding *resenc,
int term)
405 const char *p, *pend;
410 p = s; pend = p +
len;
411 rb_str_coderange_scan_restartable(p, pend, enc, &cr);
414 c = rb_enc_ascget(p, pend, &clen, enc);
417 p += mbclen(p, pend, enc);
441 int unicode_p = rb_enc_unicode_p(enc);
444 c = rb_enc_ascget(p, pend, &clen, enc);
445 if (c ==
'\\' && p+clen < pend) {
446 int n = clen + mbclen(p+clen, pend, enc);
452 clen = rb_enc_precise_mbclen(p, pend, enc);
454 c = (
unsigned char)*p;
459 unsigned int c = rb_enc_mbc_to_codepoint(p, pend, enc);
460 rb_str_buf_cat_escaped_char(str, c, unicode_p);
467 else if (c == term) {
475 else if (!rb_enc_isspace(c, enc)) {
479 snprintf(b,
sizeof(b),
"\\x%02X", c);
493 rb_encoding *enc = rb_enc_get(re);
498 if (re && rb_enc_asciicompat(enc)) {
499 rb_enc_copy(str, re);
506 rb_reg_expr_str(str, RSTRING_PTR(src_str), RSTRING_LEN(src_str), enc, resenc,
'/');
511 char opts[OPTBUF_SIZE];
513 if (*option_to_str(opts,
RREGEXP_PTR(re)->options))
515 if (
RBASIC(re)->flags & REG_ENCODING_NONE)
541rb_reg_source(
VALUE re)
562rb_reg_inspect(
VALUE re)
564 if (!reg_initialized_p(re)) {
567 return rb_reg_desc(re);
570static VALUE rb_reg_str_with_term(
VALUE re,
int term);
602 return rb_reg_str_with_term(re,
'/');
606rb_reg_preprocess(
const char *p,
const char *end, rb_encoding *enc,
607 rb_encoding **fixed_enc, onig_errmsg_buffer err,
int options);
610rb_reg_str_with_term(
VALUE re,
int term)
613 const int embeddable = ONIG_OPTION_MULTILINE|ONIG_OPTION_IGNORECASE|ONIG_OPTION_EXTEND;
615 char optbuf[OPTBUF_SIZE + 1];
616 rb_encoding *enc = rb_enc_get(re);
620 rb_enc_copy(str, re);
623 const UChar *ptr = (UChar *)RSTRING_PTR(src_str);
626 if (
len >= 4 && ptr[0] ==
'(' && ptr[1] ==
'?' && rb_enc_asciicompat(enc)) {
629 if ((
len -= 2) > 0) {
631 opt = char_to_option((
int )*ptr);
641 if (
len > 1 && *ptr ==
'-') {
645 opt = char_to_option((
int )*ptr);
660 if (*ptr ==
':' && ptr[
len-1] ==
')') {
663 rb_encoding *fixed_enc = 0;
664 onig_errmsg_buffer errmsg =
"";
669 unescaped = rb_reg_preprocess((
const char *)ptr, (
const char *)ptr +
len,
670 enc, &fixed_enc, errmsg, options);
671 if (!
NIL_P(unescaped) && (!fixed_enc || fixed_enc == enc)) {
673 err = onig_new(&rp, (UChar *)RSTRING_PTR(unescaped),
675 enc, OnigDefaultSyntax, NULL);
690 if ((options & embeddable) != embeddable) {
692 option_to_str(optbuf + 1, ~options);
697 if (rb_enc_asciicompat(enc)) {
698 rb_reg_expr_str(str, (
char*)ptr,
len, enc, NULL, term);
710 s = RSTRING_PTR(str);
716 rb_str_resize(str, RSTRING_LEN(str) - n);
718 rb_reg_expr_str(str, (
char*)ptr,
len, enc, NULL, term);
721 rb_enc_copy(str, re);
728NORETURN(
static void rb_reg_raise(
const char *err,
VALUE re));
731rb_reg_raise(
const char *err,
VALUE re)
733 VALUE desc = rb_reg_desc(re);
739rb_enc_reg_error_desc(
const char *s,
rb_len_t len, rb_encoding *enc,
int options,
const char *err)
741 char opts[OPTBUF_SIZE + 1];
746 rb_enc_associate(desc, enc);
748 rb_reg_expr_str(desc, s,
len, enc, resenc,
'/');
750 option_to_str(opts + 1, options);
755NORETURN(
static void rb_enc_reg_raise(
const char *s,
rb_len_t len, rb_encoding *enc,
int options,
const char *err));
758rb_enc_reg_raise(
const char *s,
rb_len_t len, rb_encoding *enc,
int options,
const char *err)
764rb_reg_error_desc(
VALUE str,
int options,
const char *err)
766 return rb_enc_reg_error_desc(RSTRING_PTR(str), RSTRING_LEN(str),
767 rb_enc_get(str), options, err);
770NORETURN(
static void rb_reg_raise_str(
VALUE str,
int options,
const char *err));
773rb_reg_raise_str(
VALUE str,
int options,
const char *err)
793rb_reg_casefold_p(
VALUE re)
796 return RBOOL(
RREGEXP_PTR(re)->options & ONIG_OPTION_IGNORECASE);
838rb_reg_options_m(
VALUE re)
845reg_names_iter(
const OnigUChar *name,
const OnigUChar *name_end,
846 int back_num,
int *back_refs, OnigRegex regex,
void *arg)
849 rb_ary_push(ary, rb_enc_str_new((
const char *)name, name_end-name, regex->enc));
867rb_reg_names(
VALUE re)
872 onig_foreach_name(
RREGEXP_PTR(re), reg_names_iter, (
void*)ary);
877reg_named_captures_iter(
const OnigUChar *name,
const OnigUChar *name_end,
878 int back_num,
int *back_refs, OnigRegex regex,
void *arg)
884 for (i = 0; i < back_num; i++)
887 rb_hash_aset(hash,
rb_str_new((
const char*)name, name_end-name),ary);
911rb_reg_named_captures(
VALUE re)
913 regex_t *reg = (rb_reg_check(re),
RREGEXP_PTR(re));
914 VALUE hash = rb_hash_new_capa(onig_number_of_names(reg));
915 onig_foreach_name(reg, reg_named_captures_iter, (
void*)hash);
920onig_new_with_source(regex_t* reg,
const UChar* pattern,
const UChar* pattern_end,
921 OnigOptionType option, OnigEncoding enc,
const OnigSyntaxType* syntax,
922 OnigErrorInfo* einfo,
const char *sourcefile,
int sourceline)
926 if (IS_NULL(reg))
return ONIGERR_MEMORY;
928 r = onig_reg_init(reg, option, ONIGENC_CASE_FOLD_DEFAULT, enc, syntax);
931 r = onig_compile_ruby(reg, pattern, pattern_end, einfo, sourcefile, sourceline);
940make_regexp(
Regexp *rp,
const char *s,
rb_len_t len, rb_encoding *enc,
int flags, onig_errmsg_buffer err,
941 const char *sourcefile,
int sourceline)
953 r = onig_new_with_source(rp, (UChar*)s, (UChar*)(s +
len), flags,
954 enc, OnigDefaultSyntax, &einfo, sourcefile, sourceline);
956 onig_error_code_to_str((UChar*)err, r, &einfo);
1120match_alloc_n(
VALUE klass,
int num_regs)
1122 int capa = num_regs * 2;
1123 size_t alloc_size = offsetof(
struct RMatch, as) +
sizeof(OnigPosition) *
capa;
1124 if (alloc_size <
sizeof(
struct RMatch)) {
1125 alloc_size =
sizeof(
struct RMatch);
1129 if (!rb_gc_size_allocatable_p(alloc_size)) {
1130 alloc_size =
sizeof(
struct RMatch);
1131 flags |= RMATCH_ONIG;
1135 NEWOBJ_OF(match,
struct RMatch, klass, flags, alloc_size);
1136 memset(((
char *)match) +
sizeof(
struct RBasic), 0, alloc_size -
sizeof(
struct RBasic));
1138 return (
VALUE)match;
1142match_alloc(
VALUE klass)
1144 return match_alloc_n(klass, 0);
1150 onig_region_copy(to, (OnigRegion *)from);
1151 if (to->allocated)
return 0;
1153 onig_region_copy(to, (OnigRegion *)from);
1154 if (to->allocated)
return 0;
1155 return ONIGERR_MEMORY;
1159match_to_onig(
VALUE match,
int num_regs,
const OnigPosition *src_beg,
const OnigPosition *src_end)
1163 if (onig_region_resize(&tmp, num_regs)) {
1166 memcpy(tmp.beg, src_beg, num_regs *
sizeof(OnigPosition));
1167 memcpy(tmp.end, src_end, num_regs *
sizeof(OnigPosition));
1173rb_match_ensure_onig(
VALUE match)
1178 match_to_onig(match, n, &rm->
as.embed[0], &rm->
as.embed[n]);
1185match_set_regs(
VALUE match,
int num_regs,
const OnigPosition *beg,
const OnigPosition *end)
1190 if (onig_region_resize(&rm->
as.onig,
num_regs)) {
1193 memcpy(rm->
as.onig.beg, beg,
num_regs *
sizeof(OnigPosition));
1194 memcpy(rm->
as.onig.end, end,
num_regs *
sizeof(OnigPosition));
1197 memcpy(&rm->
as.embed[0], beg,
num_regs *
sizeof(OnigPosition));
1201 match_to_onig(match,
num_regs, beg, end);
1210rb_match_blob_dump(
VALUE match,
VALUE *regexp_out,
VALUE *str_out,
int *num_regs_out,
bool release_source)
1214 *regexp_out = rm->
regexp;
1218 OnigPosition *blob =
ALLOC_N(OnigPosition, n ? 2 * n : 1);
1219 const OnigPosition *beg = RMATCH_BEG_PTR(match);
1220 const OnigPosition *end = RMATCH_END_PTR(match);
1221 for (
int i = 0; i < n; i++) {
1222 blob[2 * i] = beg[i];
1223 blob[2 * i + 1] = end[i];
1227 if (release_source) {
1229 onig_region_free(&rm->
as.onig, 0);
1230 memset(&rm->
as.onig, 0,
sizeof(rm->
as.onig));
1245 return match_alloc_n(klass,
num_regs);
1251 const OnigPosition *blob = blob_;
1258 for (
int i = 0; i <
num_regs; i++) {
1259 beg[i] = blob[2 * i];
1260 end[i] = blob[2 * i + 1];
1262 match_set_regs(match,
num_regs, beg, end);
1268rb_match_blob_free(
void *blob)
1279pair_byte_cmp(
const void *pair1,
const void *pair2)
1282#if SIZEOF_RB_LEN_T > SIZEOF_INT
1283 return diff ? diff > 0 ? 1 : -1 : 0;
1290update_char_offset(
VALUE match)
1323 if (RMATCH_BEG(match, i) < 0)
1325 pairs[num_pos++].byte_pos = RMATCH_BEG(match, i);
1326 pairs[num_pos++].byte_pos = RMATCH_END(match, i);
1328 qsort(pairs, num_pos,
sizeof(
pair_t), pair_byte_cmp);
1330 s = p = RSTRING_PTR(
RMATCH(match)->
str);
1332 for (i = 0; i < num_pos; i++) {
1333 q = s + pairs[i].byte_pos;
1335 pairs[i].char_pos = c;
1341 if (RMATCH_BEG(match, i) < 0) {
1347 key.byte_pos = RMATCH_BEG(match, i);
1348 found = bsearch(&key, pairs, num_pos,
sizeof(
pair_t), pair_byte_cmp);
1351 key.byte_pos = RMATCH_END(match, i);
1352 found = bsearch(&key, pairs, num_pos,
sizeof(
pair_t), pair_byte_cmp);
1360match_check(
VALUE match)
1379 match_set_regs(obj, RMATCH_NREGS(orig), RMATCH_BEG_PTR(orig), RMATCH_END_PTR(orig));
1415match_regexp(
VALUE match)
1446match_names(
VALUE match)
1472match_size(
VALUE match)
1475 return INT2FIX(RMATCH_NREGS(match));
1478static int match_name_to_backref_number(
VALUE match,
VALUE name);
1479NORETURN(
static void name_to_backref_error(
VALUE name));
1482name_to_backref_error(
VALUE name)
1484 rb_raise(
rb_eIndexError,
"undefined group name reference: % "PRIsVALUE,
1489backref_number_check(
VALUE match,
int i)
1491 if (i < 0 || RMATCH_NREGS(match) <= i)
1496match_backref_number(
VALUE match,
VALUE backref)
1508 num = match_name_to_backref_number(match, backref);
1511 name_to_backref_error(backref);
1520 return match_backref_number(match, backref);
1574 int i = match_backref_number(match, n);
1577 backref_number_check(match, i);
1579 if (RMATCH_BEG(match, i) < 0)
1582 update_char_offset(match);
1635 int i = match_backref_number(match, n);
1638 backref_number_check(match, i);
1640 if (RMATCH_BEG(match, i) < 0)
1694 int i = match_backref_number(match, n);
1697 backref_number_check(match, i);
1699 if (RMATCH_BEG(match, i) < 0)
1701 return LEN2NUM(RMATCH_BEG(match, i));
1754 int i = match_backref_number(match, n);
1757 backref_number_check(match, i);
1759 if (RMATCH_BEG(match, i) < 0)
1761 return LEN2NUM(RMATCH_END(match, i));
1813 int i = match_backref_number(match, n);
1816 backref_number_check(match, i);
1818 if (RMATCH_BEG(match, i) < 0)
1821 update_char_offset(match);
1873 int i = match_backref_number(match, n);
1876 backref_number_check(match, i);
1878 if (RMATCH_BEG(match, i) < 0)
1881 update_char_offset(match);
1956 int i = match_backref_number(match, n);
1958 backref_number_check(match, i);
1960 rb_len_t start = RMATCH_BEG(match, i), end = RMATCH_END(match, i);
2017 int i = match_backref_number(match, n);
2020 backref_number_check(match, i);
2022 if (RMATCH_BEG(match, i) < 0)
2025 update_char_offset(match);
2027 &
RMATCH(match)->char_offset[i];
2034 FL_SET(match, MATCH_BUSY);
2038rb_match_unbusy(
VALUE match)
2044rb_match_count(
VALUE match)
2046 if (
NIL_P(match))
return -1;
2047 return RMATCH_NREGS(match);
2051match_alloc_or_reuse(
VALUE existing,
int num_regs)
2057 if (!
NIL_P(existing) &&
2059 !
FL_TEST(existing, MATCH_BUSY) &&
2063 return match_alloc_n(
rb_cMatch, num_regs);
2073 OnigPosition beg = pos, end = pos +
len;
2074 match_set_regs(m, 1, &beg, &end);
2081 match_set_string(match,
string, pos,
len);
2116rb_reg_fixed_encoding_p(
VALUE re)
2118 return RBOOL(
FL_TEST(re, KCODE_FIXED));
2127 "incompatible encoding regexp match (%s regexp with %s string)",
2128 rb_enc_inspect_name(rb_enc_get(re)),
2129 rb_enc_inspect_name(rb_enc_get(
str)));
2135 rb_encoding *enc = 0;
2136 int cr = rb_enc_str_coderange(
str);
2139 rb_raise(rb_eArgError,
2140 "invalid byte sequence in %s",
2141 rb_enc_name(rb_enc_get(
str)));
2145 enc = rb_enc_get(
str);
2152 else if (!rb_enc_asciicompat(enc)) {
2153 reg_enc_error(re,
str);
2155 else if (rb_reg_fixed_encoding_p(re)) {
2158 reg_enc_error(re,
str);
2162 else if (warn && (
RBASIC(re)->flags & REG_ENCODING_NONE) &&
2165 rb_warn(
"historical binary regexp match /.../n against %s string",
2174 for (; variant; variant = variant->next) {
2175 if (variant->reg.enc == enc)
return &variant->reg;
2186 rb_encoding *fixed_enc = 0;
2187 rb_encoding *enc = rb_reg_prepare_enc(re,
str, 1);
2190 if (reg->enc == enc)
return reg;
2193 regex_t *cached = reg_find_encoding(head, enc);
2194 if (cached && !caller_owned)
return cached;
2197 const char *pattern = RSTRING_PTR(src_str);
2199 onig_errmsg_buffer err =
"";
2200 unescaped = rb_reg_preprocess(
2201 pattern, pattern + RSTRING_LEN(src_str), enc,
2202 &fixed_enc, err, reg->options);
2204 if (
NIL_P(unescaped)) {
2205 rb_raise(rb_eArgError,
"regexp preprocess failed: %s", err);
2209 rb_hrtime_t timelimit = reg->timelimit;
2216 r = onig_new_without_alloc(&variant->reg, (UChar *)ptr, (UChar *)(ptr +
len),
2217 reg->options, enc, OnigDefaultSyntax, &einfo);
2220 onig_free_body(&variant->reg);
2221 SIZED_FREE(variant);
2222 onig_error_code_to_str((UChar*)err, r, &einfo);
2223 rb_reg_raise(err, re);
2226 reg = &variant->reg;
2227 reg->timelimit = timelimit;
2229 rb_bug(
"group count mismatch in the recompiled regexp: %d != %d", reg->num_mem,
RREGEXP_PTR(re)->num_mem);
2234 reg = malloc(
sizeof(regex_t));
2236 onig_free_body(&variant->reg);
2237 SIZED_FREE(variant);
2240 *reg = variant->reg;
2241 SIZED_FREE(variant);
2249 variant->next = head;
2251 if (previous == head)
break;
2254 cached = reg_find_encoding(head, enc);
2257 onig_free_body(&variant->reg);
2258 SIZED_FREE(variant);
2275 return reg_prepare_re(re, str,
true);
2280 OnigPosition (*match)(regex_t *reg,
VALUE str,
struct re_registers *regs,
void *args),
2283 regex_t *reg = reg_prepare_re(re, str,
false);
2285 OnigPosition result = match(reg, str, regs, args);
2293 case ONIGERR_TIMEOUT:
2294 rb_raise(rb_eRegexpTimeoutError,
"regexp match timeout");
2296 onig_errmsg_buffer err =
"";
2297 onig_error_code_to_str((UChar*)err, (
int)result);
2298 rb_reg_raise(err, re);
2313 enc = rb_reg_prepare_enc(re, str, 0);
2319 range = RSTRING_LEN(str) - pos;
2322 if (pos > 0 && ONIGENC_MBC_MAXLEN(enc) != 1 && pos < RSTRING_LEN(str)) {
2323 string = (UChar*)RSTRING_PTR(str);
2326 p = onigenc_get_right_adjust_char_head(enc,
string,
string + pos,
string + RSTRING_LEN(str));
2329 p = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc,
string,
string + pos,
string + RSTRING_LEN(str));
2343reg_onig_search(regex_t *reg,
VALUE str,
struct re_registers *regs,
void *args_ptr)
2353 (UChar *)(ptr +
len),
2354 (UChar *)(ptr + args->pos),
2355 (UChar *)(ptr + args->range),
2365 if (pos >
len || pos < 0) {
2372 .range = reverse ? 0 :
len,
2380 int cap = n < ONIG_NREGION ? ONIG_NREGION : n;
2382 OnigPosition *buf =
ALLOCV_N(OnigPosition, regs_buf, (
size_t)cap * 2);
2390 OnigPosition result =
rb_reg_onig_match(re, str, reg_onig_search, &args, ®s);
2392 if (result == ONIG_MISMATCH) {
2395 return ONIG_MISMATCH;
2399 VALUE match = match_alloc_or_reuse(existing, regs.num_regs);
2401 match_set_regs(match, regs.num_regs, regs.beg, regs.end);
2404 if (set_backref_str) {
2418 if (set_match) *set_match = match;
2426 return rb_reg_search_set_match(re, str, pos, reverse, set_backref_str, match);
2432 return rb_reg_search_set_match(re, str, pos, reverse, 1, NULL);
2445 (UChar *)(ptr +
len),
2457 int cap = n < ONIG_NREGION ? ONIG_NREGION : n;
2459 OnigPosition *buf =
ALLOCV_N(OnigPosition, regs_buf, (
size_t)cap * 2);
2474 match_set_regs(match, regs.num_regs, regs.beg, regs.end);
2489 int num_regs = RMATCH_NREGS(match);
2490 if (nth >= num_regs) {
2495 if (nth <= 0)
return Qnil;
2497 return RBOOL(RMATCH_BEG(match, nth) != -1);
2508 int num_regs = RMATCH_NREGS(match);
2509 if (nth >= num_regs) {
2514 if (nth <= 0)
return Qnil;
2516 start = RMATCH_BEG(match, nth);
2517 if (start == -1)
return Qnil;
2518 end = RMATCH_END(match, nth);
2557 if (RMATCH_BEG(match, 0) == -1)
return Qnil;
2590 if (RMATCH_BEG(match, 0) == -1)
return Qnil;
2591 str =
RMATCH(match)->str;
2592 pos = RMATCH_END(match, 0);
2598match_last_index(
VALUE match)
2602 if (
NIL_P(match))
return -1;
2604 if (RMATCH_BEG(match, 0) == -1)
return -1;
2606 for (i = RMATCH_NREGS(match) - 1; RMATCH_BEG(match, i) == -1 && i > 0; i--)
2614 int i = match_last_index(match);
2615 if (i <= 0)
return Qnil;
2616 rb_len_t start = RMATCH_BEG(match, i);
2621rb_reg_last_defined(
VALUE match)
2623 int i = match_last_index(match);
2624 if (i < 0)
return Qnil;
2629last_match_getter(
ID _x,
VALUE *_y)
2635prematch_getter(
ID _x,
VALUE *_y)
2641postmatch_getter(
ID _x,
VALUE *_y)
2647last_paren_match_getter(
ID _x,
VALUE *_y)
2653match_array(
VALUE match,
int start)
2660 int num_regs = RMATCH_NREGS(match);
2662 target =
RMATCH(match)->str;
2664 for (i = start; i < num_regs; i++) {
2665 rb_len_t beg = RMATCH_BEG(match, i);
2696match_to_a(
VALUE match)
2698 return match_array(match, 0);
2724match_captures(
VALUE match)
2726 return match_array(match, 1);
2730name_to_backref_number(
const struct re_registers *regs,
VALUE regexp,
const char* name,
const char* name_end)
2732 if (
NIL_P(regexp))
return -1;
2733 return onig_name_to_backref_number(
RREGEXP_PTR(regexp),
2734 (
const unsigned char *)name, (
const unsigned char *)name_end, regs);
2737#define NAME_TO_NUMBER(regs, re, name, name_ptr, name_end) \
2739 !rb_enc_compatible(RREGEXP_SRC(re), (name)) ? 0 : \
2740 name_to_backref_number((regs), (re), (name_ptr), (name_end)))
2743match_name_to_backref_number(
VALUE match,
VALUE name)
2746 if (
NIL_P(regexp))
return -1;
2749 int n = onig_name_to_group_numbers(
RREGEXP_PTR(regexp),
2750 (
const unsigned char *)RSTRING_PTR(name),
2752 if (n < 0)
return n;
2753 if (n == 0)
return ONIGERR_PARSER_BUG;
2754 if (n == 1)
return nums[0];
2755 for (
int i = n - 1; i >= 0; i--) {
2756 if (RMATCH_BEG(match, nums[i]) != ONIG_REGION_NOTPOS)
2763namev_to_backref_number(
VALUE match,
VALUE name)
2779 num = match_name_to_backref_number(match, name);
2782 name_to_backref_error(name);
2790 rb_len_t olen = RMATCH_NREGS(match);
2793 if (
len == 0)
return result;
2795 for (j = beg; j < end; j++) {
2798 if (beg +
len > j) {
2808 int num_regs = RMATCH_NREGS(match);
2819 return match_ary_subseq(match, beg,
len, result);
2921match_aref(
int argc,
VALUE *argv,
VALUE match)
2928 if (
NIL_P(length)) {
2933 int num = namev_to_backref_number(match, idx);
2938 return match_ary_aref(match, idx,
Qnil);
2945 rb_len_t num_regs = RMATCH_NREGS(match);
2951 if (beg < 0)
return Qnil;
2953 else if (beg > num_regs) {
2956 if (beg+
len > num_regs) {
2957 len = num_regs - beg;
2959 return match_ary_subseq(match, beg,
len,
Qnil);
3039match_values_at(
int argc,
VALUE *argv,
VALUE match)
3047 for (i=0; i<argc; i++) {
3052 int num = namev_to_backref_number(match, argv[i]);
3057 match_ary_aref(match, argv[i], result);
3084match_to_s(
VALUE match)
3099match_named_captures_iter(
const OnigUChar *name,
const OnigUChar *name_end,
3100 int back_num,
int *back_refs, OnigRegex regex,
void *arg)
3103 VALUE hash = data->hash;
3104 VALUE match = data->match;
3106 VALUE key = rb_enc_str_new((
const char *)name, name_end-name, regex->enc);
3108 if (data->symbolize) {
3117 for (i = 0; i < back_num; i++) {
3120 rb_hash_aset(hash, key, value);
3126 rb_hash_aset(hash, key,
Qnil);
3168match_named_captures(
int argc,
VALUE *argv,
VALUE match)
3177 int symbolize_names = 0;
3182 static ID keyword_ids[1];
3184 VALUE symbolize_names_val;
3186 if (!keyword_ids[0]) {
3189 rb_get_kwargs(opt, keyword_ids, 0, 1, &symbolize_names_val);
3190 if (!UNDEF_P(symbolize_names_val) &&
RTEST(symbolize_names_val)) {
3191 symbolize_names = 1;
3198 onig_foreach_name(
RREGEXP_PTR(
RMATCH(match)->regexp), match_named_captures_iter, &data);
3244match_deconstruct_keys(
VALUE match,
VALUE keys)
3260 onig_foreach_name(
RREGEXP_PTR(
RMATCH(match)->regexp), match_named_captures_iter, &data);
3281 int num = match_name_to_backref_number(match, name);
3313match_string(
VALUE match)
3316 return RMATCH(match)->str;
3325match_inspect_name_iter(
const OnigUChar *name,
const OnigUChar *name_end,
3326 int back_num,
int *back_refs, OnigRegex regex,
void *arg0)
3331 for (i = 0; i < back_num; i++) {
3332 arg[back_refs[i]].name = name;
3333 arg[back_refs[i]].len = name_end - name;
3363match_inspect(
VALUE match)
3368 int num_regs = RMATCH_NREGS(match);
3374 return rb_sprintf(
"#<%"PRIsVALUE
":%p>", cname, (
void*)match);
3376 else if (
NIL_P(regexp)) {
3377 return rb_sprintf(
"#<%"PRIsVALUE
": %"PRIsVALUE
">",
3385 match_inspect_name_iter, names);
3390 for (i = 0; i < num_regs; i++) {
3397 rb_str_catf(str,
"%d", i);
3416read_escaped_byte(
const char **pp,
const char *end, onig_errmsg_buffer err)
3418 const char *p = *pp;
3420 int meta_prefix = 0, ctrl_prefix = 0;
3423 if (p == end || *p++ !=
'\\') {
3424 errcpy(err,
"too short escaped multibyte character");
3430 errcpy(err,
"too short escape sequence");
3434 case '\\': code =
'\\';
break;
3435 case 'n': code =
'\n';
break;
3436 case 't': code =
'\t';
break;
3437 case 'r': code =
'\r';
break;
3438 case 'f': code =
'\f';
break;
3439 case 'v': code =
'\013';
break;
3440 case 'a': code =
'\007';
break;
3441 case 'e': code =
'\033';
break;
3444 case '0':
case '1':
case '2':
case '3':
3445 case '4':
case '5':
case '6':
case '7':
3454 errcpy(err,
"invalid hex escape");
3462 errcpy(err,
"duplicate meta escape");
3466 if (p+1 < end && *p++ ==
'-' && (*p & 0x80) == 0) {
3476 errcpy(err,
"too short meta escape");
3480 if (p == end || *p++ !=
'-') {
3481 errcpy(err,
"too short control escape");
3486 errcpy(err,
"duplicate control escape");
3490 if (p < end && (*p & 0x80) == 0) {
3500 errcpy(err,
"too short control escape");
3504 errcpy(err,
"unexpected escape sequence");
3507 if (code < 0 || 0xff < code) {
3508 errcpy(err,
"invalid escape code");
3522unescape_escaped_nonascii(
const char **pp,
const char *end, rb_encoding *enc,
3523 VALUE buf, rb_encoding **encp, onig_errmsg_buffer err)
3525 const char *p = *pp;
3527 unsigned char *area =
ALLOCA_N(
unsigned char, chmaxlen);
3528 char *chbuf = (
char *)area;
3533 memset(chbuf, 0, chmaxlen);
3535 byte = read_escaped_byte(&p, end, err);
3540 area[chlen++] = byte;
3541 while (chlen < chmaxlen &&
3543 byte = read_escaped_byte(&p, end, err);
3547 area[chlen++] = byte;
3550 l = rb_enc_precise_mbclen(chbuf, chbuf+chlen, enc);
3552 errcpy(err,
"invalid multibyte escape");
3555 if (1 < chlen || (area[0] & 0x80)) {
3560 else if (*encp != enc) {
3561 errcpy(err,
"escaped non ASCII character in UTF-8 regexp");
3567 snprintf(escbuf,
sizeof(escbuf),
"\\x%02X", area[0]&0xff);
3575check_unicode_range(
unsigned long code, onig_errmsg_buffer err)
3577 if ((0xd800 <= code && code <= 0xdfff) ||
3579 errcpy(err,
"invalid Unicode range");
3586append_utf8(
unsigned long uv,
3587 VALUE buf, rb_encoding **encp, onig_errmsg_buffer err)
3589 if (check_unicode_range(uv, err) != 0)
3593 snprintf(escbuf,
sizeof(escbuf),
"\\x%02X", (
int)uv);
3605 errcpy(err,
"UTF-8 character in non UTF-8 regexp");
3613unescape_unicode_list(
const char **pp,
const char *end,
3614 VALUE buf, rb_encoding **encp, onig_errmsg_buffer err)
3616 const char *p = *pp;
3617 int has_unicode = 0;
3621 while (p < end &&
ISSPACE(*p)) p++;
3628 errcpy(err,
"invalid Unicode range");
3632 if (append_utf8(code, buf, encp, err) != 0)
3636 while (p < end &&
ISSPACE(*p)) p++;
3639 if (has_unicode == 0) {
3640 errcpy(err,
"invalid Unicode list");
3650unescape_unicode_bmp(
const char **pp,
const char *end,
3651 VALUE buf, rb_encoding **encp, onig_errmsg_buffer err)
3653 const char *p = *pp;
3658 errcpy(err,
"invalid Unicode escape");
3663 errcpy(err,
"invalid Unicode escape");
3666 if (append_utf8(code, buf, encp, err) != 0)
3673unescape_nonascii0(
const char **pp,
const char *end, rb_encoding *enc,
3674 VALUE buf, rb_encoding **encp,
int *has_property,
3675 onig_errmsg_buffer err,
int options,
int recurse)
3677 const char *p = *pp;
3680 int in_char_class = 0;
3682 int extended_mode = options & ONIG_OPTION_EXTEND;
3686 int chlen = rb_enc_precise_mbclen(p, end, enc);
3689 errcpy(err,
"invalid multibyte character");
3693 if (1 < chlen || (*p & 0x80)) {
3699 else if (*encp != enc) {
3700 errcpy(err,
"non ASCII character in UTF-8 regexp");
3709 errcpy(err,
"too short escape sequence");
3712 chlen = rb_enc_precise_mbclen(p, end, enc);
3714 goto invalid_multibyte;
3723 case '1':
case '2':
case '3':
3724 case '4':
case '5':
case '6':
case '7':
3726 size_t len = end-(p-1), octlen;
3743 if (rb_is_usascii_enc(enc)) {
3744 const char *pbeg = p;
3745 int byte = read_escaped_byte(&p, end, err);
3746 if (
byte == -1)
return -1;
3751 if (unescape_escaped_nonascii(&p, end, enc, buf, encp, err) != 0)
3758 errcpy(err,
"too short escape sequence");
3764 if (unescape_unicode_list(&p, end, buf, encp, err) != 0)
3766 if (p == end || *p++ !=
'}') {
3767 errcpy(err,
"invalid Unicode list");
3774 if (unescape_unicode_bmp(&p, end, buf, encp, err) != 0)
3796 if (extended_mode && !in_char_class) {
3798 while ((p < end) && ((c = *p++) !=
'\n')) {
3813 if (in_char_class) {
3820 if (!in_char_class && recurse) {
3821 if (--parens == 0) {
3828 if (!in_char_class && p + 1 < end && *p ==
'?') {
3829 if (*(p+1) ==
'#') {
3831 const char *orig_p = p;
3834 while (cont && (p < end)) {
3837 if (!(c & 0x80))
break;
3844 chlen = rb_enc_precise_mbclen(p, end, enc);
3846 goto invalid_multibyte;
3870 int local_extend = 0;
3877 for (s = p+1; s < end; s++) {
3880 local_extend = invert ? -1 : 1;
3887 if (local_extend == 0 ||
3888 (local_extend == -1 && !extended_mode) ||
3889 (local_extend == 1 && extended_mode)) {
3896 int local_options = options;
3897 if (local_extend == 1) {
3898 local_options |= ONIG_OPTION_EXTEND;
3901 local_options &= ~ONIG_OPTION_EXTEND;
3905 int ret = unescape_nonascii0(&p, end, enc, buf, encp,
3908 if (ret < 0)
return ret;
3913 extended_mode = local_extend == 1;
3930 else if (!in_char_class && recurse) {
3948unescape_nonascii(
const char *p,
const char *end, rb_encoding *enc,
3949 VALUE buf, rb_encoding **encp,
int *has_property,
3950 onig_errmsg_buffer err,
int options)
3952 return unescape_nonascii0(&p, end, enc, buf, encp, has_property,
3957rb_reg_preprocess(
const char *p,
const char *end, rb_encoding *enc,
3958 rb_encoding **fixed_enc, onig_errmsg_buffer err,
int options)
3961 int has_property = 0;
3965 if (rb_enc_asciicompat(enc))
3969 rb_enc_associate(buf, enc);
3972 if (unescape_nonascii(p, end, enc, buf, fixed_enc, &has_property, err, options) != 0)
3975 if (has_property && !*fixed_enc) {
3980 rb_enc_associate(buf, *fixed_enc);
3987rb_reg_check_preprocess(
VALUE str)
3989 rb_encoding *fixed_enc = 0;
3990 onig_errmsg_buffer err =
"";
3996 p = RSTRING_PTR(str);
3997 end = p + RSTRING_LEN(str);
3998 enc = rb_enc_get(str);
4000 buf = rb_reg_preprocess(p, end, enc, &fixed_enc, err, 0);
4004 return rb_reg_error_desc(str, 0, err);
4010rb_reg_preprocess_dregexp(
VALUE ary,
int options)
4012 rb_encoding *fixed_enc = 0;
4013 rb_encoding *regexp_enc = 0;
4014 onig_errmsg_buffer err =
"";
4020 rb_raise(rb_eArgError,
"no arguments given");
4027 rb_encoding *src_enc;
4029 src_enc = rb_enc_get(str);
4030 if (options & ARG_ENCODING_NONE &&
4031 src_enc != ascii8bit) {
4033 rb_raise(
rb_eRegexpError,
"/.../n has a non escaped non ASCII character in non ASCII-8BIT script");
4035 src_enc = ascii8bit;
4039 p = RSTRING_PTR(str);
4040 end = p + RSTRING_LEN(str);
4042 buf = rb_reg_preprocess(p, end, src_enc, &fixed_enc, err, options);
4045 rb_raise(rb_eArgError,
"%s", err);
4047 if (fixed_enc != 0) {
4048 if (regexp_enc != 0 && regexp_enc != fixed_enc) {
4049 rb_raise(
rb_eRegexpError,
"encoding mismatch in dynamic regexp : %s and %s",
4050 rb_enc_name(regexp_enc), rb_enc_name(fixed_enc));
4052 regexp_enc = fixed_enc;
4061 rb_enc_associate(result, regexp_enc);
4068rb_reg_initialize_check(
VALUE obj)
4070 rb_check_frozen(obj);
4078 int options, onig_errmsg_buffer err,
4079 const char *sourcefile,
int sourceline)
4083 rb_encoding *fixed_enc = 0;
4086 rb_reg_initialize_check(obj);
4088 if (rb_enc_dummy_p(enc)) {
4089 errcpy(err,
"can't make regexp with dummy encoding");
4093 unescaped = rb_reg_preprocess(s, s+
len, enc, &fixed_enc, err, options);
4094 if (
NIL_P(unescaped))
4098 if ((fixed_enc != enc && (options & ARG_ENCODING_FIXED)) ||
4099 (fixed_enc != a_enc && (options & ARG_ENCODING_NONE))) {
4100 errcpy(err,
"incompatible character encoding");
4103 if (fixed_enc != a_enc) {
4104 options |= ARG_ENCODING_FIXED;
4108 else if (!(options & ARG_ENCODING_FIXED)) {
4113 bool success = make_regexp(®, RSTRING_PTR(unescaped), RSTRING_LEN(unescaped), enc,
4114 options & ARG_REG_OPTION_MASK, err,
4115 sourcefile, sourceline);
4116 if (!success)
return -1;
4118 onig_free_body(®);
4119 rb_reg_initialize_check(obj);
4123 rb_enc_associate((
VALUE)re, enc);
4124 if ((options & ARG_ENCODING_FIXED) || fixed_enc) {
4127 if (options & ARG_ENCODING_NONE) {
4140reg_set_source(
VALUE reg,
VALUE str, rb_encoding *enc)
4142 rb_encoding *regenc = rb_enc_get(reg);
4144 if (regenc != enc) {
4146 str = rb_enc_associate(dup, enc = regenc);
4148 str = rb_fstring(str);
4153rb_reg_initialize_str(
VALUE obj,
VALUE str,
int options, onig_errmsg_buffer err,
4154 const char *sourcefile,
int sourceline)
4157 rb_encoding *str_enc = rb_enc_get(str), *enc = str_enc;
4158 if (options & ARG_ENCODING_NONE) {
4160 if (enc != ascii8bit) {
4162 errcpy(err,
"/.../n has a non escaped non ASCII character in non ASCII-8BIT script");
4168 ret = rb_reg_initialize(obj, RSTRING_PTR(str), RSTRING_LEN(str), enc,
4169 options, err, sourcefile, sourceline);
4170 if (ret == 0) reg_set_source(obj, str, str_enc);
4175rb_reg_s_alloc(
VALUE klass)
4195 return rb_reg_init_str(rb_reg_alloc(), s, options);
4199rb_reg_init_str(
VALUE re,
VALUE s,
int options)
4201 onig_errmsg_buffer err =
"";
4203 if (rb_reg_initialize_str(re, s, options, err, NULL, 0) != 0) {
4204 rb_reg_raise_str(s, options, err);
4211rb_reg_init_str_enc(
VALUE re,
VALUE s, rb_encoding *enc,
int options)
4213 onig_errmsg_buffer err =
"";
4215 if (rb_reg_initialize(re, RSTRING_PTR(s), RSTRING_LEN(s),
4216 enc, options, err, NULL, 0) != 0) {
4217 rb_reg_raise_str(s, options, err);
4219 reg_set_source(re, s, enc);
4225rb_reg_new_from_values(
rb_len_t cnt,
const VALUE *elements,
int opt)
4227 const VALUE ary = rb_ary_tmp_new_from_values(0, cnt, elements);
4236 VALUE re = rb_reg_alloc();
4237 onig_errmsg_buffer err =
"";
4239 if (rb_reg_initialize(re, s,
len, enc, options, err, NULL, 0) != 0) {
4240 rb_enc_reg_raise(s,
len, enc, options, err);
4254rb_reg_compile(
VALUE str,
int options,
const char *sourcefile,
int sourceline)
4256 VALUE re = rb_reg_alloc();
4257 onig_errmsg_buffer err =
"";
4260 if (rb_reg_initialize_str(re, str, options, err, sourcefile, sourceline) != 0) {
4261 rb_set_errinfo(rb_reg_error_desc(str, options, err));
4267static VALUE reg_cache;
4272 if (rb_ractor_main_p()) {
4275 && memcmp(
RREGEXP_SRC_PTR(reg_cache), RSTRING_PTR(str), RSTRING_LEN(str)) == 0)
4285static st_index_t reg_hash(
VALUE re);
4297rb_reg_hash(
VALUE re)
4299 st_index_t hashval = reg_hash(re);
4332 if (re1 == re2)
return Qtrue;
4334 rb_reg_check(re1); rb_reg_check(re2);
4364match_hash(
VALUE match)
4370 hashval =
rb_hash_uint(hashval, reg_hash(match_regexp(match)));
4371 int num_regs = RMATCH_NREGS(match);
4406 if (match1 == match2)
return Qtrue;
4410 if (!rb_reg_equal(match_regexp(match1), match_regexp(match2)))
return Qfalse;
4411 int num_regs = RMATCH_NREGS(match1);
4412 if (num_regs != RMATCH_NREGS(match2))
return Qfalse;
4413 if (memcmp(RMATCH_BEG_PTR(match1), RMATCH_BEG_PTR(match2), num_regs *
sizeof(OnigPosition)))
return Qfalse;
4414 if (memcmp(RMATCH_END_PTR(match1), RMATCH_END_PTR(match2), num_regs *
sizeof(OnigPosition)))
return Qfalse;
4473match_integer_at(
int argc,
VALUE *argv,
VALUE match)
4485 else if ((nth = namev_to_backref_number(match, idx)) < 0) {
4486 name_to_backref_error(idx);
4489 if (argc > 1 && (base =
NUM2INT(argv[1])) < 0) {
4490 rb_raise(rb_eArgError,
"invalid radix %d", base);
4493 if (nth >= RMATCH_NREGS(match))
return Qnil;
4494 if (nth < 0 && (nth += RMATCH_NREGS(match)) <= 0)
return Qnil;
4496 rb_len_t start = RMATCH_BEG(match, nth), end = RMATCH_END(match, nth);
4497 if (start < 0)
return Qnil;
4498 RUBY_ASSERT(start <= end, "%"PRIdLEN" > %
"PRIdLEN, start, end);
4500 VALUE str = RMATCH(match)->str;
4501 RUBY_ASSERT(end <= RSTRING_LEN(str), "%
"PRIdLEN" > %
"PRIdLEN, end, RSTRING_LEN(str));
4504 return rb_int_parse_cstr(RSTRING_PTR(str) + start, end - start, &endp, NULL,
4505 base, RB_INT_PARSE_DEFAULT);
4509reg_operand(VALUE s, int check)
4512 return rb_sym2str(s);
4514 else if (RB_TYPE_P(s, T_STRING)) {
4518 return check ? rb_str_to_str(s) : rb_check_string_type(s);
4523reg_match_pos(VALUE re, VALUE *strp, rb_len_t pos, VALUE* set_match)
4528 rb_backref_set(Qnil);
4531 *strp = str = reg_operand(str, TRUE);
4534 VALUE l = rb_str_length(str);
4537 rb_backref_set(Qnil);
4541 pos = rb_str_offset(str, pos);
4543 return rb_reg_search_set_match(re, str, pos, 0, 1, set_match);
4548 * self =~ other -> integer or nil
4550 * Returns the integer index (in characters) of the first match
4551 * for +self+ and +other+, or +nil+ if none;
4552 * updates {Regexp-related global variables}[rdoc-ref:Regexp@Global+Variables].
4554 * /at/ =~ 'input data' # => 7
4555 * $~ # => #<MatchData "at
">
4556 * /ax/ =~ 'input data' # => nil
4559 * Assigns named captures to local variables of the same names
4560 * if and only if +self+:
4562 * - Is a regexp literal;
4563 * see {Regexp Literals}[rdoc-ref:syntax/literals.rdoc@Regexp+Literals].
4564 * - Does not contain interpolations;
4565 * see {Regexp interpolation}[rdoc-ref:Regexp@Interpolation+Mode].
4566 * - Is at the left of the expression.
4570 * /(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ ' x = y '
4574 * Assigns +nil+ if not matched:
4576 * /(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ ' x = '
4580 * Does not make local variable assignments if +self+ is not a regexp literal:
4582 * r = /(?<foo>\w+)\s*=\s*(?<foo>\w+)/
4584 * p foo # Undefined local variable
4585 * p bar # Undefined local variable
4587 * The assignment does not occur if the regexp is not at the left:
4589 * ' x = y ' =~ /(?<foo>\w+)\s*=\s*(?<foo>\w+)/
4590 * p foo, foo # Undefined local variables
4592 * A regexp interpolation, <tt>#{}</tt>, also disables
4596 * /(?<foo>\w+)\s*=\s*#{r}/ =~ 'x = y'
4597 * p foo # Undefined local variable
4602rb_reg_match(VALUE re, VALUE str)
4604 rb_len_t pos = reg_match_pos(re, &str, 0, NULL);
4605 if (pos < 0) return Qnil;
4606 pos = rb_str_sublen(str, pos);
4607 return LEN2NUM(pos);
4612 * self === other -> true or false
4614 * Returns whether +self+ finds a match in +other+:
4616 * /^[a-z]*$/ === 'HELLO' # => false
4617 * /^[A-Z]*$/ === 'HELLO' # => true
4619 * This method is called in case statements:
4623 * when /\A[a-z]*\z/; print "Lower
case\n
"
4624 * when /\A[A-Z]*\z/; print "Upper
case\n
"
4625 * else print "Mixed
case\n
"
4626 * end # => "Upper
case"
4631rb_reg_eqq(VALUE re, VALUE str)
4635 str = reg_operand(str, FALSE);
4637 rb_backref_set(Qnil);
4640 start = rb_reg_search(re, str, 0, 0);
4641 return RBOOL(start >= 0);
4647 * ~ rxp -> integer or nil
4649 * Equivalent to <tt><i>rxp</i> =~ $_</tt>:
4657rb_reg_match2(VALUE re)
4660 VALUE line = rb_lastline_get();
4662 if (!RB_TYPE_P(line, T_STRING)) {
4663 rb_backref_set(Qnil);
4667 start = rb_reg_search(re, line, 0, 0);
4671 start = rb_str_sublen(line, start);
4672 return LEN2NUM(start);
4678 * match(string, offset = 0) -> matchdata or nil
4679 * match(string, offset = 0) {|matchdata| ... } -> object
4681 * With no block given, returns the MatchData object
4682 * that describes the match, if any, or +nil+ if none;
4683 * the search begins at the given character +offset+ in +string+:
4685 * /abra/.match('abracadabra') # => #<MatchData "abra
">
4686 * /abra/.match('abracadabra', 4) # => #<MatchData "abra
">
4687 * /abra/.match('abracadabra', 8) # => nil
4688 * /abra/.match('abracadabra', 800) # => nil
4690 * string = "\u{5d0 5d1 5e8 5d0}cadabra
"
4691 * /abra/.match(string, 7) #=> #<MatchData "abra
">
4692 * /abra/.match(string, 8) #=> nil
4693 * /abra/.match(string.b, 8) #=> #<MatchData "abra
">
4695 * With a block given, calls the block if and only if a match is found;
4696 * returns the block's value:
4698 * /abra/.match('abracadabra') {|matchdata| p matchdata }
4699 * # => #<MatchData "abra
">
4700 * /abra/.match('abracadabra', 4) {|matchdata| p matchdata }
4701 * # => #<MatchData "abra
">
4702 * /abra/.match('abracadabra', 8) {|matchdata| p matchdata }
4704 * /abra/.match('abracadabra', 8) {|marchdata| fail 'Cannot happen' }
4707 * Output (from the first two blocks above):
4709 * #<MatchData "abra
">
4710 * #<MatchData "abra
">
4712 * /(.)(.)(.)/.match("abc
")[2] # => "b
"
4713 * /(.)(.)/.match("abc
", 1)[2] # => "c
"
4718rb_reg_match_m(int argc, VALUE *argv, VALUE re)
4720 VALUE result = Qnil, str, initpos;
4723 if (rb_scan_args(argc, argv, "11
", &str, &initpos) == 2) {
4724 pos = NUM2LEN(initpos);
4730 pos = reg_match_pos(re, &str, pos, &result);
4734 rb_match_busy(result);
4735 if (!NIL_P(result) && rb_block_given_p()) {
4736 return rb_yield(result);
4743 * match?(string) -> true or false
4744 * match?(string, offset = 0) -> true or false
4746 * Returns <code>true</code> or <code>false</code> to indicate whether the
4747 * regexp is matched or not without updating $~ and other related variables.
4748 * If the second parameter is present, it specifies the position in the string
4749 * to begin the search.
4751 * /R.../.match?("Ruby
") # => true
4752 * /R.../.match?("Ruby
", 1) # => false
4753 * /P.../.match?("Ruby
") # => false
4758rb_reg_match_m_p(int argc, VALUE *argv, VALUE re)
4760 rb_len_t pos = rb_check_arity(argc, 1, 2) > 1 ? NUM2LEN(argv[1]) : 0;
4761 return rb_reg_match_p(re, argv[0], pos);
4765rb_reg_match_p(VALUE re, VALUE str, rb_len_t pos)
4767 if (NIL_P(str)) return Qfalse;
4768 str = SYMBOL_P(str) ? rb_sym2str(str) : StringValue(str);
4771 pos += NUM2LEN(rb_str_length(str));
4772 if (pos < 0) return Qfalse;
4776 const char *beg = rb_str_subpos(str, pos, &len);
4777 if (!beg) return Qfalse;
4778 pos = beg - RSTRING_PTR(str);
4782 struct reg_onig_search_args args = {
4784 .range = RSTRING_LEN(str),
4787 return rb_reg_onig_match(re, str, reg_onig_search, &args, NULL) == ONIG_MISMATCH ? Qfalse : Qtrue;
4791 * Document-method: compile
4793 * Alias for Regexp.new
4797str_to_option(VALUE str)
4802 str = rb_check_string_type(str);
4803 if (NIL_P(str)) return -1;
4804 RSTRING_GETMEM(str, ptr, len);
4805 for (rb_len_t i = 0; i < len; ++i) {
4806 int f = char_to_option(ptr[i]);
4808 rb_raise(rb_eArgError, "unknown regexp option: %
"PRIsVALUE, str);
4816set_timeout(rb_hrtime_t *hrt, VALUE timeout)
4818 double timeout_d = NIL_P(timeout) ? 0.0 : NUM2DBL(timeout);
4819 if (!NIL_P(timeout) && !(timeout_d > 0)) {
4820 rb_raise(rb_eArgError, "invalid timeout: %
"PRIsVALUE, timeout);
4822 double2hrtime(hrt, timeout_d);
4826reg_copy(VALUE copy, VALUE orig)
4829 rb_reg_initialize_check(copy);
4830 if ((r = onig_reg_copy_body(RREGEXP_PTR(copy), RREGEXP_PTR(orig))) != 0) {
4831 /* ONIGERR_MEMORY only */
4832 rb_raise(rb_eRegexpError, "%s
", onig_error_code_to_format(r));
4834 FL_SET_RAW(copy, RREGEXP_INITIALIZED);
4836 RB_OBJ_WRITE(copy, &RREGEXP(copy)->src, RREGEXP(orig)->src);
4837 RREGEXP_PTR(copy)->timelimit = RREGEXP_PTR(orig)->timelimit;
4838 rb_enc_copy(copy, orig);
4839 FL_SET_RAW(copy, FL_TEST_RAW(orig, KCODE_FIXED|REG_ENCODING_NONE));
4840 if (RBASIC_CLASS(copy) == rb_cRegexp) {
4847struct reg_init_args {
4854static VALUE reg_extract_args(int argc, VALUE *argv, struct reg_init_args *args);
4855static VALUE reg_init_args(VALUE self, VALUE str, rb_encoding *enc, int flags);
4859 * Regexp.new(string, options = 0, timeout: nil) -> regexp
4860 * Regexp.new(regexp, timeout: nil) -> regexp
4862 * With argument +string+ given, returns a new regexp with the given string
4865 * r = Regexp.new('foo') # => /foo/
4866 * r.source # => "foo
"
4869 * Passing untrusted input as +string+ is generally not recommended;
4870 * see {Untrusted Patterns}[rdoc-ref:Regexp@Untrusted+Patterns].
4872 * Optional argument +options+ is one of the following:
4874 * - A String of options:
4876 * Regexp.new('foo', 'i') # => /foo/i
4877 * Regexp.new('foo', 'im') # => /foo/im
4879 * - The bit-wise OR of one or more of the constants
4880 * Regexp::EXTENDED, Regexp::IGNORECASE, Regexp::MULTILINE, and
4881 * Regexp::NOENCODING:
4883 * Regexp.new('foo', Regexp::IGNORECASE) # => /foo/i
4884 * Regexp.new('foo', Regexp::EXTENDED) # => /foo/x
4885 * Regexp.new('foo', Regexp::MULTILINE) # => /foo/m
4886 * Regexp.new('foo', Regexp::NOENCODING) # => /foo/n
4887 * flags = Regexp::IGNORECASE | Regexp::EXTENDED | Regexp::MULTILINE
4888 * Regexp.new('foo', flags) # => /foo/mix
4890 * - +nil+ or +false+, which is ignored.
4891 * - Any other truthy value, in which case the regexp will be
4894 * If optional keyword argument +timeout+ is given,
4895 * its float value overrides the timeout interval for the class,
4897 * If +nil+ is passed as +timeout, it uses the timeout interval
4898 * for the class, Regexp.timeout.
4900 * With argument +regexp+ given, returns a new regexp. The source,
4901 * options, timeout are the same as +regexp+. +options+ and +n_flag+
4902 * arguments are ineffective. The timeout can be overridden by
4903 * +timeout+ keyword.
4905 * options = Regexp::MULTILINE
4906 * r = Regexp.new('foo', options, timeout: 1.1) # => /foo/m
4907 * r2 = Regexp.new(r) # => /foo/m
4908 * r2.timeout # => 1.1
4909 * r3 = Regexp.new(r, timeout: 3.14) # => /foo/m
4910 * r3.timeout # => 3.14
4915rb_reg_initialize_m(int argc, VALUE *argv, VALUE self)
4917 struct reg_init_args args;
4918 VALUE re = reg_extract_args(argc, argv, &args);
4921 reg_init_args(self, args.str, args.enc, args.flags);
4927 set_timeout(&RREGEXP_PTR(self)->timelimit, args.timeout);
4928 if (RBASIC_CLASS(self) == rb_cRegexp) {
4936reg_extract_args(int argc, VALUE *argv, struct reg_init_args *args)
4939 rb_encoding *enc = 0;
4940 VALUE str, src, opts = Qundef, kwargs;
4943 rb_scan_args(argc, argv, "11:
", &src, &opts, &kwargs);
4945 args->timeout = Qnil;
4946 if (!NIL_P(kwargs)) {
4947 static ID keywords[1];
4949 keywords[0] = rb_intern_const("timeout
");
4951 rb_get_kwargs(kwargs, keywords, 0, 1, &args->timeout);
4954 if (RB_TYPE_P(src, T_REGEXP)) {
4958 rb_warn("flags ignored
");
4961 flags = rb_reg_options(re);
4962 str = RREGEXP_SRC(re);
4967 if (FIXNUM_P(opts)) flags = FIX2INT(opts);
4968 else if ((f = str_to_option(opts)) >= 0) flags = f;
4969 else if (rb_bool_expected(opts, "ignorecase
", FALSE))
4970 flags = ONIG_OPTION_IGNORECASE;
4972 str = StringValue(src);
4976 args->flags = flags;
4981reg_init_args(VALUE self, VALUE str, rb_encoding *enc, int flags)
4983 if (enc && rb_enc_get(str) != enc)
4984 rb_reg_init_str_enc(self, str, enc, flags);
4986 rb_reg_init_str(self, str, flags);
4991rb_reg_quote(VALUE str)
4993 rb_encoding *enc = rb_enc_get(str);
4997 int ascii_only = rb_enc_str_asciionly_p(str);
4999 s = RSTRING_PTR(str);
5000 send = s + RSTRING_LEN(str);
5002 c = rb_enc_ascget(s, send, &clen, enc);
5004 s += mbclen(s, send, enc);
5008 case '[': case ']': case '{': case '}':
5009 case '(': case ')': case '|': case '-':
5010 case '*': case '.': case '\\':
5011 case '?': case '+': case '^': case '$':
5013 case '\t': case '\f': case '\v': case '\n': case '\r':
5018 tmp = rb_str_new3(str);
5020 rb_enc_associate(tmp, rb_usascii_encoding());
5025 tmp = rb_str_new(0, RSTRING_LEN(str)*2);
5027 rb_enc_associate(tmp, rb_usascii_encoding());
5030 rb_enc_copy(tmp, str);
5032 t = RSTRING_PTR(tmp);
5033 /* copy upto metacharacter */
5034 const char *p = RSTRING_PTR(str);
5035 memcpy(t, p, s - p);
5039 c = rb_enc_ascget(s, send, &clen, enc);
5041 int n = mbclen(s, send, enc);
5049 case '[': case ']': case '{': case '}':
5050 case '(': case ')': case '|': case '-':
5051 case '*': case '.': case '\\':
5052 case '?': case '+': case '^': case '$':
5054 t += rb_enc_mbcput('\\', t, enc);
5057 t += rb_enc_mbcput('\\', t, enc);
5058 t += rb_enc_mbcput(' ', t, enc);
5061 t += rb_enc_mbcput('\\', t, enc);
5062 t += rb_enc_mbcput('t', t, enc);
5065 t += rb_enc_mbcput('\\', t, enc);
5066 t += rb_enc_mbcput('n', t, enc);
5069 t += rb_enc_mbcput('\\', t, enc);
5070 t += rb_enc_mbcput('r', t, enc);
5073 t += rb_enc_mbcput('\\', t, enc);
5074 t += rb_enc_mbcput('f', t, enc);
5077 t += rb_enc_mbcput('\\', t, enc);
5078 t += rb_enc_mbcput('v', t, enc);
5081 t += rb_enc_mbcput(c, t, enc);
5083 rb_str_resize(tmp, t - RSTRING_PTR(tmp));
5090 * Regexp.escape(string) -> new_string
5092 * Returns a new string that escapes any characters
5093 * that have special meaning in a regular expression:
5095 * s = Regexp.escape('\*?{}.') # => "\\\\\\*\\?\\{\\}\\.
"
5097 * For any string +s+, this call returns a MatchData object:
5099 * r = Regexp.new(Regexp.escape(s)) # => /\\\\\\\*\\\?\\\{\\\}\\\./
5100 * r.match(s) # => #<MatchData "\\\\\\*\\?\\{\\}\\.
">
5105rb_reg_s_quote(VALUE c, VALUE str)
5107 return rb_reg_quote(reg_operand(str, TRUE));
5111rb_reg_options(VALUE re)
5116 options = RREGEXP_PTR(re)->options & ARG_REG_OPTION_MASK;
5117 if (RBASIC(re)->flags & KCODE_FIXED) options |= ARG_ENCODING_FIXED;
5118 if (RBASIC(re)->flags & REG_ENCODING_NONE) options |= ARG_ENCODING_NONE;
5123rb_check_regexp_type(VALUE re)
5125 return rb_check_convert_type(re, T_REGEXP, "Regexp
", "to_regexp
");
5130 * Regexp.try_convert(object) -> regexp or nil
5132 * Returns +object+ if it is a regexp:
5134 * Regexp.try_convert(/re/) # => /re/
5136 * Otherwise if +object+ responds to <tt>:to_regexp</tt>,
5137 * calls <tt>object.to_regexp</tt> and returns the result.
5139 * Returns +nil+ if +object+ does not respond to <tt>:to_regexp</tt>.
5141 * Regexp.try_convert('re') # => nil
5143 * Raises an exception unless <tt>object.to_regexp</tt> returns a regexp.
5147rb_reg_s_try_convert(VALUE dummy, VALUE re)
5149 return rb_check_regexp_type(re);
5153rb_reg_s_union(VALUE self, VALUE args0)
5155 rb_len_t argc = RARRAY_LEN(args0);
5159 args[0] = rb_str_new2("(?!)
");
5160 return rb_class_new_instance(1, args, rb_cRegexp);
5162 else if (argc == 1) {
5163 VALUE arg = rb_ary_entry(args0, 0);
5164 VALUE re = rb_check_regexp_type(arg);
5169 quoted = rb_reg_s_quote(Qnil, arg);
5170 return rb_reg_new_str(quoted, 0);
5175 VALUE source = rb_str_buf_new(0);
5176 rb_encoding *result_enc;
5178 int has_asciionly = 0;
5179 rb_encoding *has_ascii_compat_fixed = 0;
5180 rb_encoding *has_ascii_incompat = 0;
5182 for (i = 0; i < argc; i++) {
5184 VALUE e = rb_ary_entry(args0, i);
5187 rb_str_buf_cat_ascii(source, "|
");
5189 v = rb_check_regexp_type(e);
5191 rb_encoding *enc = rb_enc_get(v);
5192 if (!rb_enc_asciicompat(enc)) {
5193 if (!has_ascii_incompat)
5194 has_ascii_incompat = enc;
5195 else if (has_ascii_incompat != enc)
5196 rb_raise(rb_eArgError, "incompatible encodings: %s and %s
",
5197 rb_enc_name(has_ascii_incompat), rb_enc_name(enc));
5199 else if (rb_reg_fixed_encoding_p(v)) {
5200 if (!has_ascii_compat_fixed)
5201 has_ascii_compat_fixed = enc;
5202 else if (has_ascii_compat_fixed != enc)
5203 rb_raise(rb_eArgError, "incompatible encodings: %s and %s
",
5204 rb_enc_name(has_ascii_compat_fixed), rb_enc_name(enc));
5209 v = rb_reg_str_with_term(v, -1);
5214 enc = rb_enc_get(e);
5215 if (!rb_enc_asciicompat(enc)) {
5216 if (!has_ascii_incompat)
5217 has_ascii_incompat = enc;
5218 else if (has_ascii_incompat != enc)
5219 rb_raise(rb_eArgError, "incompatible encodings: %s and %s
",
5220 rb_enc_name(has_ascii_incompat), rb_enc_name(enc));
5222 else if (rb_enc_str_asciionly_p(e)) {
5226 if (!has_ascii_compat_fixed)
5227 has_ascii_compat_fixed = enc;
5228 else if (has_ascii_compat_fixed != enc)
5229 rb_raise(rb_eArgError, "incompatible encodings: %s and %s
",
5230 rb_enc_name(has_ascii_compat_fixed), rb_enc_name(enc));
5232 v = rb_reg_s_quote(Qnil, e);
5234 if (has_ascii_incompat) {
5235 if (has_asciionly) {
5236 rb_raise(rb_eArgError, "ASCII incompatible encoding: %s
",
5237 rb_enc_name(has_ascii_incompat));
5239 if (has_ascii_compat_fixed) {
5240 rb_raise(rb_eArgError, "incompatible encodings: %s and %s
",
5241 rb_enc_name(has_ascii_incompat), rb_enc_name(has_ascii_compat_fixed));
5246 rb_enc_copy(source, v);
5248 rb_str_append(source, v);
5251 if (has_ascii_incompat) {
5252 result_enc = has_ascii_incompat;
5254 else if (has_ascii_compat_fixed) {
5255 result_enc = has_ascii_compat_fixed;
5258 result_enc = rb_ascii8bit_encoding();
5261 rb_enc_associate(source, result_enc);
5262 return rb_class_new_instance(1, &source, rb_cRegexp);
5268 * Regexp.union(*patterns) -> regexp
5269 * Regexp.union(array_of_patterns) -> regexp
5271 * Returns a regexp that is the union of the given patterns:
5273 * r = Regexp.union(%w[cat dog]) # => /cat|dog/
5274 * r.match('cat') # => #<MatchData "cat
">
5275 * r.match('dog') # => #<MatchData "dog
">
5276 * r.match('cog') # => nil
5278 * Each string pattern is escaped so that it is matched literally:
5280 * Regexp.union('penzance') # => /penzance/
5281 * Regexp.union('a+b*c') # => /a\+b\*c/
5282 * Regexp.union('skiing', 'sledding') # => /skiing|sledding/
5283 * Regexp.union(['skiing', 'sledding']) # => /skiing|sledding/
5285 * For each pattern that is a regexp, it is used as is,
5286 * including its flags:
5288 * Regexp.union(/foo/i, /bar/m, /baz/x)
5289 * # => /(?i-mx:foo)|(?m-ix:bar)|(?x-mi:baz)/
5290 * Regexp.union([/foo/i, /bar/m, /baz/x])
5291 * # => /(?i-mx:foo)|(?m-ix:bar)|(?x-mi:baz)/
5293 * With no arguments, returns <tt>/(?!)/</tt>:
5295 * Regexp.union # => /(?!)/
5297 * If any regexp pattern contains captures, the behavior is unspecified.
5301rb_reg_s_union_m(VALUE self, VALUE args)
5304 if (RARRAY_LEN(args) == 1 &&
5305 !NIL_P(v = rb_check_array_type(rb_ary_entry(args, 0)))) {
5306 return rb_reg_s_union(self, v);
5308 return rb_reg_s_union(self, args);
5313 * Regexp.linear_time?(re)
5314 * Regexp.linear_time?(string, options = 0)
5316 * Returns +true+ if matching against <tt>re</tt> can be
5317 * done in linear time to the input string.
5319 * Regexp.linear_time?(/re/) # => true
5321 * Note that this is a property of the ruby interpreter, not of the argument
5322 * regular expression. Identical regexp can or cannot run in linear time
5323 * depending on your ruby binary. Neither forward nor backward compatibility
5324 * is guaranteed about the return value of this method. Our current algorithm
5325 * is (*1) but this is subject to change in the future. Alternative
5326 * implementations can also behave differently. They might always return
5327 * false for everything.
5329 * (*1): https://doi.org/10.1109/SP40001.2021.00032
5333rb_reg_s_linear_time_p(int argc, VALUE *argv, VALUE self)
5335 struct reg_init_args args;
5336 VALUE re = reg_extract_args(argc, argv, &args);
5339 re = reg_init_args(rb_reg_alloc(), args.str, args.enc, args.flags);
5342 return RBOOL(onig_check_linear_time(RREGEXP_PTR(re)));
5347rb_reg_init_copy(VALUE copy, VALUE re)
5349 if (!OBJ_INIT_COPY(copy, re)) return copy;
5351 return reg_copy(copy, re);
5355do_regsub(VALUE str, VALUE src, VALUE regexp, int num_regs, const OnigPosition *beg, const OnigPosition *end)
5360 rb_encoding *str_enc = rb_enc_get(str);
5361 rb_encoding *src_enc = rb_enc_get(src);
5362 int acompat = rb_enc_asciicompat(str_enc);
5364#define ASCGET(s,e,cl) (acompat ? (*(cl)=1,ISASCII((s)[0])?(s)[0]:-1) : rb_enc_ascget((s), (e), (cl), str_enc))
5366 RSTRING_GETMEM(str, s, n);
5371 int c = ASCGET(s, e, &clen);
5375 s += mbclen(s, e, str_enc);
5381 if (c != '\\' || s == e) continue;
5384 val = rb_str_buf_new(ss-p);
5386 rb_enc_str_buf_cat(val, p, ss-p, str_enc);
5388 c = ASCGET(s, e, &clen);
5390 s += mbclen(s, e, str_enc);
5391 rb_enc_str_buf_cat(val, ss, s-ss, str_enc);
5399 case '1': case '2': case '3': case '4':
5400 case '5': case '6': case '7': case '8': case '9':
5401 if (!NIL_P(regexp) && onig_noname_group_capture_is_active(RREGEXP_PTR(regexp))) {
5410 if (s < e && ASCGET(s, e, &clen) == '<') {
5411 char *name, *name_end;
5413 name_end = name = s + clen;
5414 while (name_end < e) {
5415 c = ASCGET(name_end, e, &clen);
5416 if (c == '>') break;
5417 name_end += c == -1 ? mbclen(name_end, e, str_enc) : clen;
5420 VALUE n = rb_str_subseq(str, (rb_len_t)(name - RSTRING_PTR(str)),
5421 (rb_len_t)(name_end - name));
5422 struct re_registers tmp = {
5423 .allocated = num_regs,
5424 .num_regs = num_regs,
5425 .beg = (OnigPosition *)beg,
5426 .end = (OnigPosition *)end,
5428 if ((no = NAME_TO_NUMBER(&tmp, regexp, n, name, name_end)) < 1) {
5429 name_to_backref_error(n);
5431 p = s = name_end + clen;
5435 rb_raise(rb_eRuntimeError, "invalid group name reference format
");
5439 rb_enc_str_buf_cat(val, ss, s-ss, str_enc);
5448 rb_enc_str_buf_cat(val, RSTRING_PTR(src), beg[0], src_enc);
5452 rb_enc_str_buf_cat(val, RSTRING_PTR(src)+end[0], RSTRING_LEN(src)-end[0], src_enc);
5457 while (beg[no] == -1 && no > 0) no--;
5458 if (no == 0) continue;
5462 rb_enc_str_buf_cat(val, s-clen, clen, str_enc);
5466 rb_enc_str_buf_cat(val, ss, s-ss, str_enc);
5471 if (no >= num_regs) continue;
5472 if (beg[no] == -1) continue;
5473 rb_enc_str_buf_cat(val, RSTRING_PTR(src)+beg[no], end[no]-beg[no], src_enc);
5477 if (!val) return str;
5479 rb_enc_str_buf_cat(val, p, e-p, str_enc);
5487rb_reg_regsub(VALUE str, VALUE src, struct re_registers *regs, VALUE regexp)
5489 return do_regsub(str, src, regexp, regs->num_regs, regs->beg, regs->end);
5493rb_reg_regsub_match(VALUE str, VALUE src, VALUE match)
5495 return do_regsub(str, src, RMATCH(match)->regexp,
5496 RMATCH_NREGS(match), RMATCH_BEG_PTR(match), RMATCH_END_PTR(match));
5500ignorecase_getter(ID _x, VALUE *_y)
5502 rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "variable $= is no longer effective
");
5507ignorecase_setter(VALUE val, ID id, VALUE *_)
5509 rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "variable $= is no longer effective; ignored
");
5515 VALUE match = rb_backref_get();
5517 if (NIL_P(match)) return Qnil;
5518 rb_match_busy(match);
5523get_LAST_MATCH_INFO(ID _x, VALUE *_y)
5525 return match_getter();
5529match_setter(VALUE val, ID _x, VALUE *_y)
5532 Check_Type(val, T_MATCH);
5535 rb_backref_set(val);
5540 * Regexp.last_match -> matchdata or nil
5541 * Regexp.last_match(n) -> string or nil
5542 * Regexp.last_match(name) -> string or nil
5544 * With no argument, returns the value of <tt>$~</tt>,
5545 * which is the result of the most recent pattern match
5546 * (see {Regexp global variables}[rdoc-ref:Regexp@Global+Variables]):
5548 * /c(.)t/ =~ 'cat' # => 0
5549 * Regexp.last_match # => #<MatchData "cat
" 1:"a
">
5550 * /a/ =~ 'foo' # => nil
5551 * Regexp.last_match # => nil
5553 * With non-negative integer argument +n+, returns the _n_th field in the
5554 * matchdata, if any, or nil if none:
5556 * /c(.)t/ =~ 'cat' # => 0
5557 * Regexp.last_match(0) # => "cat
"
5558 * Regexp.last_match(1) # => "a
"
5559 * Regexp.last_match(2) # => nil
5561 * With negative integer argument +n+, counts backwards from the last field:
5563 * Regexp.last_match(-1) # => "a
"
5565 * With string or symbol argument +name+,
5566 * returns the string value for the named capture, if any:
5568 * /(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ 'var = val'
5569 * Regexp.last_match # => #<MatchData "var = val
" lhs:"var
"rhs:"val
">
5570 * Regexp.last_match(:lhs) # => "var
"
5571 * Regexp.last_match('rhs') # => "val
"
5572 * Regexp.last_match('foo') # Raises IndexError.
5577rb_reg_s_last_match(int argc, VALUE *argv, VALUE _)
5579 if (rb_check_arity(argc, 0, 1) == 1) {
5580 VALUE match = rb_backref_get();
5582 if (NIL_P(match)) return Qnil;
5583 n = match_backref_number(match, argv[0]);
5584 return rb_reg_nth_match(n, match);
5586 return match_getter();
5590re_warn(const char *s)
5595// This function is periodically called during regexp matching
5597rb_reg_timeout_p(regex_t *reg, void *end_time_)
5599 rb_hrtime_t *end_time = (rb_hrtime_t *)end_time_;
5601 if (*end_time == 0) {
5602 // This is the first time to check interrupts;
5603 // just measure the current time and determine the end time
5604 // if timeout is set.
5605 rb_hrtime_t timelimit = reg->timelimit;
5608 // no per-object timeout.
5609 timelimit = rb_reg_match_time_limit;
5613 *end_time = rb_hrtime_add(timelimit, rb_hrtime_now());
5616 // no timeout is set
5617 *end_time = RB_HRTIME_MAX;
5621 if (*end_time < rb_hrtime_now()) {
5622 // Timeout has exceeded
5632 * Regexp.timeout -> float or nil
5634 * It returns the current default timeout interval for Regexp matching in second.
5635 * +nil+ means no default timeout configuration.
5639rb_reg_s_timeout_get(VALUE dummy)
5641 double d = hrtime2double(rb_reg_match_time_limit);
5642 if (d == 0.0) return Qnil;
5648 * Regexp.timeout = float or nil
5650 * It sets the default timeout interval for Regexp matching in second.
5651 * +nil+ means no default timeout configuration.
5652 * This configuration is process-global. If you want to set timeout for
5653 * each Regexp, use +timeout+ keyword for <code>Regexp.new</code>.
5655 * Regexp.timeout = 1
5656 * /^a*b?a*$/ =~ "a
" * 100000 + "x
" #=> regexp match timeout (RuntimeError)
5660rb_reg_s_timeout_set(VALUE dummy, VALUE timeout)
5662 rb_ractor_ensure_main_ractor("can not access
Regexp.timeout from non-main Ractors
");
5664 set_timeout(&rb_reg_match_time_limit, timeout);
5671 * rxp.timeout -> float or nil
5673 * It returns the timeout interval for Regexp matching in second.
5674 * +nil+ means no default timeout configuration.
5676 * This configuration is per-object. The global configuration set by
5677 * Regexp.timeout= is ignored if per-object configuration is set.
5679 * re = Regexp.new("^a*b?a*$
", timeout: 1)
5680 * re.timeout #=> 1.0
5681 * re =~ "a
" * 100000 + "x
" #=> regexp match timeout (RuntimeError)
5685rb_reg_timeout_get(VALUE re)
5688 double d = hrtime2double(RREGEXP_PTR(re)->timelimit);
5689 if (d == 0.0) return Qnil;
5694 * Document-class: RegexpError
5696 * Raised when given an invalid regexp expression.
5700 * <em>raises the exception:</em>
5702 * RegexpError: target of repeat operator is not specified: /?/
5706 * Document-class: Regexp
5708 * :include: doc/_regexp.rdoc
5714 rb_eRegexpError = rb_define_class("RegexpError
", rb_eStandardError);
5716 onigenc_set_default_encoding(ONIG_ENCODING_ASCII);
5717 onig_set_warn_func(re_warn);
5718 onig_set_verb_warn_func(re_warn);
5720 rb_define_virtual_variable("$~
", get_LAST_MATCH_INFO, match_setter);
5721 rb_define_virtual_variable("$&
", last_match_getter, 0);
5722 rb_define_virtual_variable("$`
", prematch_getter, 0);
5723 rb_define_virtual_variable("$
'", postmatch_getter, 0);
5724 rb_define_virtual_variable("$+", last_paren_match_getter, 0);
5726 rb_gvar_ractor_local("$~");
5727 rb_gvar_ractor_local("$&");
5728 rb_gvar_ractor_local("$`");
5729 rb_gvar_ractor_local("$'");
5730 rb_gvar_ractor_local("$+
");
5731 rb_gvar_box_dynamic("$~
");
5732 rb_gvar_box_ready("$&
");
5733 rb_gvar_box_ready("$`
");
5734 rb_gvar_box_ready("$
'");
5735 rb_gvar_box_ready("$+");
5737 rb_define_virtual_variable("$=", ignorecase_getter, ignorecase_setter);
5739 rb_cRegexp = rb_define_class("Regexp", rb_cObject);
5740 rb_define_alloc_func(rb_cRegexp, rb_reg_s_alloc);
5741 rb_define_singleton_method(rb_cRegexp, "compile", rb_class_new_instance_pass_kw, -1);
5742 rb_define_singleton_method(rb_cRegexp, "quote", rb_reg_s_quote, 1);
5743 rb_define_singleton_method(rb_cRegexp, "escape", rb_reg_s_quote, 1);
5744 rb_define_singleton_method(rb_cRegexp, "union", rb_reg_s_union_m, -2);
5745 rb_define_singleton_method(rb_cRegexp, "last_match", rb_reg_s_last_match, -1);
5746 rb_define_singleton_method(rb_cRegexp, "try_convert", rb_reg_s_try_convert, 1);
5747 rb_define_singleton_method(rb_cRegexp, "linear_time?", rb_reg_s_linear_time_p, -1);
5749 rb_define_method(rb_cRegexp, "initialize", rb_reg_initialize_m, -1);
5750 rb_define_method(rb_cRegexp, "initialize_copy", rb_reg_init_copy, 1);
5751 rb_define_method(rb_cRegexp, "hash", rb_reg_hash, 0);
5752 rb_define_method(rb_cRegexp, "eql?", rb_reg_equal, 1);
5753 rb_define_method(rb_cRegexp, "==", rb_reg_equal, 1);
5754 rb_define_method(rb_cRegexp, "=~", rb_reg_match, 1);
5755 rb_define_method(rb_cRegexp, "===", rb_reg_eqq, 1);
5756 rb_define_method(rb_cRegexp, "~", rb_reg_match2, 0);
5757 rb_define_method(rb_cRegexp, "match", rb_reg_match_m, -1);
5758 rb_define_method(rb_cRegexp, "match?", rb_reg_match_m_p, -1);
5759 rb_define_method(rb_cRegexp, "to_s", rb_reg_to_s, 0);
5760 rb_define_method(rb_cRegexp, "inspect", rb_reg_inspect, 0);
5761 rb_define_method(rb_cRegexp, "source", rb_reg_source, 0);
5762 rb_define_method(rb_cRegexp, "casefold?", rb_reg_casefold_p, 0);
5763 rb_define_method(rb_cRegexp, "options", rb_reg_options_m, 0);
5764 rb_define_method(rb_cRegexp, "encoding", rb_obj_encoding, 0); /* in encoding.c */
5765 rb_define_method(rb_cRegexp, "fixed_encoding?", rb_reg_fixed_encoding_p, 0);
5766 rb_define_method(rb_cRegexp, "names", rb_reg_names, 0);
5767 rb_define_method(rb_cRegexp, "named_captures", rb_reg_named_captures, 0);
5768 rb_define_method(rb_cRegexp, "timeout", rb_reg_timeout_get, 0);
5770 /* Raised when regexp matching timed out. */
5771 rb_eRegexpTimeoutError = rb_define_class_under(rb_cRegexp, "TimeoutError", rb_eRegexpError);
5772 rb_define_singleton_method(rb_cRegexp, "timeout", rb_reg_s_timeout_get, 0);
5773 rb_define_singleton_method(rb_cRegexp, "timeout=", rb_reg_s_timeout_set, 1);
5775 /* see Regexp.options and Regexp.new */
5776 rb_define_const(rb_cRegexp, "IGNORECASE", INT2FIX(ONIG_OPTION_IGNORECASE));
5777 /* see Regexp.options and Regexp.new */
5778 rb_define_const(rb_cRegexp, "EXTENDED", INT2FIX(ONIG_OPTION_EXTEND));
5779 /* see Regexp.options and Regexp.new */
5780 rb_define_const(rb_cRegexp, "MULTILINE", INT2FIX(ONIG_OPTION_MULTILINE));
5781 /* see Regexp.options and Regexp.new */
5782 rb_define_const(rb_cRegexp, "FIXEDENCODING", INT2FIX(ARG_ENCODING_FIXED));
5783 /* see Regexp.options and Regexp.new */
5784 rb_define_const(rb_cRegexp, "NOENCODING", INT2FIX(ARG_ENCODING_NONE));
5786 rb_global_variable(®_cache);
5788 rb_cMatch = rb_define_class("MatchData", rb_cObject);
5789 rb_define_alloc_func(rb_cMatch, match_alloc);
5790 rb_undef_method(CLASS_OF(rb_cMatch), "new");
5791 rb_undef_method(CLASS_OF(rb_cMatch), "allocate");
5793 rb_define_method(rb_cMatch, "initialize_copy", rb_match_init_copy, 1);
5794 rb_define_method(rb_cMatch, "regexp", match_regexp, 0);
5795 rb_define_method(rb_cMatch, "names", match_names, 0);
5796 rb_define_method(rb_cMatch, "size", match_size, 0);
5797 rb_define_method(rb_cMatch, "length", match_size, 0);
5798 rb_define_method(rb_cMatch, "offset", match_offset, 1);
5799 rb_define_method(rb_cMatch, "byteoffset", match_byteoffset, 1);
5800 rb_define_method(rb_cMatch, "bytebegin", match_bytebegin, 1);
5801 rb_define_method(rb_cMatch, "byteend", match_byteend, 1);
5802 rb_define_method(rb_cMatch, "begin", match_begin, 1);
5803 rb_define_method(rb_cMatch, "end", match_end, 1);
5804 rb_define_method(rb_cMatch, "match", match_nth, 1);
5805 rb_define_method(rb_cMatch, "match_length", match_nth_length, 1);
5806 rb_define_method(rb_cMatch, "to_a", match_to_a, 0);
5807 rb_define_method(rb_cMatch, "[]", match_aref, -1);
5808 rb_define_method(rb_cMatch, "captures", match_captures, 0);
5809 rb_define_alias(rb_cMatch, "deconstruct", "captures");
5810 rb_define_method(rb_cMatch, "named_captures", match_named_captures, -1);
5811 rb_define_method(rb_cMatch, "deconstruct_keys", match_deconstruct_keys, 1);
5812 rb_define_method(rb_cMatch, "values_at", match_values_at, -1);
5813 rb_define_method(rb_cMatch, "pre_match", rb_reg_match_pre, 0);
5814 rb_define_method(rb_cMatch, "post_match", rb_reg_match_post, 0);
5815 rb_define_method(rb_cMatch, "to_s", match_to_s, 0);
5816 rb_define_method(rb_cMatch, "inspect", match_inspect, 0);
5817 rb_define_method(rb_cMatch, "string", match_string, 0);
5818 rb_define_method(rb_cMatch, "hash", match_hash, 0);
5819 rb_define_method(rb_cMatch, "eql?", match_equal, 1);
5820 rb_define_method(rb_cMatch, "==", match_equal, 1);
5821 rb_define_method(rb_cMatch, "integer_at", match_integer_at, -1);
#define RUBY_ATOMIC_PTR_LOAD(var)
Identical to RUBY_ATOMIC_LOAD, except it expects its arguments are void*.
#define RUBY_ATOMIC_PTR_CAS(var, oldval, newval)
Identical to RUBY_ATOMIC_CAS, except it expects its arguments are void*.
#define ISSPACE
@old{rb_isspace}
static bool rb_enc_isprint(OnigCodePoint c, rb_encoding *enc)
Identical to rb_isprint(), except it additionally takes an encoding.
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_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
Keyword argument deconstructor.
#define ENC_CODERANGE_7BIT
Old name of RUBY_ENC_CODERANGE_7BIT.
struct re_pattern_buffer Regexp
Old name of re_pattern_buffer.
#define FL_UNSET_RAW
Old name of RB_FL_UNSET_RAW.
#define rb_str_buf_cat2
Old name of rb_usascii_str_new_cstr.
#define OBJ_INIT_COPY(obj, orig)
Old name of RB_OBJ_INIT_COPY.
#define ALLOC
Old name of RB_ALLOC.
#define T_STRING
Old name of RUBY_T_STRING.
#define ENC_CODERANGE_CLEAN_P(cr)
Old name of RB_ENC_CODERANGE_CLEAN_P.
#define INT2FIX
Old name of RB_INT2FIX.
#define OBJ_FROZEN
Old name of RB_OBJ_FROZEN.
#define LEN2NUM
Old name of RB_LEN2NUM.
#define rb_str_buf_new2
Old name of rb_str_buf_new_cstr.
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
#define ENC_CODERANGE_UNKNOWN
Old name of RUBY_ENC_CODERANGE_UNKNOWN.
#define ENCODING_GET(obj)
Old name of RB_ENCODING_GET.
#define FIX2INT
Old name of RB_FIX2INT.
#define ALLOC_N
Old name of RB_ALLOC_N.
#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 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 ALLOCV_N
Old name of RB_ALLOCV_N.
#define MBCLEN_CHARFOUND_P(ret)
Old name of ONIGENC_MBCLEN_CHARFOUND_P.
#define T_SYMBOL
Old name of RUBY_T_SYMBOL.
#define T_MATCH
Old name of RUBY_T_MATCH.
#define FL_TEST
Old name of RB_FL_TEST.
#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 NUM2LEN
Old name of RB_NUM2LEN.
#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 ALLOCV_END
Old name of RB_ALLOCV_END.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
#define T_REGEXP
Old name of RUBY_T_REGEXP.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
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.
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
VALUE rb_eIndexError
IndexError exception.
VALUE rb_obj_reveal(VALUE obj, VALUE klass)
Make a hidden object visible again.
VALUE rb_any_to_s(VALUE obj)
Generates a textual representation of the given object.
VALUE rb_cMatch
MatchData class.
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
VALUE rb_cRegexp
Regexp class.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
rb_encoding * rb_utf8_encoding(void)
Queries the encoding that represents UTF-8.
rb_encoding * rb_ascii8bit_encoding(void)
Queries the encoding that represents ASCII-8BIT a.k.a.
rb_encoding * rb_default_internal_encoding(void)
Queries the "default internal" encoding.
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_utf8_encindex(void)
Identical to rb_utf8_encoding(), except it returns the encoding's index instead of the encoding itsel...
int rb_ascii8bit_encindex(void)
Identical to rb_ascii8bit_encoding(), except it returns the encoding's index instead of the encoding ...
rb_encoding * rb_default_external_encoding(void)
Queries the "default external" encoding.
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.
rb_encoding * rb_usascii_encoding(void)
Queries the encoding that represents US-ASCII.
VALUE rb_enc_reg_new(const char *ptr, rb_len_t len, rb_encoding *enc, int opts)
Identical to rb_reg_new(), except it additionally takes an encoding.
rb_len_t 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.
rb_len_t rb_memsearch(const void *x, rb_len_t m, const void *y, rb_len_t n, rb_encoding *enc)
Looks for the passed string in the passed buffer.
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.
void rb_memerror(void)
Triggers out-of-memory error.
void rb_gc(void)
Triggers a GC process.
VALUE rb_ary_new_capa(rb_len_t capa)
Identical to rb_ary_new(), except it additionally specifies how many rooms of objects it should alloc...
void rb_ary_store(VALUE ary, rb_len_t key, VALUE val)
Destructively stores the passed value to the passed array's passed index.
VALUE rb_ary_resize(VALUE ary, rb_len_t len)
Expands or shrinks the passed array to the passed length.
VALUE rb_ary_clear(VALUE ary)
Destructively removes everything form an array.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
VALUE rb_assoc_new(VALUE car, VALUE cdr)
Identical to rb_ary_new_from_values(), except it expects exactly two parameters.
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_hash_new(void)
Creates a new, empty hash object.
VALUE rb_backref_get(void)
Queries the last match, or Regexp.last_match, or the $~.
void rb_backref_set(VALUE md)
Updates $~.
VALUE rb_range_beg_len(VALUE range, rb_len_t *begp, rb_len_t *lenp, rb_len_t 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.
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_new(const char *src, rb_len_t len, int opts)
Creates a new Regular expression.
VALUE rb_str_subseq(VALUE str, rb_len_t beg, rb_len_t len)
Identical to rb_str_substr(), except the numbers are interpreted as byte offsets instead of character...
#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.
#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.
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.
st_index_t rb_memhash(const void *ptr, rb_len_t len)
This is a universal hash function.
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_new(rb_len_t capa)
Allocates a "string buffer".
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.
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 capa
Designed capacity of the buffer.
int len
Length of the buffer.
rb_len_t rb_reg_search(VALUE re, VALUE str, rb_len_t 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 ...
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.
int rb_reg_region_copy(struct re_registers *dst, const struct re_registers *src)
Duplicates a match data.
rb_len_t rb_reg_adjust_startpos(VALUE re, VALUE str, rb_len_t pos, int dir)
Tell us if this is a wrong idea, but it seems this function has no usage at all.
unsigned long ruby_scan_hex(const char *str, size_t len, size_t *ret)
Interprets the passed string a hexadecimal unsigned integer.
unsigned long ruby_scan_oct(const char *str, size_t len, size_t *consumed)
Interprets the passed string as an octal unsigned integer.
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
#define ALLOCA_N(type, n)
#define RB_ALLOCV_N(type, v, n)
Allocates a memory region, possibly on stack.
#define MEMZERO(p, type, n)
Handy macro to erase a region of memory.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
#define RB_ALLOCV_END(v)
Polite way to declare that the given array is not used any longer.
#define RARRAY_LEN
Just another name of rb_array_len.
#define RARRAY_AREF(a, i)
References an object in an array.
static VALUE RBASIC_CLASS(VALUE obj)
Queries the class of an object.
#define RBASIC(obj)
Convenient casting macro.
#define RMATCH(obj)
Convenient casting macro.
#define RREGEXP(obj)
Convenient casting macro.
static struct re_pattern_buffer * RREGEXP_PTR(VALUE rexp)
Convenient getter function.
static VALUE RREGEXP_SRC(VALUE rexp)
Convenient getter function.
static rb_len_t 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.
#define RTEST
This is an old name of RB_TEST.
#define _(args)
This was a transition path from K&R to ANSI.
Ruby object's base components.
VALUE flags
Per-object flags.
Regular expression execution context.
VALUE regexp
The expression of this match.
struct rmatch_offset * char_offset
Capture group offsets, in C array.
union RMatch::@357327212031205367147161324375004050200256000107 as
"Registers" of a match.
int char_offset_num_allocated
Number of rmatch_offset that rmatch::char_offset holds.
int num_regs
Number of capture-group registers.
int capa
Capacity of as.embed, in OnigPosition slots.
VALUE str
The target string that the match was made against.
Ruby's regular expression.
struct rb_regexp_variant * variants
Compiled variants for other encodings.
struct RBasic basic
Basic part, including flags and class.
const VALUE src
Source code of this expression.
Represents the region of a capture group.
rb_len_t end
End of a group.
rb_len_t beg
Beginning of a group.
long rb_len_t
A signed integer type for lengths and indices of objects such as String and Array.
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.