1 /* mpn_get_str -- Convert a MSIZE long limb vector pointed to by MPTR
2 to a printable string in STR in base BASE.
4 Copyright (C) 1991, 1992, 1993, 1994, 1996, 2000 Free Software Foundation,
7 This file is part of the GNU MP Library.
9 The GNU MP Library is free software; you can redistribute it and/or modify
10 it under the terms of the GNU Lesser General Public License as published by
11 the Free Software Foundation; either version 2.1 of the License, or (at your
12 option) any later version.
14 The GNU MP Library is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
17 License for more details.
19 You should have received a copy of the GNU Lesser General Public License
20 along with the GNU MP Library; see the file COPYING.LIB. If not, write to
21 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
22 MA 02111-1307, USA. */
28 /* Convert the limb vector pointed to by MPTR and MSIZE long to a
29 char array, using base BASE for the result array. Store the
30 result in the character array STR. STR must point to an array with
31 space for the largest possible number represented by a MSIZE long
32 limb vector + 1 extra character.
34 The result is NOT in Ascii, to convert it to printable format, add
35 '0' or 'A' depending on the base and range.
37 Return the number of digits in the result string.
38 This may include some leading zeros.
40 The limb vector pointed to by MPTR is clobbered. */
44 mpn_get_str (unsigned char *str, int base, mp_ptr mptr, mp_size_t msize)
46 mpn_get_str (str, base, mptr, msize)
54 #if UDIV_NEEDS_NORMALIZATION || UDIV_TIME > 2 * UMUL_TIME
55 int normalization_steps;
57 #if UDIV_TIME > 2 * UMUL_TIME
58 mp_limb_t big_base_inverted;
60 unsigned int dig_per_u;
62 register unsigned char *s;
64 big_base = __mp_bases[base].big_base;
68 /* Special case zero, as the code below doesn't handle it. */
75 if ((base & (base - 1)) == 0)
77 /* The base is a power of 2. Make conversion from most
80 register int bits_per_digit = big_base;
86 count_leading_zeros (x, n1);
88 /* BIT_POS should be R when input ends in least sign. nibble,
89 R + bits_per_digit * n when input ends in n:th least significant
95 bits = BITS_PER_MP_LIMB * msize - x;
96 x = bits % bits_per_digit;
98 bits += bits_per_digit - x;
99 bit_pos = bits - (msize - 1) * BITS_PER_MP_LIMB;
102 /* Fast loop for bit output. */
106 bit_pos -= bits_per_digit;
109 *s++ = (n1 >> bit_pos) & ((1 << bits_per_digit) - 1);
110 bit_pos -= bits_per_digit;
115 n0 = (n1 << -bit_pos) & ((1 << bits_per_digit) - 1);
117 bit_pos += BITS_PER_MP_LIMB;
118 *s++ = n0 | (n1 >> bit_pos);
127 /* General case. The base is not a power of 2. Make conversion
128 from least significant end. */
130 /* If udiv_qrnnd only handles divisors with the most significant bit
131 set, prepare BIG_BASE for being a divisor by shifting it to the
132 left exactly enough to set the most significant bit. */
133 #if UDIV_NEEDS_NORMALIZATION || UDIV_TIME > 2 * UMUL_TIME
134 count_leading_zeros (normalization_steps, big_base);
135 big_base <<= normalization_steps;
136 #if UDIV_TIME > 2 * UMUL_TIME
137 /* Get the fixed-point approximation to 1/(BIG_BASE << NORMALIZATION_STEPS). */
138 big_base_inverted = __mp_bases[base].big_base_inverted;
142 dig_per_u = __mp_bases[base].chars_per_limb;
143 out_len = ((size_t) msize * BITS_PER_MP_LIMB
144 * __mp_bases[base].chars_per_bit_exactly) + 1;
152 #if UDIV_NEEDS_NORMALIZATION || UDIV_TIME > 2 * UMUL_TIME
153 /* If we shifted BIG_BASE above, shift the dividend too, to get
154 the right quotient. We need to do this every loop,
155 since the intermediate quotients are OK, but the quotient from
156 one turn in the loop is going to be the dividend in the
157 next turn, and the dividend needs to be up-shifted. */
158 if (normalization_steps != 0)
160 n0 = mpn_lshift (mptr, mptr, msize, normalization_steps);
162 /* If the shifting gave a carry out limb, store it and
163 increase the length. */
172 /* Divide the number at TP with BIG_BASE to get a quotient and a
173 remainder. The remainder is our new digit in base BIG_BASE. */
188 #if UDIV_TIME > 2 * UMUL_TIME
189 udiv_qrnnd_preinv (mptr[i], n1, n1, n0, big_base, big_base_inverted);
191 udiv_qrnnd (mptr[i], n1, n1, n0, big_base);
195 #if UDIV_NEEDS_NORMALIZATION || UDIV_TIME > 2 * UMUL_TIME
196 /* If we shifted above (at previous UDIV_NEEDS_NORMALIZATION tests)
197 the remainder will be up-shifted here. Compensate. */
198 n1 >>= normalization_steps;
201 /* Convert N1 from BIG_BASE to a string of digits in BASE
202 using single precision operations. */
203 for (i = dig_per_u - 1; i >= 0; i--)
207 if (n1 == 0 && msize == 0)