Skip to content

Use rb_len_t for String lengths and positions #222

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
hsbt wants to merge 3 commits into
base: master
Choose a base branch
from
+47 −39
Open

Use rb_len_t for String lengths and positions #222

Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
315fe21
Use rb_len_t for String lengths and positions
hsbt Oct 9, 2026
d1a3bb5
Fix lengths of 2**30 or more where long is 32 bits
hsbt Oct 9, 2026
25cc3ca
Keep capture group indices in long
hsbt Oct 12, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
86 changes: 47 additions & 39 deletions ext/strscan/strscan.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -12,6 +12,13 @@
#include "ruby/re.h"
#include "ruby/encoding.h"

#ifndef HAVE_RB_LEN_T
typedef long rb_len_t;
# define LEN2NUM LONG2NUM
# define NUM2LEN NUM2LONG
# define PRIdLEN "ld"
#endif

#ifdef RUBY_EXTCONF_H
# include RUBY_EXTCONF_H
#endif
Expand Down Expand Up @@ -51,8 +58,8 @@ struct strscanner
VALUE str;

/* scan pointers */
long prev; /* legal only when MATCHED_P(s) */
long curr; /* always legal */
rb_len_t prev; /* legal only when MATCHED_P(s) */
rb_len_t curr; /* always legal */

/* the regexp register; legal only when MATCHED_P(s) */
struct re_registers regs;
Expand Down Expand Up @@ -90,9 +97,9 @@ struct strscanner
Function Prototypes
======================================================================= */

static inline long minl _((const long n, const long x));
static VALUE extract_range _((struct strscanner *p, long beg_i, long end_i));
static VALUE extract_beg_len _((struct strscanner *p, long beg_i, long len));
static inline rb_len_t minl _((const rb_len_t n, const rb_len_t x));
static VALUE extract_range _((struct strscanner *p, rb_len_t beg_i, rb_len_t end_i));
static VALUE extract_beg_len _((struct strscanner *p, rb_len_t beg_i, rb_len_t len));

static struct strscanner *check_strscan _((VALUE obj));
static void strscan_mark _((void *p));
Expand Down Expand Up @@ -149,29 +156,29 @@ static VALUE inspect2 _((struct strscanner *p));
======================================================================= */

static VALUE
str_new(struct strscanner *p, const char *ptr, long len)
str_new(struct strscanner *p, const char *ptr, rb_len_t len)
{
VALUE str = rb_str_new(ptr, len);
rb_enc_copy(str, p->str);
return str;
}

static inline long
minl(const long x, const long y)
static inline rb_len_t
minl(const rb_len_t x, const rb_len_t y)
{
return (x < y) ? x : y;
}

static VALUE
extract_range(struct strscanner *p, long beg_i, long end_i)
extract_range(struct strscanner *p, rb_len_t beg_i, rb_len_t end_i)
{
if (beg_i > S_LEN(p)) return Qnil;
end_i = minl(end_i, S_LEN(p));
return str_new(p, S_PBEG(p) + beg_i, end_i - beg_i);
}

static VALUE
extract_beg_len(struct strscanner *p, long beg_i, long len)
extract_beg_len(struct strscanner *p, rb_len_t beg_i, rb_len_t len)
{
if (beg_i > S_LEN(p)) return Qnil;
len = minl(len, S_LEN(p) - beg_i);
Expand Down Expand Up @@ -558,7 +565,7 @@ strscan_get_pos(VALUE self)
struct strscanner *p;

GET_SCANNER(self, p);
return LONG2NUM(p->curr);
return LEN2NUM(p->curr);
}

