Check in the pristine copy of ICU 4.6...

icu46/source/i18n/choicfmt.cpp

+/*
+*******************************************************************************
+* Copyright (C) 1997-2009, International Business Machines Corporation and    *
+* others. All Rights Reserved.                                                *
+*******************************************************************************
+*
+* File CHOICFMT.CPP
+*
+* Modification History:
+*
+*   Date        Name        Description
+*   02/19/97    aliu        Converted from java.
+*   03/20/97    helena      Finished first cut of implementation and got rid 
+*                           of nextDouble/previousDouble and replaced with
+*                           boolean array.
+*   4/10/97     aliu        Clean up.  Modified to work on AIX.
+*   06/04/97    helena      Fixed applyPattern(), toPattern() and not to include 
+*                           wchar.h.
+*   07/09/97    helena      Made ParsePosition into a class.
+*   08/06/97    nos         removed overloaded constructor, fixed 'format(array)'
+*   07/22/98    stephen     JDK 1.2 Sync - removed UBool array (doubleFlags)
+*   02/22/99    stephen     Removed character literals for EBCDIC safety
+********************************************************************************
+*/
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include "unicode/choicfmt.h"
+#include "unicode/numfmt.h"
+#include "unicode/locid.h"
+#include "cpputils.h"
+#include "cstring.h"
+#include "putilimp.h"
+#include <stdio.h>
+#include <float.h>
+
+// *****************************************************************************
+// class ChoiceFormat
+// *****************************************************************************
+
+U_NAMESPACE_BEGIN
+
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ChoiceFormat)
+
+// Special characters used by ChoiceFormat.  There are two characters
+// used interchangeably to indicate <=.  Either is parsed, but only
+// LESS_EQUAL is generated by toPattern().
+#define SINGLE_QUOTE ((UChar)0x0027)   /*'*/
+#define LESS_THAN    ((UChar)0x003C)   /*<*/
+#define LESS_EQUAL   ((UChar)0x0023)   /*#*/
+#define LESS_EQUAL2  ((UChar)0x2264)
+#define VERTICAL_BAR ((UChar)0x007C)   /*|*/
+#define MINUS        ((UChar)0x002D)   /*-*/
+
+#ifdef INFINITY
+#undef INFINITY
+#endif
+#define INFINITY     ((UChar)0x221E)
+
+static const UChar gPositiveInfinity[] = {INFINITY, 0};
+static const UChar gNegativeInfinity[] = {MINUS, INFINITY, 0};
+#define POSITIVE_INF_STRLEN 1
+#define NEGATIVE_INF_STRLEN 2
+
+// -------------------------------------
+// Creates a ChoiceFormat instance based on the pattern.
+
+ChoiceFormat::ChoiceFormat(const UnicodeString& newPattern,
+                           UErrorCode& status)
+: fChoiceLimits(0),
+  fClosures(0),
+  fChoiceFormats(0),
+  fCount(0)
+{
+    applyPattern(newPattern, status);
+}
+
+// -------------------------------------
+// Creates a ChoiceFormat instance with the limit array and 
+// format strings for each limit.
+
+ChoiceFormat::ChoiceFormat(const double* limits, 
+                           const UnicodeString* formats, 
+                           int32_t cnt )
+: fChoiceLimits(0),
+  fClosures(0),
+  fChoiceFormats(0),
+  fCount(0)
+{
+    setChoices(limits, formats, cnt );
+}
+
+// -------------------------------------
+
+ChoiceFormat::ChoiceFormat(const double* limits, 
+                           const UBool* closures,
+                           const UnicodeString* formats, 
+                           int32_t cnt )
+: fChoiceLimits(0),
+  fClosures(0),
+  fChoiceFormats(0),
+  fCount(0)
+{
+    setChoices(limits, closures, formats, cnt );
+}
+
+// -------------------------------------
+// copy constructor
+
+ChoiceFormat::ChoiceFormat(const    ChoiceFormat&   that) 
+: NumberFormat(that),
+  fChoiceLimits(0),
+  fClosures(0),
+  fChoiceFormats(0)
+{
+    *this = that;
+}
+
+// -------------------------------------
+// Private constructor that creates a 
+// ChoiceFormat instance based on the 
+// pattern and populates UParseError
+
+ChoiceFormat::ChoiceFormat(const UnicodeString& newPattern,
+                           UParseError& parseError,
+                           UErrorCode& status)
+: fChoiceLimits(0),
+  fClosures(0),
+  fChoiceFormats(0),
+  fCount(0)
+{
+    applyPattern(newPattern,parseError, status);
+}
+// -------------------------------------
+
+UBool
+ChoiceFormat::operator==(const Format& that) const
+{
+    if (this == &that) return TRUE;
+    if (!NumberFormat::operator==(that)) return FALSE;
+    ChoiceFormat& thatAlias = (ChoiceFormat&)that;
+    if (fCount != thatAlias.fCount) return FALSE;
+    // Checks the limits, the corresponding format string and LE or LT flags.
+    // LE means less than and equal to, LT means less than.
+    for (int32_t i = 0; i < fCount; i++) {
+        if ((fChoiceLimits[i] != thatAlias.fChoiceLimits[i]) ||
+            (fClosures[i] != thatAlias.fClosures[i]) ||
+            (fChoiceFormats[i] != thatAlias.fChoiceFormats[i]))
+            return FALSE;
+    }
+    return TRUE;
+}
+
+// -------------------------------------
+// copy constructor
+
+const ChoiceFormat&
+ChoiceFormat::operator=(const   ChoiceFormat& that)
+{
+    if (this != &that) {
+        NumberFormat::operator=(that);
+        fCount = that.fCount;
+        uprv_free(fChoiceLimits);
+        fChoiceLimits = NULL;
+        uprv_free(fClosures);
+        fClosures = NULL;
+        delete [] fChoiceFormats;
+        fChoiceFormats = NULL;
+
+        fChoiceLimits = (double*) uprv_malloc( sizeof(double) * fCount);
+        fClosures = (UBool*) uprv_malloc( sizeof(UBool) * fCount);
+        fChoiceFormats = new UnicodeString[fCount];
+        
+        // check for memory allocation error
+        if (!fChoiceLimits || !fClosures || !fChoiceFormats) {
+            if (fChoiceLimits) {
+                uprv_free(fChoiceLimits);
+                fChoiceLimits = NULL;
+            }
+            if (fClosures) {
+                uprv_free(fClosures);
+                fClosures = NULL;
+            }
+            if (fChoiceFormats) {
+                delete[] fChoiceFormats;
+                fChoiceFormats = NULL;
+            }
+        } else {
+            uprv_arrayCopy(that.fChoiceLimits, fChoiceLimits, fCount);
+            uprv_arrayCopy(that.fClosures, fClosures, fCount);
+            uprv_arrayCopy(that.fChoiceFormats, fChoiceFormats, fCount);
+        }
+    }
+    return *this;
+}
+
+// -------------------------------------
+
+ChoiceFormat::~ChoiceFormat()
+{
+    uprv_free(fChoiceLimits);
+    fChoiceLimits = NULL;
+    uprv_free(fClosures);
+    fClosures = NULL;
+    delete [] fChoiceFormats;
+    fChoiceFormats = NULL;
+    fCount = 0;
+}
+
+/**
+ * Convert a string to a double value
+ */
+double
+ChoiceFormat::stod(const UnicodeString& string)
+{
+    char source[256];
+    char* end;
+
+    string.extract(0, string.length(), source, (int32_t)sizeof(source), US_INV);    /* invariant codepage */
+    return uprv_strtod(source,&end);
+}
+
+// -------------------------------------
+
+/**
+ * Convert a double value to a string without the overhead of ICU.
+ */
+UnicodeString&
+ChoiceFormat::dtos(double value,
+                   UnicodeString& string)
+{
+    /* Buffer to contain the digits and any extra formatting stuff. */
+    char temp[DBL_DIG + 16];
+    char *itrPtr = temp;
+    char *expPtr;
+
+    sprintf(temp, "%.*g", DBL_DIG, value);
+
+    /* Find and convert the decimal point.
+       Using setlocale on some machines will cause sprintf to use a comma for certain locales.
+    */
+    while (*itrPtr && (*itrPtr == '-' || isdigit(*itrPtr))) {
+        itrPtr++;
+    }
+    if (*itrPtr != 0 && *itrPtr != 'e') {
+        /* We reached something that looks like a decimal point.
+        In case someone used setlocale(), which changes the decimal point. */
+        *itrPtr = '.';
+        itrPtr++;
+    }
+    /* Search for the exponent */
+    while (*itrPtr && *itrPtr != 'e') {
+        itrPtr++;
+    }
+    if (*itrPtr == 'e') {
+        itrPtr++;
+        /* Verify the exponent sign */
+        if (*itrPtr == '+' || *itrPtr == '-') {
+            itrPtr++;
+        }
+        /* Remove leading zeros. You will see this on Windows machines. */
+        expPtr = itrPtr;
+        while (*itrPtr == '0') {
+            itrPtr++;
+        }
+        if (*itrPtr && expPtr != itrPtr) {
+            /* Shift the exponent without zeros. */
+            while (*itrPtr) {
+                *(expPtr++)  = *(itrPtr++);
+            }
+            // NULL terminate
+            *expPtr = 0;
+        }
+    }
+
+    string = UnicodeString(temp, -1, US_INV);    /* invariant codepage */
+    return string;
+}
+
+// -------------------------------------
+// calls the overloaded applyPattern method.
+
+void
+ChoiceFormat::applyPattern(const UnicodeString& pattern,
+                           UErrorCode& status)
+{
+    UParseError parseError;
+    applyPattern(pattern, parseError, status);
+}
+
+// -------------------------------------
+// Applies the pattern to this ChoiceFormat instance.
+
+void
+ChoiceFormat::applyPattern(const UnicodeString& pattern,
+                           UParseError& parseError,
+                           UErrorCode& status)
+{
+    if (U_FAILURE(status)) 
+    {
+        return;
+    }
+
+    // Clear error struct
+    parseError.offset = -1;
+    parseError.preContext[0] = parseError.postContext[0] = (UChar)0;
+
+    // Perform 2 passes.  The first computes the number of limits in
+    // this pattern (fCount), which is 1 more than the number of
+    // literal VERTICAL_BAR characters.
+    int32_t count = 1;
+    int32_t i;
+    for (i=0; i<pattern.length(); ++i) {
+        UChar c = pattern[i];
+        if (c == SINGLE_QUOTE) {
+            // Skip over the entire quote, including embedded
+            // contiguous pairs of SINGLE_QUOTE.
+            for (;;) {
+                do {
+                    ++i;
+                } while (i<pattern.length() &&
+                         pattern[i] != SINGLE_QUOTE);
+                if ((i+1)<pattern.length() &&
+                    pattern[i+1] == SINGLE_QUOTE) {
+                    // SINGLE_QUOTE pair; skip over it
+                    ++i;
+                } else {
+                    break;
+                }
+            }
+        } else if (c == VERTICAL_BAR) {
+            ++count;
+        }
+    }
+
+    // Allocate the required storage.
+    double *newLimits = (double*) uprv_malloc( sizeof(double) * count);
+    /* test for NULL */
+    if (newLimits == 0) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
+    UBool *newClosures = (UBool*) uprv_malloc( sizeof(UBool) * count);
+    /* test for NULL */
+    if (newClosures == 0) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        uprv_free(newLimits);
+        return;
+    }
+    UnicodeString *newFormats = new UnicodeString[count];
+    /* test for NULL */
+    if (newFormats == 0) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        uprv_free(newLimits);
+        uprv_free(newClosures);
+        return;
+    }
+
+    // Perform the second pass
+    int32_t k = 0; // index into newXxx[] arrays
+    UnicodeString buf; // scratch buffer
+    UBool inQuote = FALSE;
+    UBool inNumber = TRUE; // TRUE before < or #, FALSE after
+
+    for (i=0; i<pattern.length(); ++i) {
+        UChar c = pattern[i];
+        if (c == SINGLE_QUOTE) {
+            // Check for SINGLE_QUOTE pair indicating a literal quote
+            if ((i+1) < pattern.length() &&
+                pattern[i+1] == SINGLE_QUOTE) {
+                buf += SINGLE_QUOTE;
+                ++i;
+            } else {
+                inQuote = !inQuote;
+            }
+        } else if (inQuote) {
+            buf += c;
+        } else if (c == LESS_THAN || c == LESS_EQUAL || c == LESS_EQUAL2) {
+            if (!inNumber || buf.length() == 0) {
+                goto error;
+            }
+            inNumber = FALSE;
+
+            double limit;
+            buf.trim();
+            if (!buf.compare(gPositiveInfinity, POSITIVE_INF_STRLEN)) {
+                limit = uprv_getInfinity();
+            } else if (!buf.compare(gNegativeInfinity, NEGATIVE_INF_STRLEN)) {
+                limit = -uprv_getInfinity();
+            } else {
+                limit = stod(buf);
+            }
+
+            if (k == count) {
+                // This shouldn't happen.  If it does, it means that
+                // the count determined in the first pass did not
+                // match the number of elements found in the second
+                // pass.
+                goto error;
+            }
+            newLimits[k] = limit;
+            newClosures[k] = (c == LESS_THAN);
+
+            if (k > 0 && limit <= newLimits[k-1]) {
+                // Each limit must be strictly > than the previous
+                // limit.  One exception: Two subsequent limits may be
+                // == if the first closure is FALSE and the second
+                // closure is TRUE.  This places the limit value in
+                // the second interval.
+                if (!(limit == newLimits[k-1] &&
+                      !newClosures[k-1] &&
+                      newClosures[k])) {
+                    goto error;
+                }
+            }
+
+            buf.truncate(0);
+        } else if (c == VERTICAL_BAR) {
+            if (inNumber) {
+                goto error;
+            }
+            inNumber = TRUE;
+
+            newFormats[k] = buf;
+            ++k;
+            buf.truncate(0);
+        } else {
+            buf += c;
+        }        
+    }
+
+    if (k != (count-1) || inNumber || inQuote) {
+        goto error;
+    }
+    newFormats[k] = buf;
+
+    // Don't modify this object until the parse succeeds
+    uprv_free(fChoiceLimits);
+    uprv_free(fClosures);
+    delete[] fChoiceFormats;
+    fCount = count;
+    fChoiceLimits  = newLimits;
+    fClosures      = newClosures;
+    fChoiceFormats = newFormats;
+    return;
+
+error:
+    status = U_ILLEGAL_ARGUMENT_ERROR;
+    syntaxError(pattern,i,parseError);
+    uprv_free(newLimits);
+    uprv_free(newClosures);
+    delete[] newFormats;
+    return;
+
+}
+// -------------------------------------
+// Reconstruct the original input pattern.
+
+UnicodeString&
+ChoiceFormat::toPattern(UnicodeString& result) const
+{
+    result.remove();
+    for (int32_t i = 0; i < fCount; ++i) {
+        if (i != 0) {
+            result += VERTICAL_BAR;
+        }
+        UnicodeString buf;
+        if (uprv_isPositiveInfinity(fChoiceLimits[i])) {
+            result += INFINITY;
+        } else if (uprv_isNegativeInfinity(fChoiceLimits[i])) {
+            result += MINUS;
+            result += INFINITY;
+        } else {
+            result += dtos(fChoiceLimits[i], buf);
+        }
+        if (fClosures[i]) {
+            result += LESS_THAN;
+        } else {
+            result += LESS_EQUAL;
+        }
+        // Append fChoiceFormats[i], using quotes if there are special
+        // characters.  Single quotes themselves must be escaped in
+        // either case.
+        const UnicodeString& text = fChoiceFormats[i];
+        UBool needQuote = text.indexOf(LESS_THAN) >= 0
+            || text.indexOf(LESS_EQUAL) >= 0
+            || text.indexOf(LESS_EQUAL2) >= 0
+            || text.indexOf(VERTICAL_BAR) >= 0;
+        if (needQuote) {
+            result += SINGLE_QUOTE;
+        }
+        if (text.indexOf(SINGLE_QUOTE) < 0) {
+            result += text;
+        }
+        else {
+            for (int32_t j = 0; j < text.length(); ++j) {
+                UChar c = text[j];
+                result += c;
+                if (c == SINGLE_QUOTE) {
+                    result += c;
+                }
+            }
+        }
+        if (needQuote) {
+            result += SINGLE_QUOTE;
+        }
+    }
+
+    return result;
+}
+
+// -------------------------------------
+// Sets the limit and format arrays. 
+void
+ChoiceFormat::setChoices(  const double* limits, 
+                           const UnicodeString* formats, 
+                           int32_t cnt )
+{
+    setChoices(limits, 0, formats, cnt);
+}
+
+// -------------------------------------
+// Sets the limit and format arrays. 
+void
+ChoiceFormat::setChoices(  const double* limits, 
+                           const UBool* closures,
+                           const UnicodeString* formats, 
+                           int32_t cnt )
+{
+    if(limits == 0 || formats == 0)
+        return;
+
+    if (fChoiceLimits) {
+        uprv_free(fChoiceLimits);
+    }
+    if (fClosures) {
+        uprv_free(fClosures);
+    }
+    if (fChoiceFormats) {
+        delete [] fChoiceFormats;
+    }
+
+    // Note that the old arrays are deleted and this owns
+    // the created array.
+    fCount = cnt;
+    fChoiceLimits = (double*) uprv_malloc( sizeof(double) * fCount);
+    fClosures = (UBool*) uprv_malloc( sizeof(UBool) * fCount);
+    fChoiceFormats = new UnicodeString[fCount];
+
+    //check for memory allocation error
+    if (!fChoiceLimits || !fClosures || !fChoiceFormats) {
+        if (fChoiceLimits) {
+            uprv_free(fChoiceLimits);
+            fChoiceLimits = NULL;
+        }
+        if (fClosures) {
+            uprv_free(fClosures);
+            fClosures = NULL;
+        }
+        if (fChoiceFormats) {
+            delete[] fChoiceFormats;
+            fChoiceFormats = NULL;
+        }
+        return;
+    }
+    
+    uprv_arrayCopy(limits, fChoiceLimits, fCount);
+    uprv_arrayCopy(formats, fChoiceFormats, fCount);
+
+    if (closures != 0) {
+        uprv_arrayCopy(closures, fClosures, fCount);
+    } else {
+        int32_t i;
+        for (i=0; i<fCount; ++i) {
+            fClosures[i] = FALSE;
+        }
+    }
+}
+
+// -------------------------------------
+// Gets the limit array.
+
+const double*
+ChoiceFormat::getLimits(int32_t& cnt) const 
+{
+    cnt = fCount;
+    return fChoiceLimits;
+}
+
+// -------------------------------------
+// Gets the closures array.
+
+const UBool*
+ChoiceFormat::getClosures(int32_t& cnt) const 
+{
+    cnt = fCount;
+    return fClosures;
+}
+
+// -------------------------------------
+// Gets the format array.
+
+const UnicodeString*
+ChoiceFormat::getFormats(int32_t& cnt) const
+{
+    cnt = fCount;
+    return fChoiceFormats;
+}
+
+// -------------------------------------
+// Formats an int64 number, it's actually formatted as
+// a double.  The returned format string may differ
+// from the input number because of this.
+
+UnicodeString&
+ChoiceFormat::format(int64_t number, 
+                     UnicodeString& appendTo, 
+                     FieldPosition& status) const
+{
+    return format((double) number, appendTo, status);
+}
+
+// -------------------------------------
+// Formats a long number, it's actually formatted as
+// a double.  The returned format string may differ
+// from the input number because of this.
+
+UnicodeString&
+ChoiceFormat::format(int32_t number, 
+                     UnicodeString& appendTo, 
+                     FieldPosition& status) const
+{
+    return format((double) number, appendTo, status);
+}
+
+// -------------------------------------
+// Formats a double number.
+
+UnicodeString&
+ChoiceFormat::format(double number, 
+                     UnicodeString& appendTo, 
+                     FieldPosition& /*pos*/) const
+{
+    // find the number
+    int32_t i;
+    for (i = 0; i < fCount; ++i) {
+        if (fClosures[i]) {
+            if (!(number > fChoiceLimits[i])) {
+                // same as number <= fChoiceLimits, except catches NaN
+                break;
+            }
+        } else if (!(number >= fChoiceLimits[i])) {
+            // same as number < fChoiceLimits, except catches NaN
+            break;
+        }
+    }
+    --i;
+    if (i < 0) {
+        i = 0;
+    }
+    // return either a formatted number, or a string
+    appendTo += fChoiceFormats[i];
+    return appendTo;
+}
+
+// -------------------------------------
+// Formats an array of objects. Checks if the data type of the objects
+// to get the right value for formatting.  
+
+UnicodeString&
+ChoiceFormat::format(const Formattable* objs,
+                     int32_t cnt,
+                     UnicodeString& appendTo,
+                     FieldPosition& pos,
+                     UErrorCode& status) const
+{
+    if(cnt < 0) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return appendTo;
+    }
+
+    UnicodeString buffer;
+    for (int32_t i = 0; i < cnt; i++) {
+        double objDouble = objs[i].getDouble(status);
+        if (U_SUCCESS(status)) {
+            buffer.remove();
+            appendTo += format(objDouble, buffer, pos);
+        }
+    }
+
+    return appendTo;
+}
+
+// -------------------------------------
+// Formats an array of objects. Checks if the data type of the objects
+// to get the right value for formatting.  
+
+UnicodeString&
+ChoiceFormat::format(const Formattable& obj, 
+                     UnicodeString& appendTo, 
+                     FieldPosition& pos,
+                     UErrorCode& status) const
+{
+    return NumberFormat::format(obj, appendTo, pos, status);
+}
+// -------------------------------------
+
+void
+ChoiceFormat::parse(const UnicodeString& text, 
+                    Formattable& result,
+                    ParsePosition& status) const
+{
+    // find the best number (defined as the one with the longest parse)
+    int32_t start = status.getIndex();
+    int32_t furthest = start;
+    double bestNumber = uprv_getNaN();
+    double tempNumber = 0.0;
+    for (int i = 0; i < fCount; ++i) {
+        int32_t len = fChoiceFormats[i].length();
+        if (text.compare(start, len, fChoiceFormats[i]) == 0) {
+            status.setIndex(start + len);
+            tempNumber = fChoiceLimits[i];
+            if (status.getIndex() > furthest) {
+                furthest = status.getIndex();
+                bestNumber = tempNumber;
+                if (furthest == text.length()) 
+                    break;
+            }
+        }
+    }
+    status.setIndex(furthest);
+    if (status.getIndex() == start) {
+        status.setErrorIndex(furthest);
+    }
+    result.setDouble(bestNumber);
+}
+
+// -------------------------------------
+// Parses the text and return the Formattable object.  
+
+void
+ChoiceFormat::parse(const UnicodeString& text, 
+                    Formattable& result,
+                    UErrorCode& status) const
+{
+    NumberFormat::parse(text, result, status);
+}
+
+// -------------------------------------
+
+Format*
+ChoiceFormat::clone() const
+{
+    ChoiceFormat *aCopy = new ChoiceFormat(*this);
+    return aCopy;
+}
+
+U_NAMESPACE_END
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
+
+//eof