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] ==
'?') {
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)) {
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)) {
4112 rb_enc_associate((
VALUE)re, enc);
4113 if ((options & ARG_ENCODING_FIXED) || fixed_enc) {
4116 if (options & ARG_ENCODING_NONE) {
4120 bool success = make_regexp(
RREGEXP_PTR(obj), RSTRING_PTR(unescaped), RSTRING_LEN(unescaped), enc,
4121 options & ARG_REG_OPTION_MASK, err,
4122 sourcefile, sourceline);
4123 if (!success)
return -1;
4134reg_set_source(
VALUE reg,
VALUE str, rb_encoding *enc)
4136 rb_encoding *regenc = rb_enc_get(reg);
4138 if (regenc != enc) {
4140 str = rb_enc_associate(dup, enc = regenc);
4142 str = rb_fstring(str);
4147rb_reg_initialize_str(
VALUE obj,
VALUE str,
int options, onig_errmsg_buffer err,
4148 const char *sourcefile,
int sourceline)
4151 rb_encoding *str_enc = rb_enc_get(str), *enc = str_enc;
4152 if (options & ARG_ENCODING_NONE) {
4154 if (enc != ascii8bit) {
4156 errcpy(err,
"/.../n has a non escaped non ASCII character in non ASCII-8BIT script");
4162 ret = rb_reg_initialize(obj, RSTRING_PTR(str), RSTRING_LEN(str), enc,
4163 options, err, sourcefile, sourceline);
4164 if (ret == 0) reg_set_source(obj, str, str_enc);
4169rb_reg_s_alloc(
VALUE klass)
4189 return rb_reg_init_str(rb_reg_alloc(), s, options);
4193rb_reg_init_str(
VALUE re,
VALUE s,
int options)
4195 onig_errmsg_buffer err =
"";
4197 if (rb_reg_initialize_str(re, s, options, err, NULL, 0) != 0) {
4198 rb_reg_raise_str(s, options, err);
4205rb_reg_init_str_enc(
VALUE re,
VALUE s, rb_encoding *enc,
int options)
4207 onig_errmsg_buffer err =
"";
4209 if (rb_reg_initialize(re, RSTRING_PTR(s), RSTRING_LEN(s),
4210 enc, options, err, NULL, 0) != 0) {
4211 rb_reg_raise_str(s, options, err);
4213 reg_set_source(re, s, enc);
4219rb_reg_new_from_values(
rb_len_t cnt,
const VALUE *elements,
int opt)
4221 const VALUE ary = rb_ary_tmp_new_from_values(0, cnt, elements);
4230 VALUE re = rb_reg_alloc();
4231 onig_errmsg_buffer err =
"";
4233 if (rb_reg_initialize(re, s,
len, enc, options, err, NULL, 0) != 0) {
4234 rb_enc_reg_raise(s,
len, enc, options, err);
4248rb_reg_compile(
VALUE str,
int options,
const char *sourcefile,
int sourceline)
4250 VALUE re = rb_reg_alloc();
4251 onig_errmsg_buffer err =
"";
4254 if (rb_reg_initialize_str(re, str, options, err, sourcefile, sourceline) != 0) {
4255 rb_set_errinfo(rb_reg_error_desc(str, options, err));
4261static VALUE reg_cache;
4266 if (rb_ractor_main_p()) {
4269 && memcmp(
RREGEXP_SRC_PTR(reg_cache), RSTRING_PTR(str), RSTRING_LEN(str)) == 0)
4279static st_index_t reg_hash(
VALUE re);
4291rb_reg_hash(
VALUE re)
4293 st_index_t hashval = reg_hash(re);
4326 if (re1 == re2)
return Qtrue;
4328 rb_reg_check(re1); rb_reg_check(re2);
4358match_hash(
VALUE match)
4364 hashval =
rb_hash_uint(hashval, reg_hash(match_regexp(match)));
4365 int num_regs = RMATCH_NREGS(match);
4400 if (match1 == match2)
return Qtrue;
4404 if (!rb_reg_equal(match_regexp(match1), match_regexp(match2)))
return Qfalse;
4405 int num_regs = RMATCH_NREGS(match1);
4406 if (num_regs != RMATCH_NREGS(match2))
return Qfalse;
4407 if (memcmp(RMATCH_BEG_PTR(match1), RMATCH_BEG_PTR(match2), num_regs *
sizeof(OnigPosition)))
return Qfalse;
4408 if (memcmp(RMATCH_END_PTR(match1), RMATCH_END_PTR(match2), num_regs *
sizeof(OnigPosition)))
return Qfalse;
4467match_integer_at(
int argc,
VALUE *argv,
VALUE match)
4479 else if ((nth = namev_to_backref_number(match, idx)) < 0) {
4480 name_to_backref_error(idx);
4483 if (argc > 1 && (base =
NUM2INT(argv[1])) < 0) {
4484 rb_raise(rb_eArgError,
"invalid radix %d", base);
4487 if (nth >= RMATCH_NREGS(match))
return Qnil;
4488 if (nth < 0 && (nth += RMATCH_NREGS(match)) <= 0)
return Qnil;
4490 rb_len_t start = RMATCH_BEG(match, nth), end = RMATCH_END(match, nth);
4491 if (start < 0)
return Qnil;
4492 RUBY_ASSERT(start <= end, "%"PRIdLEN" > %
"PRIdLEN, start, end);
4494 VALUE str = RMATCH(match)->str;
4495 RUBY_ASSERT(end <= RSTRING_LEN(str), "%
"PRIdLEN" > %
"PRIdLEN, end, RSTRING_LEN(str));
4498 return rb_int_parse_cstr(RSTRING_PTR(str) + start, end - start, &endp, NULL,
4499 base, RB_INT_PARSE_DEFAULT);
4503reg_operand(VALUE s, int check)
4506 return rb_sym2str(s);
4508 else if (RB_TYPE_P(s, T_STRING)) {
4512 return check ? rb_str_to_str(s) : rb_check_string_type(s);
4517reg_match_pos(VALUE re, VALUE *strp, rb_len_t pos, VALUE* set_match)
4522 rb_backref_set(Qnil);
4525 *strp = str = reg_operand(str, TRUE);
4528 VALUE l = rb_str_length(str);
4531 rb_backref_set(Qnil);
4535 pos = rb_str_offset(str, pos);
4537 return rb_reg_search_set_match(re, str, pos, 0, 1, set_match);
4542 * self =~ other -> integer or nil
4544 * Returns the integer index (in characters) of the first match
4545 * for +self+ and +other+, or +nil+ if none;
4546 * updates {Regexp-related global variables}[rdoc-ref:Regexp@Global+Variables].
4548 * /at/ =~ 'input data' # => 7
4549 * $~ # => #<MatchData "at
">
4550 * /ax/ =~ 'input data' # => nil
4553 * Assigns named captures to local variables of the same names
4554 * if and only if +self+:
4556 * - Is a regexp literal;
4557 * see {Regexp Literals}[rdoc-ref:syntax/literals.rdoc@Regexp+Literals].
4558 * - Does not contain interpolations;
4559 * see {Regexp interpolation}[rdoc-ref:Regexp@Interpolation+Mode].
4560 * - Is at the left of the expression.
4564 * /(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ ' x = y '
4568 * Assigns +nil+ if not matched:
4570 * /(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ ' x = '
4574 * Does not make local variable assignments if +self+ is not a regexp literal:
4576 * r = /(?<foo>\w+)\s*=\s*(?<foo>\w+)/
4578 * p foo # Undefined local variable
4579 * p bar # Undefined local variable
4581 * The assignment does not occur if the regexp is not at the left:
4583 * ' x = y ' =~ /(?<foo>\w+)\s*=\s*(?<foo>\w+)/
4584 * p foo, foo # Undefined local variables
4586 * A regexp interpolation, <tt>#{}</tt>, also disables
4590 * /(?<foo>\w+)\s*=\s*#{r}/ =~ 'x = y'
4591 * p foo # Undefined local variable
4596rb_reg_match(VALUE re, VALUE str)
4598 rb_len_t pos = reg_match_pos(re, &str, 0, NULL);
4599 if (pos < 0) return Qnil;
4600 pos = rb_str_sublen(str, pos);
4601 return LEN2NUM(pos);
4606 * self === other -> true or false
4608 * Returns whether +self+ finds a match in +other+:
4610 * /^[a-z]*$/ === 'HELLO' # => false
4611 * /^[A-Z]*$/ === 'HELLO' # => true
4613 * This method is called in case statements:
4617 * when /\A[a-z]*\z/; print "Lower
case\n
"
4618 * when /\A[A-Z]*\z/; print "Upper
case\n
"
4619 * else print "Mixed
case\n
"
4620 * end # => "Upper
case"
4625rb_reg_eqq(VALUE re, VALUE str)
4629 str = reg_operand(str, FALSE);
4631 rb_backref_set(Qnil);
4634 start = rb_reg_search(re, str, 0, 0);
4635 return RBOOL(start >= 0);
4641 * ~ rxp -> integer or nil
4643 * Equivalent to <tt><i>rxp</i> =~ $_</tt>:
4651rb_reg_match2(VALUE re)
4654 VALUE line = rb_lastline_get();
4656 if (!RB_TYPE_P(line, T_STRING)) {
4657 rb_backref_set(Qnil);
4661 start = rb_reg_search(re, line, 0, 0);
4665 start = rb_str_sublen(line, start);
4666 return LEN2NUM(start);
4672 * match(string, offset = 0) -> matchdata or nil
4673 * match(string, offset = 0) {|matchdata| ... } -> object
4675 * With no block given, returns the MatchData object
4676 * that describes the match, if any, or +nil+ if none;
4677 * the search begins at the given character +offset+ in +string+:
4679 * /abra/.match('abracadabra') # => #<MatchData "abra
">
4680 * /abra/.match('abracadabra', 4) # => #<MatchData "abra
">
4681 * /abra/.match('abracadabra', 8) # => nil
4682 * /abra/.match('abracadabra', 800) # => nil
4684 * string = "\u{5d0 5d1 5e8 5d0}cadabra
"
4685 * /abra/.match(string, 7) #=> #<MatchData "abra
">
4686 * /abra/.match(string, 8) #=> nil
4687 * /abra/.match(string.b, 8) #=> #<MatchData "abra
">
4689 * With a block given, calls the block if and only if a match is found;
4690 * returns the block's value:
4692 * /abra/.match('abracadabra') {|matchdata| p matchdata }
4693 * # => #<MatchData "abra
">
4694 * /abra/.match('abracadabra', 4) {|matchdata| p matchdata }
4695 * # => #<MatchData "abra
">
4696 * /abra/.match('abracadabra', 8) {|matchdata| p matchdata }
4698 * /abra/.match('abracadabra', 8) {|marchdata| fail 'Cannot happen' }
4701 * Output (from the first two blocks above):
4703 * #<MatchData "abra
">
4704 * #<MatchData "abra
">
4706 * /(.)(.)(.)/.match("abc
")[2] # => "b
"
4707 * /(.)(.)/.match("abc
", 1)[2] # => "c
"
4712rb_reg_match_m(int argc, VALUE *argv, VALUE re)
4714 VALUE result = Qnil, str, initpos;
4717 if (rb_scan_args(argc, argv, "11
", &str, &initpos) == 2) {
4718 pos = NUM2LEN(initpos);
4724 pos = reg_match_pos(re, &str, pos, &result);
4728 rb_match_busy(result);
4729 if (!NIL_P(result) && rb_block_given_p()) {
4730 return rb_yield(result);
4737 * match?(string) -> true or false
4738 * match?(string, offset = 0) -> true or false
4740 * Returns <code>true</code> or <code>false</code> to indicate whether the
4741 * regexp is matched or not without updating $~ and other related variables.
4742 * If the second parameter is present, it specifies the position in the string
4743 * to begin the search.
4745 * /R.../.match?("Ruby
") # => true
4746 * /R.../.match?("Ruby
", 1) # => false
4747 * /P.../.match?("Ruby
") # => false
4752rb_reg_match_m_p(int argc, VALUE *argv, VALUE re)
4754 rb_len_t pos = rb_check_arity(argc, 1, 2) > 1 ? NUM2LEN(argv[1]) : 0;
4755 return rb_reg_match_p(re, argv[0], pos);
4759rb_reg_match_p(VALUE re, VALUE str, rb_len_t pos)
4761 if (NIL_P(str)) return Qfalse;
4762 str = SYMBOL_P(str) ? rb_sym2str(str) : StringValue(str);
4765 pos += NUM2LEN(rb_str_length(str));
4766 if (pos < 0) return Qfalse;
4770 const char *beg = rb_str_subpos(str, pos, &len);
4771 if (!beg) return Qfalse;
4772 pos = beg - RSTRING_PTR(str);
4776 struct reg_onig_search_args args = {
4778 .range = RSTRING_LEN(str),
4781 return rb_reg_onig_match(re, str, reg_onig_search, &args, NULL) == ONIG_MISMATCH ? Qfalse : Qtrue;
4785 * Document-method: compile
4787 * Alias for Regexp.new
4791str_to_option(VALUE str)
4796 str = rb_check_string_type(str);
4797 if (NIL_P(str)) return -1;
4798 RSTRING_GETMEM(str, ptr, len);
4799 for (rb_len_t i = 0; i < len; ++i) {
4800 int f = char_to_option(ptr[i]);
4802 rb_raise(rb_eArgError, "unknown regexp option: %
"PRIsVALUE, str);
4810set_timeout(rb_hrtime_t *hrt, VALUE timeout)
4812 double timeout_d = NIL_P(timeout) ? 0.0 : NUM2DBL(timeout);
4813 if (!NIL_P(timeout) && !(timeout_d > 0)) {
4814 rb_raise(rb_eArgError, "invalid timeout: %
"PRIsVALUE, timeout);
4816 double2hrtime(hrt, timeout_d);
4820reg_copy(VALUE copy, VALUE orig)
4823 rb_reg_initialize_check(copy);
4824 if ((r = onig_reg_copy_body(RREGEXP_PTR(copy), RREGEXP_PTR(orig))) != 0) {
4825 /* ONIGERR_MEMORY only */
4826 rb_raise(rb_eRegexpError, "%s
", onig_error_code_to_format(r));
4828 FL_SET_RAW(copy, RREGEXP_INITIALIZED);
4830 RB_OBJ_WRITE(copy, &RREGEXP(copy)->src, RREGEXP(orig)->src);
4831 RREGEXP_PTR(copy)->timelimit = RREGEXP_PTR(orig)->timelimit;
4832 rb_enc_copy(copy, orig);
4833 FL_SET_RAW(copy, FL_TEST_RAW(orig, KCODE_FIXED|REG_ENCODING_NONE));
4834 if (RBASIC_CLASS(copy) == rb_cRegexp) {
4841struct reg_init_args {
4848static VALUE reg_extract_args(int argc, VALUE *argv, struct reg_init_args *args);
4849static VALUE reg_init_args(VALUE self, VALUE str, rb_encoding *enc, int flags);
4853 * Regexp.new(string, options = 0, timeout: nil) -> regexp
4854 * Regexp.new(regexp, timeout: nil) -> regexp
4856 * With argument +string+ given, returns a new regexp with the given string
4859 * r = Regexp.new('foo') # => /foo/
4860 * r.source # => "foo
"
4863 * Optional argument +options+ is one of the following:
4865 * - A String of options:
4867 * Regexp.new('foo', 'i') # => /foo/i
4868 * Regexp.new('foo', 'im') # => /foo/im
4870 * - The bit-wise OR of one or more of the constants
4871 * Regexp::EXTENDED, Regexp::IGNORECASE, Regexp::MULTILINE, and
4872 * Regexp::NOENCODING:
4874 * Regexp.new('foo', Regexp::IGNORECASE) # => /foo/i
4875 * Regexp.new('foo', Regexp::EXTENDED) # => /foo/x
4876 * Regexp.new('foo', Regexp::MULTILINE) # => /foo/m
4877 * Regexp.new('foo', Regexp::NOENCODING) # => /foo/n
4878 * flags = Regexp::IGNORECASE | Regexp::EXTENDED | Regexp::MULTILINE
4879 * Regexp.new('foo', flags) # => /foo/mix
4881 * - +nil+ or +false+, which is ignored.
4882 * - Any other truthy value, in which case the regexp will be
4885 * If optional keyword argument +timeout+ is given,
4886 * its float value overrides the timeout interval for the class,
4888 * If +nil+ is passed as +timeout, it uses the timeout interval
4889 * for the class, Regexp.timeout.
4891 * With argument +regexp+ given, returns a new regexp. The source,
4892 * options, timeout are the same as +regexp+. +options+ and +n_flag+
4893 * arguments are ineffective. The timeout can be overridden by
4894 * +timeout+ keyword.
4896 * options = Regexp::MULTILINE
4897 * r = Regexp.new('foo', options, timeout: 1.1) # => /foo/m
4898 * r2 = Regexp.new(r) # => /foo/m
4899 * r2.timeout # => 1.1
4900 * r3 = Regexp.new(r, timeout: 3.14) # => /foo/m
4901 * r3.timeout # => 3.14
4906rb_reg_initialize_m(int argc, VALUE *argv, VALUE self)
4908 struct reg_init_args args;
4909 VALUE re = reg_extract_args(argc, argv, &args);
4912 reg_init_args(self, args.str, args.enc, args.flags);
4918 set_timeout(&RREGEXP_PTR(self)->timelimit, args.timeout);
4919 if (RBASIC_CLASS(self) == rb_cRegexp) {
4927reg_extract_args(int argc, VALUE *argv, struct reg_init_args *args)
4930 rb_encoding *enc = 0;
4931 VALUE str, src, opts = Qundef, kwargs;
4934 rb_scan_args(argc, argv, "11:
", &src, &opts, &kwargs);
4936 args->timeout = Qnil;
4937 if (!NIL_P(kwargs)) {
4938 static ID keywords[1];
4940 keywords[0] = rb_intern_const("timeout
");
4942 rb_get_kwargs(kwargs, keywords, 0, 1, &args->timeout);
4945 if (RB_TYPE_P(src, T_REGEXP)) {
4949 rb_warn("flags ignored
");
4952 flags = rb_reg_options(re);
4953 str = RREGEXP_SRC(re);
4958 if (FIXNUM_P(opts)) flags = FIX2INT(opts);
4959 else if ((f = str_to_option(opts)) >= 0) flags = f;
4960 else if (rb_bool_expected(opts, "ignorecase
", FALSE))
4961 flags = ONIG_OPTION_IGNORECASE;
4963 str = StringValue(src);
4967 args->flags = flags;
4972reg_init_args(VALUE self, VALUE str, rb_encoding *enc, int flags)
4974 if (enc && rb_enc_get(str) != enc)
4975 rb_reg_init_str_enc(self, str, enc, flags);
4977 rb_reg_init_str(self, str, flags);
4982rb_reg_quote(VALUE str)
4984 rb_encoding *enc = rb_enc_get(str);
4988 int ascii_only = rb_enc_str_asciionly_p(str);
4990 s = RSTRING_PTR(str);
4991 send = s + RSTRING_LEN(str);
4993 c = rb_enc_ascget(s, send, &clen, enc);
4995 s += mbclen(s, send, enc);
4999 case '[': case ']': case '{': case '}':
5000 case '(': case ')': case '|': case '-':
5001 case '*': case '.': case '\\':
5002 case '?': case '+': case '^': case '$':
5004 case '\t': case '\f': case '\v': case '\n': case '\r':
5009 tmp = rb_str_new3(str);
5011 rb_enc_associate(tmp, rb_usascii_encoding());
5016 tmp = rb_str_new(0, RSTRING_LEN(str)*2);
5018 rb_enc_associate(tmp, rb_usascii_encoding());
5021 rb_enc_copy(tmp, str);
5023 t = RSTRING_PTR(tmp);
5024 /* copy upto metacharacter */
5025 const char *p = RSTRING_PTR(str);
5026 memcpy(t, p, s - p);
5030 c = rb_enc_ascget(s, send, &clen, enc);
5032 int n = mbclen(s, send, enc);
5040 case '[': case ']': case '{': case '}':
5041 case '(': case ')': case '|': case '-':
5042 case '*': case '.': case '\\':
5043 case '?': case '+': case '^': case '$':
5045 t += rb_enc_mbcput('\\', t, enc);
5048 t += rb_enc_mbcput('\\', t, enc);
5049 t += rb_enc_mbcput(' ', t, enc);
5052 t += rb_enc_mbcput('\\', t, enc);
5053 t += rb_enc_mbcput('t', t, enc);
5056 t += rb_enc_mbcput('\\', t, enc);
5057 t += rb_enc_mbcput('n', t, enc);
5060 t += rb_enc_mbcput('\\', t, enc);
5061 t += rb_enc_mbcput('r', t, enc);
5064 t += rb_enc_mbcput('\\', t, enc);
5065 t += rb_enc_mbcput('f', t, enc);
5068 t += rb_enc_mbcput('\\', t, enc);
5069 t += rb_enc_mbcput('v', t, enc);
5072 t += rb_enc_mbcput(c, t, enc);
5074 rb_str_resize(tmp, t - RSTRING_PTR(tmp));
5081 * Regexp.escape(string) -> new_string
5083 * Returns a new string that escapes any characters
5084 * that have special meaning in a regular expression:
5086 * s = Regexp.escape('\*?{}.') # => "\\\\\\*\\?\\{\\}\\.
"
5088 * For any string +s+, this call returns a MatchData object:
5090 * r = Regexp.new(Regexp.escape(s)) # => /\\\\\\\*\\\?\\\{\\\}\\\./
5091 * r.match(s) # => #<MatchData "\\\\\\*\\?\\{\\}\\.
">
5096rb_reg_s_quote(VALUE c, VALUE str)
5098 return rb_reg_quote(reg_operand(str, TRUE));
5102rb_reg_options(VALUE re)
5107 options = RREGEXP_PTR(re)->options & ARG_REG_OPTION_MASK;
5108 if (RBASIC(re)->flags & KCODE_FIXED) options |= ARG_ENCODING_FIXED;
5109 if (RBASIC(re)->flags & REG_ENCODING_NONE) options |= ARG_ENCODING_NONE;
5114rb_check_regexp_type(VALUE re)
5116 return rb_check_convert_type(re, T_REGEXP, "Regexp
", "to_regexp
");
5121 * Regexp.try_convert(object) -> regexp or nil
5123 * Returns +object+ if it is a regexp:
5125 * Regexp.try_convert(/re/) # => /re/
5127 * Otherwise if +object+ responds to <tt>:to_regexp</tt>,
5128 * calls <tt>object.to_regexp</tt> and returns the result.
5130 * Returns +nil+ if +object+ does not respond to <tt>:to_regexp</tt>.
5132 * Regexp.try_convert('re') # => nil
5134 * Raises an exception unless <tt>object.to_regexp</tt> returns a regexp.
5138rb_reg_s_try_convert(VALUE dummy, VALUE re)
5140 return rb_check_regexp_type(re);
5144rb_reg_s_union(VALUE self, VALUE args0)
5146 rb_len_t argc = RARRAY_LEN(args0);
5150 args[0] = rb_str_new2("(?!)
");
5151 return rb_class_new_instance(1, args, rb_cRegexp);
5153 else if (argc == 1) {
5154 VALUE arg = rb_ary_entry(args0, 0);
5155 VALUE re = rb_check_regexp_type(arg);
5160 quoted = rb_reg_s_quote(Qnil, arg);
5161 return rb_reg_new_str(quoted, 0);
5166 VALUE source = rb_str_buf_new(0);
5167 rb_encoding *result_enc;
5169 int has_asciionly = 0;
5170 rb_encoding *has_ascii_compat_fixed = 0;
5171 rb_encoding *has_ascii_incompat = 0;
5173 for (i = 0; i < argc; i++) {
5175 VALUE e = rb_ary_entry(args0, i);
5178 rb_str_buf_cat_ascii(source, "|
");
5180 v = rb_check_regexp_type(e);
5182 rb_encoding *enc = rb_enc_get(v);
5183 if (!rb_enc_asciicompat(enc)) {
5184 if (!has_ascii_incompat)
5185 has_ascii_incompat = enc;
5186 else if (has_ascii_incompat != enc)
5187 rb_raise(rb_eArgError, "incompatible encodings: %s and %s
",
5188 rb_enc_name(has_ascii_incompat), rb_enc_name(enc));
5190 else if (rb_reg_fixed_encoding_p(v)) {
5191 if (!has_ascii_compat_fixed)
5192 has_ascii_compat_fixed = enc;
5193 else if (has_ascii_compat_fixed != enc)
5194 rb_raise(rb_eArgError, "incompatible encodings: %s and %s
",
5195 rb_enc_name(has_ascii_compat_fixed), rb_enc_name(enc));
5200 v = rb_reg_str_with_term(v, -1);
5205 enc = rb_enc_get(e);
5206 if (!rb_enc_asciicompat(enc)) {
5207 if (!has_ascii_incompat)
5208 has_ascii_incompat = enc;
5209 else if (has_ascii_incompat != enc)
5210 rb_raise(rb_eArgError, "incompatible encodings: %s and %s
",
5211 rb_enc_name(has_ascii_incompat), rb_enc_name(enc));
5213 else if (rb_enc_str_asciionly_p(e)) {
5217 if (!has_ascii_compat_fixed)
5218 has_ascii_compat_fixed = enc;
5219 else if (has_ascii_compat_fixed != enc)
5220 rb_raise(rb_eArgError, "incompatible encodings: %s and %s
",
5221 rb_enc_name(has_ascii_compat_fixed), rb_enc_name(enc));
5223 v = rb_reg_s_quote(Qnil, e);
5225 if (has_ascii_incompat) {
5226 if (has_asciionly) {
5227 rb_raise(rb_eArgError, "ASCII incompatible encoding: %s
",
5228 rb_enc_name(has_ascii_incompat));
5230 if (has_ascii_compat_fixed) {
5231 rb_raise(rb_eArgError, "incompatible encodings: %s and %s
",
5232 rb_enc_name(has_ascii_incompat), rb_enc_name(has_ascii_compat_fixed));
5237 rb_enc_copy(source, v);
5239 rb_str_append(source, v);
5242 if (has_ascii_incompat) {
5243 result_enc = has_ascii_incompat;
5245 else if (has_ascii_compat_fixed) {
5246 result_enc = has_ascii_compat_fixed;
5249 result_enc = rb_ascii8bit_encoding();
5252 rb_enc_associate(source, result_enc);
5253 return rb_class_new_instance(1, &source, rb_cRegexp);
5259 * Regexp.union(*patterns) -> regexp
5260 * Regexp.union(array_of_patterns) -> regexp
5262 * Returns a regexp that is the union of the given patterns:
5264 * r = Regexp.union(%w[cat dog]) # => /cat|dog/
5265 * r.match('cat') # => #<MatchData "cat
">
5266 * r.match('dog') # => #<MatchData "dog
">
5267 * r.match('cog') # => nil
5269 * Each string pattern is escaped so that it is matched literally:
5271 * Regexp.union('penzance') # => /penzance/
5272 * Regexp.union('a+b*c') # => /a\+b\*c/
5273 * Regexp.union('skiing', 'sledding') # => /skiing|sledding/
5274 * Regexp.union(['skiing', 'sledding']) # => /skiing|sledding/
5276 * For each pattern that is a regexp, it is used as is,
5277 * including its flags:
5279 * Regexp.union(/foo/i, /bar/m, /baz/x)
5280 * # => /(?i-mx:foo)|(?m-ix:bar)|(?x-mi:baz)/
5281 * Regexp.union([/foo/i, /bar/m, /baz/x])
5282 * # => /(?i-mx:foo)|(?m-ix:bar)|(?x-mi:baz)/
5284 * With no arguments, returns <tt>/(?!)/</tt>:
5286 * Regexp.union # => /(?!)/
5288 * If any regexp pattern contains captures, the behavior is unspecified.
5292rb_reg_s_union_m(VALUE self, VALUE args)
5295 if (RARRAY_LEN(args) == 1 &&
5296 !NIL_P(v = rb_check_array_type(rb_ary_entry(args, 0)))) {
5297 return rb_reg_s_union(self, v);
5299 return rb_reg_s_union(self, args);
5304 * Regexp.linear_time?(re)
5305 * Regexp.linear_time?(string, options = 0)
5307 * Returns +true+ if matching against <tt>re</tt> can be
5308 * done in linear time to the input string.
5310 * Regexp.linear_time?(/re/) # => true
5312 * Note that this is a property of the ruby interpreter, not of the argument
5313 * regular expression. Identical regexp can or cannot run in linear time
5314 * depending on your ruby binary. Neither forward nor backward compatibility
5315 * is guaranteed about the return value of this method. Our current algorithm
5316 * is (*1) but this is subject to change in the future. Alternative
5317 * implementations can also behave differently. They might always return
5318 * false for everything.
5320 * (*1): https://doi.org/10.1109/SP40001.2021.00032
5324rb_reg_s_linear_time_p(int argc, VALUE *argv, VALUE self)
5326 struct reg_init_args args;
5327 VALUE re = reg_extract_args(argc, argv, &args);
5330 re = reg_init_args(rb_reg_alloc(), args.str, args.enc, args.flags);
5333 return RBOOL(onig_check_linear_time(RREGEXP_PTR(re)));
5338rb_reg_init_copy(VALUE copy, VALUE re)
5340 if (!OBJ_INIT_COPY(copy, re)) return copy;
5342 return reg_copy(copy, re);
5346do_regsub(VALUE str, VALUE src, VALUE regexp, int num_regs, const OnigPosition *beg, const OnigPosition *end)
5351 rb_encoding *str_enc = rb_enc_get(str);
5352 rb_encoding *src_enc = rb_enc_get(src);
5353 int acompat = rb_enc_asciicompat(str_enc);
5355#define ASCGET(s,e,cl) (acompat ? (*(cl)=1,ISASCII((s)[0])?(s)[0]:-1) : rb_enc_ascget((s), (e), (cl), str_enc))
5357 RSTRING_GETMEM(str, s, n);
5362 int c = ASCGET(s, e, &clen);
5366 s += mbclen(s, e, str_enc);
5372 if (c != '\\' || s == e) continue;
5375 val = rb_str_buf_new(ss-p);
5377 rb_enc_str_buf_cat(val, p, ss-p, str_enc);
5379 c = ASCGET(s, e, &clen);
5381 s += mbclen(s, e, str_enc);
5382 rb_enc_str_buf_cat(val, ss, s-ss, str_enc);
5390 case '1': case '2': case '3': case '4':
5391 case '5': case '6': case '7': case '8': case '9':
5392 if (!NIL_P(regexp) && onig_noname_group_capture_is_active(RREGEXP_PTR(regexp))) {
5401 if (s < e && ASCGET(s, e, &clen) == '<') {
5402 char *name, *name_end;
5404 name_end = name = s + clen;
5405 while (name_end < e) {
5406 c = ASCGET(name_end, e, &clen);
5407 if (c == '>') break;
5408 name_end += c == -1 ? mbclen(name_end, e, str_enc) : clen;
5411 VALUE n = rb_str_subseq(str, (rb_len_t)(name - RSTRING_PTR(str)),
5412 (rb_len_t)(name_end - name));
5413 struct re_registers tmp = {
5414 .allocated = num_regs,
5415 .num_regs = num_regs,
5416 .beg = (OnigPosition *)beg,
5417 .end = (OnigPosition *)end,
5419 if ((no = NAME_TO_NUMBER(&tmp, regexp, n, name, name_end)) < 1) {
5420 name_to_backref_error(n);
5422 p = s = name_end + clen;
5426 rb_raise(rb_eRuntimeError, "invalid group name reference format
");
5430 rb_enc_str_buf_cat(val, ss, s-ss, str_enc);
5439 rb_enc_str_buf_cat(val, RSTRING_PTR(src), beg[0], src_enc);
5443 rb_enc_str_buf_cat(val, RSTRING_PTR(src)+end[0], RSTRING_LEN(src)-end[0], src_enc);
5448 while (beg[no] == -1 && no > 0) no--;
5449 if (no == 0) continue;
5453 rb_enc_str_buf_cat(val, s-clen, clen, str_enc);
5457 rb_enc_str_buf_cat(val, ss, s-ss, str_enc);
5462 if (no >= num_regs) continue;
5463 if (beg[no] == -1) continue;
5464 rb_enc_str_buf_cat(val, RSTRING_PTR(src)+beg[no], end[no]-beg[no], src_enc);
5468 if (!val) return str;
5470 rb_enc_str_buf_cat(val, p, e-p, str_enc);
5478rb_reg_regsub(VALUE str, VALUE src, struct re_registers *regs, VALUE regexp)
5480 return do_regsub(str, src, regexp, regs->num_regs, regs->beg, regs->end);
5484rb_reg_regsub_match(VALUE str, VALUE src, VALUE match)
5486 return do_regsub(str, src, RMATCH(match)->regexp,
5487 RMATCH_NREGS(match), RMATCH_BEG_PTR(match), RMATCH_END_PTR(match));
5491ignorecase_getter(ID _x, VALUE *_y)
5493 rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "variable $= is no longer effective
");
5498ignorecase_setter(VALUE val, ID id, VALUE *_)
5500 rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "variable $= is no longer effective; ignored
");
5506 VALUE match = rb_backref_get();
5508 if (NIL_P(match)) return Qnil;
5509 rb_match_busy(match);
5514get_LAST_MATCH_INFO(ID _x, VALUE *_y)
5516 return match_getter();
5520match_setter(VALUE val, ID _x, VALUE *_y)
5523 Check_Type(val, T_MATCH);
5526 rb_backref_set(val);
5531 * Regexp.last_match -> matchdata or nil
5532 * Regexp.last_match(n) -> string or nil
5533 * Regexp.last_match(name) -> string or nil
5535 * With no argument, returns the value of <tt>$~</tt>,
5536 * which is the result of the most recent pattern match
5537 * (see {Regexp global variables}[rdoc-ref:Regexp@Global+Variables]):
5539 * /c(.)t/ =~ 'cat' # => 0
5540 * Regexp.last_match # => #<MatchData "cat
" 1:"a
">
5541 * /a/ =~ 'foo' # => nil
5542 * Regexp.last_match # => nil
5544 * With non-negative integer argument +n+, returns the _n_th field in the
5545 * matchdata, if any, or nil if none:
5547 * /c(.)t/ =~ 'cat' # => 0
5548 * Regexp.last_match(0) # => "cat
"
5549 * Regexp.last_match(1) # => "a
"
5550 * Regexp.last_match(2) # => nil
5552 * With negative integer argument +n+, counts backwards from the last field:
5554 * Regexp.last_match(-1) # => "a
"
5556 * With string or symbol argument +name+,
5557 * returns the string value for the named capture, if any:
5559 * /(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ 'var = val'
5560 * Regexp.last_match # => #<MatchData "var = val
" lhs:"var
"rhs:"val
">
5561 * Regexp.last_match(:lhs) # => "var
"
5562 * Regexp.last_match('rhs') # => "val
"
5563 * Regexp.last_match('foo') # Raises IndexError.
5568rb_reg_s_last_match(int argc, VALUE *argv, VALUE _)
5570 if (rb_check_arity(argc, 0, 1) == 1) {
5571 VALUE match = rb_backref_get();
5573 if (NIL_P(match)) return Qnil;
5574 n = match_backref_number(match, argv[0]);
5575 return rb_reg_nth_match(n, match);
5577 return match_getter();
5581re_warn(const char *s)
5586// This function is periodically called during regexp matching
5588rb_reg_timeout_p(regex_t *reg, void *end_time_)
5590 rb_hrtime_t *end_time = (rb_hrtime_t *)end_time_;
5592 if (*end_time == 0) {
5593 // This is the first time to check interrupts;
5594 // just measure the current time and determine the end time
5595 // if timeout is set.
5596 rb_hrtime_t timelimit = reg->timelimit;
5599 // no per-object timeout.
5600 timelimit = rb_reg_match_time_limit;
5604 *end_time = rb_hrtime_add(timelimit, rb_hrtime_now());
5607 // no timeout is set
5608 *end_time = RB_HRTIME_MAX;
5612 if (*end_time < rb_hrtime_now()) {
5613 // Timeout has exceeded
5623 * Regexp.timeout -> float or nil
5625 * It returns the current default timeout interval for Regexp matching in second.
5626 * +nil+ means no default timeout configuration.
5630rb_reg_s_timeout_get(VALUE dummy)
5632 double d = hrtime2double(rb_reg_match_time_limit);
5633 if (d == 0.0) return Qnil;
5639 * Regexp.timeout = float or nil
5641 * It sets the default timeout interval for Regexp matching in second.
5642 * +nil+ means no default timeout configuration.
5643 * This configuration is process-global. If you want to set timeout for
5644 * each Regexp, use +timeout+ keyword for <code>Regexp.new</code>.
5646 * Regexp.timeout = 1
5647 * /^a*b?a*$/ =~ "a
" * 100000 + "x
" #=> regexp match timeout (RuntimeError)
5651rb_reg_s_timeout_set(VALUE dummy, VALUE timeout)
5653 rb_ractor_ensure_main_ractor("can not access
Regexp.timeout from non-main Ractors
");
5655 set_timeout(&rb_reg_match_time_limit, timeout);
5662 * rxp.timeout -> float or nil
5664 * It returns the timeout interval for Regexp matching in second.
5665 * +nil+ means no default timeout configuration.
5667 * This configuration is per-object. The global configuration set by
5668 * Regexp.timeout= is ignored if per-object configuration is set.
5670 * re = Regexp.new("^a*b?a*$
", timeout: 1)
5671 * re.timeout #=> 1.0
5672 * re =~ "a
" * 100000 + "x
" #=> regexp match timeout (RuntimeError)
5676rb_reg_timeout_get(VALUE re)
5679 double d = hrtime2double(RREGEXP_PTR(re)->timelimit);
5680 if (d == 0.0) return Qnil;
5685 * Document-class: RegexpError
5687 * Raised when given an invalid regexp expression.
5691 * <em>raises the exception:</em>
5693 * RegexpError: target of repeat operator is not specified: /?/
5697 * Document-class: Regexp
5699 * :include: doc/_regexp.rdoc
5705 rb_eRegexpError = rb_define_class("RegexpError
", rb_eStandardError);
5707 onigenc_set_default_encoding(ONIG_ENCODING_ASCII);
5708 onig_set_warn_func(re_warn);
5709 onig_set_verb_warn_func(re_warn);
5711 rb_define_virtual_variable("$~
", get_LAST_MATCH_INFO, match_setter);
5712 rb_define_virtual_variable("$&
", last_match_getter, 0);
5713 rb_define_virtual_variable("$`
", prematch_getter, 0);
5714 rb_define_virtual_variable("$
'", postmatch_getter, 0);
5715 rb_define_virtual_variable("$+", last_paren_match_getter, 0);
5717 rb_gvar_ractor_local("$~");
5718 rb_gvar_ractor_local("$&");
5719 rb_gvar_ractor_local("$`");
5720 rb_gvar_ractor_local("$'");
5721 rb_gvar_ractor_local("$+
");
5722 rb_gvar_box_dynamic("$~
");
5723 rb_gvar_box_ready("$&
");
5724 rb_gvar_box_ready("$`
");
5725 rb_gvar_box_ready("$
'");
5726 rb_gvar_box_ready("$+");
5728 rb_define_virtual_variable("$=", ignorecase_getter, ignorecase_setter);
5730 rb_cRegexp = rb_define_class("Regexp", rb_cObject);
5731 rb_define_alloc_func(rb_cRegexp, rb_reg_s_alloc);
5732 rb_define_singleton_method(rb_cRegexp, "compile", rb_class_new_instance_pass_kw, -1);
5733 rb_define_singleton_method(rb_cRegexp, "quote", rb_reg_s_quote, 1);
5734 rb_define_singleton_method(rb_cRegexp, "escape", rb_reg_s_quote, 1);
5735 rb_define_singleton_method(rb_cRegexp, "union", rb_reg_s_union_m, -2);
5736 rb_define_singleton_method(rb_cRegexp, "last_match", rb_reg_s_last_match, -1);
5737 rb_define_singleton_method(rb_cRegexp, "try_convert", rb_reg_s_try_convert, 1);
5738 rb_define_singleton_method(rb_cRegexp, "linear_time?", rb_reg_s_linear_time_p, -1);
5740 rb_define_method(rb_cRegexp, "initialize", rb_reg_initialize_m, -1);
5741 rb_define_method(rb_cRegexp, "initialize_copy", rb_reg_init_copy, 1);
5742 rb_define_method(rb_cRegexp, "hash", rb_reg_hash, 0);
5743 rb_define_method(rb_cRegexp, "eql?", rb_reg_equal, 1);
5744 rb_define_method(rb_cRegexp, "==", rb_reg_equal, 1);
5745 rb_define_method(rb_cRegexp, "=~", rb_reg_match, 1);
5746 rb_define_method(rb_cRegexp, "===", rb_reg_eqq, 1);
5747 rb_define_method(rb_cRegexp, "~", rb_reg_match2, 0);
5748 rb_define_method(rb_cRegexp, "match", rb_reg_match_m, -1);
5749 rb_define_method(rb_cRegexp, "match?", rb_reg_match_m_p, -1);
5750 rb_define_method(rb_cRegexp, "to_s", rb_reg_to_s, 0);
5751 rb_define_method(rb_cRegexp, "inspect", rb_reg_inspect, 0);
5752 rb_define_method(rb_cRegexp, "source", rb_reg_source, 0);
5753 rb_define_method(rb_cRegexp, "casefold?", rb_reg_casefold_p, 0);
5754 rb_define_method(rb_cRegexp, "options", rb_reg_options_m, 0);
5755 rb_define_method(rb_cRegexp, "encoding", rb_obj_encoding, 0); /* in encoding.c */
5756 rb_define_method(rb_cRegexp, "fixed_encoding?", rb_reg_fixed_encoding_p, 0);
5757 rb_define_method(rb_cRegexp, "names", rb_reg_names, 0);
5758 rb_define_method(rb_cRegexp, "named_captures", rb_reg_named_captures, 0);
5759 rb_define_method(rb_cRegexp, "timeout", rb_reg_timeout_get, 0);
5761 /* Raised when regexp matching timed out. */
5762 rb_eRegexpTimeoutError = rb_define_class_under(rb_cRegexp, "TimeoutError", rb_eRegexpError);
5763 rb_define_singleton_method(rb_cRegexp, "timeout", rb_reg_s_timeout_get, 0);
5764 rb_define_singleton_method(rb_cRegexp, "timeout=", rb_reg_s_timeout_set, 1);
5766 /* see Regexp.options and Regexp.new */
5767 rb_define_const(rb_cRegexp, "IGNORECASE", INT2FIX(ONIG_OPTION_IGNORECASE));
5768 /* see Regexp.options and Regexp.new */
5769 rb_define_const(rb_cRegexp, "EXTENDED", INT2FIX(ONIG_OPTION_EXTEND));
5770 /* see Regexp.options and Regexp.new */
5771 rb_define_const(rb_cRegexp, "MULTILINE", INT2FIX(ONIG_OPTION_MULTILINE));
5772 /* see Regexp.options and Regexp.new */
5773 rb_define_const(rb_cRegexp, "FIXEDENCODING", INT2FIX(ARG_ENCODING_FIXED));
5774 /* see Regexp.options and Regexp.new */
5775 rb_define_const(rb_cRegexp, "NOENCODING", INT2FIX(ARG_ENCODING_NONE));
5777 rb_global_variable(®_cache);
5779 rb_cMatch = rb_define_class("MatchData", rb_cObject);
5780 rb_define_alloc_func(rb_cMatch, match_alloc);
5781 rb_undef_method(CLASS_OF(rb_cMatch), "new");
5782 rb_undef_method(CLASS_OF(rb_cMatch), "allocate");
5784 rb_define_method(rb_cMatch, "initialize_copy", rb_match_init_copy, 1);
5785 rb_define_method(rb_cMatch, "regexp", match_regexp, 0);
5786 rb_define_method(rb_cMatch, "names", match_names, 0);
5787 rb_define_method(rb_cMatch, "size", match_size, 0);
5788 rb_define_method(rb_cMatch, "length", match_size, 0);
5789 rb_define_method(rb_cMatch, "offset", match_offset, 1);
5790 rb_define_method(rb_cMatch, "byteoffset", match_byteoffset, 1);
5791 rb_define_method(rb_cMatch, "bytebegin", match_bytebegin, 1);
5792 rb_define_method(rb_cMatch, "byteend", match_byteend, 1);
5793 rb_define_method(rb_cMatch, "begin", match_begin, 1);
5794 rb_define_method(rb_cMatch, "end", match_end, 1);
5795 rb_define_method(rb_cMatch, "match", match_nth, 1);
5796 rb_define_method(rb_cMatch, "match_length", match_nth_length, 1);
5797 rb_define_method(rb_cMatch, "to_a", match_to_a, 0);
5798 rb_define_method(rb_cMatch, "[]", match_aref, -1);
5799 rb_define_method(rb_cMatch, "captures", match_captures, 0);
5800 rb_define_alias(rb_cMatch, "deconstruct", "captures");
5801 rb_define_method(rb_cMatch, "named_captures", match_named_captures, -1);
5802 rb_define_method(rb_cMatch, "deconstruct_keys", match_deconstruct_keys, 1);
5803 rb_define_method(rb_cMatch, "values_at", match_values_at, -1);
5804 rb_define_method(rb_cMatch, "pre_match", rb_reg_match_pre, 0);
5805 rb_define_method(rb_cMatch, "post_match", rb_reg_match_post, 0);
5806 rb_define_method(rb_cMatch, "to_s", match_to_s, 0);
5807 rb_define_method(rb_cMatch, "inspect", match_inspect, 0);
5808 rb_define_method(rb_cMatch, "string", match_string, 0);
5809 rb_define_method(rb_cMatch, "hash", match_hash, 0);
5810 rb_define_method(rb_cMatch, "eql?", match_equal, 1);
5811 rb_define_method(rb_cMatch, "==", match_equal, 1);
5812 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 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.