/*
Expand All @@ -578,7 +585,7 @@ strscan_get_charpos(VALUE self)
GET_SCANNER(self, p);

s = EOS_P(p) ? S_PEND(p) : CURPTR(p);
return LONG2NUM(rb_enc_strlen(S_PBEG(p), s, rb_enc_get(p->str)));
return LEN2NUM(rb_enc_strlen(S_PBEG(p), s, rb_enc_get(p->str)));
}

/*
Expand All @@ -594,15 +601,15 @@ static VALUE
strscan_set_pos(VALUE self, VALUE v)
{
struct strscanner *p;
long i;
rb_len_t i;

GET_SCANNER(self, p);
i = NUM2LONG(v);
i = NUM2LEN(v);
if (i < 0) i += S_LEN(p);
if (i < 0) rb_raise(rb_eRangeError, "index out of range");
if (i > S_LEN(p)) rb_raise(rb_eRangeError, "index out of range");
p->curr = i;
return LONG2NUM(i);
return LEN2NUM(i);
}

static inline UChar *
Expand Down Expand Up @@ -658,7 +665,7 @@ succ(struct strscanner *p)
}
}

static inline long
static inline rb_len_t
last_match_length(struct strscanner *p)
{
if (p->fixed_anchor_p) {
Expand All @@ -670,8 +677,8 @@ last_match_length(struct strscanner *p)
}
}

static inline long
adjust_register_position(struct strscanner *p, long position)
static inline rb_len_t
adjust_register_position(struct strscanner *p, rb_len_t position)
{
if (p->fixed_anchor_p) {
return position;
Expand Down Expand Up @@ -798,8 +805,8 @@ strscan_do_scan(VALUE self, VALUE pattern, int succptr, int getstr, int headonly
}
else {
rb_encoding *enc = rb_enc_check(p->str, pattern);
long pos = rb_memsearch(RSTRING_PTR(pattern), RSTRING_LEN(pattern),
CURPTR(p), S_RESTLEN(p), enc);
rb_len_t pos = rb_memsearch(RSTRING_PTR(pattern), RSTRING_LEN(pattern),
CURPTR(p), S_RESTLEN(p), enc);
if (pos == -1) {
return Qnil;
}
Expand All @@ -814,12 +821,12 @@ strscan_do_scan(VALUE self, VALUE pattern, int succptr, int getstr, int headonly
succ(p);
}
{
const long length = last_match_length(p);
const rb_len_t length = last_match_length(p);
if (getstr) {
return extract_beg_len(p, p->prev, length);
}
else {
return INT2FIX(length);
return LEN2NUM(length);
}
}
}
Expand Down Expand Up @@ -1208,7 +1215,7 @@ static VALUE
strscan_getch(VALUE self)
{
struct strscanner *p;
long len;
rb_len_t len;

GET_SCANNER(self, p);
CLEAR_MATCH_STATUS(p);
Expand Down Expand Up @@ -1322,11 +1329,11 @@ static VALUE
strscan_peek(VALUE self, VALUE vlen)
{
struct strscanner *p;
long len;
rb_len_t len;

GET_SCANNER(self, p);

len = NUM2LONG(vlen);
len = NUM2LEN(vlen);
if (EOS_P(p))
return str_new(p, "", 0);

Expand All @@ -1335,7 +1342,7 @@ strscan_peek(VALUE self, VALUE vlen)
}

static VALUE
strscan_parse_integer(struct strscanner *p, int base, long len)
strscan_parse_integer(struct strscanner *p, int base, rb_len_t len)
{
VALUE buffer_v, integer;

Expand Down Expand Up @@ -1377,7 +1384,7 @@ static VALUE
strscan_scan_base10_integer(VALUE self)
{
char *ptr;
long len = 0, remaining_len;
rb_len_t len = 0, remaining_len;
struct strscanner *p;

GET_SCANNER(self, p);
Expand Down Expand Up @@ -1415,7 +1422,7 @@ static VALUE
strscan_scan_base16_integer(VALUE self)
{
char *ptr;
long len = 0, remaining_len;
rb_len_t len = 0, remaining_len;
struct strscanner *p;

GET_SCANNER(self, p);
Expand Down Expand Up @@ -1693,14 +1700,14 @@ static VALUE
strscan_matched_size(VALUE self)
{
struct strscanner *p;
long beg, end;
rb_len_t beg, end;

GET_SCANNER(self, p);
if (! MATCHED_P(p)) return Qnil;
beg = adjust_register_position(p, p->regs.beg[0]);
if (beg > S_LEN(p)) return Qnil;
end = minl(adjust_register_position(p, p->regs.end[0]), S_LEN(p));
return LONG2NUM(end - beg);
return LEN2NUM(end - beg);
}

static int
Expand Down Expand Up @@ -1729,15 +1736,16 @@ static long
resolve_capture_index(struct strscanner *p, VALUE specifier)
{
const char *name;
rb_len_t len;
long i;
if (! MATCHED_P(p)) return -1;
switch (TYPE(specifier)) {
case T_SYMBOL:
specifier = rb_sym2str(specifier);
/* fall through */
case T_STRING:
RSTRING_GETMEM(specifier, name, i);
i = name_to_backref_number(&(p->regs), p->regex, name, name + i,
RSTRING_GETMEM(specifier, name, len);
i = name_to_backref_number(&(p->regs), p->regex, name, name + len,
rb_enc_get(specifier));
break;
default:
Expand Down Expand Up @@ -1873,7 +1881,7 @@ strscan_integer_at(int argc, VALUE *argv, VALUE self)
{
struct strscanner *p;
long i;
long beg, end, len;
rb_len_t beg, end, len;
const char *ptr;
VALUE rb_specifier;
VALUE rb_base;
Expand Down Expand Up @@ -2176,14 +2184,14 @@ static VALUE
strscan_rest_size(VALUE self)
{
struct strscanner *p;
long i;
rb_len_t i;

GET_SCANNER(self, p);
if (EOS_P(p)) {
return INT2FIX(0);
}
i = S_RESTLEN(p);
return INT2FIX(i);
return LEN2NUM(i);
}

#define INSPECT_LENGTH 5
Expand Down Expand Up @@ -2240,15 +2248,15 @@ strscan_inspect(VALUE self)
}
if (p->curr == 0) {
b = inspect2(p);
a = rb_sprintf("#<%"PRIsVALUE" %ld/%ld @ %"PRIsVALUE">",
a = rb_sprintf("#<%"PRIsVALUE" %"PRIdLEN"/%"PRIdLEN" @ %"PRIsVALUE">",
rb_obj_class(self),
p->curr, S_LEN(p),
b);
return a;
}
a = inspect1(p);
b = inspect2(p);
a = rb_sprintf("#<%"PRIsVALUE" %ld/%ld %"PRIsVALUE" @ %"PRIsVALUE">",
a = rb_sprintf("#<%"PRIsVALUE" %"PRIdLEN"/%"PRIdLEN" %"PRIsVALUE" @ %"PRIsVALUE">",
rb_obj_class(self),
p->curr, S_LEN(p),
a, b);
Expand All @@ -2259,7 +2267,7 @@ static VALUE
inspect1(struct strscanner *p)
{
VALUE str;
long len;
rb_len_t len;

if (p->curr == 0) return rb_str_new2("");
if (p->curr > INSPECT_LENGTH) {
Expand All @@ -2278,7 +2286,7 @@ static VALUE
inspect2(struct strscanner *p)
{
VALUE str;
long len;
rb_len_t len;

if (EOS_P(p)) return rb_str_new2("");
len = S_RESTLEN(p);
Expand Down
Loading