/*
*******************************************************************************
* 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