Lines Matching refs:Py_SIZE
26 #define IS_MEDIUM_VALUE(x) (((size_t)Py_SIZE(x)) + 1U < 3U)
33 return ((stwodigits)Py_SIZE(x)) * x->ob_digit[0];
127 Py_ssize_t j = Py_ABS(Py_SIZE(v));
133 Py_SET_SIZE(v, (Py_SIZE(v) < 0) ? -(i) : i);
178 i = Py_SIZE(src);
189 Py_SET_SIZE(result, Py_SIZE(src));
277 Py_SET_SIZE(x, -Py_SIZE(x));
426 Py_SET_SIZE(v, -(Py_SIZE(v)));
481 i = Py_SIZE(v);
584 i = Py_SIZE(v);
639 i = Py_SIZE(v);
683 i = Py_SIZE(v);
722 i = Py_SIZE(v);
771 return Py_SIZE(v) == 0 ? 0 : (Py_SIZE(v) < 0 ? -1 : 1);
794 ndigits = Py_ABS(Py_SIZE(v));
942 if (Py_SIZE(v) < 0) {
943 ndigits = -(Py_SIZE(v));
952 ndigits = Py_SIZE(v);
1223 switch(Py_SIZE(v)) {
1268 switch(Py_SIZE(v)) {
1299 switch(Py_SIZE(v)) {
1303 i = Py_SIZE(v);
1378 i = Py_SIZE(v);
1663 const Py_ssize_t size = Py_ABS(Py_SIZE(a));
1695 const Py_ssize_t size = Py_ABS(Py_SIZE(a));
1727 size_a = Py_ABS(Py_SIZE(a));
1728 negative = Py_SIZE(a) < 0;
1947 size_a = Py_ABS(Py_SIZE(a));
1948 negative = Py_SIZE(a) < 0;
2552 pzstop = pz + Py_SIZE(z);
2561 if (Py_SIZE(z) < size_z) {
2563 Py_SET_SIZE(z, Py_SIZE(z) + 1);
2568 assert(Py_SIZE(z) == size_z);
2592 if (Py_SIZE(z) != 0) {
2602 Py_SET_SIZE(z, -(Py_SIZE(z)));
2702 Py_ssize_t size_a = Py_ABS(Py_SIZE(a)), size_b = Py_ABS(Py_SIZE(b));
2744 if ((Py_SIZE(a) < 0) != (Py_SIZE(b) < 0)) {
2751 if (Py_SIZE(a) < 0 && Py_SIZE(*prem) != 0) {
2768 Py_ssize_t size_a = Py_ABS(Py_SIZE(a)), size_b = Py_ABS(Py_SIZE(b));
2795 if (Py_SIZE(a) < 0 && Py_SIZE(*prem) != 0) {
2806 and w1 should satisfy 2 <= Py_ABS(Py_SIZE(w1)) <= Py_ABS(Py_SIZE(v1)). */
2826 size_v = Py_ABS(Py_SIZE(v1));
2827 size_w = Py_ABS(Py_SIZE(w1));
2966 a_size = Py_ABS(Py_SIZE(a));
3052 return Py_SIZE(a) < 0 ? -dx : dx;
3104 Py_ssize_t sign = Py_SIZE(a) - Py_SIZE(b);
3106 Py_ssize_t i = Py_ABS(Py_SIZE(a));
3114 sign = Py_SIZE(a) < 0 ? -diff : diff;
3138 i = Py_SIZE(v);
3194 Py_ssize_t size_a = Py_ABS(Py_SIZE(a)), size_b = Py_ABS(Py_SIZE(b));
3228 Py_ssize_t size_a = Py_ABS(Py_SIZE(a)), size_b = Py_ABS(Py_SIZE(b));
3274 Py_SET_SIZE(z, -Py_SIZE(z));
3287 if (Py_SIZE(a) < 0) {
3288 if (Py_SIZE(b) < 0) {
3296 Py_SET_SIZE(z, -(Py_SIZE(z)));
3303 if (Py_SIZE(b) < 0)
3326 if (Py_SIZE(a) < 0) {
3327 if (Py_SIZE(b) < 0) {
3333 assert(Py_SIZE(z) == 0 || Py_REFCNT(z) == 1);
3334 Py_SET_SIZE(z, -(Py_SIZE(z)));
3339 if (Py_SIZE(b) < 0)
3361 Py_ssize_t size_a = Py_ABS(Py_SIZE(a));
3362 Py_ssize_t size_b = Py_ABS(Py_SIZE(b));
3369 memset(z->ob_digit, 0, Py_SIZE(z) * sizeof(digit));
3470 const Py_ssize_t size_n = Py_ABS(Py_SIZE(n));
3499 Py_ssize_t asize = Py_ABS(Py_SIZE(a));
3500 Py_ssize_t bsize = Py_ABS(Py_SIZE(b));
3552 assert(Py_SIZE(ah) > 0); /* the split isn't degenerate */
3583 memset(ret->ob_digit, 0xDF, Py_SIZE(ret) * sizeof(digit));
3588 assert(Py_SIZE(t1) >= 0);
3589 assert(2*shift + Py_SIZE(t1) <= Py_SIZE(ret));
3591 Py_SIZE(t1) * sizeof(digit));
3594 i = Py_SIZE(ret) - 2*shift - Py_SIZE(t1);
3596 memset(ret->ob_digit + 2*shift + Py_SIZE(t1), 0,
3604 assert(Py_SIZE(t2) >= 0);
3605 assert(Py_SIZE(t2) <= 2*shift); /* no overlap with high digits */
3606 memcpy(ret->ob_digit, t2->ob_digit, Py_SIZE(t2) * sizeof(digit));
3609 i = 2*shift - Py_SIZE(t2); /* number of uninitialized digits */
3611 memset(ret->ob_digit + Py_SIZE(t2), 0, i * sizeof(digit));
3616 i = Py_SIZE(ret) - shift; /* # digits after shift */
3617 (void)v_isub(ret->ob_digit + shift, i, t2->ob_digit, Py_SIZE(t2));
3620 (void)v_isub(ret->ob_digit + shift, i, t1->ob_digit, Py_SIZE(t1));
3645 assert(Py_SIZE(t3) >= 0);
3650 (void)v_iadd(ret->ob_digit + shift, i, t3->ob_digit, Py_SIZE(t3));
3720 const Py_ssize_t asize = Py_ABS(Py_SIZE(a));
3721 Py_ssize_t bsize = Py_ABS(Py_SIZE(b));
3733 memset(ret->ob_digit, 0, Py_SIZE(ret) * sizeof(digit));
3754 (void)v_iadd(ret->ob_digit + nbdone, Py_SIZE(ret) - nbdone,
3755 product->ob_digit, Py_SIZE(product));
3784 if (((Py_SIZE(a) ^ Py_SIZE(b)) < 0) && z) {
3807 assert(Py_ABS(Py_SIZE(a)) == 1);
3808 assert(Py_ABS(Py_SIZE(b)) == 1);
3810 if (Py_SIZE(a) == Py_SIZE(b)) {
3819 return PyLong_FromLong(mod * (sdigit)Py_SIZE(b));
3830 assert(Py_ABS(Py_SIZE(a)) == 1);
3831 assert(Py_ABS(Py_SIZE(b)) == 1);
3833 if (Py_SIZE(a) == Py_SIZE(b)) {
3872 if (Py_ABS(Py_SIZE(v)) == 1 && Py_ABS(Py_SIZE(w)) == 1) {
3898 if ((Py_SIZE(mod) < 0 && Py_SIZE(w) > 0) ||
3899 (Py_SIZE(mod) > 0 && Py_SIZE(w) < 0)) {
3940 if (Py_ABS(Py_SIZE(v)) == 1 && Py_ABS(Py_SIZE(w)) == 1) {
3947 if ((Py_SIZE(mod) < 0 && Py_SIZE(w) > 0) ||
3948 (Py_SIZE(mod) > 0 && Py_SIZE(w) < 0)) {
3968 if (Py_ABS(Py_SIZE(a)) == 1 && Py_ABS(Py_SIZE(b)) == 1) {
4083 a_size = Py_ABS(Py_SIZE(a));
4084 b_size = Py_ABS(Py_SIZE(b));
4085 negate = (Py_SIZE(a) < 0) ^ (Py_SIZE(b) < 0);
4178 x_size = Py_SIZE(x);
4196 if (Py_SIZE(rem))
4200 x_size = Py_ABS(Py_SIZE(x));
4302 assert(Py_SIZE(n) > 0);
4317 while (Py_SIZE(n) != 0) {
4406 if (Py_SIZE(b) < 0 && c == NULL) {
4419 if (Py_SIZE(c) == 0) {
4428 if (Py_SIZE(c) < 0) {
4443 if ((Py_SIZE(c) == 1) && (c->ob_digit[0] == 1)) {
4450 if (Py_SIZE(b) < 0) {
4478 if (Py_SIZE(a) < 0 || Py_SIZE(a) > Py_SIZE(c)) {
4521 i = Py_SIZE(b);
4616 for (i = Py_SIZE(b) - 1; i >= 0; --i) {
4634 if (negativeOutput && (Py_SIZE(z) != 0)) {
4670 longs will have been caught in the Py_SIZE <= 1 fast path. */
4682 Py_SET_SIZE(z, -(Py_SIZE(v)));
4689 if (Py_SIZE(v) < 0)
4698 return Py_SIZE(v) != 0;
4706 assert(Py_SIZE(shiftby) >= 0);
4713 /* PyLong_Check(shiftby) is true and Py_SIZE(shiftby) >= 0, so it must
4760 a_negative = Py_SIZE(a) < 0;
4761 size_a = Py_ABS(Py_SIZE(a));
4832 if (Py_SIZE(b) < 0) {
4836 if (Py_SIZE(a) == 0) {
4852 if (Py_SIZE(a) == 0) {
4874 oldsize = Py_ABS(Py_SIZE(a));
4881 if (Py_SIZE(a) < 0) {
4883 Py_SET_SIZE(z, -Py_SIZE(z));
4909 if (Py_SIZE(b) < 0) {
4913 if (Py_SIZE(a) == 0) {
4929 if (Py_SIZE(a) == 0) {
4971 size_a = Py_ABS(Py_SIZE(a));
4972 nega = Py_SIZE(a) < 0;
4985 size_b = Py_ABS(Py_SIZE(b));
4986 negb = Py_SIZE(b) < 0;
5067 Py_SET_SIZE(z, -(Py_SIZE(z)));
5135 size_a = Py_SIZE(a);
5136 size_b = Py_SIZE(b);
5159 alloc_a = Py_SIZE(a);
5160 alloc_b = Py_SIZE(b);
5162 while ((size_a = Py_SIZE(a)) > 2) {
5166 size_b = Py_SIZE(b);
5211 alloc_b = Py_SIZE(b);
5390 return _PyLong_FromBytes(string, Py_SIZE(x), (int)base);
5415 n = Py_SIZE(tmp);
5429 Py_SET_SIZE(newobj, Py_SIZE(tmp));
5521 quo_is_neg = (Py_SIZE(a) < 0) != (Py_SIZE(b) < 0);
5542 quo_is_odd = Py_SIZE(quo) != 0 && ((quo->ob_digit[0] & 1) != 0);
5543 if ((Py_SIZE(b) < 0 ? cmp < 0 : cmp > 0) || (cmp == 0 && quo_is_odd)) {
5618 if (Py_SIZE(ndigits) >= 0) {
5671 one digit, even though the integer zero has a Py_SIZE of 0 */
5672 + Py_MAX(Py_ABS(Py_SIZE(self)), 1)*sizeof(digit);
5699 ndigits = Py_ABS(Py_SIZE(self));
5770 Py_ssize_t ndigits = Py_ABS(Py_SIZE(z));
5947 (unsigned char *)PyBytes_AS_STRING(bytes), Py_SIZE(bytes),