scuffed-code/icu4c/source/i18n/digitlst.cpp

/*
**********************************************************************
*   Copyright (C) 1997-1999, International Business Machines
*   Corporation and others.  All Rights Reserved.
**********************************************************************
*
* File DIGITLST.CPP
*
* Modification History:
*
*   Date        Name        Description
*   03/21/97    clhuang     Converted from java.
*   03/21/97    clhuang     Implemented with new APIs.
*   03/27/97    helena      Updated to pass the simple test after code review.
*   03/31/97    aliu        Moved isLONG_MIN to here, and fixed it.
*   04/15/97    aliu        Changed MAX_COUNT to DBL_DIG.  Changed Digit to char.
*                           Reworked representation by replacing fDecimalAt with
*                           fExponent.
*   04/16/97    aliu        Rewrote set() and getDouble() to use sprintf/atof
*                           to do digit conversion.
*   09/09/97    aliu        Modified for exponential notation support.
*    08/02/98    stephen        Added nearest/even rounding
*                            Fixed bug in fitsIntoLong
********************************************************************************
*/

#include "digitlst.h"
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <stdio.h>

// *****************************************************************************
// class DigitList
// This class handles the transcoding between numeric values and strings of
//  characters.  Only handles as non-negative numbers.  
// *****************************************************************************

const char DigitList::kZero = '0';

char DigitList::LONG_MIN_REP[LONG_DIGITS];
int32_t  DigitList::LONG_MIN_REP_LENGTH = 0;

// -------------------------------------
// default constructor

DigitList::DigitList()
{
    clear();
}

// -------------------------------------

DigitList::~DigitList()
{
}

// -------------------------------------
// copy constructor

DigitList::DigitList(const DigitList &other)
{
    *this = other;
}

// -------------------------------------
// assignment operator

DigitList&
DigitList::operator=(const DigitList& other)
{
    if (this != &other)
    {
        fDecimalAt = other.fDecimalAt;
        fCount = other.fCount;
        strncpy(fDigits, other.fDigits, MAX_DIGITS);
    }
    return *this;
}

// -------------------------------------

UBool
DigitList::operator==(const DigitList& that) const
{
    return ((this == &that) ||
            (fDecimalAt == that.fDecimalAt &&
             fCount == that.fCount &&
             0 == strncmp(fDigits, that.fDigits, fCount)));
}

// -------------------------------------
// Resets the digit list; sets all the digits to zero.

void
DigitList::clear()
{
    fDecimalAt = 0;
    fCount = 0;
    for (int32_t i=0; i<MAX_DIGITS; ++i) fDigits[i] = kZero;
}

// -------------------------------------
// Appends the digit to the digit list if it's not out of scope.
// Ignores the digit, otherwise.

void
DigitList::append(char digit)
{
    // Ignore digits which exceed the precision we can represent
    if (fCount < MAX_DIGITS) fDigits[fCount++] = digit;
}

// -------------------------------------

/**
 * Currently, getDouble() depends on atof() to do its conversion.
 */
double
DigitList::getDouble() const
{
    if (fCount == 0) return 0.0;

    // For the string "." + fDigits + "e" + fDecimalAt.
    char buffer[MAX_DIGITS+32];
    *buffer = '.';
    strncpy(buffer+1, fDigits, fCount);
    sprintf(buffer+fCount+1, "e%d", fDecimalAt);
    return atof(buffer);
}

// -------------------------------------

int32_t DigitList::getLong() const
{
    // This is 100% accurate in c++ because if we are representing
    // an integral value, we suffer nothing in the conversion to
    // double.  If we are to support 64-bit longs later, this method
    // must be rewritten. [LIU]
    return (int32_t)getDouble();
}

/**
 * Return true if the number represented by this object can fit into
 * a long.
 */
