remove MP_IS_* macros
This commit is contained in:
parent
f8b2f5d6fe
commit
a44e68e652
@ -12,7 +12,7 @@ mp_err mp_add_d(const mp_int *a, mp_digit b, mp_int *c)
|
||||
|
||||
/* fast path for a == c */
|
||||
if (a == c &&
|
||||
!MP_IS_ZERO(c) &&
|
||||
!mp_iszero(c) &&
|
||||
c->sign == MP_ZPOS &&
|
||||
c->dp[0] + b < MP_DIGIT_MAX) {
|
||||
c->dp[0] += b;
|
||||
|
@ -14,7 +14,7 @@ int mp_cnt_lsb(const mp_int *a)
|
||||
mp_digit q, qq;
|
||||
|
||||
/* easy out */
|
||||
if (MP_IS_ZERO(a)) {
|
||||
if (mp_iszero(a)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -10,7 +10,7 @@ int mp_count_bits(const mp_int *a)
|
||||
mp_digit q;
|
||||
|
||||
/* shortcut */
|
||||
if (MP_IS_ZERO(a)) {
|
||||
if (mp_iszero(a)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
2
mp_div.c
2
mp_div.c
@ -8,7 +8,7 @@ mp_err mp_div(const mp_int *a, const mp_int *b, mp_int *c, mp_int *d)
|
||||
mp_err err;
|
||||
|
||||
/* is divisor zero ? */
|
||||
if (MP_IS_ZERO(b)) {
|
||||
if (mp_iszero(b)) {
|
||||
return MP_VAL;
|
||||
}
|
||||
|
||||
|
@ -18,7 +18,7 @@ mp_err mp_div_d(const mp_int *a, mp_digit b, mp_int *c, mp_digit *d)
|
||||
}
|
||||
|
||||
/* quick outs */
|
||||
if ((b == 1u) || MP_IS_ZERO(a)) {
|
||||
if ((b == 1u) || mp_iszero(a)) {
|
||||
if (d != NULL) {
|
||||
*d = 0;
|
||||
}
|
||||
|
@ -62,7 +62,7 @@ LBL_ERR:
|
||||
}
|
||||
|
||||
/* if the modulus is odd or dr != 0 use the montgomery method */
|
||||
if (MP_HAS(S_MP_EXPTMOD_FAST) && (MP_IS_ODD(P) || (dr != 0))) {
|
||||
if (MP_HAS(S_MP_EXPTMOD_FAST) && (mp_isodd(P) || (dr != 0))) {
|
||||
return s_mp_exptmod_fast(G, X, P, Y, dr);
|
||||
} else if (MP_HAS(S_MP_EXPTMOD)) {
|
||||
/* otherwise use the generic Barrett reduction technique */
|
||||
|
@ -24,7 +24,7 @@ mp_err mp_exteuclid(const mp_int *a, const mp_int *b, mp_int *U1, mp_int *U2, mp
|
||||
if ((err = mp_copy(b, &v3)) != MP_OKAY) goto LBL_ERR;
|
||||
|
||||
/* loop while v3 != 0 */
|
||||
while (!MP_IS_ZERO(&v3)) {
|
||||
while (!mp_iszero(&v3)) {
|
||||
/* q = u3/v3 */
|
||||
if ((err = mp_div(&u3, &v3, &q, NULL)) != MP_OKAY) goto LBL_ERR;
|
||||
|
||||
|
6
mp_gcd.c
6
mp_gcd.c
@ -11,10 +11,10 @@ mp_err mp_gcd(const mp_int *a, const mp_int *b, mp_int *c)
|
||||
mp_err err;
|
||||
|
||||
/* either zero than gcd is the largest */
|
||||
if (MP_IS_ZERO(a)) {
|
||||
if (mp_iszero(a)) {
|
||||
return mp_abs(b, c);
|
||||
}
|
||||
if (MP_IS_ZERO(b)) {
|
||||
if (mp_iszero(b)) {
|
||||
return mp_abs(a, c);
|
||||
}
|
||||
|
||||
@ -59,7 +59,7 @@ mp_err mp_gcd(const mp_int *a, const mp_int *b, mp_int *c)
|
||||
}
|
||||
}
|
||||
|
||||
while (!MP_IS_ZERO(&v)) {
|
||||
while (!mp_iszero(&v)) {
|
||||
/* make sure v is the largest */
|
||||
if (mp_cmp_mag(&u, &v) == MP_GT) {
|
||||
/* swap u and v to make sure v is >= u */
|
||||
|
@ -12,7 +12,7 @@ mp_err mp_invmod(const mp_int *a, const mp_int *b, mp_int *c)
|
||||
}
|
||||
|
||||
/* if the modulus is odd we can use a faster routine instead */
|
||||
if (MP_HAS(S_MP_INVMOD_FAST) && MP_IS_ODD(b)) {
|
||||
if (MP_HAS(S_MP_INVMOD_FAST) && mp_isodd(b)) {
|
||||
return s_mp_invmod_fast(a, b, c);
|
||||
}
|
||||
|
||||
|
@ -40,7 +40,7 @@ mp_err mp_is_square(const mp_int *arg, mp_bool *ret)
|
||||
return MP_VAL;
|
||||
}
|
||||
|
||||
if (MP_IS_ZERO(arg)) {
|
||||
if (mp_iszero(arg)) {
|
||||
return MP_OKAY;
|
||||
}
|
||||
|
||||
|
@ -25,7 +25,7 @@ mp_err mp_kronecker(const mp_int *a, const mp_int *p, int *c)
|
||||
|
||||
static const int table[8] = {0, 1, 0, -1, 0, -1, 0, 1};
|
||||
|
||||
if (MP_IS_ZERO(p)) {
|
||||
if (mp_iszero(p)) {
|
||||
if ((a->used == 1) && (a->dp[0] == 1u)) {
|
||||
*c = 1;
|
||||
} else {
|
||||
@ -34,7 +34,7 @@ mp_err mp_kronecker(const mp_int *a, const mp_int *p, int *c)
|
||||
return MP_OKAY;
|
||||
}
|
||||
|
||||
if (MP_IS_EVEN(a) && MP_IS_EVEN(p)) {
|
||||
if (mp_iseven(a) && mp_iseven(p)) {
|
||||
*c = 0;
|
||||
return MP_OKAY;
|
||||
}
|
||||
@ -69,7 +69,7 @@ mp_err mp_kronecker(const mp_int *a, const mp_int *p, int *c)
|
||||
}
|
||||
|
||||
for (;;) {
|
||||
if (MP_IS_ZERO(&a1)) {
|
||||
if (mp_iszero(&a1)) {
|
||||
if (mp_cmp_d(&p1, 1uL) == MP_EQ) {
|
||||
*c = k;
|
||||
goto LBL_KRON;
|
||||
|
@ -9,7 +9,7 @@ mp_err mp_log_u32(const mp_int *a, uint32_t base, uint32_t *c)
|
||||
return MP_VAL;
|
||||
}
|
||||
|
||||
if (MP_IS_ZERO(a)) {
|
||||
if (mp_iszero(a)) {
|
||||
return MP_VAL;
|
||||
}
|
||||
|
||||
|
@ -15,7 +15,7 @@ mp_err mp_lshd(mp_int *a, int b)
|
||||
return MP_OKAY;
|
||||
}
|
||||
/* no need to shift 0 around */
|
||||
if (MP_IS_ZERO(a)) {
|
||||
if (mp_iszero(a)) {
|
||||
return MP_OKAY;
|
||||
}
|
||||
|
||||
|
2
mp_mod.c
2
mp_mod.c
@ -17,7 +17,7 @@ mp_err mp_mod(const mp_int *a, const mp_int *b, mp_int *c)
|
||||
goto LBL_ERR;
|
||||
}
|
||||
|
||||
if (MP_IS_ZERO(&t) || (t.sign == b->sign)) {
|
||||
if (mp_iszero(&t) || (t.sign == b->sign)) {
|
||||
err = MP_OKAY;
|
||||
mp_exch(&t, c);
|
||||
} else {
|
||||
|
2
mp_neg.c
2
mp_neg.c
@ -13,7 +13,7 @@ mp_err mp_neg(const mp_int *a, mp_int *b)
|
||||
}
|
||||
}
|
||||
|
||||
if (!MP_IS_ZERO(b)) {
|
||||
if (!mp_iszero(b)) {
|
||||
b->sign = (a->sign == MP_ZPOS) ? MP_NEG : MP_ZPOS;
|
||||
} else {
|
||||
b->sign = MP_ZPOS;
|
||||
|
@ -112,7 +112,7 @@ mp_err mp_prime_frobenius_underwood(const mp_int *N, mp_bool *result)
|
||||
|
||||
mp_set_u32(&T1z, (uint32_t)((2 * a) + 5));
|
||||
if ((err = mp_mod(&T1z, N, &T1z)) != MP_OKAY) goto LBL_FU_ERR;
|
||||
if (MP_IS_ZERO(&sz) && (mp_cmp(&tz, &T1z) == MP_EQ)) {
|
||||
if (mp_iszero(&sz) && (mp_cmp(&tz, &T1z) == MP_EQ)) {
|
||||
*result = MP_YES;
|
||||
}
|
||||
|
||||
|
@ -39,7 +39,7 @@ mp_err mp_prime_is_prime(const mp_int *a, int t, mp_bool *result)
|
||||
}
|
||||
|
||||
/* N must be odd */
|
||||
if (MP_IS_EVEN(a)) {
|
||||
if (mp_iseven(a)) {
|
||||
return MP_OKAY;
|
||||
}
|
||||
/* N is not a perfect square: floor(sqrt(N))^2 != N */
|
||||
|
@ -58,7 +58,7 @@ mp_err mp_prime_next_prime(mp_int *a, int t, mp_bool bbs_style)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (MP_IS_EVEN(a)) {
|
||||
if (mp_iseven(a)) {
|
||||
/* force odd */
|
||||
if ((err = mp_sub_d(a, 1uL, a)) != MP_OKAY) {
|
||||
return err;
|
||||
|
@ -206,7 +206,7 @@ mp_err mp_prime_strong_lucas_selfridge(const mp_int *a, mp_bool *result)
|
||||
if ((err = mp_mul(&U2mz, &Uz, &T4z)) != MP_OKAY) goto LBL_LS_ERR;
|
||||
if ((err = s_mp_mul_si(&T4z, Ds, &T4z)) != MP_OKAY) goto LBL_LS_ERR;
|
||||
if ((err = mp_add(&T1z, &T2z, &Uz)) != MP_OKAY) goto LBL_LS_ERR;
|
||||
if (MP_IS_ODD(&Uz)) {
|
||||
if (mp_isodd(&Uz)) {
|
||||
if ((err = mp_add(&Uz, a, &Uz)) != MP_OKAY) goto LBL_LS_ERR;
|
||||
}
|
||||
/* CZ
|
||||
@ -214,16 +214,16 @@ mp_err mp_prime_strong_lucas_selfridge(const mp_int *a, mp_bool *result)
|
||||
* Thomas R. Nicely used GMP's mpz_fdiv_q_2exp().
|
||||
* But mp_div_2() does not do so, it is truncating instead.
|
||||
*/
|
||||
oddness = MP_IS_ODD(&Uz) ? MP_YES : MP_NO;
|
||||
oddness = mp_isodd(&Uz) ? MP_YES : MP_NO;
|
||||
if ((err = mp_div_2(&Uz, &Uz)) != MP_OKAY) goto LBL_LS_ERR;
|
||||
if ((Uz.sign == MP_NEG) && (oddness != MP_NO)) {
|
||||
if ((err = mp_sub_d(&Uz, 1uL, &Uz)) != MP_OKAY) goto LBL_LS_ERR;
|
||||
}
|
||||
if ((err = mp_add(&T3z, &T4z, &Vz)) != MP_OKAY) goto LBL_LS_ERR;
|
||||
if (MP_IS_ODD(&Vz)) {
|
||||
if (mp_isodd(&Vz)) {
|
||||
if ((err = mp_add(&Vz, a, &Vz)) != MP_OKAY) goto LBL_LS_ERR;
|
||||
}
|
||||
oddness = MP_IS_ODD(&Vz) ? MP_YES : MP_NO;
|
||||
oddness = mp_isodd(&Vz) ? MP_YES : MP_NO;
|
||||
if ((err = mp_div_2(&Vz, &Vz)) != MP_OKAY) goto LBL_LS_ERR;
|
||||
if ((Vz.sign == MP_NEG) && (oddness != MP_NO)) {
|
||||
if ((err = mp_sub_d(&Vz, 1uL, &Vz)) != MP_OKAY) goto LBL_LS_ERR;
|
||||
@ -239,7 +239,7 @@ mp_err mp_prime_strong_lucas_selfridge(const mp_int *a, mp_bool *result)
|
||||
|
||||
/* If U_d or V_d is congruent to 0 mod N, then N is a prime or a
|
||||
strong Lucas pseudoprime. */
|
||||
if (MP_IS_ZERO(&Uz) || MP_IS_ZERO(&Vz)) {
|
||||
if (mp_iszero(&Uz) || mp_iszero(&Vz)) {
|
||||
*result = MP_YES;
|
||||
goto LBL_LS_ERR;
|
||||
}
|
||||
@ -262,7 +262,7 @@ mp_err mp_prime_strong_lucas_selfridge(const mp_int *a, mp_bool *result)
|
||||
if ((err = mp_sqr(&Vz, &Vz)) != MP_OKAY) goto LBL_LS_ERR;
|
||||
if ((err = mp_sub(&Vz, &Q2kdz, &Vz)) != MP_OKAY) goto LBL_LS_ERR;
|
||||
if ((err = mp_mod(&Vz, a, &Vz)) != MP_OKAY) goto LBL_LS_ERR;
|
||||
if (MP_IS_ZERO(&Vz)) {
|
||||
if (mp_iszero(&Vz)) {
|
||||
*result = MP_YES;
|
||||
goto LBL_LS_ERR;
|
||||
}
|
||||
|
@ -15,7 +15,7 @@ mp_err mp_radix_size(const mp_int *a, int radix, size_t *size)
|
||||
return MP_VAL;
|
||||
}
|
||||
|
||||
if (MP_IS_ZERO(a)) {
|
||||
if (mp_iszero(a)) {
|
||||
*size = 2;
|
||||
return MP_OKAY;
|
||||
}
|
||||
|
@ -71,7 +71,7 @@ mp_err mp_read_radix(mp_int *a, const char *str, int radix)
|
||||
}
|
||||
|
||||
/* set the sign only if a != 0 */
|
||||
if (!MP_IS_ZERO(a)) {
|
||||
if (!mp_iszero(a)) {
|
||||
a->sign = neg;
|
||||
}
|
||||
return MP_OKAY;
|
||||
|
@ -30,7 +30,7 @@ mp_err mp_set_double(mp_int *a, double b)
|
||||
return err;
|
||||
}
|
||||
|
||||
if (((cast.bits >> 63) != 0uLL) && !MP_IS_ZERO(a)) {
|
||||
if (((cast.bits >> 63) != 0uLL) && !mp_iszero(a)) {
|
||||
a->sign = MP_NEG;
|
||||
}
|
||||
|
||||
|
@ -15,7 +15,7 @@ mp_err mp_sqrt(const mp_int *arg, mp_int *ret)
|
||||
}
|
||||
|
||||
/* easy out */
|
||||
if (MP_IS_ZERO(arg)) {
|
||||
if (mp_iszero(arg)) {
|
||||
mp_zero(ret);
|
||||
return MP_OKAY;
|
||||
}
|
||||
|
@ -51,7 +51,7 @@ mp_err mp_sqrtmod_prime(const mp_int *n, const mp_int *prime, mp_int *ret)
|
||||
/* Q = prime - 1 */
|
||||
mp_zero(&S);
|
||||
/* S = 0 */
|
||||
while (MP_IS_EVEN(&Q)) {
|
||||
while (mp_iseven(&Q)) {
|
||||
if ((err = mp_div_2(&Q, &Q)) != MP_OKAY) goto cleanup;
|
||||
/* Q = Q / 2 */
|
||||
if ((err = mp_add_d(&S, 1uL, &S)) != MP_OKAY) goto cleanup;
|
||||
|
@ -12,7 +12,7 @@ mp_err mp_sub_d(const mp_int *a, mp_digit b, mp_int *c)
|
||||
|
||||
/* fast path for a == c */
|
||||
if (a == c &&
|
||||
!MP_IS_ZERO(c) &&
|
||||
!mp_iszero(c) &&
|
||||
c->sign == MP_ZPOS &&
|
||||
c->dp[0] > b) {
|
||||
c->dp[0] -= b;
|
||||
|
@ -42,7 +42,7 @@ mp_err mp_to_radix(const mp_int *a, char *str, size_t maxlen, size_t *written, i
|
||||
}
|
||||
|
||||
/* quick out if its zero */
|
||||
if (MP_IS_ZERO(a)) {
|
||||
if (mp_iszero(a)) {
|
||||
*str++ = '0';
|
||||
*str = '\0';
|
||||
if (written != NULL) {
|
||||
@ -68,7 +68,7 @@ mp_err mp_to_radix(const mp_int *a, char *str, size_t maxlen, size_t *written, i
|
||||
--maxlen;
|
||||
}
|
||||
digs = 0u;
|
||||
while (!MP_IS_ZERO(&t)) {
|
||||
while (!mp_iszero(&t)) {
|
||||
if (--maxlen < 1u) {
|
||||
/* no more room */
|
||||
err = MP_BUF;
|
||||
|
@ -37,11 +37,11 @@ mp_err s_mp_div_small(const mp_int *a, const mp_int *b, mp_int *c, mp_int *d)
|
||||
sign = (a->sign == b->sign) ? MP_ZPOS : MP_NEG;
|
||||
if (c != NULL) {
|
||||
mp_exch(c, &q);
|
||||
c->sign = MP_IS_ZERO(c) ? MP_ZPOS : sign;
|
||||
c->sign = mp_iszero(c) ? MP_ZPOS : sign;
|
||||
}
|
||||
if (d != NULL) {
|
||||
mp_exch(d, &ta);
|
||||
d->sign = MP_IS_ZERO(d) ? MP_ZPOS : a->sign;
|
||||
d->sign = mp_iszero(d) ? MP_ZPOS : a->sign;
|
||||
}
|
||||
LBL_ERR:
|
||||
mp_clear_multi(&ta, &tb, &tq, &q, NULL);
|
||||
|
@ -16,7 +16,7 @@ mp_err s_mp_invmod_fast(const mp_int *a, const mp_int *b, mp_int *c)
|
||||
mp_err err;
|
||||
|
||||
/* 2. [modified] b must be odd */
|
||||
if (MP_IS_EVEN(b)) {
|
||||
if (mp_iseven(b)) {
|
||||
return MP_VAL;
|
||||
}
|
||||
|
||||
@ -32,7 +32,7 @@ mp_err s_mp_invmod_fast(const mp_int *a, const mp_int *b, mp_int *c)
|
||||
if ((err = mp_mod(a, b, &y)) != MP_OKAY) goto LBL_ERR;
|
||||
|
||||
/* if one of x,y is zero return an error! */
|
||||
if (MP_IS_ZERO(&x) || MP_IS_ZERO(&y)) {
|
||||
if (mp_iszero(&x) || mp_iszero(&y)) {
|
||||
err = MP_VAL;
|
||||
goto LBL_ERR;
|
||||
}
|
||||
@ -44,12 +44,12 @@ mp_err s_mp_invmod_fast(const mp_int *a, const mp_int *b, mp_int *c)
|
||||
|
||||
top:
|
||||
/* 4. while u is even do */
|
||||
while (MP_IS_EVEN(&u)) {
|
||||
while (mp_iseven(&u)) {
|
||||
/* 4.1 u = u/2 */
|
||||
if ((err = mp_div_2(&u, &u)) != MP_OKAY) goto LBL_ERR;
|
||||
|
||||
/* 4.2 if B is odd then */
|
||||
if (MP_IS_ODD(&B)) {
|
||||
if (mp_isodd(&B)) {
|
||||
if ((err = mp_sub(&B, &x, &B)) != MP_OKAY) goto LBL_ERR;
|
||||
}
|
||||
/* B = B/2 */
|
||||
@ -57,12 +57,12 @@ top:
|
||||
}
|
||||
|
||||
/* 5. while v is even do */
|
||||
while (MP_IS_EVEN(&v)) {
|
||||
while (mp_iseven(&v)) {
|
||||
/* 5.1 v = v/2 */
|
||||
if ((err = mp_div_2(&v, &v)) != MP_OKAY) goto LBL_ERR;
|
||||
|
||||
/* 5.2 if D is odd then */
|
||||
if (MP_IS_ODD(&D)) {
|
||||
if (mp_isodd(&D)) {
|
||||
/* D = (D-x)/2 */
|
||||
if ((err = mp_sub(&D, &x, &D)) != MP_OKAY) goto LBL_ERR;
|
||||
}
|
||||
@ -84,7 +84,7 @@ top:
|
||||
}
|
||||
|
||||
/* if not zero goto step 4 */
|
||||
if (!MP_IS_ZERO(&u)) {
|
||||
if (!mp_iszero(&u)) {
|
||||
goto top;
|
||||
}
|
||||
|
||||
|
@ -10,7 +10,7 @@ mp_err s_mp_invmod_slow(const mp_int *a, const mp_int *b, mp_int *c)
|
||||
mp_err err;
|
||||
|
||||
/* b cannot be negative */
|
||||
if ((b->sign == MP_NEG) || MP_IS_ZERO(b)) {
|
||||
if ((b->sign == MP_NEG) || mp_iszero(b)) {
|
||||
return MP_VAL;
|
||||
}
|
||||
|
||||
@ -25,7 +25,7 @@ mp_err s_mp_invmod_slow(const mp_int *a, const mp_int *b, mp_int *c)
|
||||
if ((err = mp_copy(b, &y)) != MP_OKAY) goto LBL_ERR;
|
||||
|
||||
/* 2. [modified] if x,y are both even then return an error! */
|
||||
if (MP_IS_EVEN(&x) && MP_IS_EVEN(&y)) {
|
||||
if (mp_iseven(&x) && mp_iseven(&y)) {
|
||||
err = MP_VAL;
|
||||
goto LBL_ERR;
|
||||
}
|
||||
@ -38,12 +38,12 @@ mp_err s_mp_invmod_slow(const mp_int *a, const mp_int *b, mp_int *c)
|
||||
|
||||
top:
|
||||
/* 4. while u is even do */
|
||||
while (MP_IS_EVEN(&u)) {
|
||||
while (mp_iseven(&u)) {
|
||||
/* 4.1 u = u/2 */
|
||||
if ((err = mp_div_2(&u, &u)) != MP_OKAY) goto LBL_ERR;
|
||||
|
||||
/* 4.2 if A or B is odd then */
|
||||
if (MP_IS_ODD(&A) || MP_IS_ODD(&B)) {
|
||||
if (mp_isodd(&A) || mp_isodd(&B)) {
|
||||
/* A = (A+y)/2, B = (B-x)/2 */
|
||||
if ((err = mp_add(&A, &y, &A)) != MP_OKAY) goto LBL_ERR;
|
||||
if ((err = mp_sub(&B, &x, &B)) != MP_OKAY) goto LBL_ERR;
|
||||
@ -54,12 +54,12 @@ top:
|
||||
}
|
||||
|
||||
/* 5. while v is even do */
|
||||
while (MP_IS_EVEN(&v)) {
|
||||
while (mp_iseven(&v)) {
|
||||
/* 5.1 v = v/2 */
|
||||
if ((err = mp_div_2(&v, &v)) != MP_OKAY) goto LBL_ERR;
|
||||
|
||||
/* 5.2 if C or D is odd then */
|
||||
if (MP_IS_ODD(&C) || MP_IS_ODD(&D)) {
|
||||
if (mp_isodd(&C) || mp_isodd(&D)) {
|
||||
/* C = (C+y)/2, D = (D-x)/2 */
|
||||
if ((err = mp_add(&C, &y, &C)) != MP_OKAY) goto LBL_ERR;
|
||||
if ((err = mp_sub(&D, &x, &D)) != MP_OKAY) goto LBL_ERR;
|
||||
@ -87,7 +87,7 @@ top:
|
||||
}
|
||||
|
||||
/* if not zero goto step 4 */
|
||||
if (!MP_IS_ZERO(&u)) {
|
||||
if (!mp_iszero(&u)) {
|
||||
goto top;
|
||||
}
|
||||
|
||||
|
@ -1,3 +1,4 @@
|
||||
|
||||
/* LibTomMath, multiple-precision integer library -- Tom St Denis */
|
||||
/* SPDX-License-Identifier: Unlicense */
|
||||
|
||||
@ -149,11 +150,6 @@ extern void MP_FREE(void *mem, size_t size);
|
||||
/* Static assertion */
|
||||
#define MP_STATIC_ASSERT(msg, cond) typedef char mp_static_assert_##msg[(cond) ? 1 : -1];
|
||||
|
||||
/* ---> Basic Manipulations <--- */
|
||||
#define MP_IS_ZERO(a) ((a)->used == 0)
|
||||
#define MP_IS_EVEN(a) (((a)->used == 0) || (((a)->dp[0] & 1u) == 0u))
|
||||
#define MP_IS_ODD(a) (((a)->used > 0) && (((a)->dp[0] & 1u) == 1u))
|
||||
|
||||
#define MP_SIZEOF_BITS(type) ((size_t)CHAR_BIT * sizeof(type))
|
||||
#define MP_MAXFAST (int)(1uL << (MP_SIZEOF_BITS(mp_word) - (2u * (size_t)MP_DIGIT_BIT)))
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user