OpenSolaris_b135/lib/libbc/libc/gen/common/_sprintf_sup.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 1988 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include "base_conversion.h"
/*
* Fundamental utilities of base conversion required for sprintf - but too
* complex or too seldom used to be worth assembly language coding.
*/
/* p = x * y + c ; return (p/10000 << 16 | p%10000) */
unsigned long
_prodc_b10000(_BIG_FLOAT_DIGIT x, _BIG_FLOAT_DIGIT y, unsigned long c)
{
unsigned long p = x * (unsigned long) y + c;
return ((p / 10000) << 16) | (p % 10000);
}
/* p = x * y ; return p */
unsigned long
_prod_b65536(_BIG_FLOAT_DIGIT x, _BIG_FLOAT_DIGIT y)
{
return (x * (unsigned long)y);
}
/* p = x * y ; return (p/10000 << 16 | p%10000) */
unsigned long
_prod_b10000(_BIG_FLOAT_DIGIT x, _BIG_FLOAT_DIGIT y)
{
unsigned long p = x * (unsigned long) y;
return ((p / 10000) << 16) | (p % 10000);
}
/* p = x << n + c ; return (p/10000 << 16 | p%10000) */
unsigned long
_lshift_b10000(_BIG_FLOAT_DIGIT x, short unsigned n, long unsigned c)
{
unsigned long p = (((unsigned long) x) << n) + c;
return ((p / 10000) << 16) | (p % 10000);
}
/* p = x * 10000 + c ; return p */
unsigned long
_prod_10000_b65536(_BIG_FLOAT_DIGIT x, long unsigned c)
{
return (x * (unsigned long) 10000 + c);
}
/* p = x << 16 + c ; return (p/10000 << 16 | p%10000) */
unsigned long
_prod_65536_b10000(_BIG_FLOAT_DIGIT x, long unsigned c)
{
unsigned long p = (((unsigned long) x) << 16) + c;
return ((p / 10000) << 16) | (p % 10000);
}
/* p = c ; return (p/10000 << 16 | p%10000) */
unsigned long
_carry_out_b10000(unsigned long c)
{
return ((c / 10000) << 16) | (c % 10000);
}
void
_left_shift_base_ten(_big_float *pbf, short unsigned multiplier)
{
/*
* Multiply a base-10**4 significand by 2<<multiplier. Extend length
* as necessary to accommodate carries.
*/
short unsigned length = pbf->blength;
int j;
unsigned long carry;
long p;
carry = 0;
for (j = 0; j < length; j++) {
p = _lshift_b10000((_BIG_FLOAT_DIGIT) pbf->bsignificand[j], multiplier, carry);
pbf->bsignificand[j] = (_BIG_FLOAT_DIGIT) (p & 0xffff);
carry = p >> 16;
}
while (carry != 0) {
p = _carry_out_b10000(carry);
pbf->bsignificand[j++] = (_BIG_FLOAT_DIGIT) (p & 0xffff);
carry = p >> 16;
}
pbf->blength = j;
}
void
_left_shift_base_two(_big_float *pbf, short unsigned multiplier)
{
/*
* Multiply a base-2**16 significand by 2<<multiplier. Extend length
* as necessary to accommodate carries.
*/
short unsigned length = pbf->blength;
long unsigned p;
int j;
unsigned long carry;
carry = 0;
for (j = 0; j < length; j++) {
p = _lshift_b65536(pbf->bsignificand[j], multiplier, carry);
pbf->bsignificand[j] = (_BIG_FLOAT_DIGIT) (p & 0xffff);
carry = p >> 16;
}
if (carry != 0) {
pbf->bsignificand[j++] = (_BIG_FLOAT_DIGIT) (_carry_out_b65536(carry) & 0xffff);
}
pbf->blength = j;
}
void
_right_shift_base_two(_big_float *pbf, short unsigned multiplier,
_BIG_FLOAT_DIGIT *sticky)
{
/* *pb = *pb / 2**multiplier to normalize. 15 <= multiplier <= 1 */
/* Any bits shifted out got to *sticky. */
long unsigned p;
int j;
unsigned long carry;
carry = 0;
for (j = pbf->blength - 1; j >= 0; j--) {
p = _rshift_b65536(pbf->bsignificand[j], multiplier, carry);
pbf->bsignificand[j] = (_BIG_FLOAT_DIGIT) (p >> 16);
carry = p & 0xffff;
}
*sticky = (_BIG_FLOAT_DIGIT) carry;
}
void
_multiply_base_ten(_big_float *pbf, _BIG_FLOAT_DIGIT multiplier)
{
/*
* Multiply a base-10**4 significand by multiplier. Extend length as
* necessary to accommodate carries.
*/
int j;
unsigned long carry;
long p;
carry = 0;
for (j = 0; j < pbf->blength; j++) {
p = _prodc_b10000((_BIG_FLOAT_DIGIT) pbf->bsignificand[j], multiplier, carry);
pbf->bsignificand[j] = (_BIG_FLOAT_DIGIT) (p & 0xffff);
carry = p >> 16;
}
while (carry != 0) {
p = _carry_out_b10000(carry);
pbf->bsignificand[j++] = (_BIG_FLOAT_DIGIT) (p & 0xffff);
carry = p >> 16;
}
pbf->blength = j;
}
void
_multiply_base_two(_big_float *pbf, _BIG_FLOAT_DIGIT multiplier,
long unsigned carry)
{
/*
* Multiply a base-2**16 significand by multiplier. Extend length as
* necessary to accommodate carries.
*/
short unsigned length = pbf->blength;
long unsigned p;
int j;
for (j = 0; j < length; j++) {
p = _prodc_b65536(pbf->bsignificand[j], multiplier, carry);
pbf->bsignificand[j] = (_BIG_FLOAT_DIGIT) (p & 0xffff);
carry = p >> 16;
}
if (carry != 0) {
pbf->bsignificand[j++] = (_BIG_FLOAT_DIGIT) (_carry_out_b65536(carry) & 0xffff);
}
pbf->blength = j;
}
void
_multiply_base_ten_by_two(_big_float *pbf, short unsigned multiplier)
{
/*
* Multiply a base-10**4 significand by 2**multiplier. Extend length
* as necessary to accommodate carries.
*/
short unsigned length = pbf->blength;
int j;
long unsigned carry, p;
carry = 0;
for (j = 0; j < length; j++) {
p = _lshift_b10000(pbf->bsignificand[j], multiplier, carry);
pbf->bsignificand[j] = (_BIG_FLOAT_DIGIT) (p & 0xffff);
carry = p >> 16;
}
while (carry != 0) {
p = _carry_out_b10000(carry);
pbf->bsignificand[j++] = (_BIG_FLOAT_DIGIT) (p & 0xffff);
carry = p >> 16;
}
pbf->blength = j;
}
void
_unpacked_to_big_float(unpacked *pu, _big_float *pb, int *pe)
{
/*
* Converts pu into a bigfloat *pb of minimal length; exponent *pe
* such that pu = *pb * 2 ** *pe
*/
int iz, it;
for (iz = (UNPACKED_SIZE - 2); pu->significand[iz] == 0; iz--); /* Find lsw. */
for (it = 0; it <= iz; it++) {
pb->bsignificand[2 * (iz - it)] = pu->significand[it] & 0xffff;
pb->bsignificand[2 * (iz - it) + 1] = pu->significand[it] >> 16;
}
pb->blength = 2 * iz + 2;
if (pb->bsignificand[0] == 0) {
for (it = 1; it < pb->blength; it++)
pb->bsignificand[it - 1] = pb->bsignificand[it];
pb->blength--;
}
*pe = pu->exponent + 1 - 16 * pb->blength;
pb->bexponent = 0;
#ifdef DEBUG
printf(" unpacked to big float 2**%d * ", *pe);
_display_big_float(pb, 2);
#endif
}
void
_mul_65536short(_big_float *pbf, unsigned long carry)
{
/* *pbf *= 65536 ; += carry ; */
long unsigned p;
int j;
for (j = 0; j < pbf->blength; j++) {
p = _prod_65536_b10000(pbf->bsignificand[j], carry);
pbf->bsignificand[j] = (_BIG_FLOAT_DIGIT) (p & 0xffff);
carry = p >> 16;
}
while (carry != 0) {
p = _carry_out_b10000(carry);
pbf->bsignificand[j++] = (_BIG_FLOAT_DIGIT) (p & 0xffff);
carry = p >> 16;
}
pbf->blength = j;
}
void
_big_binary_to_big_decimal(_big_float *pb, _big_float *pd)
{
/* Convert _big_float from binary form to decimal form. */
int i;
pd->bsignificand[0] = pb->bsignificand[pb->blength - 1] % 10000;
if (pd->bsignificand[0] == pb->bsignificand[pb->blength - 1]) {
pd->blength = 1;
} else {
pd->blength = 2;
pd->bsignificand[1] = pb->bsignificand[pb->blength - 1] / 10000;
}
for (i = pb->blength - 2; i >= 0; i--) { /* Multiply by 2**16 and
* add next significand. */
_mul_65536short(pd, (unsigned long) pb->bsignificand[i]);
}
for (i = 0; i <= (pb->bexponent - 16); i += 16) { /* Multiply by 2**16 for
* each trailing zero. */
_mul_65536short(pd, (unsigned long) 0);
}
if (pb->bexponent > i)
_left_shift_base_ten(pd, (short unsigned) (pb->bexponent - i));
pd->bexponent = 0;
#ifdef DEBUG
printf(" _big_binary_to_big_decimal ");
_display_big_float(pd, 10);
#endif
}