UBool
DigitList::fitsIntoLong(UBool isPositive, UBool ignoreNegativeZero)
{
    // Figure out if the result will fit in a long.  We have to
    // first look for nonzero digits after the decimal point;
    // then check the size.  If the digit count is 18 or less, then
    // the value can definitely be represented as a long.  If it is 19
    // then it may be too large.

    // Trim trailing zeros.  This does not change the represented value.
    while (fCount > 0 && fDigits[fCount - 1] == '0') --fCount;

    if (fCount == 0) {
        // Positive zero fits into a long, but negative zero can only
        // be represented as a double. - bug 4162852
        return isPositive || ignoreNegativeZero;
    }
    
    initializeLONG_MIN_REP();

    // If the digit list represents a double or this number is too
    // big for a long.
    if (fDecimalAt < fCount || fDecimalAt > LONG_MIN_REP_LENGTH) return FALSE;

    // If number is small enough to fit in a long
    if (fDecimalAt < LONG_MIN_REP_LENGTH) return TRUE;

    // At this point we have fDecimalAt == fCount, and fCount == LONG_MIN_REP_LENGTH.
    // The number will overflow if it is larger than LONG_MAX
    // or smaller than LONG_MIN.
    for (int32_t i=0; i<fCount; ++i)
    {
        char dig = fDigits[i], max = LONG_MIN_REP[i];
        if (dig > max) return FALSE;
        if (dig < max) return TRUE;
    }
    
    // At this point the first count digits match.  If fDecimalAt is less
    // than count, then the remaining digits are zero, and we return true.
    if (fCount < fDecimalAt) return TRUE;

    // Now we have a representation of Long.MIN_VALUE, without the leading
    // negative sign.  If this represents a positive value, then it does
    // not fit; otherwise it fits.
    return !isPositive;
}

// -------------------------------------

/**
 * @param maximumDigits The maximum digits to be generated.  If zero,
 * there is no maximum -- generate all digits.
 */
void
DigitList::set(int32_t source, int32_t maximumDigits)
{
    // for now, simple implementation; later, do proper IEEE stuff
    //String stringDigits = Long.toString(source);
    char string [10 + 1];    // maximum digits for a 32-bit signed number is 10 + 1 for sign
    sprintf(string, "%d", source);

    char *stringDigits = string;
    // This method does not expect a negative number. However,
    // "source" can be a Long.MIN_VALUE (-9223372036854775808),
    // if the number being formatted is a Long.MIN_VALUE.  In that
    // case, it will be formatted as -Long.MIN_VALUE, a number
    // which is outside the legal range of a long, but which can
    // be represented by DigitList.
    if (stringDigits[0] == '-') 
        stringDigits++;

    fCount = fDecimalAt = strlen(stringDigits);
    
    // Don't copy trailing zeros
    while (fCount > 1 && stringDigits[fCount - 1] == '0') 
        --fCount;
    
    //for (int32_t i = 0; i < fCount; ++i)
    //    fDigits[i] = (char) stringDigits[i];
    strncpy(fDigits, stringDigits, fCount);

    if(maximumDigits > 0) 
        round(maximumDigits);

#if(0)
    // {sfb} old implementation, keep around for now

    // Handle the case in which source == LONG_MIN
    set((source >= 0 ? (double)source : -((double)source)),
        maximumDigits > 0 ? maximumDigits : MAX_DIGITS,
        maximumDigits == 0);
#endif
}

/**
 * Set the digit list to a representation of the given double value.
 * This method supports both fixed-point and exponential notation.
 * @param source Value to be converted; must not be Inf, -Inf, Nan,
 * or a value <= 0.
 * @param maximumDigits The most fractional or total digits which should
 * be converted.  If total digits, and the value is zero, then
 * there is no maximum -- generate all digits.
 * @param fixedPoint If true, then maximumDigits is the maximum
 * fractional digits to be converted.  If false, total digits.
 */
