1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

* bignum.c (rb_cstr_to_inum): Avoid temporary buffer allocation except

Browse Source 
very big base non-power-of-2 numbers.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@41772 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
akr 2013-07-04 09:38:11 +00:00
parent 0eed101a54
commit fd8f2338e9
2 changed files with 81 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ChangeLog
View File

@ -1,3 +1,8 @@
Thu Jul 4 18:25:25 2013 Tanaka Akira <akr@fsij.org>
* bignum.c (rb_cstr_to_inum): Avoid temporary buffer allocation except
very big base non-power-of-2 numbers.
Thu Jul 4 15:51:56 2013 NARUSE, Yui <naruse@ruby-lang.org> Thu Jul 4 15:51:56 2013 NARUSE, Yui <naruse@ruby-lang.org>
* string.c (rb_str_succ): use ONIGENC_MBCLEN_CHARFOUND_P correctly. * string.c (rb_str_succ): use ONIGENC_MBCLEN_CHARFOUND_P correctly.

133
bignum.c
View File

@ -1900,19 +1900,16 @@ VALUE
rb_cstr_to_inum(const char *str, int base, int badcheck) rb_cstr_to_inum(const char *str, int base, int badcheck)
{ {
const char *s = str; const char *s = str;
char *end;
char sign = 1, nondigit = 0; char sign = 1, nondigit = 0;
int c; int c;
BDIGIT_DBL num;
VALUE z; VALUE z;
BDIGIT *zds;
int bits_per_digit; int bits_per_digit;
size_t size, len, i; size_t i;
size_t blen = 1;
VALUE v = 0; const char *digits_start, *digits_end, *p;
uint8_t *buf; size_t num_digits;
uint8_t *p; size_t num_bdigits;
#undef ISDIGIT #undef ISDIGIT
#define ISDIGIT(c) ('0' <= (c) && (c) <= '9') #define ISDIGIT(c) ('0' <= (c) && (c) <= '9')
@ -2006,10 +2003,9 @@ rb_cstr_to_inum(const char *str, int base, int badcheck)
return INT2FIX(0); return INT2FIX(0);
} }
size = strlen(str);
bits_per_digit = bitsize(base-1); bits_per_digit = bitsize(base-1);
len = bits_per_digit * size; if (bits_per_digit * strlen(str) <= sizeof(long) * CHAR_BIT) {
if (len <= (sizeof(long)*CHAR_BIT)) { char *end;
unsigned long val = STRTOUL(str, &end, base); unsigned long val = STRTOUL(str, &end, base);
if (str < end && *end == '_') goto bigparse; if (str < end && *end == '_') goto bigparse;
@ -2033,11 +2029,10 @@ rb_cstr_to_inum(const char *str, int base, int badcheck)
} }
} }
bigparse: bigparse:
buf = ALLOCV(v, size+1);
p = buf;
if (badcheck && *str == '_') goto bad; if (badcheck && *str == '_') goto bad;
num_digits = 0;
digits_start = digits_end = str;
while ((c = *str++) != 0) { while ((c = *str++) != 0) {
if (c == '_') { if (c == '_') {
if (nondigit) { if (nondigit) {
@ -2052,7 +2047,8 @@ rb_cstr_to_inum(const char *str, int base, int badcheck)
} }
if (c >= base) break; if (c >= base) break;
nondigit = 0; nondigit = 0;
*p++ = (uint8_t)c; num_digits++;
digits_end = str;
} }
if (badcheck) { if (badcheck) {
str--; str--;
@ -2060,31 +2056,54 @@ rb_cstr_to_inum(const char *str, int base, int badcheck)
while (*str && ISSPACE(*str)) str++; while (*str && ISSPACE(*str)) str++;
if (*str) { if (*str) {
bad: bad:
if (v)
ALLOCV_END(v);
rb_invalid_str(s, "Integer()"); rb_invalid_str(s, "Integer()");
} }
} }
while (buf < p && *buf == 0)
buf++;
if (POW2_P(base)) { if (POW2_P(base)) {
int flags = INTEGER_PACK_BIG_ENDIAN; BDIGIT *dp;
if (!sign) BDIGIT_DBL dd;
flags |= INTEGER_PACK_NEGATIVE; int numbits;
z = rb_integer_unpack(buf, p - buf, 1, CHAR_BIT - bits_per_digit, flags); num_bdigits = (num_digits / BITSPERDIG) * bits_per_digit + roomof((num_digits % BITSPERDIG) * bits_per_digit, BITSPERDIG);
z = bignew(num_bdigits, sign);
dp = BDIGITS(z);
dd = 0;
numbits = 0;
for (p = digits_end; digits_start < p; p--) {
if ((c = conv_digit(p[-1])) < 0)
continue;
dd |= (BDIGIT_DBL)c << numbits;
numbits += bits_per_digit;
if (BITSPERDIG <= numbits) {
*dp++ = BIGLO(dd);
dd = BIGDN(dd);
numbits -= BITSPERDIG;
}
}
if (numbits) {
*dp++ = BIGLO(dd);
}
assert((size_t)(dp - BDIGITS(z)) == num_bdigits);
} }
else { else {
len = (len/BITSPERDIG)+1; int digits_per_bdigits_dbl;
if (len < KARATSUBA_MUL_DIGITS) { BDIGIT_DBL power;
z = bignew(len, sign); power = maxpow_in_bdigit_dbl(base, &digits_per_bdigits_dbl);
zds = BDIGITS(z); num_bdigits = roomof(num_digits, digits_per_bdigits_dbl)*2;
for (i=len;i--;) zds[i]=0;
size = p - buf; if (num_bdigits < KARATSUBA_MUL_DIGITS) {
for (p = buf; p < buf + size; p++) { size_t blen = 1;
num = *p; BDIGIT *zds;
BDIGIT_DBL num;
z = bignew(num_bdigits, sign);
zds = BDIGITS(z);
MEMZERO(zds, BDIGIT, num_bdigits);
for (p = digits_start; p < digits_end; p++) {
if ((c = conv_digit(*p)) < 0)
continue;
num = c;
i = 0; i = 0;
for (;;) { for (;;) {
while (i<blen) { while (i<blen) {
@ -2098,47 +2117,49 @@ rb_cstr_to_inum(const char *str, int base, int badcheck)
} }
break; break;
} }
assert(blen <= num_bdigits);
} }
} }
else { else {
int digits_per_bdigits_dbl;
BDIGIT_DBL power;
VALUE powerv; VALUE powerv;
int j;
size_t num_bdigits;
size_t unit; size_t unit;
VALUE tmpuv = 0; VALUE tmpuv = 0;
BDIGIT *uds, *vds, *tds; BDIGIT *uds, *vds, *tds;
BDIGIT_DBL dd;
power = maxpow_in_bdigit_dbl(base, &digits_per_bdigits_dbl); BDIGIT_DBL current_base;
int m;
size = p - buf;
num_bdigits = roomof(size, digits_per_bdigits_dbl)*2;
uds = ALLOCV_N(BDIGIT, tmpuv, 2*num_bdigits); uds = ALLOCV_N(BDIGIT, tmpuv, 2*num_bdigits);
vds = uds + num_bdigits; vds = uds + num_bdigits;
powerv = bignew(2, 1); powerv = bignew(2, 1);
BDIGITS(powerv)[0] = (BDIGIT)BIGLO(power); BDIGITS(powerv)[0] = BIGLO(power);
BDIGITS(powerv)[1] = (BDIGIT)BIGDN(power); BDIGITS(powerv)[1] = (BDIGIT)BIGDN(power);
i = 0; i = 0;
while (buf < p) { dd = 0;
int m; current_base = 1;
BDIGIT_DBL d = 0;
if (digits_per_bdigits_dbl <= p - buf) {
m = digits_per_bdigits_dbl; m = digits_per_bdigits_dbl;
if (num_digits < (size_t)m)
m = (int)num_digits;
for (p = digits_end; digits_start < p; p--) {
if ((c = conv_digit(p[-1])) < 0)
continue;
dd = dd + c * current_base;
current_base *= base;
num_digits--;
m--;
if (m == 0) {
uds[i++] = BIGLO(dd);
uds[i++] = (BDIGIT)BIGDN(dd);
dd = 0;
m = digits_per_bdigits_dbl;
if (num_digits < (size_t)m)
m = (int)num_digits;
current_base = 1;
} }
else {
m = (int)(p - buf);
}
p -= m;
for (j = 0; j < m; j++) {
d = d * base + p[j];
}
uds[i++] = (BDIGIT)BIGLO(d);
uds[i++] = (BDIGIT)BIGDN(d);
} }
assert(i == num_bdigits);
for (unit = 2; unit < num_bdigits; unit *= 2) { for (unit = 2; unit < num_bdigits; unit *= 2) {
for (i = 0; i < num_bdigits; i += unit*2) { for (i = 0; i < num_bdigits; i += unit*2) {
if (2*unit <= num_bdigits - i) { if (2*unit <= num_bdigits - i) {
@ -2168,8 +2189,6 @@ rb_cstr_to_inum(const char *str, int base, int badcheck)
} }
} }
if (v)
ALLOCV_END(v);
return bignorm(z); return bignorm(z);
} }