Issue #21490: Add new C macros: Py_ABS() and Py_STRINGIFY()
Keep _Py_STRINGIZE() in PC/pyconfig.h to not introduce a dependency between pyconfig.h and pymacros.h.
This commit is contained in:
parent
79b49ab553
commit
45e8e2f218
|
@ -1,13 +1,26 @@
|
||||||
#ifndef Py_PYMACRO_H
|
#ifndef Py_PYMACRO_H
|
||||||
#define Py_PYMACRO_H
|
#define Py_PYMACRO_H
|
||||||
|
|
||||||
|
/* Minimum value between x and y */
|
||||||
#define Py_MIN(x, y) (((x) > (y)) ? (y) : (x))
|
#define Py_MIN(x, y) (((x) > (y)) ? (y) : (x))
|
||||||
|
|
||||||
|
/* Maximum value between x and y */
|
||||||
#define Py_MAX(x, y) (((x) > (y)) ? (x) : (y))
|
#define Py_MAX(x, y) (((x) > (y)) ? (x) : (y))
|
||||||
|
|
||||||
|
/* Absolute value of the number x */
|
||||||
|
#define Py_ABS(x) ((x) < 0 ? -(x) : (x))
|
||||||
|
|
||||||
|
#define _Py_XSTRINGIFY(x) #x
|
||||||
|
|
||||||
|
/* Convert the argument to a string. For example, Py_STRINGIFY(123) is replaced
|
||||||
|
with "123" by the preprocessor. Defines are also replaced by their value.
|
||||||
|
For example Py_STRINGIFY(__LINE__) is replaced by the line number, not
|
||||||
|
by "__LINE__". */
|
||||||
|
#define Py_STRINGIFY(x) _Py_XSTRINGIFY(x)
|
||||||
|
|
||||||
/* Argument must be a char or an int in [-128, 127] or [0, 255]. */
|
/* Argument must be a char or an int in [-128, 127] or [0, 255]. */
|
||||||
#define Py_CHARMASK(c) ((unsigned char)((c) & 0xff))
|
#define Py_CHARMASK(c) ((unsigned char)((c) & 0xff))
|
||||||
|
|
||||||
|
|
||||||
/* Assert a build-time dependency, as an expression.
|
/* Assert a build-time dependency, as an expression.
|
||||||
|
|
||||||
Your compile will fail if the condition isn't true, or can't be evaluated
|
Your compile will fail if the condition isn't true, or can't be evaluated
|
||||||
|
|
|
@ -249,10 +249,8 @@ typedef enum {
|
||||||
} timeout_state;
|
} timeout_state;
|
||||||
|
|
||||||
/* Wrap error strings with filename and line # */
|
/* Wrap error strings with filename and line # */
|
||||||
#define STRINGIFY1(x) #x
|
|
||||||
#define STRINGIFY2(x) STRINGIFY1(x)
|
|
||||||
#define ERRSTR1(x,y,z) (x ":" y ": " z)
|
#define ERRSTR1(x,y,z) (x ":" y ": " z)
|
||||||
#define ERRSTR(x) ERRSTR1("_ssl.c", STRINGIFY2(__LINE__), x)
|
#define ERRSTR(x) ERRSTR1("_ssl.c", Py_STRINGIFY(__LINE__), x)
|
||||||
|
|
||||||
|
|
||||||
/*
|
/*
|
||||||
|
|
|
@ -85,8 +85,6 @@ typedef struct { char c; _Bool x; } s_bool;
|
||||||
#define BOOL_ALIGN 0
|
#define BOOL_ALIGN 0
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#define STRINGIFY(x) #x
|
|
||||||
|
|
||||||
#ifdef __powerc
|
#ifdef __powerc
|
||||||
#pragma options align=reset
|
#pragma options align=reset
|
||||||
#endif
|
#endif
|
||||||
|
@ -546,8 +544,8 @@ np_short(char *p, PyObject *v, const formatdef *f)
|
||||||
return -1;
|
return -1;
|
||||||
if (x < SHRT_MIN || x > SHRT_MAX){
|
if (x < SHRT_MIN || x > SHRT_MAX){
|
||||||
PyErr_SetString(StructError,
|
PyErr_SetString(StructError,
|
||||||
"short format requires " STRINGIFY(SHRT_MIN)
|
"short format requires " Py_STRINGIFY(SHRT_MIN)
|
||||||
" <= number <= " STRINGIFY(SHRT_MAX));
|
" <= number <= " Py_STRINGIFY(SHRT_MAX));
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
y = (short)x;
|
y = (short)x;
|
||||||
|
@ -564,7 +562,8 @@ np_ushort(char *p, PyObject *v, const formatdef *f)
|
||||||
return -1;
|
return -1;
|
||||||
if (x < 0 || x > USHRT_MAX){
|
if (x < 0 || x > USHRT_MAX){
|
||||||
PyErr_SetString(StructError,
|
PyErr_SetString(StructError,
|
||||||
"ushort format requires 0 <= number <= " STRINGIFY(USHRT_MAX));
|
"ushort format requires 0 <= number <= "
|
||||||
|
Py_STRINGIFY(USHRT_MAX));
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
y = (unsigned short)x;
|
y = (unsigned short)x;
|
||||||
|
|
|
@ -16,9 +16,6 @@ static void raw_free(void *ptr);
|
||||||
# define TRACE_DEBUG
|
# define TRACE_DEBUG
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#define _STR(VAL) #VAL
|
|
||||||
#define STR(VAL) _STR(VAL)
|
|
||||||
|
|
||||||
/* Protected by the GIL */
|
/* Protected by the GIL */
|
||||||
static struct {
|
static struct {
|
||||||
PyMemAllocator mem;
|
PyMemAllocator mem;
|
||||||
|
|
|
@ -21,7 +21,6 @@
|
||||||
Py_SIZE(x) < 0 ? -(sdigit)(x)->ob_digit[0] : \
|
Py_SIZE(x) < 0 ? -(sdigit)(x)->ob_digit[0] : \
|
||||||
(Py_SIZE(x) == 0 ? (sdigit)0 : \
|
(Py_SIZE(x) == 0 ? (sdigit)0 : \
|
||||||
(sdigit)(x)->ob_digit[0]))
|
(sdigit)(x)->ob_digit[0]))
|
||||||
#define ABS(x) ((x) < 0 ? -(x) : (x))
|
|
||||||
|
|
||||||
#if NSMALLNEGINTS + NSMALLPOSINTS > 0
|
#if NSMALLNEGINTS + NSMALLPOSINTS > 0
|
||||||
/* Small integers are preallocated in this array so that they
|
/* Small integers are preallocated in this array so that they
|
||||||
|
@ -57,7 +56,7 @@ get_small_int(sdigit ival)
|
||||||
static PyLongObject *
|
static PyLongObject *
|
||||||
maybe_small_long(PyLongObject *v)
|
maybe_small_long(PyLongObject *v)
|
||||||
{
|
{
|
||||||
if (v && ABS(Py_SIZE(v)) <= 1) {
|
if (v && Py_ABS(Py_SIZE(v)) <= 1) {
|
||||||
sdigit ival = MEDIUM_VALUE(v);
|
sdigit ival = MEDIUM_VALUE(v);
|
||||||
if (-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS) {
|
if (-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS) {
|
||||||
Py_DECREF(v);
|
Py_DECREF(v);
|
||||||
|
@ -114,7 +113,7 @@ _PyLong_Negate(PyLongObject **x_p)
|
||||||
static PyLongObject *
|
static PyLongObject *
|
||||||
long_normalize(PyLongObject *v)
|
long_normalize(PyLongObject *v)
|
||||||
{
|
{
|
||||||
Py_ssize_t j = ABS(Py_SIZE(v));
|
Py_ssize_t j = Py_ABS(Py_SIZE(v));
|
||||||
Py_ssize_t i = j;
|
Py_ssize_t i = j;
|
||||||
|
|
||||||
while (i > 0 && v->ob_digit[i-1] == 0)
|
while (i > 0 && v->ob_digit[i-1] == 0)
|
||||||
|
@ -718,7 +717,7 @@ _PyLong_NumBits(PyObject *vv)
|
||||||
|
|
||||||
assert(v != NULL);
|
assert(v != NULL);
|
||||||
assert(PyLong_Check(v));
|
assert(PyLong_Check(v));
|
||||||
ndigits = ABS(Py_SIZE(v));
|
ndigits = Py_ABS(Py_SIZE(v));
|
||||||
assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0);
|
assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0);
|
||||||
if (ndigits > 0) {
|
if (ndigits > 0) {
|
||||||
digit msd = v->ob_digit[ndigits - 1];
|
digit msd = v->ob_digit[ndigits - 1];
|
||||||
|
@ -1565,7 +1564,7 @@ inplace_divrem1(digit *pout, digit *pin, Py_ssize_t size, digit n)
|
||||||
static PyLongObject *
|
static PyLongObject *
|
||||||
divrem1(PyLongObject *a, digit n, digit *prem)
|
divrem1(PyLongObject *a, digit n, digit *prem)
|
||||||
{
|
{
|
||||||
const Py_ssize_t size = ABS(Py_SIZE(a));
|
const Py_ssize_t size = Py_ABS(Py_SIZE(a));
|
||||||
PyLongObject *z;
|
PyLongObject *z;
|
||||||
|
|
||||||
assert(n > 0 && n <= PyLong_MASK);
|
assert(n > 0 && n <= PyLong_MASK);
|
||||||
|
@ -1597,7 +1596,7 @@ long_to_decimal_string_internal(PyObject *aa,
|
||||||
PyErr_BadInternalCall();
|
PyErr_BadInternalCall();
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
size_a = ABS(Py_SIZE(a));
|
size_a = Py_ABS(Py_SIZE(a));
|
||||||
negative = Py_SIZE(a) < 0;
|
negative = Py_SIZE(a) < 0;
|
||||||
|
|
||||||
/* quick and dirty upper bound for the number of digits
|
/* quick and dirty upper bound for the number of digits
|
||||||
|
@ -1766,7 +1765,7 @@ long_format_binary(PyObject *aa, int base, int alternate,
|
||||||
PyErr_BadInternalCall();
|
PyErr_BadInternalCall();
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
size_a = ABS(Py_SIZE(a));
|
size_a = Py_ABS(Py_SIZE(a));
|
||||||
negative = Py_SIZE(a) < 0;
|
negative = Py_SIZE(a) < 0;
|
||||||
|
|
||||||
/* Compute a rough upper bound for the length of the string */
|
/* Compute a rough upper bound for the length of the string */
|
||||||
|
@ -2380,7 +2379,7 @@ static int
|
||||||
long_divrem(PyLongObject *a, PyLongObject *b,
|
long_divrem(PyLongObject *a, PyLongObject *b,
|
||||||
PyLongObject **pdiv, PyLongObject **prem)
|
PyLongObject **pdiv, PyLongObject **prem)
|
||||||
{
|
{
|
||||||
Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b));
|
Py_ssize_t size_a = Py_ABS(Py_SIZE(a)), size_b = Py_ABS(Py_SIZE(b));
|
||||||
PyLongObject *z;
|
PyLongObject *z;
|
||||||
|
|
||||||
if (size_b == 0) {
|
if (size_b == 0) {
|
||||||
|
@ -2439,7 +2438,7 @@ long_divrem(PyLongObject *a, PyLongObject *b,
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Unsigned int division with remainder -- the algorithm. The arguments v1
|
/* Unsigned int division with remainder -- the algorithm. The arguments v1
|
||||||
and w1 should satisfy 2 <= ABS(Py_SIZE(w1)) <= ABS(Py_SIZE(v1)). */
|
and w1 should satisfy 2 <= Py_ABS(Py_SIZE(w1)) <= Py_ABS(Py_SIZE(v1)). */
|
||||||
|
|
||||||
static PyLongObject *
|
static PyLongObject *
|
||||||
x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
|
x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
|
||||||
|
@ -2459,8 +2458,8 @@ x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
|
||||||
that won't overflow a digit. */
|
that won't overflow a digit. */
|
||||||
|
|
||||||
/* allocate space; w will also be used to hold the final remainder */
|
/* allocate space; w will also be used to hold the final remainder */
|
||||||
size_v = ABS(Py_SIZE(v1));
|
size_v = Py_ABS(Py_SIZE(v1));
|
||||||
size_w = ABS(Py_SIZE(w1));
|
size_w = Py_ABS(Py_SIZE(w1));
|
||||||
assert(size_v >= size_w && size_w >= 2); /* Assert checks by div() */
|
assert(size_v >= size_w && size_w >= 2); /* Assert checks by div() */
|
||||||
v = _PyLong_New(size_v+1);
|
v = _PyLong_New(size_v+1);
|
||||||
if (v == NULL) {
|
if (v == NULL) {
|
||||||
|
@ -2591,7 +2590,7 @@ _PyLong_Frexp(PyLongObject *a, Py_ssize_t *e)
|
||||||
multiple of 4, rounding ties to a multiple of 8. */
|
multiple of 4, rounding ties to a multiple of 8. */
|
||||||
static const int half_even_correction[8] = {0, -1, -2, 1, 0, -1, 2, 1};
|
static const int half_even_correction[8] = {0, -1, -2, 1, 0, -1, 2, 1};
|
||||||
|
|
||||||
a_size = ABS(Py_SIZE(a));
|
a_size = Py_ABS(Py_SIZE(a));
|
||||||
if (a_size == 0) {
|
if (a_size == 0) {
|
||||||
/* Special case for 0: significand 0.0, exponent 0. */
|
/* Special case for 0: significand 0.0, exponent 0. */
|
||||||
*e = 0;
|
*e = 0;
|
||||||
|
@ -2732,7 +2731,7 @@ long_compare(PyLongObject *a, PyLongObject *b)
|
||||||
sign = Py_SIZE(a) - Py_SIZE(b);
|
sign = Py_SIZE(a) - Py_SIZE(b);
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
Py_ssize_t i = ABS(Py_SIZE(a));
|
Py_ssize_t i = Py_ABS(Py_SIZE(a));
|
||||||
while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i])
|
while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i])
|
||||||
;
|
;
|
||||||
if (i < 0)
|
if (i < 0)
|
||||||
|
@ -2850,7 +2849,7 @@ long_hash(PyLongObject *v)
|
||||||
static PyLongObject *
|
static PyLongObject *
|
||||||
x_add(PyLongObject *a, PyLongObject *b)
|
x_add(PyLongObject *a, PyLongObject *b)
|
||||||
{
|
{
|
||||||
Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b));
|
Py_ssize_t size_a = Py_ABS(Py_SIZE(a)), size_b = Py_ABS(Py_SIZE(b));
|
||||||
PyLongObject *z;
|
PyLongObject *z;
|
||||||
Py_ssize_t i;
|
Py_ssize_t i;
|
||||||
digit carry = 0;
|
digit carry = 0;
|
||||||
|
@ -2884,7 +2883,7 @@ x_add(PyLongObject *a, PyLongObject *b)
|
||||||
static PyLongObject *
|
static PyLongObject *
|
||||||
x_sub(PyLongObject *a, PyLongObject *b)
|
x_sub(PyLongObject *a, PyLongObject *b)
|
||||||
{
|
{
|
||||||
Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b));
|
Py_ssize_t size_a = Py_ABS(Py_SIZE(a)), size_b = Py_ABS(Py_SIZE(b));
|
||||||
PyLongObject *z;
|
PyLongObject *z;
|
||||||
Py_ssize_t i;
|
Py_ssize_t i;
|
||||||
int sign = 1;
|
int sign = 1;
|
||||||
|
@ -2944,7 +2943,7 @@ long_add(PyLongObject *a, PyLongObject *b)
|
||||||
|
|
||||||
CHECK_BINOP(a, b);
|
CHECK_BINOP(a, b);
|
||||||
|
|
||||||
if (ABS(Py_SIZE(a)) <= 1 && ABS(Py_SIZE(b)) <= 1) {
|
if (Py_ABS(Py_SIZE(a)) <= 1 && Py_ABS(Py_SIZE(b)) <= 1) {
|
||||||
PyObject *result = PyLong_FromLong(MEDIUM_VALUE(a) +
|
PyObject *result = PyLong_FromLong(MEDIUM_VALUE(a) +
|
||||||
MEDIUM_VALUE(b));
|
MEDIUM_VALUE(b));
|
||||||
return result;
|
return result;
|
||||||
|
@ -2974,7 +2973,7 @@ long_sub(PyLongObject *a, PyLongObject *b)
|
||||||
|
|
||||||
CHECK_BINOP(a, b);
|
CHECK_BINOP(a, b);
|
||||||
|
|
||||||
if (ABS(Py_SIZE(a)) <= 1 && ABS(Py_SIZE(b)) <= 1) {
|
if (Py_ABS(Py_SIZE(a)) <= 1 && Py_ABS(Py_SIZE(b)) <= 1) {
|
||||||
PyObject* r;
|
PyObject* r;
|
||||||
r = PyLong_FromLong(MEDIUM_VALUE(a)-MEDIUM_VALUE(b));
|
r = PyLong_FromLong(MEDIUM_VALUE(a)-MEDIUM_VALUE(b));
|
||||||
return r;
|
return r;
|
||||||
|
@ -3003,8 +3002,8 @@ static PyLongObject *
|
||||||
x_mul(PyLongObject *a, PyLongObject *b)
|
x_mul(PyLongObject *a, PyLongObject *b)
|
||||||
{
|
{
|
||||||
PyLongObject *z;
|
PyLongObject *z;
|
||||||
Py_ssize_t size_a = ABS(Py_SIZE(a));
|
Py_ssize_t size_a = Py_ABS(Py_SIZE(a));
|
||||||
Py_ssize_t size_b = ABS(Py_SIZE(b));
|
Py_ssize_t size_b = Py_ABS(Py_SIZE(b));
|
||||||
Py_ssize_t i;
|
Py_ssize_t i;
|
||||||
|
|
||||||
z = _PyLong_New(size_a + size_b);
|
z = _PyLong_New(size_a + size_b);
|
||||||
|
@ -3098,7 +3097,7 @@ kmul_split(PyLongObject *n,
|
||||||
{
|
{
|
||||||
PyLongObject *hi, *lo;
|
PyLongObject *hi, *lo;
|
||||||
Py_ssize_t size_lo, size_hi;
|
Py_ssize_t size_lo, size_hi;
|
||||||
const Py_ssize_t size_n = ABS(Py_SIZE(n));
|
const Py_ssize_t size_n = Py_ABS(Py_SIZE(n));
|
||||||
|
|
||||||
size_lo = Py_MIN(size_n, size);
|
size_lo = Py_MIN(size_n, size);
|
||||||
size_hi = size_n - size_lo;
|
size_hi = size_n - size_lo;
|
||||||
|
@ -3127,8 +3126,8 @@ static PyLongObject *k_lopsided_mul(PyLongObject *a, PyLongObject *b);
|
||||||
static PyLongObject *
|
static PyLongObject *
|
||||||
k_mul(PyLongObject *a, PyLongObject *b)
|
k_mul(PyLongObject *a, PyLongObject *b)
|
||||||
{
|
{
|
||||||
Py_ssize_t asize = ABS(Py_SIZE(a));
|
Py_ssize_t asize = Py_ABS(Py_SIZE(a));
|
||||||
Py_ssize_t bsize = ABS(Py_SIZE(b));
|
Py_ssize_t bsize = Py_ABS(Py_SIZE(b));
|
||||||
PyLongObject *ah = NULL;
|
PyLongObject *ah = NULL;
|
||||||
PyLongObject *al = NULL;
|
PyLongObject *al = NULL;
|
||||||
PyLongObject *bh = NULL;
|
PyLongObject *bh = NULL;
|
||||||
|
@ -3348,8 +3347,8 @@ ah*bh and al*bl too.
|
||||||
static PyLongObject *
|
static PyLongObject *
|
||||||
k_lopsided_mul(PyLongObject *a, PyLongObject *b)
|
k_lopsided_mul(PyLongObject *a, PyLongObject *b)
|
||||||
{
|
{
|
||||||
const Py_ssize_t asize = ABS(Py_SIZE(a));
|
const Py_ssize_t asize = Py_ABS(Py_SIZE(a));
|
||||||
Py_ssize_t bsize = ABS(Py_SIZE(b));
|
Py_ssize_t bsize = Py_ABS(Py_SIZE(b));
|
||||||
Py_ssize_t nbdone; /* # of b digits already multiplied */
|
Py_ssize_t nbdone; /* # of b digits already multiplied */
|
||||||
PyLongObject *ret;
|
PyLongObject *ret;
|
||||||
PyLongObject *bslice = NULL;
|
PyLongObject *bslice = NULL;
|
||||||
|
@ -3407,7 +3406,7 @@ long_mul(PyLongObject *a, PyLongObject *b)
|
||||||
CHECK_BINOP(a, b);
|
CHECK_BINOP(a, b);
|
||||||
|
|
||||||
/* fast path for single-digit multiplication */
|
/* fast path for single-digit multiplication */
|
||||||
if (ABS(Py_SIZE(a)) <= 1 && ABS(Py_SIZE(b)) <= 1) {
|
if (Py_ABS(Py_SIZE(a)) <= 1 && Py_ABS(Py_SIZE(b)) <= 1) {
|
||||||
stwodigits v = (stwodigits)(MEDIUM_VALUE(a)) * MEDIUM_VALUE(b);
|
stwodigits v = (stwodigits)(MEDIUM_VALUE(a)) * MEDIUM_VALUE(b);
|
||||||
#ifdef HAVE_LONG_LONG
|
#ifdef HAVE_LONG_LONG
|
||||||
return PyLong_FromLongLong((PY_LONG_LONG)v);
|
return PyLong_FromLongLong((PY_LONG_LONG)v);
|
||||||
|
@ -3614,8 +3613,8 @@ long_true_divide(PyObject *v, PyObject *w)
|
||||||
*/
|
*/
|
||||||
|
|
||||||
/* Reduce to case where a and b are both positive. */
|
/* Reduce to case where a and b are both positive. */
|
||||||
a_size = ABS(Py_SIZE(a));
|
a_size = Py_ABS(Py_SIZE(a));
|
||||||
b_size = ABS(Py_SIZE(b));
|
b_size = Py_ABS(Py_SIZE(b));
|
||||||
negate = (Py_SIZE(a) < 0) ^ (Py_SIZE(b) < 0);
|
negate = (Py_SIZE(a) < 0) ^ (Py_SIZE(b) < 0);
|
||||||
if (b_size == 0) {
|
if (b_size == 0) {
|
||||||
PyErr_SetString(PyExc_ZeroDivisionError,
|
PyErr_SetString(PyExc_ZeroDivisionError,
|
||||||
|
@ -3731,7 +3730,7 @@ long_true_divide(PyObject *v, PyObject *w)
|
||||||
inexact = 1;
|
inexact = 1;
|
||||||
Py_DECREF(rem);
|
Py_DECREF(rem);
|
||||||
}
|
}
|
||||||
x_size = ABS(Py_SIZE(x));
|
x_size = Py_ABS(Py_SIZE(x));
|
||||||
assert(x_size > 0); /* result of division is never zero */
|
assert(x_size > 0); /* result of division is never zero */
|
||||||
x_bits = (x_size-1)*PyLong_SHIFT+bits_in_digit(x->ob_digit[x_size-1]);
|
x_bits = (x_size-1)*PyLong_SHIFT+bits_in_digit(x->ob_digit[x_size-1]);
|
||||||
|
|
||||||
|
@ -4003,7 +4002,7 @@ long_invert(PyLongObject *v)
|
||||||
/* Implement ~x as -(x+1) */
|
/* Implement ~x as -(x+1) */
|
||||||
PyLongObject *x;
|
PyLongObject *x;
|
||||||
PyLongObject *w;
|
PyLongObject *w;
|
||||||
if (ABS(Py_SIZE(v)) <=1)
|
if (Py_ABS(Py_SIZE(v)) <=1)
|
||||||
return PyLong_FromLong(-(MEDIUM_VALUE(v)+1));
|
return PyLong_FromLong(-(MEDIUM_VALUE(v)+1));
|
||||||
w = (PyLongObject *)PyLong_FromLong(1L);
|
w = (PyLongObject *)PyLong_FromLong(1L);
|
||||||
if (w == NULL)
|
if (w == NULL)
|
||||||
|
@ -4020,7 +4019,7 @@ static PyObject *
|
||||||
long_neg(PyLongObject *v)
|
long_neg(PyLongObject *v)
|
||||||
{
|
{
|
||||||
PyLongObject *z;
|
PyLongObject *z;
|
||||||
if (ABS(Py_SIZE(v)) <= 1)
|
if (Py_ABS(Py_SIZE(v)) <= 1)
|
||||||
return PyLong_FromLong(-MEDIUM_VALUE(v));
|
return PyLong_FromLong(-MEDIUM_VALUE(v));
|
||||||
z = (PyLongObject *)_PyLong_Copy(v);
|
z = (PyLongObject *)_PyLong_Copy(v);
|
||||||
if (z != NULL)
|
if (z != NULL)
|
||||||
|
@ -4075,7 +4074,7 @@ long_rshift(PyLongObject *a, PyLongObject *b)
|
||||||
goto rshift_error;
|
goto rshift_error;
|
||||||
}
|
}
|
||||||
wordshift = shiftby / PyLong_SHIFT;
|
wordshift = shiftby / PyLong_SHIFT;
|
||||||
newsize = ABS(Py_SIZE(a)) - wordshift;
|
newsize = Py_ABS(Py_SIZE(a)) - wordshift;
|
||||||
if (newsize <= 0)
|
if (newsize <= 0)
|
||||||
return PyLong_FromLong(0);
|
return PyLong_FromLong(0);
|
||||||
loshift = shiftby % PyLong_SHIFT;
|
loshift = shiftby % PyLong_SHIFT;
|
||||||
|
@ -4122,7 +4121,7 @@ long_lshift(PyObject *v, PyObject *w)
|
||||||
wordshift = shiftby / PyLong_SHIFT;
|
wordshift = shiftby / PyLong_SHIFT;
|
||||||
remshift = shiftby - wordshift * PyLong_SHIFT;
|
remshift = shiftby - wordshift * PyLong_SHIFT;
|
||||||
|
|
||||||
oldsize = ABS(Py_SIZE(a));
|
oldsize = Py_ABS(Py_SIZE(a));
|
||||||
newsize = oldsize + wordshift;
|
newsize = oldsize + wordshift;
|
||||||
if (remshift)
|
if (remshift)
|
||||||
++newsize;
|
++newsize;
|
||||||
|
@ -4183,7 +4182,7 @@ long_bitwise(PyLongObject *a,
|
||||||
result back to sign-magnitude at the end. */
|
result back to sign-magnitude at the end. */
|
||||||
|
|
||||||
/* If a is negative, replace it by its two's complement. */
|
/* If a is negative, replace it by its two's complement. */
|
||||||
size_a = ABS(Py_SIZE(a));
|
size_a = Py_ABS(Py_SIZE(a));
|
||||||
nega = Py_SIZE(a) < 0;
|
nega = Py_SIZE(a) < 0;
|
||||||
if (nega) {
|
if (nega) {
|
||||||
z = _PyLong_New(size_a);
|
z = _PyLong_New(size_a);
|
||||||
|
@ -4197,7 +4196,7 @@ long_bitwise(PyLongObject *a,
|
||||||
Py_INCREF(a);
|
Py_INCREF(a);
|
||||||
|
|
||||||
/* Same for b. */
|
/* Same for b. */
|
||||||
size_b = ABS(Py_SIZE(b));
|
size_b = Py_ABS(Py_SIZE(b));
|
||||||
negb = Py_SIZE(b) < 0;
|
negb = Py_SIZE(b) < 0;
|
||||||
if (negb) {
|
if (negb) {
|
||||||
z = _PyLong_New(size_b);
|
z = _PyLong_New(size_b);
|
||||||
|
@ -4630,7 +4629,7 @@ long_sizeof(PyLongObject *v)
|
||||||
{
|
{
|
||||||
Py_ssize_t res;
|
Py_ssize_t res;
|
||||||
|
|
||||||
res = offsetof(PyLongObject, ob_digit) + ABS(Py_SIZE(v))*sizeof(digit);
|
res = offsetof(PyLongObject, ob_digit) + Py_ABS(Py_SIZE(v))*sizeof(digit);
|
||||||
return PyLong_FromSsize_t(res);
|
return PyLong_FromSsize_t(res);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -4644,7 +4643,7 @@ long_bit_length(PyLongObject *v)
|
||||||
assert(v != NULL);
|
assert(v != NULL);
|
||||||
assert(PyLong_Check(v));
|
assert(PyLong_Check(v));
|
||||||
|
|
||||||
ndigits = ABS(Py_SIZE(v));
|
ndigits = Py_ABS(Py_SIZE(v));
|
||||||
if (ndigits == 0)
|
if (ndigits == 0)
|
||||||
return PyLong_FromLong(0);
|
return PyLong_FromLong(0);
|
||||||
|
|
||||||
|
@ -4849,7 +4848,7 @@ long_from_bytes(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
||||||
if (type != &PyLong_Type && PyType_IsSubtype(type, &PyLong_Type)) {
|
if (type != &PyLong_Type && PyType_IsSubtype(type, &PyLong_Type)) {
|
||||||
PyLongObject *newobj;
|
PyLongObject *newobj;
|
||||||
int i;
|
int i;
|
||||||
Py_ssize_t n = ABS(Py_SIZE(long_obj));
|
Py_ssize_t n = Py_ABS(Py_SIZE(long_obj));
|
||||||
|
|
||||||
newobj = (PyLongObject *)type->tp_alloc(type, n);
|
newobj = (PyLongObject *)type->tp_alloc(type, n);
|
||||||
if (newobj == NULL) {
|
if (newobj == NULL) {
|
||||||
|
|
|
@ -48,9 +48,6 @@
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
||||||
#define XSTRINGIZE(v) #v
|
|
||||||
#define STRINGIZE(v) XSTRINGIZE(v)
|
|
||||||
|
|
||||||
#define CHECK_MBUF_RELEASED(mbuf) \
|
#define CHECK_MBUF_RELEASED(mbuf) \
|
||||||
if (((_PyManagedBufferObject *)mbuf)->flags&_Py_MANAGED_BUFFER_RELEASED) { \
|
if (((_PyManagedBufferObject *)mbuf)->flags&_Py_MANAGED_BUFFER_RELEASED) { \
|
||||||
PyErr_SetString(PyExc_ValueError, \
|
PyErr_SetString(PyExc_ValueError, \
|
||||||
|
@ -660,7 +657,7 @@ mbuf_add_view(_PyManagedBufferObject *mbuf, const Py_buffer *src)
|
||||||
if (src->ndim > PyBUF_MAX_NDIM) {
|
if (src->ndim > PyBUF_MAX_NDIM) {
|
||||||
PyErr_SetString(PyExc_ValueError,
|
PyErr_SetString(PyExc_ValueError,
|
||||||
"memoryview: number of dimensions must not exceed "
|
"memoryview: number of dimensions must not exceed "
|
||||||
STRINGIZE(PyBUF_MAX_NDIM));
|
Py_STRINGIFY(PyBUF_MAX_NDIM));
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1341,7 +1338,7 @@ memory_cast(PyMemoryViewObject *self, PyObject *args, PyObject *kwds)
|
||||||
if (ndim > PyBUF_MAX_NDIM) {
|
if (ndim > PyBUF_MAX_NDIM) {
|
||||||
PyErr_SetString(PyExc_ValueError,
|
PyErr_SetString(PyExc_ValueError,
|
||||||
"memoryview: number of dimensions must not exceed "
|
"memoryview: number of dimensions must not exceed "
|
||||||
STRINGIZE(PyBUF_MAX_NDIM));
|
Py_STRINGIFY(PyBUF_MAX_NDIM));
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
if (self->view.ndim != 1 && ndim != 1) {
|
if (self->view.ndim != 1 && ndim != 1) {
|
||||||
|
|
|
@ -13,8 +13,6 @@
|
||||||
#include "code.h"
|
#include "code.h"
|
||||||
#include "marshal.h"
|
#include "marshal.h"
|
||||||
|
|
||||||
#define ABS(x) ((x) < 0 ? -(x) : (x))
|
|
||||||
|
|
||||||
/* High water mark to determine when the marshalled object is dangerously deep
|
/* High water mark to determine when the marshalled object is dangerously deep
|
||||||
* and risks coring the interpreter. When the object stack gets this deep,
|
* and risks coring the interpreter. When the object stack gets this deep,
|
||||||
* raise an exception instead of continuing.
|
* raise an exception instead of continuing.
|
||||||
|
@ -192,7 +190,7 @@ w_PyLong(const PyLongObject *ob, char flag, WFILE *p)
|
||||||
}
|
}
|
||||||
|
|
||||||
/* set l to number of base PyLong_MARSHAL_BASE digits */
|
/* set l to number of base PyLong_MARSHAL_BASE digits */
|
||||||
n = ABS(Py_SIZE(ob));
|
n = Py_ABS(Py_SIZE(ob));
|
||||||
l = (n-1) * PyLong_MARSHAL_RATIO;
|
l = (n-1) * PyLong_MARSHAL_RATIO;
|
||||||
d = ob->ob_digit[n-1];
|
d = ob->ob_digit[n-1];
|
||||||
assert(d != 0); /* a PyLong is always normalized */
|
assert(d != 0); /* a PyLong is always normalized */
|
||||||
|
@ -727,8 +725,8 @@ r_PyLong(RFILE *p)
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
size = 1 + (ABS(n) - 1) / PyLong_MARSHAL_RATIO;
|
size = 1 + (Py_ABS(n) - 1) / PyLong_MARSHAL_RATIO;
|
||||||
shorts_in_top_digit = 1 + (ABS(n) - 1) % PyLong_MARSHAL_RATIO;
|
shorts_in_top_digit = 1 + (Py_ABS(n) - 1) % PyLong_MARSHAL_RATIO;
|
||||||
ob = _PyLong_New(size);
|
ob = _PyLong_New(size);
|
||||||
if (ob == NULL)
|
if (ob == NULL)
|
||||||
return NULL;
|
return NULL;
|
||||||
|
|
Loading…
Reference in New Issue