void
DigitList::set(double source, int32_t maximumDigits, UBool fixedPoint)
{
    if(source == 0) source = 0;
    // Generate a representation of the form DDDDD, DDDDD.DDDDD, or
    // DDDDDE+/-DDDDD.
    //String rep = Double.toString(source);
    char rep[MAX_DIGITS + 7]; // Extra space for '.', e+NNN, and '\0' (actually +7 is enough)
    sprintf(rep, "%1.*e", MAX_DIGITS - 1, source);

    fDecimalAt             = -1;
    fCount                 = 0;
    int32_t exponent     = 0;
    // Number of zeros between decimal point and first non-zero digit after
    // decimal point, for numbers < 1.
    int32_t leadingZerosAfterDecimal = 0;
    UBool nonZeroDigitSeen = FALSE;
    for (int32_t i=0; i < MAX_DIGITS + 7; ++i) {
        char c = rep[i];
        if (c == '.') {
            fDecimalAt = fCount;
        }
        else if (c == 'e' || c == 'E') {
            // Parse an exponent of the form /[eE][+-]?[0-9]*/
            //exponent = Integer.valueOf(rep.substring(i+1)).intValue();
            i += 1;                 // adjust for 'e'
            UBool negExp = rep[i] == '-';
            if (negExp || rep[i] == '+') {
                ++i;
            }
            while ((c = rep[i++]) >= '0' && c <= '9') {
                exponent = 10*exponent + c - '0';
            }
            if (negExp) {
                exponent = -exponent;
            }
            break;
        }
        else if (fCount < MAX_DIGITS) {
            if ( ! nonZeroDigitSeen) {
                nonZeroDigitSeen = (c != '0');
                if ( ! nonZeroDigitSeen && fDecimalAt != -1) 
                    ++leadingZerosAfterDecimal;
            }
    
            if (nonZeroDigitSeen) 
                fDigits[fCount++] = (char)c;
        }
    }
    if (fDecimalAt == -1) 
        fDecimalAt = fCount;
    fDecimalAt += exponent - leadingZerosAfterDecimal;

    if (fixedPoint)
    {
        // The negative of the exponent represents the number of leading
        // zeros between the decimal and the first non-zero digit, for
        // a value < 0.1 (e.g., for 0.00123, -decimalAt == 2).  If this
        // is more than the maximum fraction digits, then we have an underflow
        // for the printed representation.
        if (-fDecimalAt > maximumDigits) {
            // Handle an underflow to zero when we round something like
            // 0.0009 to 2 fractional digits.
            fCount = 0;
            return;
        } else if (-fDecimalAt == maximumDigits) {
            // If we round 0.0009 to 3 fractional digits, then we have to
            // create a new one digit in the least significant location.
            if (shouldRoundUp(0)) {
                fCount = 1;
                ++fDecimalAt;
                fDigits[0] = (char)'1';
            } else {
                fCount = 0;
            }
            return;
        }
    }

    // Eliminate trailing zeros.
    while (fCount > 1 && fDigits[fCount - 1] == '0')
        --fCount;

    /*if (DEBUG)
    {
        System.out.print("Before rounding 0.");
        for (int i=0; i<fCount; ++i) System.out.print((char)digits[i]);
        System.out.println("x10^" + fDecimalAt);
    }*/

    // Eliminate digits beyond maximum digits to be displayed.
    // Round up if appropriate.  Do NOT round in the special
    // case where maximumDigits == 0 and fixedPoint is FALSE.
    if (fixedPoint || maximumDigits > 0) {
        round(fixedPoint ? (maximumDigits + fDecimalAt) : maximumDigits);
    }

    /*if (DEBUG)
    {
        System.out.print("After rounding 0.");
        for (int i=0; i<fCount; ++i) System.out.print((char)digits[i]);
        System.out.println("x10^" + fDecimalAt);
    }*/
}

// -------------------------------------

/**
 * Round the representation to the given number of digits.
 * @param maximumDigits The maximum number of digits to be shown.
 * Upon return, count will be less than or equal to maximumDigits.
 */
void 
DigitList::round(int32_t maximumDigits)
{
    // Eliminate digits beyond maximum digits to be displayed.
    // Round up if appropriate.
    if (maximumDigits >= 0 && maximumDigits < fCount)
    {
        if (shouldRoundUp(maximumDigits)) {
            // Rounding up involved incrementing digits from LSD to MSD.
            // In most cases this is simple, but in a worst case situation
            // (9999..99) we have to adjust the decimalAt value.
            for (;;)
            {
                --maximumDigits;
                if (maximumDigits < 0)
                {
                    // We have all 9's, so we increment to a single digit
                    // of one and adjust the exponent.
                    fDigits[0] = (char) '1';
                    ++fDecimalAt;
                    maximumDigits = 0; // Adjust the count
                    break;
                }

                ++fDigits[maximumDigits];
                if (fDigits[maximumDigits] <= '9') break;
                // fDigits[maximumDigits] = '0'; // Unnecessary since we'll truncate this
            }
            ++maximumDigits; // Increment for use as count
        }
        fCount = maximumDigits;

        // Eliminate trailing zeros.
        while (fCount > 1 && fDigits[fCount-1] == '0') {
            --fCount;
        }
    }
}

