Lines Matching refs:Py_SIZE
49 Py_ssize_t j = ABS(Py_SIZE(v));
55 Py_SIZE(v) = (Py_SIZE(v) < 0) ? -(i) : i;
160 Py_SIZE(v) = ndigits;
207 Py_SIZE(v) = -(Py_SIZE(v));
277 i = Py_SIZE(v);
430 i = Py_SIZE(v);
488 return Py_SIZE(v) == 0 ? 0 : (Py_SIZE(v) < 0 ? -1 : 1);
500 ndigits = ABS(Py_SIZE(v));
630 Py_SIZE(v) = is_signed ? -idigit : idigit;
651 if (Py_SIZE(v) < 0) {
652 ndigits = -(Py_SIZE(v));
661 ndigits = Py_SIZE(v);
876 Py_SIZE(v) = negative ? -ndigits : ndigits;
904 Py_SIZE(v) = ndigits;
1095 i = Py_SIZE(v);
1321 const Py_ssize_t size = ABS(Py_SIZE(a));
1351 size_a = ABS(Py_SIZE(a));
1352 negative = Py_SIZE(a) < 0;
1473 size_a = ABS(Py_SIZE(a));
1900 Py_SIZE(z) = 0;
1930 pzstop = pz + Py_SIZE(z);
1939 if (Py_SIZE(z) < size_z) {
1941 ++Py_SIZE(z);
1946 assert(Py_SIZE(z) == size_z);
1968 Py_SIZE(z) = -(Py_SIZE(z));
2027 Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b));
2075 and w1 should satisfy 2 <= ABS(Py_SIZE(w1)) <= ABS(Py_SIZE(v1)). */
2095 size_v = ABS(Py_SIZE(v1));
2096 size_w = ABS(Py_SIZE(w1));
2227 a_size = ABS(Py_SIZE(a));
2316 return Py_SIZE(a) < 0 ? -dx : dx;
2373 if (Py_SIZE(a) != Py_SIZE(b)) {
2374 sign = Py_SIZE(a) - Py_SIZE(b);
2377 Py_ssize_t i = ABS(Py_SIZE(a));
2384 if (Py_SIZE(a) < 0)
2433 Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b));
2467 Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b));
2577 Py_ssize_t size_a = ABS(Py_SIZE(a));
2578 Py_ssize_t size_b = ABS(Py_SIZE(b));
2585 memset(z->ob_digit, 0, Py_SIZE(z) * sizeof(digit));
2672 const Py_ssize_t size_n = ABS(Py_SIZE(n));
2701 Py_ssize_t asize = ABS(Py_SIZE(a));
2702 Py_ssize_t bsize = ABS(Py_SIZE(b));
2754 assert(Py_SIZE(ah) > 0); /* the split isn't degenerate */
2785 memset(ret->ob_digit, 0xDF, Py_SIZE(ret) * sizeof(digit));
2790 assert(Py_SIZE(t1) >= 0);
2791 assert(2*shift + Py_SIZE(t1) <= Py_SIZE(ret));
2793 Py_SIZE(t1) * sizeof(digit));
2796 i = Py_SIZE(ret) - 2*shift - Py_SIZE(t1);
2798 memset(ret->ob_digit + 2*shift + Py_SIZE(t1), 0,
2806 assert(Py_SIZE(t2) >= 0);
2807 assert(Py_SIZE(t2) <= 2*shift); /* no overlap with high digits */
2808 memcpy(ret->ob_digit, t2->ob_digit, Py_SIZE(t2) * sizeof(digit));
2811 i = 2*shift - Py_SIZE(t2); /* number of uninitialized digits */
2813 memset(ret->ob_digit + Py_SIZE(t2), 0, i * sizeof(digit));
2818 i = Py_SIZE(ret) - shift; /* # digits after shift */
2819 (void)v_isub(ret->ob_digit + shift, i, t2->ob_digit, Py_SIZE(t2));
2822 (void)v_isub(ret->ob_digit + shift, i, t1->ob_digit, Py_SIZE(t1));
2847 assert(Py_SIZE(t3) >= 0);
2852 (void)v_iadd(ret->ob_digit + shift, i, t3->ob_digit, Py_SIZE(t3));
2922 const Py_ssize_t asize = ABS(Py_SIZE(a));
2923 Py_ssize_t bsize = ABS(Py_SIZE(b));
2935 memset(ret->ob_digit, 0, Py_SIZE(ret) * sizeof(digit));
2950 Py_SIZE(bslice) = nbtouse;
2956 (void)v_iadd(ret->ob_digit + nbdone, Py_SIZE(ret) - nbdone,
2957 product->ob_digit, Py_SIZE(product));
3021 if ((Py_SIZE(mod) < 0 && Py_SIZE(w) > 0) ||
3022 (Py_SIZE(mod) > 0 && Py_SIZE(w) < 0)) {
3190 a_size = ABS(Py_SIZE(a));
3191 b_size = ABS(Py_SIZE(b));
3192 negate = (Py_SIZE(a) < 0) ^ (Py_SIZE(b) < 0);
3285 x_size = Py_SIZE(x);
3303 if (Py_SIZE(rem))
3307 x_size = ABS(Py_SIZE(x));
3431 if (Py_SIZE(b) < 0) { /* if exponent is negative */
3450 if (Py_SIZE(c) == 0) {
3459 if (Py_SIZE(c) < 0) {
3472 if ((Py_SIZE(c) == 1) && (c->ob_digit[0] == 1)) {
3486 if (Py_SIZE(a) < 0 || Py_SIZE(a) > Py_SIZE(c)) {
3529 if (Py_SIZE(b) <= FIVEARY_CUTOFF) {
3532 for (i = Py_SIZE(b) - 1; i >= 0; --i) {
3549 for (i = Py_SIZE(b) - 1; i >= 0; --i) {
3562 if (negativeOutput && (Py_SIZE(z) != 0)) {
3579 if (Py_SIZE(b) > FIVEARY_CUTOFF) {
3603 Py_SIZE(x) = -(Py_SIZE(x));
3634 return Py_SIZE(v) != 0;
3647 if (Py_SIZE(a) < 0) {
3670 newsize = ABS(Py_SIZE(a)) - wordshift;
3684 if (Py_SIZE(a) < 0)
3685 Py_SIZE(z) = -(Py_SIZE(z));
3719 if (Py_SIZE(a) == 0) {
3790 size_a = ABS(Py_SIZE(a));
3791 nega = Py_SIZE(a) < 0;
3804 size_b = ABS(Py_SIZE(b));
3805 negb = Py_SIZE(b) < 0;
3888 Py_SIZE(z) = -(Py_SIZE(z));
4078 n = Py_SIZE(tmp);
4087 Py_SIZE(newobj) = Py_SIZE(tmp);
4145 res = v->ob_type->tp_basicsize + ABS(Py_SIZE(v))*sizeof(digit);
4159 ndigits = ABS(Py_SIZE(v));
