12#include "ruby/internal/config.h"
19#include "internal/encoding.h"
20#include "internal/hash.h"
21#include "internal/imemo.h"
22#include "internal/re.h"
23#include "internal/string.h"
24#include "internal/object.h"
25#include "internal/ractor.h"
26#include "internal/variable.h"
31#include "ractor_core.h"
35typedef char onig_errmsg_buffer[ONIG_MAX_ERROR_MESSAGE_LEN];
36#define errcpy(err, msg) strlcpy((err), (msg), ONIG_MAX_ERROR_MESSAGE_LEN)
38#define BEG(no) (regs->beg[(no)])
39#define END(no) (regs->end[(no)])
42static const char casetable[] = {
43 '\000',
'\001',
'\002',
'\003',
'\004',
'\005',
'\006',
'\007',
44 '\010',
'\011',
'\012',
'\013',
'\014',
'\015',
'\016',
'\017',
45 '\020',
'\021',
'\022',
'\023',
'\024',
'\025',
'\026',
'\027',
46 '\030',
'\031',
'\032',
'\033',
'\034',
'\035',
'\036',
'\037',
48 '\040',
'\041',
'\042',
'\043',
'\044',
'\045',
'\046',
'\047',
50 '\050',
'\051',
'\052',
'\053',
'\054',
'\055',
'\056',
'\057',
52 '\060',
'\061',
'\062',
'\063',
'\064',
'\065',
'\066',
'\067',
54 '\070',
'\071',
'\072',
'\073',
'\074',
'\075',
'\076',
'\077',
56 '\100',
'\141',
'\142',
'\143',
'\144',
'\145',
'\146',
'\147',
58 '\150',
'\151',
'\152',
'\153',
'\154',
'\155',
'\156',
'\157',
60 '\160',
'\161',
'\162',
'\163',
'\164',
'\165',
'\166',
'\167',
62 '\170',
'\171',
'\172',
'\133',
'\134',
'\135',
'\136',
'\137',
64 '\140',
'\141',
'\142',
'\143',
'\144',
'\145',
'\146',
'\147',
66 '\150',
'\151',
'\152',
'\153',
'\154',
'\155',
'\156',
'\157',
68 '\160',
'\161',
'\162',
'\163',
'\164',
'\165',
'\166',
'\167',
70 '\170',
'\171',
'\172',
'\173',
'\174',
'\175',
'\176',
'\177',
71 '\200',
'\201',
'\202',
'\203',
'\204',
'\205',
'\206',
'\207',
72 '\210',
'\211',
'\212',
'\213',
'\214',
'\215',
'\216',
'\217',
73 '\220',
'\221',
'\222',
'\223',
'\224',
'\225',
'\226',
'\227',
74 '\230',
'\231',
'\232',
'\233',
'\234',
'\235',
'\236',
'\237',
75 '\240',
'\241',
'\242',
'\243',
'\244',
'\245',
'\246',
'\247',
76 '\250',
'\251',
'\252',
'\253',
'\254',
'\255',
'\256',
'\257',
77 '\260',
'\261',
'\262',
'\263',
'\264',
'\265',
'\266',
'\267',
78 '\270',
'\271',
'\272',
'\273',
'\274',
'\275',
'\276',
'\277',
79 '\300',
'\301',
'\302',
'\303',
'\304',
'\305',
'\306',
'\307',
80 '\310',
'\311',
'\312',
'\313',
'\314',
'\315',
'\316',
'\317',
81 '\320',
'\321',
'\322',
'\323',
'\324',
'\325',
'\326',
'\327',
82 '\330',
'\331',
'\332',
'\333',
'\334',
'\335',
'\336',
'\337',
83 '\340',
'\341',
'\342',
'\343',
'\344',
'\345',
'\346',
'\347',
84 '\350',
'\351',
'\352',
'\353',
'\354',
'\355',
'\356',
'\357',
85 '\360',
'\361',
'\362',
'\363',
'\364',
'\365',
'\366',
'\367',
86 '\370',
'\371',
'\372',
'\373',
'\374',
'\375',
'\376',
'\377',
89# error >>> "You lose. You will need a translation table for your character set." <<<
93rb_hrtime_t rb_reg_match_time_limit = 0;
96rb_memcicmp(
const void *x,
const void *y,
long len)
98 const unsigned char *p1 = x, *p2 = y;
102 if ((tmp = casetable[(
unsigned)*p1++] - casetable[(
unsigned)*p2++]))
110rb_memsearch_ss(
const unsigned char *xs,
long m,
const unsigned char *ys,
long n)
112 const unsigned char *y;
114 if ((y = memmem(ys, n, xs, m)) != NULL)
121rb_memsearch_ss(
const unsigned char *xs,
long m,
const unsigned char *ys,
long n)
123 const unsigned char *x = xs, *xe = xs + m;
124 const unsigned char *y = ys, *ye = ys + n;
125#define VALUE_MAX ((VALUE)~(VALUE)0)
129 rb_bug(
"!!too long pattern string!!");
131 if (!(y = memchr(y, *x, n - m + 1)))
135 for (hx = *x++, hy = *y++; x < xe; ++x, ++y) {
155rb_memsearch_qs(
const unsigned char *xs,
long m,
const unsigned char *ys,
long n)
157 const unsigned char *x = xs, *xe = xs + m;
158 const unsigned char *y = ys;
159 VALUE i, qstable[256];
162 for (i = 0; i < 256; ++i)
165 qstable[*x] = xe - x;
167 for (; y + m <= ys + n; y += *(qstable + y[m])) {
168 if (*xs == *y && memcmp(xs, y, m) == 0)
174static inline unsigned int
175rb_memsearch_qs_utf8_hash(
const unsigned char *x,
const unsigned char *e)
177 register const unsigned int mix = 8353;
178 register unsigned int h = *x;
182 else if (e - x < (h < 0xE0 ? 2 : h < 0xF0 ? 3 : 4)) {
206 return (
unsigned char)h;
210rb_memsearch_qs_utf8(
const unsigned char *xs,
long m,
const unsigned char *ys,
long n)
212 const unsigned char *x = xs, *xe = xs + m;
213 const unsigned char *y = ys;
214 VALUE i, qstable[512];
217 for (i = 0; i < 512; ++i) {
220 for (; x < xe; ++x) {
221 qstable[rb_memsearch_qs_utf8_hash(x, xe)] = xe - x;
224 for (; y + m <= ys + n; y += qstable[rb_memsearch_qs_utf8_hash(y+m, ys+n)]) {
225 if (*xs == *y && memcmp(xs, y, m) == 0)
232rb_memsearch_with_char_size(
const unsigned char *xs,
long m,
const unsigned char *ys,
long n,
int char_size)
234 const unsigned char *x = xs, x0 = *xs, *y = ys;
236 for (n -= m; n >= 0; n -= char_size, y += char_size) {
237 if (x0 == *y && memcmp(x+1, y+1, m-1) == 0)
244rb_memsearch_wchar(
const unsigned char *xs,
long m,
const unsigned char *ys,
long n)
246 return rb_memsearch_with_char_size(xs, m, ys, n, 2);
250rb_memsearch_qchar(
const unsigned char *xs,
long m,
const unsigned char *ys,
long n)
252 return rb_memsearch_with_char_size(xs, m, ys, n, 4);
256rb_memsearch(
const void *x0,
long m,
const void *y0,
long n, rb_encoding *enc)
258 const unsigned char *x = x0, *y = y0;
260 if (m > n)
return -1;
262 return memcmp(x0, y0, m) == 0 ? 0 : -1;
268 const unsigned char *ys = memchr(y, *x, n);
275 else if (LIKELY(rb_enc_mbminlen(enc) == 1)) {
277 return rb_memsearch_ss(x0, m, y0, n);
279 else if (enc == rb_utf8_encoding()){
280 return rb_memsearch_qs_utf8(x0, m, y0, n);
283 else if (LIKELY(rb_enc_mbminlen(enc) == 2)) {
284 return rb_memsearch_wchar(x0, m, y0, n);
286 else if (LIKELY(rb_enc_mbminlen(enc) == 4)) {
287 return rb_memsearch_qchar(x0, m, y0, n);
289 return rb_memsearch_qs(x0, m, y0, n);
292#define REG_ENCODING_NONE FL_USER6
294#define KCODE_FIXED FL_USER4
303 val = ONIG_OPTION_IGNORECASE;
306 val = ONIG_OPTION_EXTEND;
309 val = ONIG_OPTION_MULTILINE;
318enum { OPTBUF_SIZE = 4 };
321option_to_str(
char str[OPTBUF_SIZE],
int options)
324 if (options & ONIG_OPTION_MULTILINE) *p++ =
'm';
325 if (options & ONIG_OPTION_IGNORECASE) *p++ =
'i';
326 if (options & ONIG_OPTION_EXTEND) *p++ =
'x';
338 *kcode = rb_ascii8bit_encindex();
339 return (*option = ARG_ENCODING_NONE);
341 *kcode = ENCINDEX_EUC_JP;
344 *kcode = ENCINDEX_Windows_31J;
347 *kcode = rb_utf8_encindex();
351 return (*option = char_to_option(c));
353 *option = ARG_ENCODING_FIXED;
358rb_reg_check(
VALUE re)
360 if (!
RREGEXP_PTR(re) || !RREGEXP_SRC(re) || !RREGEXP_SRC_PTR(re)) {
366rb_reg_expr_str(
VALUE str,
const char *s,
long len,
367 rb_encoding *enc, rb_encoding *resenc,
int term)
369 const char *p, *pend;
374 p = s; pend = p +
len;
375 rb_str_coderange_scan_restartable(p, pend, enc, &cr);
378 c = rb_enc_ascget(p, pend, &clen, enc);
381 p += mbclen(p, pend, enc);
388 else if (c != term && rb_enc_isprint(c, enc)) {
405 int unicode_p = rb_enc_unicode_p(enc);
408 c = rb_enc_ascget(p, pend, &clen, enc);
409 if (c ==
'\\' && p+clen < pend) {
410 int n = clen + mbclen(p+clen, pend, enc);
416 clen = rb_enc_precise_mbclen(p, pend, enc);
418 c = (
unsigned char)*p;
423 unsigned int c = rb_enc_mbc_to_codepoint(p, pend, enc);
424 rb_str_buf_cat_escaped_char(str, c, unicode_p);
431 else if (c == term) {
436 else if (rb_enc_isprint(c, enc)) {
439 else if (!rb_enc_isspace(c, enc)) {
443 snprintf(b,
sizeof(b),
"\\x%02X", c);
457 rb_encoding *enc = rb_enc_get(re);
459 rb_encoding *resenc = rb_default_internal_encoding();
460 if (resenc == NULL) resenc = rb_default_external_encoding();
462 if (re && rb_enc_asciicompat(enc)) {
463 rb_enc_copy(str, re);
466 rb_enc_associate(str, rb_usascii_encoding());
469 VALUE src_str = RREGEXP_SRC(re);
470 rb_reg_expr_str(str, RSTRING_PTR(src_str), RSTRING_LEN(src_str), enc, resenc,
'/');
475 char opts[OPTBUF_SIZE];
477 if (*option_to_str(opts,
RREGEXP_PTR(re)->options))
479 if (
RBASIC(re)->flags & REG_ENCODING_NONE)
505rb_reg_source(
VALUE re)
526rb_reg_inspect(
VALUE re)
528 if (!
RREGEXP_PTR(re) || !RREGEXP_SRC(re) || !RREGEXP_SRC_PTR(re)) {
531 return rb_reg_desc(re);
534static VALUE rb_reg_str_with_term(
VALUE re,
int term);
566 return rb_reg_str_with_term(re,
'/');
570rb_reg_preprocess(
const char *p,
const char *end, rb_encoding *enc,
571 rb_encoding **fixed_enc, onig_errmsg_buffer err,
int options);
574rb_reg_str_with_term(
VALUE re,
int term)
577 const int embeddable = ONIG_OPTION_MULTILINE|ONIG_OPTION_IGNORECASE|ONIG_OPTION_EXTEND;
579 char optbuf[OPTBUF_SIZE + 1];
580 rb_encoding *enc = rb_enc_get(re);
584 rb_enc_copy(str, re);
586 VALUE src_str = RREGEXP_SRC(re);
587 const UChar *
ptr = (UChar *)RSTRING_PTR(src_str);
588 long len = RSTRING_LEN(src_str);
590 if (
len >= 4 &&
ptr[0] ==
'(' &&
ptr[1] ==
'?') {
593 if ((
len -= 2) > 0) {
595 opt = char_to_option((
int )*
ptr);
605 if (
len > 1 && *
ptr ==
'-') {
609 opt = char_to_option((
int )*
ptr);
627 rb_encoding *fixed_enc = 0;
628 onig_errmsg_buffer errmsg =
"";
633 unescaped = rb_reg_preprocess((
const char *)
ptr, (
const char *)
ptr +
len,
634 enc, &fixed_enc, errmsg, options);
635 if (!
NIL_P(unescaped)) {
637 err = onig_new(&rp, (UChar *)RSTRING_PTR(unescaped),
638 (UChar *)RSTRING_END(unescaped), options,
639 enc, OnigDefaultSyntax, NULL);
647 ptr = (UChar*)RREGEXP_SRC_PTR(re);
648 len = RREGEXP_SRC_LEN(re);
654 if ((options & embeddable) != embeddable) {
656 option_to_str(optbuf + 1, ~options);
661 if (rb_enc_asciicompat(enc)) {
662 rb_reg_expr_str(str, (
char*)
ptr,
len, enc, NULL, term);
670 rb_enc_associate(str, rb_usascii_encoding());
674 s = RSTRING_PTR(str);
675 e = RSTRING_END(str);
676 s = rb_enc_left_char_head(s, e-1, e, enc);
680 rb_str_resize(str, RSTRING_LEN(str) - n);
682 rb_reg_expr_str(str, (
char*)
ptr,
len, enc, NULL, term);
685 rb_enc_copy(str, re);
692NORETURN(
static void rb_reg_raise(
const char *err,
VALUE re));
695rb_reg_raise(
const char *err,
VALUE re)
697 VALUE desc = rb_reg_desc(re);
703rb_enc_reg_error_desc(
const char *s,
long len, rb_encoding *enc,
int options,
const char *err)
705 char opts[OPTBUF_SIZE + 1];
707 rb_encoding *resenc = rb_default_internal_encoding();
708 if (resenc == NULL) resenc = rb_default_external_encoding();
710 rb_enc_associate(desc, enc);
712 rb_reg_expr_str(desc, s,
len, enc, resenc,
'/');
714 option_to_str(opts + 1, options);
719NORETURN(
static void rb_enc_reg_raise(
const char *s,
long len, rb_encoding *enc,
int options,
const char *err));
722rb_enc_reg_raise(
const char *s,
long len, rb_encoding *enc,
int options,
const char *err)
728rb_reg_error_desc(
VALUE str,
int options,
const char *err)
730 return rb_enc_reg_error_desc(RSTRING_PTR(str), RSTRING_LEN(str),
731 rb_enc_get(str), options, err);
734NORETURN(
static void rb_reg_raise_str(
VALUE str,
int options,
const char *err));
737rb_reg_raise_str(
VALUE str,
int options,
const char *err)
757rb_reg_casefold_p(
VALUE re)
760 return RBOOL(
RREGEXP_PTR(re)->options & ONIG_OPTION_IGNORECASE);
802rb_reg_options_m(
VALUE re)
809reg_names_iter(
const OnigUChar *name,
const OnigUChar *name_end,
810 int back_num,
int *back_refs, OnigRegex regex,
void *arg)
813 rb_ary_push(ary, rb_enc_str_new((
const char *)name, name_end-name, regex->enc));
831rb_reg_names(
VALUE re)
836 onig_foreach_name(
RREGEXP_PTR(re), reg_names_iter, (
void*)ary);
841reg_named_captures_iter(
const OnigUChar *name,
const OnigUChar *name_end,
842 int back_num,
int *back_refs, OnigRegex regex,
void *arg)
848 for (i = 0; i < back_num; i++)
851 rb_hash_aset(hash,
rb_str_new((
const char*)name, name_end-name),ary);
875rb_reg_named_captures(
VALUE re)
877 regex_t *reg = (rb_reg_check(re),
RREGEXP_PTR(re));
878 VALUE hash = rb_hash_new_with_size(onig_number_of_names(reg));
879 onig_foreach_name(reg, reg_named_captures_iter, (
void*)hash);
884onig_new_with_source(regex_t** reg,
const UChar* pattern,
const UChar* pattern_end,
885 OnigOptionType option, OnigEncoding enc,
const OnigSyntaxType* syntax,
886 OnigErrorInfo* einfo,
const char *sourcefile,
int sourceline)
890 *reg = (regex_t* )malloc(
sizeof(regex_t));
891 if (IS_NULL(*reg))
return ONIGERR_MEMORY;
893 r = onig_reg_init(*reg, option, ONIGENC_CASE_FOLD_DEFAULT, enc, syntax);
896 r = onig_compile_ruby(*reg, pattern, pattern_end, einfo, sourcefile, sourceline);
906make_regexp(
const char *s,
long len, rb_encoding *enc,
int flags, onig_errmsg_buffer err,
907 const char *sourcefile,
int sourceline)
920 r = onig_new_with_source(&rp, (UChar*)s, (UChar*)(s +
len), flags,
921 enc, OnigDefaultSyntax, &einfo, sourcefile, sourceline);
923 onig_error_code_to_str((UChar*)err, r, &einfo);
982match_alloc(
VALUE klass)
984 size_t alloc_size =
sizeof(
struct RMatch) + sizeof(rb_matchext_t);
986 NEWOBJ_OF(match,
struct RMatch, klass, flags, alloc_size, 0);
990 memset(RMATCH_EXT(match), 0,
sizeof(rb_matchext_t));
998 onig_region_copy(to, (OnigRegion *)from);
999 if (to->allocated)
return 0;
1001 onig_region_copy(to, (OnigRegion *)from);
1002 if (to->allocated)
return 0;
1003 return ONIGERR_MEMORY;
1012pair_byte_cmp(
const void *pair1,
const void *pair2)
1014 long diff = ((
pair_t*)pair1)->byte_pos - ((
pair_t*)pair2)->byte_pos;
1015#if SIZEOF_LONG > SIZEOF_INT
1016 return diff ? diff > 0 ? 1 : -1 : 0;
1023update_char_offset(
VALUE match)
1025 rb_matchext_t *rm = RMATCH_EXT(match);
1027 int i, num_regs, num_pos;
1037 num_regs = rm->
regs.num_regs;
1044 enc = rb_enc_get(
RMATCH(match)->str);
1045 if (rb_enc_mbmaxlen(enc) == 1) {
1046 for (i = 0; i < num_regs; i++) {
1055 for (i = 0; i < num_regs; i++) {
1058 pairs[num_pos++].byte_pos = BEG(i);
1059 pairs[num_pos++].byte_pos = END(i);
1061 qsort(pairs, num_pos,
sizeof(
pair_t), pair_byte_cmp);
1063 s = p = RSTRING_PTR(
RMATCH(match)->str);
1065 for (i = 0; i < num_pos; i++) {
1066 q = s + pairs[i].byte_pos;
1068 pairs[i].char_pos = c;
1072 for (i = 0; i < num_regs; i++) {
1080 key.byte_pos = BEG(i);
1081 found = bsearch(&key, pairs, num_pos,
sizeof(
pair_t), pair_byte_cmp);
1084 key.byte_pos = END(i);
1085 found = bsearch(&key, pairs, num_pos,
sizeof(
pair_t), pair_byte_cmp);
1091match_check(
VALUE match)
1093 if (!
RMATCH(match)->regexp) {
1110 rm = RMATCH_EXT(obj);
1114 if (RMATCH_EXT(orig)->char_offset_num_allocated) {
1140match_regexp(
VALUE match)
1144 regexp =
RMATCH(match)->regexp;
1145 if (
NIL_P(regexp)) {
1175match_names(
VALUE match)
1180 return rb_reg_names(
RMATCH(match)->regexp);
1196match_size(
VALUE match)
1199 return INT2FIX(RMATCH_REGS(match)->num_regs);
1202static int name_to_backref_number(
struct re_registers *,
VALUE,
const char*,
const char*);
1203NORETURN(
static void name_to_backref_error(
VALUE name));
1206name_to_backref_error(
VALUE name)
1208 rb_raise(
rb_eIndexError,
"undefined group name reference: % "PRIsVALUE,
1215 if (i < 0 || regs->num_regs <= i)
1220match_backref_number(
VALUE match,
VALUE backref)
1232 else if (!RB_TYPE_P(backref,
T_STRING)) {
1237 num = name_to_backref_number(regs, regexp, name, name + RSTRING_LEN(backref));
1240 name_to_backref_error(backref);
1249 return match_backref_number(match, backref);
1264 int i = match_backref_number(match, n);
1268 backref_number_check(regs, i);
1273 update_char_offset(match);
1275 LONG2NUM(RMATCH_EXT(match)->char_offset[i].end));
1299 int i = match_backref_number(match, n);
1303 backref_number_check(regs, i);
1323 int i = match_backref_number(match, n);
1327 backref_number_check(regs, i);
1347 int i = match_backref_number(match, n);
1351 backref_number_check(regs, i);
1371 int i = match_backref_number(match, n);
1375 backref_number_check(regs, i);
1380 update_char_offset(match);
1381 return LONG2NUM(RMATCH_EXT(match)->char_offset[i].beg);
1397 int i = match_backref_number(match, n);
1401 backref_number_check(regs, i);
1406 update_char_offset(match);
1407 return LONG2NUM(RMATCH_EXT(match)->char_offset[i].end);
1439 int i = match_backref_number(match, n);
1442 backref_number_check(regs, i);
1444 long start = BEG(i), end = END(i);
1483 int i = match_backref_number(match, n);
1487 backref_number_check(regs, i);
1492 update_char_offset(match);
1494 &RMATCH_EXT(match)->char_offset[i];
1498#define MATCH_BUSY FL_USER2
1503 FL_SET(match, MATCH_BUSY);
1507rb_match_unbusy(
VALUE match)
1513rb_match_count(
VALUE match)
1516 if (
NIL_P(match))
return -1;
1517 regs = RMATCH_REGS(match);
1518 if (!regs)
return -1;
1519 return regs->num_regs;
1526 rb_matchext_t *rmatch = RMATCH_EXT(match);
1530 int err = onig_region_resize(&rmatch->
regs, 1);
1531 if (err) rb_memerror();
1532 rmatch->
regs.beg[0] = pos;
1533 rmatch->
regs.end[0] = pos +
len;
1537rb_backref_set_string(
VALUE string,
long pos,
long len)
1543 match_set_string(match,
string, pos,
len);
1578rb_reg_fixed_encoding_p(
VALUE re)
1580 return RBOOL(
FL_TEST(re, KCODE_FIXED));
1589 "incompatible encoding regexp match (%s regexp with %s string)",
1590 rb_enc_inspect_name(rb_enc_get(re)),
1591 rb_enc_inspect_name(rb_enc_get(
str)));
1607 rb_encoding *enc = 0;
1608 int cr = str_coderange(
str);
1611 rb_raise(rb_eArgError,
1612 "invalid byte sequence in %s",
1613 rb_enc_name(rb_enc_get(
str)));
1617 enc = rb_enc_get(
str);
1624 else if (!rb_enc_asciicompat(enc)) {
1625 reg_enc_error(re,
str);
1627 else if (rb_reg_fixed_encoding_p(re)) {
1630 reg_enc_error(re,
str);
1634 else if (warn && (
RBASIC(re)->flags & REG_ENCODING_NONE) &&
1635 enc != rb_ascii8bit_encoding() &&
1637 rb_warn(
"historical binary regexp match /.../n against %s string",
1649 rb_encoding *fixed_enc = 0;
1650 rb_encoding *enc = rb_reg_prepare_enc(re,
str, 1);
1653 if (reg->enc == enc)
return reg;
1657 VALUE src_str = RREGEXP_SRC(re);
1658 const char *pattern = RSTRING_PTR(src_str);
1660 onig_errmsg_buffer err =
"";
1661 unescaped = rb_reg_preprocess(
1662 pattern, pattern + RSTRING_LEN(src_str), enc,
1663 &fixed_enc, err, reg->options);
1665 if (
NIL_P(unescaped)) {
1666 rb_raise(rb_eArgError,
"regexp preprocess failed: %s", err);
1670 rb_hrtime_t timelimit = reg->timelimit;
1677 if (ruby_single_main_ractor &&
RREGEXP(re)->usecnt == 0) {
1679 r = onig_new_without_alloc(&tmp_reg, (UChar *)
ptr, (UChar *)(
ptr +
len),
1681 OnigDefaultSyntax, &einfo);
1685 onig_free_body(&tmp_reg);
1688 onig_free_body(reg);
1694 r = onig_new(®, (UChar *)
ptr, (UChar *)(
ptr +
len),
1696 OnigDefaultSyntax, &einfo);
1700 onig_error_code_to_str((UChar*)err, r, &einfo);
1701 rb_reg_raise(err, re);
1704 reg->timelimit = timelimit;
1706 rb_bug(
"group count mismatch in the recompiled regexp: %d != %d", reg->num_mem,
RREGEXP_PTR(re)->num_mem);
1722 if (!tmpreg)
RREGEXP(re)->usecnt++;
1724 OnigPosition result = match(reg,
str, regs, args);
1726 if (!tmpreg)
RREGEXP(re)->usecnt--;
1732 onig_region_free(regs, 0);
1737 case ONIGERR_TIMEOUT:
1738 rb_raise(rb_eRegexpTimeoutError,
"regexp match timeout");
1740 onig_errmsg_buffer err =
"";
1741 onig_error_code_to_str((UChar*)err, (
int)result);
1742 rb_reg_raise(err, re);
1757 enc = rb_reg_prepare_enc(re,
str, 0);
1763 range = RSTRING_LEN(
str) - pos;
1766 if (pos > 0 && ONIGENC_MBC_MAXLEN(enc) != 1 && pos < RSTRING_LEN(
str)) {
1767 string = (UChar*)RSTRING_PTR(
str);
1770 p = onigenc_get_right_adjust_char_head(enc,
string,
string + pos,
string + RSTRING_LEN(
str));
1773 p = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc,
string,
string + pos,
string + RSTRING_LEN(
str));
1787reg_onig_search(regex_t *reg,
VALUE str,
struct re_registers *regs,
void *args_ptr)
1798 (UChar *)(
ptr + args->pos),
1799 (UChar *)(
ptr + args->range),
1806rb_reg_search_set_match(
VALUE re,
VALUE str,
long pos,
int reverse,
int set_backref_str,
VALUE *set_match)
1808 long len = RSTRING_LEN(str);
1809 if (pos >
len || pos < 0) {
1816 .range = reverse ? 0 :
len,
1820 OnigPosition result =
rb_reg_onig_match(re, str, reg_onig_search, &args, ®s);
1822 if (result == ONIG_MISMATCH) {
1824 return ONIG_MISMATCH;
1844 onig_region_free(&RMATCH_EXT(match)->regs,
false);
1847 rb_matchext_t *rm = RMATCH_EXT(match);
1850 if (set_backref_str) {
1864 if (set_match) *set_match = match;
1870rb_reg_search0(
VALUE re,
VALUE str,
long pos,
int reverse,
int set_backref_str,
VALUE *match)
1872 return rb_reg_search_set_match(re, str, pos, reverse, set_backref_str, match);
1878 return rb_reg_search_set_match(re, str, pos, reverse, 1, NULL);
1925 regs = RMATCH_REGS(match);
1926 if (nth >= regs->num_regs) {
1930 nth += regs->num_regs;
1931 if (nth <= 0)
return Qnil;
1933 return RBOOL(BEG(nth) != -1);
1940 long start, end,
len;
1945 regs = RMATCH_REGS(match);
1946 if (nth >= regs->num_regs) {
1950 nth += regs->num_regs;
1951 if (nth <= 0)
return Qnil;
1954 if (start == -1)
return Qnil;
1993 regs = RMATCH_REGS(match);
1994 if (BEG(0) == -1)
return Qnil;
2027 regs = RMATCH_REGS(match);
2028 if (BEG(0) == -1)
return Qnil;
2029 str =
RMATCH(match)->str;
2036match_last_index(
VALUE match)
2041 if (
NIL_P(match))
return -1;
2043 regs = RMATCH_REGS(match);
2044 if (BEG(0) == -1)
return -1;
2046 for (i=regs->num_regs-1; BEG(i) == -1 && i > 0; i--)
2054 int i = match_last_index(match);
2055 if (i <= 0)
return Qnil;
2061rb_reg_last_defined(
VALUE match)
2063 int i = match_last_index(match);
2064 if (i < 0)
return Qnil;
2069last_match_getter(
ID _x,
VALUE *_y)
2075prematch_getter(
ID _x,
VALUE *_y)
2081postmatch_getter(
ID _x,
VALUE *_y)
2087last_paren_match_getter(
ID _x,
VALUE *_y)
2093match_array(
VALUE match,
int start)
2101 regs = RMATCH_REGS(match);
2103 target =
RMATCH(match)->str;
2105 for (i=start; i<regs->num_regs; i++) {
2106 if (regs->beg[i] == -1) {
2133match_to_a(
VALUE match)
2135 return match_array(match, 0);
2155match_captures(
VALUE match)
2157 return match_array(match, 1);
2161name_to_backref_number(
struct re_registers *regs,
VALUE regexp,
const char* name,
const char* name_end)
2163 if (
NIL_P(regexp))
return -1;
2164 return onig_name_to_backref_number(
RREGEXP_PTR(regexp),
2165 (
const unsigned char *)name, (
const unsigned char *)name_end, regs);
2168#define NAME_TO_NUMBER(regs, re, name, name_ptr, name_end) \
2170 !rb_enc_compatible(RREGEXP_SRC(re), (name)) ? 0 : \
2171 name_to_backref_number((regs), (re), (name_ptr), (name_end)))
2181 else if (!RB_TYPE_P(name,
T_STRING)) {
2184 num = NAME_TO_NUMBER(regs, re, name,
2185 RSTRING_PTR(name), RSTRING_END(name));
2187 name_to_backref_error(name);
2193match_ary_subseq(
VALUE match,
long beg,
long len,
VALUE result)
2195 long olen = RMATCH_REGS(match)->num_regs;
2196 long j, end = olen < beg+
len ? olen : beg+
len;
2198 if (
len == 0)
return result;
2200 for (j = beg; j < end; j++) {
2203 if (beg +
len > j) {
2213 int num_regs = RMATCH_REGS(match)->num_regs;
2224 return match_ary_subseq(match, beg,
len, result);
2267match_aref(
int argc,
VALUE *argv,
VALUE match)
2274 if (
NIL_P(length)) {
2279 int num = namev_to_backref_number(RMATCH_REGS(match),
RMATCH(match)->regexp, idx);
2284 return match_ary_aref(match, idx,
Qnil);
2291 long num_regs = RMATCH_REGS(match)->num_regs;
2297 if (beg < 0)
return Qnil;
2299 else if (beg > num_regs) {
2302 if (beg+
len > num_regs) {
2303 len = num_regs - beg;
2305 return match_ary_subseq(match, beg,
len,
Qnil);
2336match_values_at(
int argc,
VALUE *argv,
VALUE match)
2344 for (i=0; i<argc; i++) {
2349 int num = namev_to_backref_number(RMATCH_REGS(match),
RMATCH(match)->regexp, argv[i]);
2354 match_ary_aref(match, argv[i], result);
2381match_to_s(
VALUE match)
2390match_named_captures_iter(
const OnigUChar *name,
const OnigUChar *name_end,
2391 int back_num,
int *back_refs, OnigRegex regex,
void *arg)
2393 struct MEMO *memo = MEMO_CAST(arg);
2394 VALUE hash = memo->v1;
2395 VALUE match = memo->v2;
2396 long symbolize = memo->u3.state;
2398 VALUE key = rb_enc_str_new((
const char *)name, name_end-name, regex->enc);
2400 if (symbolize > 0) {
2409 for (i = 0; i < back_num; i++) {
2412 rb_hash_aset(hash, key, value);
2418 rb_hash_aset(hash, key,
Qnil);
2457match_named_captures(
int argc,
VALUE *argv,
VALUE match)
2464 return rb_hash_new();
2467 VALUE symbolize_names = 0;
2472 static ID keyword_ids[1];
2474 VALUE symbolize_names_val;
2476 if (!keyword_ids[0]) {
2477 keyword_ids[0] = rb_intern_const(
"symbolize_names");
2479 rb_get_kwargs(opt, keyword_ids, 0, 1, &symbolize_names_val);
2480 if (!UNDEF_P(symbolize_names_val) &&
RTEST(symbolize_names_val)) {
2481 symbolize_names = 1;
2485 hash = rb_hash_new();
2486 memo = MEMO_NEW(hash, match, symbolize_names);
2488 onig_foreach_name(
RREGEXP(
RMATCH(match)->regexp)->
ptr, match_named_captures_iter, (
void*)memo);
2510match_deconstruct_keys(
VALUE match,
VALUE keys)
2518 return rb_hash_new_with_size(0);
2522 h = rb_hash_new_with_size(onig_number_of_names(
RREGEXP_PTR(
RMATCH(match)->regexp)));
2525 memo = MEMO_NEW(h, match, 1);
2527 onig_foreach_name(
RREGEXP_PTR(
RMATCH(match)->regexp), match_named_captures_iter, (
void*)memo);
2535 return rb_hash_new_with_size(0);
2548 int num = NAME_TO_NUMBER(RMATCH_REGS(match),
RMATCH(match)->regexp,
RMATCH(match)->regexp,
2549 RSTRING_PTR(name), RSTRING_END(name));
2576match_string(
VALUE match)
2579 return RMATCH(match)->str;
2588match_inspect_name_iter(
const OnigUChar *name,
const OnigUChar *name_end,
2589 int back_num,
int *back_refs, OnigRegex regex,
void *arg0)
2594 for (i = 0; i < back_num; i++) {
2595 arg[back_refs[i]].name = name;
2596 arg[back_refs[i]].len = name_end - name;
2623match_inspect(
VALUE match)
2629 int num_regs = regs->num_regs;
2634 return rb_sprintf(
"#<%"PRIsVALUE
":%p>", cname, (
void*)match);
2636 else if (
NIL_P(regexp)) {
2637 return rb_sprintf(
"#<%"PRIsVALUE
": %"PRIsVALUE
">",
2645 match_inspect_name_iter, names);
2650 for (i = 0; i < num_regs; i++) {
2657 rb_str_catf(str,
"%d", i);
2675read_escaped_byte(
const char **pp,
const char *end, onig_errmsg_buffer err)
2677 const char *p = *pp;
2679 int meta_prefix = 0, ctrl_prefix = 0;
2682 if (p == end || *p++ !=
'\\') {
2683 errcpy(err,
"too short escaped multibyte character");
2689 errcpy(err,
"too short escape sequence");
2693 case '\\': code =
'\\';
break;
2694 case 'n': code =
'\n';
break;
2695 case 't': code =
'\t';
break;
2696 case 'r': code =
'\r';
break;
2697 case 'f': code =
'\f';
break;
2698 case 'v': code =
'\013';
break;
2699 case 'a': code =
'\007';
break;
2700 case 'e': code =
'\033';
break;
2703 case '0':
case '1':
case '2':
case '3':
2704 case '4':
case '5':
case '6':
case '7':
2713 errcpy(err,
"invalid hex escape");
2721 errcpy(err,
"duplicate meta escape");
2725 if (p+1 < end && *p++ ==
'-' && (*p & 0x80) == 0) {
2735 errcpy(err,
"too short meta escape");
2739 if (p == end || *p++ !=
'-') {
2740 errcpy(err,
"too short control escape");
2745 errcpy(err,
"duplicate control escape");
2749 if (p < end && (*p & 0x80) == 0) {
2759 errcpy(err,
"too short control escape");
2763 errcpy(err,
"unexpected escape sequence");
2766 if (code < 0 || 0xff < code) {
2767 errcpy(err,
"invalid escape code");
2781unescape_escaped_nonascii(
const char **pp,
const char *end, rb_encoding *enc,
2782 VALUE buf, rb_encoding **encp, onig_errmsg_buffer err)
2784 const char *p = *pp;
2785 int chmaxlen = rb_enc_mbmaxlen(enc);
2786 unsigned char *area =
ALLOCA_N(
unsigned char, chmaxlen);
2787 char *chbuf = (
char *)area;
2792 memset(chbuf, 0, chmaxlen);
2794 byte = read_escaped_byte(&p, end, err);
2799 area[chlen++] = byte;
2800 while (chlen < chmaxlen &&
2802 byte = read_escaped_byte(&p, end, err);
2806 area[chlen++] = byte;
2809 l = rb_enc_precise_mbclen(chbuf, chbuf+chlen, enc);
2811 errcpy(err,
"invalid multibyte escape");
2814 if (1 < chlen || (area[0] & 0x80)) {
2819 else if (*encp != enc) {
2820 errcpy(err,
"escaped non ASCII character in UTF-8 regexp");
2826 snprintf(escbuf,
sizeof(escbuf),
"\\x%02X", area[0]&0xff);
2834check_unicode_range(
unsigned long code, onig_errmsg_buffer err)
2836 if ((0xd800 <= code && code <= 0xdfff) ||
2838 errcpy(err,
"invalid Unicode range");
2845append_utf8(
unsigned long uv,
2846 VALUE buf, rb_encoding **encp, onig_errmsg_buffer err)
2848 if (check_unicode_range(uv, err) != 0)
2852 snprintf(escbuf,
sizeof(escbuf),
"\\x%02X", (
int)uv);
2862 *encp = rb_utf8_encoding();
2863 else if (*encp != rb_utf8_encoding()) {
2864 errcpy(err,
"UTF-8 character in non UTF-8 regexp");
2872unescape_unicode_list(
const char **pp,
const char *end,
2873 VALUE buf, rb_encoding **encp, onig_errmsg_buffer err)
2875 const char *p = *pp;
2876 int has_unicode = 0;
2880 while (p < end &&
ISSPACE(*p)) p++;
2883 code = ruby_scan_hex(p, end-p, &
len);
2887 errcpy(err,
"invalid Unicode range");
2891 if (append_utf8(code, buf, encp, err) != 0)
2895 while (p < end &&
ISSPACE(*p)) p++;
2898 if (has_unicode == 0) {
2899 errcpy(err,
"invalid Unicode list");
2909unescape_unicode_bmp(
const char **pp,
const char *end,
2910 VALUE buf, rb_encoding **encp, onig_errmsg_buffer err)
2912 const char *p = *pp;
2917 errcpy(err,
"invalid Unicode escape");
2920 code = ruby_scan_hex(p, 4, &
len);
2922 errcpy(err,
"invalid Unicode escape");
2925 if (append_utf8(code, buf, encp, err) != 0)
2932unescape_nonascii0(
const char **pp,
const char *end, rb_encoding *enc,
2933 VALUE buf, rb_encoding **encp,
int *has_property,
2934 onig_errmsg_buffer err,
int options,
int recurse)
2936 const char *p = *pp;
2939 int in_char_class = 0;
2941 int extended_mode = options & ONIG_OPTION_EXTEND;
2945 int chlen = rb_enc_precise_mbclen(p, end, enc);
2948 errcpy(err,
"invalid multibyte character");
2952 if (1 < chlen || (*p & 0x80)) {
2958 else if (*encp != enc) {
2959 errcpy(err,
"non ASCII character in UTF-8 regexp");
2968 errcpy(err,
"too short escape sequence");
2971 chlen = rb_enc_precise_mbclen(p, end, enc);
2973 goto invalid_multibyte;
2982 case '1':
case '2':
case '3':
2983 case '4':
case '5':
case '6':
case '7':
2985 size_t len = end-(p-1), octlen;
2986 if (ruby_scan_oct(p-1,
len < 3 ?
len : 3, &octlen) <= 0177) {
3002 if (rb_is_usascii_enc(enc)) {
3003 const char *pbeg = p;
3004 int byte = read_escaped_byte(&p, end, err);
3005 if (
byte == -1)
return -1;
3010 if (unescape_escaped_nonascii(&p, end, enc, buf, encp, err) != 0)
3017 errcpy(err,
"too short escape sequence");
3023 if (unescape_unicode_list(&p, end, buf, encp, err) != 0)
3025 if (p == end || *p++ !=
'}') {
3026 errcpy(err,
"invalid Unicode list");
3033 if (unescape_unicode_bmp(&p, end, buf, encp, err) != 0)
3055 if (extended_mode && !in_char_class) {
3057 while ((p < end) && ((c = *p++) !=
'\n')) {
3058 if ((c & 0x80) && !*encp && enc == rb_utf8_encoding()) {
3072 if (in_char_class) {
3079 if (!in_char_class && recurse) {
3080 if (--parens == 0) {
3087 if (!in_char_class && p + 1 < end && *p ==
'?') {
3088 if (*(p+1) ==
'#') {
3090 const char *orig_p = p;
3093 while (cont && (p < end)) {
3096 if (!(c & 0x80))
break;
3097 if (!*encp && enc == rb_utf8_encoding()) {
3103 chlen = rb_enc_precise_mbclen(p, end, enc);
3105 goto invalid_multibyte;
3129 int local_extend = 0;
3136 for (s = p+1; s < end; s++) {
3139 local_extend = invert ? -1 : 1;
3146 if (local_extend == 0 ||
3147 (local_extend == -1 && !extended_mode) ||
3148 (local_extend == 1 && extended_mode)) {
3155 int local_options = options;
3156 if (local_extend == 1) {
3157 local_options |= ONIG_OPTION_EXTEND;
3160 local_options &= ~ONIG_OPTION_EXTEND;
3164 int ret = unescape_nonascii0(&p, end, enc, buf, encp,
3167 if (ret < 0)
return ret;
3172 extended_mode = local_extend == 1;
3189 else if (!in_char_class && recurse) {
3207unescape_nonascii(
const char *p,
const char *end, rb_encoding *enc,
3208 VALUE buf, rb_encoding **encp,
int *has_property,
3209 onig_errmsg_buffer err,
int options)
3211 return unescape_nonascii0(&p, end, enc, buf, encp, has_property,
3216rb_reg_preprocess(
const char *p,
const char *end, rb_encoding *enc,
3217 rb_encoding **fixed_enc, onig_errmsg_buffer err,
int options)
3220 int has_property = 0;
3224 if (rb_enc_asciicompat(enc))
3228 rb_enc_associate(buf, enc);
3231 if (unescape_nonascii(p, end, enc, buf, fixed_enc, &has_property, err, options) != 0)
3234 if (has_property && !*fixed_enc) {
3239 rb_enc_associate(buf, *fixed_enc);
3246rb_reg_check_preprocess(
VALUE str)
3248 rb_encoding *fixed_enc = 0;
3249 onig_errmsg_buffer err =
"";
3255 p = RSTRING_PTR(str);
3256 end = p + RSTRING_LEN(str);
3257 enc = rb_enc_get(str);
3259 buf = rb_reg_preprocess(p, end, enc, &fixed_enc, err, 0);
3263 return rb_reg_error_desc(str, 0, err);
3269rb_reg_preprocess_dregexp(
VALUE ary,
int options)
3271 rb_encoding *fixed_enc = 0;
3272 rb_encoding *regexp_enc = 0;
3273 onig_errmsg_buffer err =
"";
3276 rb_encoding *ascii8bit = rb_ascii8bit_encoding();
3279 rb_raise(rb_eArgError,
"no arguments given");
3286 rb_encoding *src_enc;
3288 src_enc = rb_enc_get(str);
3289 if (options & ARG_ENCODING_NONE &&
3290 src_enc != ascii8bit) {
3292 rb_raise(
rb_eRegexpError,
"/.../n has a non escaped non ASCII character in non ASCII-8BIT script");
3294 src_enc = ascii8bit;
3298 p = RSTRING_PTR(str);
3299 end = p + RSTRING_LEN(str);
3301 buf = rb_reg_preprocess(p, end, src_enc, &fixed_enc, err, options);
3304 rb_raise(rb_eArgError,
"%s", err);
3306 if (fixed_enc != 0) {
3307 if (regexp_enc != 0 && regexp_enc != fixed_enc) {
3308 rb_raise(
rb_eRegexpError,
"encoding mismatch in dynamic regexp : %s and %s",
3309 rb_enc_name(regexp_enc), rb_enc_name(fixed_enc));
3311 regexp_enc = fixed_enc;
3320 rb_enc_associate(result, regexp_enc);
3327rb_reg_initialize_check(
VALUE obj)
3329 rb_check_frozen(obj);
3336rb_reg_initialize(
VALUE obj,
const char *s,
long len, rb_encoding *enc,
3337 int options, onig_errmsg_buffer err,
3338 const char *sourcefile,
int sourceline)
3342 rb_encoding *fixed_enc = 0;
3343 rb_encoding *a_enc = rb_ascii8bit_encoding();
3345 rb_reg_initialize_check(obj);
3347 if (rb_enc_dummy_p(enc)) {
3348 errcpy(err,
"can't make regexp with dummy encoding");
3352 unescaped = rb_reg_preprocess(s, s+
len, enc, &fixed_enc, err, options);
3353 if (
NIL_P(unescaped))
3357 if ((fixed_enc != enc && (options & ARG_ENCODING_FIXED)) ||
3358 (fixed_enc != a_enc && (options & ARG_ENCODING_NONE))) {
3359 errcpy(err,
"incompatible character encoding");
3362 if (fixed_enc != a_enc) {
3363 options |= ARG_ENCODING_FIXED;
3367 else if (!(options & ARG_ENCODING_FIXED)) {
3368 enc = rb_usascii_encoding();
3371 rb_enc_associate((
VALUE)re, enc);
3372 if ((options & ARG_ENCODING_FIXED) || fixed_enc) {
3375 if (options & ARG_ENCODING_NONE) {
3379 re->
ptr = make_regexp(RSTRING_PTR(unescaped), RSTRING_LEN(unescaped), enc,
3380 options & ARG_REG_OPTION_MASK, err,
3381 sourcefile, sourceline);
3382 if (!re->
ptr)
return -1;
3388reg_set_source(
VALUE reg,
VALUE str, rb_encoding *enc)
3390 rb_encoding *regenc = rb_enc_get(reg);
3392 if (regenc != enc) {
3394 str = rb_enc_associate(dup, enc = regenc);
3396 str = rb_fstring(str);
3401rb_reg_initialize_str(
VALUE obj,
VALUE str,
int options, onig_errmsg_buffer err,
3402 const char *sourcefile,
int sourceline)
3405 rb_encoding *str_enc = rb_enc_get(str), *enc = str_enc;
3406 if (options & ARG_ENCODING_NONE) {
3407 rb_encoding *ascii8bit = rb_ascii8bit_encoding();
3408 if (enc != ascii8bit) {
3410 errcpy(err,
"/.../n has a non escaped non ASCII character in non ASCII-8BIT script");
3416 ret = rb_reg_initialize(obj, RSTRING_PTR(str), RSTRING_LEN(str), enc,
3417 options, err, sourcefile, sourceline);
3418 if (ret == 0) reg_set_source(obj, str, str_enc);
3423rb_reg_s_alloc(
VALUE klass)
3443 return rb_reg_init_str(rb_reg_alloc(), s, options);
3447rb_reg_init_str(
VALUE re,
VALUE s,
int options)
3449 onig_errmsg_buffer err =
"";
3451 if (rb_reg_initialize_str(re, s, options, err, NULL, 0) != 0) {
3452 rb_reg_raise_str(s, options, err);
3459rb_reg_init_str_enc(
VALUE re,
VALUE s, rb_encoding *enc,
int options)
3461 onig_errmsg_buffer err =
"";
3463 if (rb_reg_initialize(re, RSTRING_PTR(s), RSTRING_LEN(s),
3464 enc, options, err, NULL, 0) != 0) {
3465 rb_reg_raise_str(s, options, err);
3467 reg_set_source(re, s, enc);
3473rb_reg_new_ary(
VALUE ary,
int opt)
3483 VALUE re = rb_reg_alloc();
3484 onig_errmsg_buffer err =
"";
3486 if (rb_reg_initialize(re, s,
len, enc, options, err, NULL, 0) != 0) {
3487 rb_enc_reg_raise(s,
len, enc, options, err);
3501rb_reg_compile(
VALUE str,
int options,
const char *sourcefile,
int sourceline)
3503 VALUE re = rb_reg_alloc();
3504 onig_errmsg_buffer err =
"";
3507 if (rb_reg_initialize_str(re, str, options, err, sourcefile, sourceline) != 0) {
3508 rb_set_errinfo(rb_reg_error_desc(str, options, err));
3515static VALUE reg_cache;
3520 if (rb_ractor_main_p()) {
3521 if (reg_cache && RREGEXP_SRC_LEN(reg_cache) == RSTRING_LEN(str)
3523 && memcmp(RREGEXP_SRC_PTR(reg_cache), RSTRING_PTR(str), RSTRING_LEN(str)) == 0)
3533static st_index_t reg_hash(
VALUE re);
3545rb_reg_hash(
VALUE re)
3547 st_index_t hashval = reg_hash(re);
3580 if (re1 == re2)
return Qtrue;
3582 rb_reg_check(re1); rb_reg_check(re2);
3585 if (RREGEXP_SRC_LEN(re1) != RREGEXP_SRC_LEN(re2))
return Qfalse;
3587 return RBOOL(memcmp(RREGEXP_SRC_PTR(re1), RREGEXP_SRC_PTR(re2), RREGEXP_SRC_LEN(re1)) == 0);
3602match_hash(
VALUE match)
3609 hashval =
rb_hash_uint(hashval, reg_hash(match_regexp(match)));
3610 regs = RMATCH_REGS(match);
3632 if (match1 == match2)
return Qtrue;
3636 if (!rb_reg_equal(match_regexp(match1), match_regexp(match2)))
return Qfalse;
3637 regs1 = RMATCH_REGS(match1);
3638 regs2 = RMATCH_REGS(match2);
3639 if (regs1->num_regs != regs2->num_regs)
return Qfalse;
3640 if (memcmp(regs1->beg, regs2->beg, regs1->num_regs *
sizeof(*regs1->beg)))
return Qfalse;
3641 if (memcmp(regs1->end, regs2->end, regs1->num_regs *
sizeof(*regs1->end)))
return Qfalse;
3646reg_operand(
VALUE s,
int check)
3668 *strp = str = reg_operand(str, TRUE);
3679 return rb_reg_search_set_match(re, str, pos, 0, 1, set_match);
3741 long pos = reg_match_pos(re, &str, 0, NULL);
3742 if (pos < 0)
return Qnil;
3772 str = reg_operand(str, FALSE);
3778 return RBOOL(start >= 0);
3855rb_reg_match_m(
int argc,
VALUE *argv,
VALUE re)
3860 if (
rb_scan_args(argc, argv,
"11", &str, &initpos) == 2) {
3867 pos = reg_match_pos(re, &str, pos, &result);
3896rb_reg_match_m_p(
int argc,
VALUE *argv,
VALUE re)
3898 long pos = rb_check_arity(argc, 1, 2) > 1 ?
NUM2LONG(argv[1]) : 0;
3899 return rb_reg_match_p(re, argv[0], pos);
3910 if (pos < 0)
return Qfalse;
3916 pos = beg - RSTRING_PTR(str);
3922 .range = RSTRING_LEN(str),
3935str_to_option(
VALUE str)
3941 if (
NIL_P(str))
return -1;
3943 for (
long i = 0; i <
len; ++i) {
3944 int f = char_to_option(
ptr[i]);
3946 rb_raise(rb_eArgError,
"unknown regexp option: %"PRIsVALUE, str);
3954set_timeout(rb_hrtime_t *hrt,
VALUE timeout)
3956 double timeout_d =
NIL_P(timeout) ? 0.0 :
NUM2DBL(timeout);
3957 if (!
NIL_P(timeout) && timeout_d <= 0) {
3958 rb_raise(rb_eArgError,
"invalid timeout: %"PRIsVALUE, timeout);
3960 double2hrtime(hrt, timeout_d);
3969 rb_reg_initialize_check(copy);
3970 if ((r = onig_reg_copy(&re,
RREGEXP_PTR(orig))) != 0) {
3977 rb_enc_copy(copy, orig);
3992void rb_warn_deprecated_to_remove(
const char *removal,
const char *fmt,
const char *suggest, ...);
4049rb_reg_initialize_m(
int argc,
VALUE *argv,
VALUE self)
4052 VALUE re = reg_extract_args(argc, argv, &args);
4061 set_timeout(&
RREGEXP_PTR(self)->timelimit, args.timeout);
4070 rb_encoding *enc = 0;
4076 args->timeout =
Qnil;
4077 if (!
NIL_P(kwargs)) {
4078 static ID keywords[1];
4080 keywords[0] = rb_intern_const(
"timeout");
4093 str = RREGEXP_SRC(re);
4099 else if ((f = str_to_option(opts)) >= 0) flags = f;
4100 else if (rb_bool_expected(opts,
"ignorecase", FALSE))
4101 flags = ONIG_OPTION_IGNORECASE;
4107 args->flags = flags;
4114 if (enc && rb_enc_get(str) != enc)
4115 rb_reg_init_str_enc(self, str, enc, flags);
4117 rb_reg_init_str(self, str, flags);
4124 rb_encoding *enc = rb_enc_get(str);
4130 s = RSTRING_PTR(str);
4131 send = s + RSTRING_LEN(str);
4133 c = rb_enc_ascget(s, send, &clen, enc);
4135 s += mbclen(s, send, enc);
4139 case '[':
case ']':
case '{':
case '}':
4140 case '(':
case ')':
case '|':
case '-':
4141 case '*':
case '.':
case '\\':
4142 case '?':
case '+':
case '^':
case '$':
4144 case '\t':
case '\f':
case '\v':
case '\n':
case '\r':
4151 rb_enc_associate(tmp, rb_usascii_encoding());
4158 rb_enc_associate(tmp, rb_usascii_encoding());
4161 rb_enc_copy(tmp, str);
4163 t = RSTRING_PTR(tmp);
4165 const char *p = RSTRING_PTR(str);
4166 memcpy(t, p, s - p);
4170 c = rb_enc_ascget(s, send, &clen, enc);
4172 int n = mbclen(s, send, enc);
4180 case '[':
case ']':
case '{':
case '}':
4181 case '(':
case ')':
case '|':
case '-':
4182 case '*':
case '.':
case '\\':
4183 case '?':
case '+':
case '^':
case '$':
4185 t += rb_enc_mbcput(
'\\', t, enc);
4188 t += rb_enc_mbcput(
'\\', t, enc);
4189 t += rb_enc_mbcput(
' ', t, enc);
4192 t += rb_enc_mbcput(
'\\', t, enc);
4193 t += rb_enc_mbcput(
't', t, enc);
4196 t += rb_enc_mbcput(
'\\', t, enc);
4197 t += rb_enc_mbcput(
'n', t, enc);
4200 t += rb_enc_mbcput(
'\\', t, enc);
4201 t += rb_enc_mbcput(
'r', t, enc);
4204 t += rb_enc_mbcput(
'\\', t, enc);
4205 t += rb_enc_mbcput(
'f', t, enc);
4208 t += rb_enc_mbcput(
'\\', t, enc);
4209 t += rb_enc_mbcput(
'v', t, enc);
4212 t += rb_enc_mbcput(c, t, enc);
4214 rb_str_resize(tmp, t - RSTRING_PTR(tmp));
4247 options =
RREGEXP_PTR(re)->options & ARG_REG_OPTION_MASK;
4248 if (
RBASIC(re)->flags & KCODE_FIXED) options |= ARG_ENCODING_FIXED;
4249 if (
RBASIC(re)->flags & REG_ENCODING_NONE) options |= ARG_ENCODING_NONE;
4254rb_check_regexp_type(
VALUE re)
4280 return rb_check_regexp_type(re);
4293 else if (argc == 1) {
4295 VALUE re = rb_check_regexp_type(arg);
4300 quoted = rb_reg_s_quote(
Qnil, arg);
4307 rb_encoding *result_enc;
4309 int has_asciionly = 0;
4310 rb_encoding *has_ascii_compat_fixed = 0;
4311 rb_encoding *has_ascii_incompat = 0;
4313 for (i = 0; i < argc; i++) {
4320 v = rb_check_regexp_type(e);
4322 rb_encoding *enc = rb_enc_get(v);
4323 if (!rb_enc_asciicompat(enc)) {
4324 if (!has_ascii_incompat)
4325 has_ascii_incompat = enc;
4326 else if (has_ascii_incompat != enc)
4327 rb_raise(rb_eArgError,
"incompatible encodings: %s and %s",
4328 rb_enc_name(has_ascii_incompat), rb_enc_name(enc));
4330 else if (rb_reg_fixed_encoding_p(v)) {
4331 if (!has_ascii_compat_fixed)
4332 has_ascii_compat_fixed = enc;
4333 else if (has_ascii_compat_fixed != enc)
4334 rb_raise(rb_eArgError,
"incompatible encodings: %s and %s",
4335 rb_enc_name(has_ascii_compat_fixed), rb_enc_name(enc));
4340 v = rb_reg_str_with_term(v, -1);
4345 enc = rb_enc_get(e);
4346 if (!rb_enc_asciicompat(enc)) {
4347 if (!has_ascii_incompat)
4348 has_ascii_incompat = enc;
4349 else if (has_ascii_incompat != enc)
4350 rb_raise(rb_eArgError,
"incompatible encodings: %s and %s",
4351 rb_enc_name(has_ascii_incompat), rb_enc_name(enc));
4357 if (!has_ascii_compat_fixed)
4358 has_ascii_compat_fixed = enc;
4359 else if (has_ascii_compat_fixed != enc)
4360 rb_raise(rb_eArgError,
"incompatible encodings: %s and %s",
4361 rb_enc_name(has_ascii_compat_fixed), rb_enc_name(enc));
4363 v = rb_reg_s_quote(
Qnil, e);
4365 if (has_ascii_incompat) {
4366 if (has_asciionly) {
4367 rb_raise(rb_eArgError,
"ASCII incompatible encoding: %s",
4368 rb_enc_name(has_ascii_incompat));
4370 if (has_ascii_compat_fixed) {
4371 rb_raise(rb_eArgError,
"incompatible encodings: %s and %s",
4372 rb_enc_name(has_ascii_incompat), rb_enc_name(has_ascii_compat_fixed));
4377 rb_enc_copy(source, v);
4382 if (has_ascii_incompat) {
4383 result_enc = has_ascii_incompat;
4385 else if (has_ascii_compat_fixed) {
4386 result_enc = has_ascii_compat_fixed;
4389 result_enc = rb_ascii8bit_encoding();
4392 rb_enc_associate(source, result_enc);
4437 return rb_reg_s_union(self, v);
4439 return rb_reg_s_union(self, args);
4464rb_reg_s_linear_time_p(
int argc,
VALUE *argv,
VALUE self)
4467 VALUE re = reg_extract_args(argc, argv, &args);
4470 re =
reg_init_args(rb_reg_alloc(), args.str, args.enc, args.flags);
4473 return RBOOL(onig_check_linear_time(
RREGEXP_PTR(re)));
4482 return reg_copy(copy, re);
4491 rb_encoding *str_enc = rb_enc_get(str);
4492 rb_encoding *src_enc = rb_enc_get(src);
4493 int acompat = rb_enc_asciicompat(str_enc);
4495#define ASCGET(s,e,cl) (acompat ? (*(cl)=1,ISASCII((s)[0])?(s)[0]:-1) : rb_enc_ascget((s), (e), (cl), str_enc))
4502 int c = ASCGET(s, e, &clen);
4506 s += mbclen(s, e, str_enc);
4512 if (c !=
'\\' || s == e)
continue;
4519 c = ASCGET(s, e, &clen);
4521 s += mbclen(s, e, str_enc);
4530 case '1':
case '2':
case '3':
case '4':
4531 case '5':
case '6':
case '7':
case '8':
case '9':
4532 if (!
NIL_P(regexp) && onig_noname_group_capture_is_active(
RREGEXP_PTR(regexp))) {
4541 if (s < e && ASCGET(s, e, &clen) ==
'<') {
4542 char *name, *name_end;
4544 name_end = name = s + clen;
4545 while (name_end < e) {
4546 c = ASCGET(name_end, e, &clen);
4547 if (c ==
'>')
break;
4548 name_end += c == -1 ? mbclen(name_end, e, str_enc) : clen;
4552 (
long)(name_end - name));
4553 if ((no = NAME_TO_NUMBER(regs, regexp, n, name, name_end)) < 1) {
4554 name_to_backref_error(n);
4556 p = s = name_end + clen;
4581 no = regs->num_regs-1;
4582 while (BEG(no) == -1 && no > 0) no--;
4583 if (no == 0)
continue;
4596 if (no >= regs->num_regs)
continue;
4597 if (BEG(no) == -1)
continue;
4602 if (!val)
return str;
4611ignorecase_getter(
ID _x,
VALUE *_y)
4634get_LAST_MATCH_INFO(
ID _x,
VALUE *_y)
4636 return match_getter();
4688rb_reg_s_last_match(
int argc,
VALUE *argv,
VALUE _)
4690 if (rb_check_arity(argc, 0, 1) == 1) {
4694 n = match_backref_number(match, argv[0]);
4697 return match_getter();
4701re_warn(
const char *s)
4708rb_reg_timeout_p(regex_t *reg,
void *end_time_)
4710 rb_hrtime_t *end_time = (rb_hrtime_t *)end_time_;
4712 if (*end_time == 0) {
4716 rb_hrtime_t timelimit = reg->timelimit;
4720 timelimit = rb_reg_match_time_limit;
4724 *end_time = rb_hrtime_add(timelimit, rb_hrtime_now());
4728 *end_time = RB_HRTIME_MAX;
4732 if (*end_time < rb_hrtime_now()) {
4750rb_reg_s_timeout_get(
VALUE dummy)
4752 double d = hrtime2double(rb_reg_match_time_limit);
4753 if (d == 0.0)
return Qnil;
4771rb_reg_s_timeout_set(
VALUE dummy,
VALUE timeout)
4773 rb_ractor_ensure_main_ractor(
"can not access Regexp.timeout from non-main Ractors");
4775 set_timeout(&rb_reg_match_time_limit, timeout);
4796rb_reg_timeout_get(
VALUE re)
4799 double d = hrtime2double(
RREGEXP_PTR(re)->timelimit);
4800 if (d == 0.0)
return Qnil;
4827 onigenc_set_default_encoding(ONIG_ENCODING_ASCII);
4828 onig_set_warn_func(re_warn);
4829 onig_set_verb_warn_func(re_warn);
4837 rb_gvar_ractor_local(
"$~");
4838 rb_gvar_ractor_local(
"$&");
4839 rb_gvar_ractor_local(
"$`");
4840 rb_gvar_ractor_local(
"$'");
4841 rb_gvar_ractor_local(
"$+");
4842 rb_gvar_box_dynamic(
"$~");
4843 rb_gvar_box_ready(
"$&");
4844 rb_gvar_box_ready(
"$`");
4845 rb_gvar_box_ready(
"$'");
4846 rb_gvar_box_ready(
"$+");
#define ISSPACE
@old{rb_isspace}
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
void rb_undef_method(VALUE klass, const char *name)
Defines an undef of a method.
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Retrieves argument from argc and argv to given VALUE references according to the format string.
int rb_block_given_p(void)
Determines if the current method is given a block.
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
Keyword argument deconstructor.
#define rb_str_new2
Old name of rb_str_new_cstr.
#define ENC_CODERANGE_7BIT
Old name of RUBY_ENC_CODERANGE_7BIT.
struct re_pattern_buffer Regexp
Old name of re_pattern_buffer.
#define rb_str_buf_cat2
Old name of rb_usascii_str_new_cstr.
#define REALLOC_N
Old name of RB_REALLOC_N.
#define OBJ_INIT_COPY(obj, orig)
Old name of RB_OBJ_INIT_COPY.
#define T_STRING
Old name of RUBY_T_STRING.
#define ENC_CODERANGE_CLEAN_P(cr)
Old name of RB_ENC_CODERANGE_CLEAN_P.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define rb_str_buf_new2
Old name of rb_str_buf_new_cstr.
#define ENC_CODERANGE(obj)
Old name of RB_ENC_CODERANGE.
#define CLASS_OF
Old name of rb_class_of.
#define ENC_CODERANGE_UNKNOWN
Old name of RUBY_ENC_CODERANGE_UNKNOWN.
#define ENCODING_GET(obj)
Old name of RB_ENCODING_GET.
#define LONG2FIX
Old name of RB_INT2FIX.
#define FIX2INT
Old name of RB_FIX2INT.
#define NUM2DBL
Old name of rb_num2dbl.
#define rb_str_new3
Old name of rb_str_new_shared.
#define MBCLEN_CHARFOUND_LEN(ret)
Old name of ONIGENC_MBCLEN_CHARFOUND_LEN.
#define FL_TEST_RAW
Old name of RB_FL_TEST_RAW.
#define FL_SET
Old name of RB_FL_SET.
#define LONG2NUM
Old name of RB_LONG2NUM.
#define rb_exc_new3
Old name of rb_exc_new_str.
#define MBCLEN_INVALID_P(ret)
Old name of ONIGENC_MBCLEN_INVALID_P.
#define Qtrue
Old name of RUBY_Qtrue.
#define ST2FIX
Old name of RB_ST2FIX.
#define MBCLEN_NEEDMORE_P(ret)
Old name of ONIGENC_MBCLEN_NEEDMORE_P.
#define NUM2INT
Old name of RB_NUM2INT.
#define INT2NUM
Old name of RB_INT2NUM.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define ENC_CODERANGE_BROKEN
Old name of RUBY_ENC_CODERANGE_BROKEN.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
#define scan_hex(s, l, e)
Old name of ruby_scan_hex.
#define NIL_P
Old name of RB_NIL_P.
#define MBCLEN_CHARFOUND_P(ret)
Old name of ONIGENC_MBCLEN_CHARFOUND_P.
#define FL_WB_PROTECTED
Old name of RUBY_FL_WB_PROTECTED.
#define T_SYMBOL
Old name of RUBY_T_SYMBOL.
#define DBL2NUM
Old name of rb_float_new.
#define T_MATCH
Old name of RUBY_T_MATCH.
#define FL_TEST
Old name of RB_FL_TEST.
#define NUM2LONG
Old name of RB_NUM2LONG.
#define FL_UNSET
Old name of RB_FL_UNSET.
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define scan_oct(s, l, e)
Old name of ruby_scan_oct.
#define rb_ary_new2
Old name of rb_ary_new_capa.
#define FL_SET_RAW
Old name of RB_FL_SET_RAW.
#define rb_str_new4
Old name of rb_str_new_frozen.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
#define T_REGEXP
Old name of RUBY_T_REGEXP.
void rb_category_warn(rb_warning_category_t category, const char *fmt,...)
Identical to rb_category_warning(), except it reports unless $VERBOSE is nil.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
VALUE rb_eStandardError
StandardError exception.
VALUE rb_eRegexpError
RegexpError exception.
#define ruby_verbose
This variable controls whether the interpreter is in debug mode.
VALUE rb_eTypeError
TypeError exception.
VALUE rb_eEncCompatError
Encoding::CompatibilityError exception.
VALUE rb_eRuntimeError
RuntimeError exception.
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
VALUE rb_eIndexError
IndexError exception.
@ RB_WARN_CATEGORY_DEPRECATED
Warning is for deprecated features.
VALUE rb_obj_reveal(VALUE obj, VALUE klass)
Make a hidden object visible again.
VALUE rb_check_convert_type(VALUE val, int type, const char *name, const char *mid)
Identical to rb_convert_type(), except it returns RUBY_Qnil instead of raising exceptions,...
VALUE rb_any_to_s(VALUE obj)
Generates a textual representation of the given object.
VALUE rb_class_new_instance(int argc, const VALUE *argv, VALUE klass)
Allocates, then initialises an instance of the given class.
VALUE rb_cMatch
MatchData class.
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
VALUE rb_class_new_instance_pass_kw(int argc, const VALUE *argv, VALUE klass)
Identical to rb_class_new_instance(), except it passes the passed keywords if any to the #initialize ...
VALUE rb_cRegexp
Regexp class.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_obj_freeze(VALUE obj)
Just calls rb_obj_freeze_inline() inside.
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
int rb_char_to_option_kcode(int c, int *option, int *kcode)
Converts a character option to its encoding.
VALUE rb_enc_reg_new(const char *ptr, long len, rb_encoding *enc, int opts)
Identical to rb_reg_new(), except it additionally takes an encoding.
int rb_enc_str_coderange(VALUE str)
Scans the passed string to collect its code range.
long rb_memsearch(const void *x, long m, const void *y, long n, rb_encoding *enc)
Looks for the passed string in the passed buffer.
long rb_enc_strlen(const char *head, const char *tail, rb_encoding *enc)
Counts the number of characters of the passed string, according to the passed encoding.
VALUE rb_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *enc)
Identical to rb_str_cat(), except it additionally takes an encoding.
int rb_enc_str_asciionly_p(VALUE str)
Queries if the passed string is "ASCII only".
VALUE rb_str_encode(VALUE str, VALUE to, int ecflags, VALUE ecopts)
Converts the contents of the passed string from its encoding to the passed one.
#define RGENGC_WB_PROTECTED_MATCH
This is a compile-time flag to enable/disable write barrier for struct RMatch.
#define RGENGC_WB_PROTECTED_REGEXP
This is a compile-time flag to enable/disable write barrier for struct RRegexp.
VALUE rb_check_array_type(VALUE obj)
Try converting an object to its array representation using its to_ary method, if any.
VALUE rb_ary_new_capa(long capa)
Identical to rb_ary_new(), except it additionally specifies how many rooms of objects it should alloc...
VALUE rb_ary_resize(VALUE ary, long len)
Expands or shrinks the passed array to the passed length.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
VALUE rb_ary_entry(VALUE ary, long off)
Queries an element of an array.
VALUE rb_assoc_new(VALUE car, VALUE cdr)
Identical to rb_ary_new_from_values(), except it expects exactly two parameters.
void rb_ary_store(VALUE ary, long key, VALUE val)
Destructively stores the passed value to the passed array's passed index.
int rb_uv_to_utf8(char buf[6], unsigned long uv)
Encodes a Unicode codepoint into its UTF-8 representation.
VALUE rb_backref_get(void)
Queries the last match, or Regexp.last_match, or the $~.
VALUE rb_lastline_get(void)
Queries the last line, or the $_.
void rb_backref_set(VALUE md)
Updates $~.
VALUE rb_range_beg_len(VALUE range, long *begp, long *lenp, long len, int err)
Deconstructs a numerical range.
int rb_reg_backref_number(VALUE match, VALUE backref)
Queries the index of the given named capture.
int rb_reg_options(VALUE re)
Queries the options of the passed regular expression.
VALUE rb_reg_last_match(VALUE md)
This just returns the argument, stringified.
VALUE rb_reg_match(VALUE re, VALUE str)
This is the match operator.
void rb_match_busy(VALUE md)
Asserts that the given MatchData is "occupied".
VALUE rb_reg_nth_match(int n, VALUE md)
Queries the nth captured substring.
VALUE rb_reg_match_post(VALUE md)
The portion of the original string after the given match.
VALUE rb_reg_nth_defined(int n, VALUE md)
Identical to rb_reg_nth_match(), except it just returns Boolean.
VALUE rb_reg_match_pre(VALUE md)
The portion of the original string before the given match.
VALUE rb_reg_new_str(VALUE src, int opts)
Identical to rb_reg_new(), except it takes the expression in Ruby's string instead of C's.
VALUE rb_reg_match_last(VALUE md)
The portion of the original string that captured at the very last.
VALUE rb_reg_match2(VALUE re)
Identical to rb_reg_match(), except it matches against rb_lastline_get() (or, the $_).
VALUE rb_reg_new(const char *src, long len, int opts)
Creates a new Regular expression.
#define rb_hash_uint(h, i)
Just another name of st_hash_uint.
#define rb_hash_end(h)
Just another name of st_hash_end.
VALUE rb_str_append(VALUE dst, VALUE src)
Identical to rb_str_buf_append(), except it converts the right hand side before concatenating.
long rb_str_offset(VALUE str, long pos)
"Inverse" of rb_str_sublen().
VALUE rb_str_subseq(VALUE str, long beg, long len)
Identical to rb_str_substr(), except the numbers are interpreted as byte offsets instead of character...
st_index_t rb_memhash(const void *ptr, long len)
This is a universal hash function.
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
#define rb_str_buf_cat
Just another name of rb_str_cat.
VALUE rb_str_dup(VALUE str)
Duplicates a string.
st_index_t rb_str_hash(VALUE str)
Calculates a hash value of a string.
char * rb_str_subpos(VALUE str, long beg, long *len)
Identical to rb_str_substr(), except it returns a C's string instead of Ruby's.
VALUE rb_str_buf_append(VALUE dst, VALUE src)
Identical to rb_str_cat_cstr(), except it takes Ruby's string instead of C's.
long rb_str_sublen(VALUE str, long pos)
Byte offset to character offset conversion.
VALUE rb_str_equal(VALUE str1, VALUE str2)
Equality of two strings.
st_index_t rb_hash_start(st_index_t i)
Starts a series of hashing.
VALUE rb_str_inspect(VALUE str)
Generates a "readable" version of the receiver.
VALUE rb_str_buf_cat_ascii(VALUE dst, const char *src)
Identical to rb_str_cat_cstr(), except it additionally assumes the source string be a NUL terminated ...
VALUE rb_check_string_type(VALUE obj)
Try converting an object to its stringised representation using its to_str method,...
VALUE rb_str_buf_new(long capa)
Allocates a "string buffer".
VALUE rb_str_length(VALUE)
Identical to rb_str_strlen(), except it returns the value in rb_cInteger.
VALUE rb_str_intern(VALUE str)
Identical to rb_to_symbol(), except it assumes the receiver being an instance of RString.
VALUE rb_class_path(VALUE mod)
Identical to rb_mod_name(), except it returns #<Class: ...> style inspection for anonymous modules.
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
VALUE rb_sym2str(VALUE symbol)
Obtain a frozen string representation of a symbol (not including the leading colon).
char * ptr
Pointer to the underlying memory region, of at least capa bytes.
int len
Length of the buffer.
long rb_reg_search(VALUE re, VALUE str, long pos, int dir)
Runs the passed regular expression over the passed string.
regex_t * rb_reg_prepare_re(VALUE re, VALUE str)
Exercises various checks and preprocesses so that the given regular expression can be applied to the ...
long rb_reg_adjust_startpos(VALUE re, VALUE str, long pos, int dir)
Tell us if this is a wrong idea, but it seems this function has no usage at all.
OnigPosition rb_reg_onig_match(VALUE re, VALUE str, OnigPosition(*match)(regex_t *reg, VALUE str, struct re_registers *regs, void *args), void *args, struct re_registers *regs)
Runs a regular expression match using function match.
VALUE rb_reg_regcomp(VALUE str)
Creates a new instance of rb_cRegexp.
VALUE rb_reg_quote(VALUE str)
Escapes any characters that would have special meaning in a regular expression.
VALUE rb_reg_regsub(VALUE repl, VALUE src, struct re_registers *regs, VALUE rexp)
Substitution.
int rb_reg_region_copy(struct re_registers *dst, const struct re_registers *src)
Duplicates a match data.
VALUE rb_yield(VALUE val)
Yields the block.
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
#define ALLOCA_N(type, n)
#define MEMZERO(p, type, n)
Handy macro to erase a region of memory.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
void rb_define_virtual_variable(const char *q, type *w, void_type *e)
Define a function-backended global variable.
#define RARRAY_LEN
Just another name of rb_array_len.
#define RARRAY_AREF(a, i)
#define RBASIC(obj)
Convenient casting macro.
#define RMATCH(obj)
Convenient casting macro.
#define RREGEXP(obj)
Convenient casting macro.
#define RREGEXP_PTR(obj)
Convenient accessor macro.
#define StringValue(v)
Ensures that the parameter object is a String.
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Convenient macro to obtain the contents and length at once.
VALUE rb_str_to_str(VALUE obj)
Identical to rb_check_string_type(), except it raises exceptions in case of conversion failures.
#define StringValueCStr(v)
Identical to StringValuePtr, except it additionally checks for the contents for viability as a C stri...
#define RTEST
This is an old name of RB_TEST.
#define _(args)
This was a transition path from K&R to ANSI.
VALUE flags
Per-object flags.
Regular expression execution context.
VALUE regexp
The expression of this match.
VALUE str
The target string that the match was made against.
Ruby's regular expression.
struct RBasic basic
Basic part, including flags and class.
const VALUE src
Source code of this expression.
unsigned long usecnt
Reference count.
struct re_pattern_buffer * ptr
The pattern buffer.
struct rmatch_offset * char_offset
Capture group offsets, in C array.
int char_offset_num_allocated
Number of rmatch_offset that rmatch::char_offset holds.
struct re_registers regs
"Registers" of a match.
Represents the region of a capture group.
long beg
Beginning of a group.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
#define SIZEOF_VALUE
Identical to sizeof(VALUE), except it is a macro that can also be used inside of preprocessor directi...
uintptr_t VALUE
Type that represents a Ruby object.