kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

* bignum.c (bigor_int): Use RB_GC_GUARD.

Browse source 
(bigxor_int): Take xn and hibitsx arguments.  Use twocomp2abs_bang.
  (rb_big_xor): Use abs2twocomp and twocomp2abs_bang.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@41692 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
akr 2013-06-29 00:08:47 +00:00
parent 88430941c8
commit f0454052f7
2 changed files with 46 additions and 46 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
ChangeLog
View file

@ -1,3 +1,9 @@
Sat Jun 29 09:07:16 2013 Tanaka Akira <akr@fsij.org>
* bignum.c (bigor_int): Use RB_GC_GUARD.
(bigxor_int): Take xn and hibitsx arguments. Use twocomp2abs_bang.
(rb_big_xor): Use abs2twocomp and twocomp2abs_bang.
Sat Jun 29 08:19:58 2013 Tanaka Akira <akr@fsij.org>
* bignum.c (bigand_int): Don't apply bitwise and for BDIGIT and long.

86
bignum.c
View file

@ -4829,6 +4829,7 @@ bigor_int(VALUE x, long xn, BDIGIT hibitsx, long y)
finish:
twocomp2abs_bang(z, hibitsx || hibitsy);
RB_GC_GUARD(x);
return bignorm(z);
}
@ -4891,22 +4892,22 @@ rb_big_or(VALUE x, VALUE y)
}
static VALUE
bigxor_int(VALUE x, long y)
bigxor_int(VALUE x, long xn, BDIGIT hibitsx, long y)
{
VALUE z;
BDIGIT *xds, *zds;
long xn, zn;
long zn;
long i;
char sign;
BDIGIT hibitsy;
sign = (y >= 0) ? 1 : 0;
hibitsy = 0 <= y ? 0 : BDIGMAX;
xds = BDIGITS(x);
zn = xn = RBIGNUM_LEN(x);
zn = RBIGNUM_LEN(x);
#if SIZEOF_BDIGITS < SIZEOF_LONG
if (zn < bdigit_roomof(SIZEOF_LONG))
zn = bdigit_roomof(SIZEOF_LONG);
#endif
z = bignew(zn, !(RBIGNUM_SIGN(x) ^ sign));
z = bignew(zn, 0);
zds = BDIGITS(z);
#if SIZEOF_BDIGITS >= SIZEOF_LONG
@ -4918,18 +4919,18 @@ bigxor_int(VALUE x, long y)
y = BIGDN(y);
}
for (; i < zn; i++) {
zds[i] = (RBIGNUM_SIGN(x) ? 0 : BDIGMAX) ^ BIGLO(y);
zds[i] = hibitsx ^ BIGLO(y);
y = BIGDN(y);
}
#endif
for (; i < xn; i++) {
zds[i] = sign ? xds[i] : BIGLO(~xds[i]);
zds[i] = xds[i] ^ hibitsy;
}
for (; i < zn; i++) {
zds[i] = sign ^ RBIGNUM_SIGN(x) ? BDIGMAX : 0;
zds[i] = hibitsx ^ hibitsy;
}
if (!RBIGNUM_SIGN(z)) get2comp(z);
twocomp2abs_bang(z, (hibitsx ^ hibitsy) != 0);
RB_GC_GUARD(x);
return bignorm(z);
}
/*
@ -4940,57 +4941,50 @@ bigxor_int(VALUE x, long y)
*/
VALUE
rb_big_xor(VALUE xx, VALUE yy)
rb_big_xor(VALUE x, VALUE y)
{
volatile VALUE x, y;
VALUE z;
BDIGIT *ds1, *ds2, *zds;
long i, l1, l2;
char sign;
long i, xl, yl, l1, l2;
BDIGIT hibitsx, hibitsy;
BDIGIT hibits1, hibits2;
VALUE tmpv;
BDIGIT tmph;
long tmpl;
if (!FIXNUM_P(yy) && !RB_TYPE_P(yy, T_BIGNUM)) {
return rb_num_coerce_bit(xx, yy, '^');
if (!FIXNUM_P(y) && !RB_TYPE_P(y, T_BIGNUM)) {
return rb_num_coerce_bit(x, y, '^');
}
x = xx;
y = yy;
if (!RBIGNUM_SIGN(x)) {
x = rb_big_clone(x);
get2comp(x);
}
hibitsx = abs2twocomp(&x, &xl);
if (FIXNUM_P(y)) {
return bigxor_int(x, FIX2LONG(y));
return bigxor_int(x, xl, hibitsx, FIX2LONG(y));
}
if (!RBIGNUM_SIGN(y)) {
y = rb_big_clone(y);
get2comp(y);
hibitsy = abs2twocomp(&y, &yl);
if (xl > yl) {
tmpv = x; x = y; y = tmpv;
tmpl = xl; xl = yl; yl = tmpl;
tmph = hibitsx; hibitsx = hibitsy; hibitsy = tmph;
}
if (RBIGNUM_LEN(x) > RBIGNUM_LEN(y)) {
l1 = RBIGNUM_LEN(y);
l2 = RBIGNUM_LEN(x);
ds1 = BDIGITS(y);
ds2 = BDIGITS(x);
sign = RBIGNUM_SIGN(y);
}
else {
l1 = RBIGNUM_LEN(x);
l2 = RBIGNUM_LEN(y);
ds1 = BDIGITS(x);
ds2 = BDIGITS(y);
sign = RBIGNUM_SIGN(x);
}
z = bignew(l2, !(RBIGNUM_SIGN(x) ^ RBIGNUM_SIGN(y)));
l1 = xl;
l2 = yl;
ds1 = BDIGITS(x);
ds2 = BDIGITS(y);
hibits1 = hibitsx;
hibits2 = hibitsy;
z = bignew(l2, 0);
zds = BDIGITS(z);
for (i=0; i<l1; i++) {
zds[i] = ds1[i] ^ ds2[i];
}
for (; i<l2; i++) {
zds[i] = sign?ds2[i]:BIGLO(~ds2[i]);
zds[i] = hibitsx ^ ds2[i];
}
if (!RBIGNUM_SIGN(z)) get2comp(z);
twocomp2abs_bang(z, (hibits1 ^ hibits2) != 0);
RB_GC_GUARD(x);
RB_GC_GUARD(y);
return bignorm(z);
}