/**
 * Return true if truncating the representation to the given number
 * of digits will result in an increment to the last digit.  This
 * method implements half-even rounding, the default rounding mode.
 * [bnf]
 * @param maximumDigits the number of digits to keep, from 0 to
 * <code>count-1</code>.  If 0, then all digits are rounded away, and
 * this method returns true if a one should be generated (e.g., formatting
 * 0.09 with "#.#").
 * @return true if digit <code>maximumDigits-1</code> should be
 * incremented
 */
UBool DigitList::shouldRoundUp(int32_t maximumDigits) {
    // Implement IEEE half-even rounding
    if (fDigits[maximumDigits] > '5') {
        return TRUE;
    } else if (fDigits[maximumDigits] == '5' ) {
        for (int i=maximumDigits+1; i<fCount; ++i) {
            if (fDigits[i] != '0') {
                return TRUE;
            }
        }
        return maximumDigits > 0 && (fDigits[maximumDigits-1] % 2 != 0);
    }
    return FALSE;
}

// -------------------------------------

// In the Java implementation, we need a separate set(long) because 64-bit longs
// have too much precision to fit into a 64-bit double.  In C++, longs can just
// be passed to set(double) as long as they are 32 bits in size.  We currently
// don't implement 64-bit longs in C++, although the code below would work for
// that with slight modifications. [LIU]

//  void
//  DigitList::set(long source)
//  {
//      // handle the special case of zero using a standard exponent of 0.
//      // mathematically, the exponent can be any value.
//      if (source == 0)
//      {
//          fcount = 0;
//          fDecimalAt = 0;
//          return;
//      }

//      // we don't accept negative numbers, with the exception of long_min.
//      // long_min is treated specially by being represented as long_max+1,
//      // which is actually an impossible signed long value, so there is no
//      // ambiguity.  we do this for convenience, so digitlist can easily
//      // represent the digits of a long.
//      bool islongmin = (source == long_min);
//      if (islongmin)
//      {
//          source = -(source + 1); // that is, long_max
//          islongmin = true;
//      }
//      sprintf(fdigits, "%d", source);

//      // now we need to compute the exponent.  it's easy in this case; it's
//      // just the same as the count.  e.g., 0.123 * 10^3 = 123.
//      fcount = strlen(fdigits);
//      fDecimalAt = fcount;

//      // here's how we represent long_max + 1.  note that we always know
//      // that the last digit of long_max will not be 9, because long_max
//      // is of the form (2^n)-1.
//      if (islongmin) ++fdigits[fcount-1];

//      // finally, we trim off trailing zeros.  we don't alter fDecimalAt,
//      // so this has no effect on the represented value.  we know the first
//      // digit is non-zero (see code above), so we only have to check down
//      // to fdigits[1].
//      while (fcount > 1 && fdigits[fcount-1] == kzero) --fcount;
//  }

/**
 * Return true if this object represents the value zero.  Anything with
 * no digits, or all zero digits, is zero, regardless of fDecimalAt.
 */
UBool
DigitList::isZero() const
{
    for (int32_t i=0; i<fCount; ++i) if (fDigits[i] != kZero) return FALSE;
    return TRUE;
}

/**
 * We represent LONG_MIN internally as LONG_MAX + 1.  This is actually an impossible
 * value, for positive long integers, so we are safe in doing so.
 */
UBool
DigitList::isLONG_MIN() const
{
    initializeLONG_MIN_REP();

    if (fCount != LONG_MIN_REP_LENGTH) return FALSE;

    for (int32_t i = 0; i < LONG_MIN_REP_LENGTH; ++i)
    {
        if (fDigits[i] != LONG_MIN_REP[i+1]) return FALSE;
    }

    return TRUE;
}

// Initialize the LONG_MIN representation buffer.  Note that LONG_MIN
// is stored as LONG_MAX+1 (LONG_MIN without the negative sign).

void
DigitList::initializeLONG_MIN_REP()
{
    if (LONG_MIN_REP_LENGTH == 0)
    {
        char buf[LONG_DIGITS];
        sprintf(buf, "%d", INT32_MIN);
        LONG_MIN_REP_LENGTH = strlen(buf) - 1;
        // assert(LONG_MIN_REP_LENGTH == LONG_DIGITS);
        for (int32_t i=1; i<=LONG_MIN_REP_LENGTH; ++i) LONG_MIN_REP[i-1] = buf[i];
    }
}

//eof