MessageFormat and related classes (choice/plural/select) have been reimplemented, + with several improvements and some incompatible changes. + See the ICU 4.8 download page for details.
++ * Note: Both properties include ASCII as well as non-ASCII, non-Latin-1 code points, + * and both properties only include BMP code points (no supplementary ones). + * Pattern_Syntax includes some unassigned code points. + *
+ * [:Pattern_White_Space:] = + * [\u0009-\u000D\ \u0085\u200E\u200F\u2028\u2029] + *
+ * [:Pattern_Syntax:] = + * [!-/\:-@\[-\^`\{-~\u00A1-\u00A7\u00A9\u00AB\u00AC\u00AE + * \u00B0\u00B1\u00B6\u00BB\u00BF\u00D7\u00F7 + * \u2010-\u2027\u2030-\u203E\u2041-\u2053\u2055-\u205E + * \u2190-\u245F\u2500-\u2775\u2794-\u2BFF\u2E00-\u2E7F + * \u3001-\u3003\u3008-\u3020\u3030\uFD3E\uFD3F\uFE45\uFE46] + * @author mscherer + */ +class U_COMMON_API PatternProps { +public: + /** + * @return TRUE if c is a Pattern_Syntax code point. + */ + static UBool isSyntax(UChar32 c); + + /** + * @return TRUE if c is a Pattern_Syntax or Pattern_White_Space code point. + */ + static UBool isSyntaxOrWhiteSpace(UChar32 c); + + /** + * @return TRUE if c is a Pattern_White_Space character. + */ + static UBool isWhiteSpace(UChar32 c); + + /** + * Skips over Pattern_White_Space starting at s. + * @return The smallest pointer at or after s with a non-white space character. + */ + static const UChar *skipWhiteSpace(const UChar *s, int32_t length); + + /** + * @return s except with leading and trailing Pattern_White_Space removed and length adjusted. + */ + static const UChar *trimWhiteSpace(const UChar *s, int32_t &length); + + /** + * Tests whether the string contains a "pattern identifier", that is, + * whether it contains only non-Pattern_White_Space, non-Pattern_Syntax characters. + * @return TRUE if there are no Pattern_White_Space or Pattern_Syntax characters in s. + */ + static UBool isIdentifier(const UChar *s, int32_t length); + + /** + * Skips over a "pattern identifier" starting at index s. + * @return The smallest pointer at or after s with + * a Pattern_White_Space or Pattern_Syntax character. + */ + static const UChar *skipIdentifier(const UChar *s, int32_t length); + +private: + PatternProps(); // no constructor: all static methods +}; + +U_NAMESPACE_END + +#endif // __PATTERNPROPS_H__ diff --git a/icu4c/source/common/unicode/messagepattern.h b/icu4c/source/common/unicode/messagepattern.h new file mode 100644 index 00000000000..296e35fef49 --- /dev/null +++ b/icu4c/source/common/unicode/messagepattern.h @@ -0,0 +1,918 @@ +/* +******************************************************************************* +* Copyright (C) 2011, International Business Machines +* Corporation and others. All Rights Reserved. +******************************************************************************* +* file name: messagepattern.h +* encoding: US-ASCII +* tab size: 8 (not used) +* indentation:4 +* +* created on: 2011mar14 +* created by: Markus W. Scherer +*/ + +#ifndef __MESSAGEPATTERN_H__ +#define __MESSAGEPATTERN_H__ + +/** + * \file + * \brief C++ API: MessagePattern class: Parses and represents ICU MessageFormat patterns. + */ + +#include "unicode/utypes.h" + +#if !UCONFIG_NO_FORMATTING + +#include "unicode/parseerr.h" +#include "unicode/unistr.h" + +/** + * Mode for when an apostrophe starts quoted literal text for MessageFormat output. + * The default is DOUBLE_OPTIONAL unless overridden via uconfig.h + * (UCONFIG_MSGPAT_DEFAULT_APOSTROPHE_MODE). + *
+ * A pair of adjacent apostrophes always results in a single apostrophe in the output, + * even when the pair is between two single, text-quoting apostrophes. + *
+ * The following table shows examples of desired MessageFormat.format() output + * with the pattern strings that yield that output. + *
+ *
| Desired output | + *DOUBLE_OPTIONAL | + *DOUBLE_REQUIRED | + *
|---|---|---|
| I see {many} | + *I see '{many}' | + *(same) | + *
| I said {'Wow!'} | + *I said '{''Wow!''}' | + *(same) | + *
| I don't know | + *I don't know OR I don''t know |
+ * I don''t know | + *
+ * This is the default behavior starting with ICU 4.8. + * @draft ICU 4.8 + */ + UMSGPAT_APOS_DOUBLE_OPTIONAL, + /** + * A literal apostrophe must be represented by + * a double apostrophe pattern character. + * A single apostrophe always starts quoted literal text. + *
+ * This is the behavior of ICU 4.6 and earlier, and of the JDK. + * @draft ICU 4.8 + */ + UMSGPAT_APOS_DOUBLE_REQUIRED +}; +typedef enum UMessagePatternApostropheMode UMessagePatternApostropheMode; + +/** + * MessagePattern::Part type constants. + * @draft ICU 4.8 + */ +enum UMessagePatternPartType { + /** + * Start of a message pattern (main or nested). + * The length is 0 for the top-level message + * and for a choice argument sub-message, otherwise 1 for the '{'. + * The value indicates the nesting level, starting with 0 for the main message. + *
+ * There is always a later MSG_LIMIT part. + * @draft ICU 4.8 + */ + UMSGPAT_PART_TYPE_MSG_START, + /** + * End of a message pattern (main or nested). + * The length is 0 for the top-level message and + * the last sub-message of a choice argument, + * otherwise 1 for the '}' or (in a choice argument style) the '|'. + * The value indicates the nesting level, starting with 0 for the main message. + * @draft ICU 4.8 + */ + UMSGPAT_PART_TYPE_MSG_LIMIT, + /** + * Indicates a substring of the pattern string which is to be skipped when formatting. + * For example, an apostrophe that begins or ends quoted text + * would be indicated with such a part. + * The value is undefined and currently always 0. + * @draft ICU 4.8 + */ + UMSGPAT_PART_TYPE_SKIP_SYNTAX, + /** + * Indicates that a syntax character needs to be inserted for auto-quoting. + * The length is 0. + * The value is the character code of the insertion character. (U+0027=APOSTROPHE) + * @draft ICU 4.8 + */ + UMSGPAT_PART_TYPE_INSERT_CHAR, + /** + * Indicates a syntactic (non-escaped) # symbol in a plural variant. + * When formatting, replace this part's substring with the + * (value-offset) for the plural argument value. + * The value is undefined and currently always 0. + * @draft ICU 4.8 + */ + UMSGPAT_PART_TYPE_REPLACE_NUMBER, + /** + * Start of an argument. + * The length is 1 for the '{'. + * The value is the ordinal value of the ArgType. Use getArgType(). + * @draft ICU 4.8 + */ + UMSGPAT_PART_TYPE_ARG_START, + /** + * End of an argument. + * The length is 1 for the '}'. + * The value is the ordinal value of the ArgType. Use getArgType(). + *
+ * This part is followed by either an ARG_NUMBER or ARG_NAME, + * followed by optional argument sub-parts (see UMessagePatternArgType constants) + * and finally an ARG_LIMIT part. + * @draft ICU 4.8 + */ + UMSGPAT_PART_TYPE_ARG_LIMIT, + /** + * The argument number, provided by the value. + * @draft ICU 4.8 + */ + UMSGPAT_PART_TYPE_ARG_NUMBER, + /** + * The argument name. + * The value is undefined and currently always 0. + * @draft ICU 4.8 + */ + UMSGPAT_PART_TYPE_ARG_NAME, + /** + * The argument type. + * The value is undefined and currently always 0. + * @draft ICU 4.8 + */ + UMSGPAT_PART_TYPE_ARG_TYPE, + /** + * The argument style text. + * The value is undefined and currently always 0. + * @draft ICU 4.8 + */ + UMSGPAT_PART_TYPE_ARG_STYLE, + /** + * A selector substring in a "complex" argument style. + * The value is undefined and currently always 0. + * @draft ICU 4.8 + */ + UMSGPAT_PART_TYPE_ARG_SELECTOR, + /** + * An integer value, for example the offset or an explicit selector value + * in a PluralFormat style. + * The part value is the integer value. + * @draft ICU 4.8 + */ + UMSGPAT_PART_TYPE_ARG_INT, + /** + * A numeric value, for example the offset or an explicit selector value + * in a PluralFormat style. + * The part value is an index into an internal array of numeric values; + * use getNumericValue(). + * @draft ICU 4.8 + */ + UMSGPAT_PART_TYPE_ARG_DOUBLE +}; +typedef enum UMessagePatternPartType UMessagePatternPartType; + +/** + * Argument type constants. + * Returned by Part.getArgType() for ARG_START and ARG_LIMIT parts. + * + * Messages nested inside an argument are each delimited by MSG_START and MSG_LIMIT, + * with a nesting level one greater than the surrounding message. + * @draft ICU 4.8 + */ +enum UMessagePatternArgType { + /** + * The argument has no specified type. + * @draft ICU 4.8 + */ + UMSGPAT_ARG_TYPE_NONE, + /** + * The argument has a "simple" type which is provided by the ARG_TYPE part. + * An ARG_STYLE part might follow that. + * @draft ICU 4.8 + */ + UMSGPAT_ARG_TYPE_SIMPLE, + /** + * The argument is a ChoiceFormat with one or more + * ((ARG_INT | ARG_DOUBLE), ARG_SELECTOR, message) tuples. + * @draft ICU 4.8 + */ + UMSGPAT_ARG_TYPE_CHOICE, + /** + * The argument is a PluralFormat with an optional ARG_INT or ARG_DOUBLE offset + * (e.g., offset:1) + * and one or more (ARG_SELECTOR [explicit-value] message) tuples. + * If the selector has an explicit value (e.g., =2), then + * that value is provided by the ARG_INT or ARG_DOUBLE part preceding the message. + * Otherwise the message immediately follows the ARG_SELECTOR. + * @draft ICU 4.8 + */ + UMSGPAT_ARG_TYPE_PLURAL, + /** + * The argument is a SelectFormat with one or more (ARG_SELECTOR, message) pairs. + * @draft ICU 4.8 + */ + UMSGPAT_ARG_TYPE_SELECT +}; +typedef enum UMessagePatternArgType UMessagePatternArgType; + +enum { + /** + * Return value from MessagePattern.validateArgumentName() for when + * the string is a valid "pattern identifier" but not a number. + * @draft ICU 4.8 + */ + UMSGPAT_ARG_NAME_NOT_NUMBER=-1, + + /** + * Return value from MessagePattern.validateArgumentName() for when + * the string is invalid. + * It might not be a valid "pattern identifier", + * or it have only ASCII digits but there is a leading zero or the number is too large. + * @draft ICU 4.8 + */ + UMSGPAT_ARG_NAME_NOT_VALID=-2 +}; + +/** + * Special value that is returned by getNumericValue(Part) when no + * numeric value is defined for a part. + * @see MessagePattern.getNumericValue() + * @draft ICU 4.8 + */ +#define UMSGPAT_NO_NUMERIC_VALUE ((double)(-123456789)) + +U_NAMESPACE_BEGIN + +class MessagePatternDoubleList; +class MessagePatternPartsList; + +/** + * Parses and represents ICU MessageFormat patterns. + * Also handles patterns for ChoiceFormat, PluralFormat and SelectFormat. + * Used in the implementations of those classes as well as in tools + * for message validation, translation and format conversion. + *
+ * The parser handles all syntax relevant for identifying message arguments. + * This includes "complex" arguments whose style strings contain + * nested MessageFormat pattern substrings. + * For "simple" arguments (with no nested MessageFormat pattern substrings), + * the argument style is not parsed any further. + *
+ * The parser handles named and numbered message arguments and allows both in one message. + *
+ * Once a pattern has been parsed successfully, iterate through the parsed data + * with countParts(), getPart() and related methods. + *
+ * The data logically represents a parse tree, but is stored and accessed + * as a list of "parts" for fast and simple parsing and to minimize object allocations. + * Arguments and nested messages are best handled via recursion. + * For every _START "part", MessagePattern.getLimitPartIndex() efficiently returns + * the index of the corresponding _LIMIT "part". + *
+ * List of "parts": + *
+ * message = MSG_START (SKIP_SYNTAX | INSERT_CHAR | REPLACE_NUMBER | argument)* MSG_LIMIT + * argument = noneArg | simpleArg | complexArg + * complexArg = choiceArg | pluralArg | selectArg + * + * noneArg = ARG_START.NONE (ARG_NAME | ARG_NUMBER) ARG_LIMIT.NONE + * simpleArg = ARG_START.SIMPLE (ARG_NAME | ARG_NUMBER) ARG_TYPE [ARG_STYLE] ARG_LIMIT.SIMPLE + * choiceArg = ARG_START.CHOICE (ARG_NAME | ARG_NUMBER) choiceStyle ARG_LIMIT.CHOICE + * pluralArg = ARG_START.PLURAL (ARG_NAME | ARG_NUMBER) pluralStyle ARG_LIMIT.PLURAL + * selectArg = ARG_START.SELECT (ARG_NAME | ARG_NUMBER) selectStyle ARG_LIMIT.SELECT + * + * choiceStyle = ((ARG_INT | ARG_DOUBLE) ARG_SELECTOR message)+ + * pluralStyle = [ARG_INT | ARG_DOUBLE] (ARG_SELECTOR [ARG_INT | ARG_DOUBLE] message)+ + * selectStyle = (ARG_SELECTOR message)+ + *+ *
ARG_START.CHOICE stands for an ARG_START Part with ArgType CHOICE.
+ * + * This class is not intended for public subclassing. + * + * @draft ICU 4.8 + */ +class U_COMMON_API MessagePattern : public UObject { +public: + /** + * Constructs an empty MessagePattern with default UMessagePatternApostropheMode. + * @param errorCode Standard ICU error code. Its input value must + * pass the U_SUCCESS() test, or else the function returns + * immediately. Check for U_FAILURE() on output or use with + * function chaining. (See User Guide for details.) + * @draft ICU 4.8 + */ + MessagePattern(UErrorCode &errorCode); + + /** + * Constructs an empty MessagePattern. + * @param mode Explicit UMessagePatternApostropheMode. + * @param errorCode Standard ICU error code. Its input value must + * pass the U_SUCCESS() test, or else the function returns + * immediately. Check for U_FAILURE() on output or use with + * function chaining. (See User Guide for details.) + * @draft ICU 4.8 + */ + MessagePattern(UMessagePatternApostropheMode mode, UErrorCode &errorCode); + + /** + * Constructs a MessagePattern with default UMessagePatternApostropheMode and + * parses the MessageFormat pattern string. + * @param pattern a MessageFormat pattern string + * @param parseError Struct to receive information on the position + * of an error within the pattern. + * Can be NULL. + * @param errorCode Standard ICU error code. Its input value must + * pass the U_SUCCESS() test, or else the function returns + * immediately. Check for U_FAILURE() on output or use with + * function chaining. (See User Guide for details.) + * TODO: turn @throws into UErrorCode specifics? + * @throws IllegalArgumentException for syntax errors in the pattern string + * @throws IndexOutOfBoundsException if certain limits are exceeded + * (e.g., argument number too high, argument name too long, etc.) + * @throws NumberFormatException if a number could not be parsed + * @draft ICU 4.8 + */ + MessagePattern(const UnicodeString &pattern, UParseError *parseError, UErrorCode &errorCode); + + /** + * Copy constructor. + * @param other Object to copy. + * @draft ICU 4.8 + */ + MessagePattern(const MessagePattern &other); + + /** + * Assignment operator. + * @param other Object to copy. + * @return *this=other + * @draft ICU 4.8 + */ + MessagePattern &operator=(const MessagePattern &other); + + /** + * Destructor. + * @draft ICU 4.8 + */ + virtual ~MessagePattern(); + + /** + * Parses a MessageFormat pattern string. + * @param pattern a MessageFormat pattern string + * @param parseError Struct to receive information on the position + * of an error within the pattern. + * Can be NULL. + * @param errorCode Standard ICU error code. Its input value must + * pass the U_SUCCESS() test, or else the function returns + * immediately. Check for U_FAILURE() on output or use with + * function chaining. (See User Guide for details.) + * @return *this + * @throws IllegalArgumentException for syntax errors in the pattern string + * @throws IndexOutOfBoundsException if certain limits are exceeded + * (e.g., argument number too high, argument name too long, etc.) + * @throws NumberFormatException if a number could not be parsed + * @draft ICU 4.8 + */ + MessagePattern &parse(const UnicodeString &pattern, + UParseError *parseError, UErrorCode &errorCode); + + /** + * Parses a ChoiceFormat pattern string. + * @param pattern a ChoiceFormat pattern string + * @param parseError Struct to receive information on the position + * of an error within the pattern. + * Can be NULL. + * @param errorCode Standard ICU error code. Its input value must + * pass the U_SUCCESS() test, or else the function returns + * immediately. Check for U_FAILURE() on output or use with + * function chaining. (See User Guide for details.) + * @return *this + * @throws IllegalArgumentException for syntax errors in the pattern string + * @throws IndexOutOfBoundsException if certain limits are exceeded + * (e.g., argument number too high, argument name too long, etc.) + * @throws NumberFormatException if a number could not be parsed + * @draft ICU 4.8 + */ + MessagePattern &parseChoiceStyle(const UnicodeString &pattern, + UParseError *parseError, UErrorCode &errorCode); + + /** + * Parses a PluralFormat pattern string. + * @param pattern a PluralFormat pattern string + * @param parseError Struct to receive information on the position + * of an error within the pattern. + * Can be NULL. + * @param errorCode Standard ICU error code. Its input value must + * pass the U_SUCCESS() test, or else the function returns + * immediately. Check for U_FAILURE() on output or use with + * function chaining. (See User Guide for details.) + * @return *this + * @throws IllegalArgumentException for syntax errors in the pattern string + * @throws IndexOutOfBoundsException if certain limits are exceeded + * (e.g., argument number too high, argument name too long, etc.) + * @throws NumberFormatException if a number could not be parsed + * @draft ICU 4.8 + */ + MessagePattern &parsePluralStyle(const UnicodeString &pattern, + UParseError *parseError, UErrorCode &errorCode); + + /** + * Parses a SelectFormat pattern string. + * @param pattern a SelectFormat pattern string + * @param parseError Struct to receive information on the position + * of an error within the pattern. + * Can be NULL. + * @param errorCode Standard ICU error code. Its input value must + * pass the U_SUCCESS() test, or else the function returns + * immediately. Check for U_FAILURE() on output or use with + * function chaining. (See User Guide for details.) + * @return *this + * @throws IllegalArgumentException for syntax errors in the pattern string + * @throws IndexOutOfBoundsException if certain limits are exceeded + * (e.g., argument number too high, argument name too long, etc.) + * @throws NumberFormatException if a number could not be parsed + * @draft ICU 4.8 + */ + MessagePattern &parseSelectStyle(const UnicodeString &pattern, + UParseError *parseError, UErrorCode &errorCode); + + /** + * Clears this MessagePattern. + * countParts() will return 0. + * @draft ICU 4.8 + */ + void clear(); + + /** + * Clears this MessagePattern and sets the UMessagePatternApostropheMode. + * countParts() will return 0. + * @param mode The new UMessagePatternApostropheMode. + * @draft ICU 4.8 + * @provisional This API might change or be removed in a future release. + */ + void clearPatternAndSetApostropheMode(UMessagePatternApostropheMode mode) { + clear(); + aposMode=mode; + } + + /** + * @param other another object to compare with. + * @return TRUE if this object is equivalent to the other one. + * @draft ICU 4.8 + */ + UBool operator==(const MessagePattern &other) const; + + /** + * @param other another object to compare with. + * @return FALSE if this object is equivalent to the other one. + * @draft ICU 4.8 + */ + inline UBool operator!=(const MessagePattern &other) const { + return !operator==(other); + } + + /** + * @return A hash code for this object. + * @draft ICU 4.8 + */ + int32_t hashCode() const; + + /** + * @return this instance's UMessagePatternApostropheMode. + * @draft ICU 4.8 + */ + UMessagePatternApostropheMode getApostropheMode() const { + return aposMode; + } + + // Java has package-private jdkAposMode() here. + // In C++, this is declared in the MessageImpl class. + + /** + * @return the parsed pattern string (null if none was parsed). + * @draft ICU 4.8 + */ + const UnicodeString &getPatternString() const { + return msg; + } + + /** + * Does the parsed pattern have named arguments like {first_name}? + * @return TRUE if the parsed pattern has at least one named argument. + * @draft ICU 4.8 + */ + UBool hasNamedArguments() const { + return hasArgNames; + } + + /** + * Does the parsed pattern have numbered arguments like {2}? + * @return TRUE if the parsed pattern has at least one numbered argument. + * @draft ICU 4.8 + */ + UBool hasNumberedArguments() const { + return hasArgNumbers; + } + + /** + * Validates and parses an argument name or argument number string. + * An argument name must be a "pattern identifier", that is, it must contain + * no Unicode Pattern_Syntax or Pattern_White_Space characters. + * If it only contains ASCII digits, then it must be a small integer with no leading zero. + * @param name Input string. + * @return >=0 if the name is a valid number, + * ARG_NAME_NOT_NUMBER (-1) if it is a "pattern identifier" but not all ASCII digits, + * ARG_NAME_NOT_VALID (-2) if it is neither. + * @draft ICU 4.8 + */ + static int32_t validateArgumentName(const UnicodeString &name); + + /** + * Returns a version of the parsed pattern string where each ASCII apostrophe + * is doubled (escaped) if it is not already, and if it is not interpreted as quoting syntax. + *
+ * For example, this turns "I don't '{know}' {gender,select,female{h''er}other{h'im}}."
+ * into "I don''t '{know}' {gender,select,female{h''er}other{h''im}}."
+ * @return the deep-auto-quoted version of the parsed pattern string.
+ * @see MessageFormat.autoQuoteApostrophe()
+ * @draft ICU 4.8
+ */
+ UnicodeString autoQuoteApostropheDeep() const;
+
+ class Part;
+
+ /**
+ * Returns the number of "parts" created by parsing the pattern string.
+ * Returns 0 if no pattern has been parsed or clear() was called.
+ * @return the number of pattern parts.
+ * @draft ICU 4.8
+ */
+ int32_t countParts() const {
+ return partsLength;
+ }
+
+ /**
+ * Gets the i-th pattern "part".
+ * @param i The index of the Part data. (0..countParts()-1)
+ * @return the i-th pattern "part".
+ * @draft ICU 4.8
+ */
+ const Part &getPart(int32_t i) const {
+ return parts[i];
+ }
+
+ /**
+ * Returns the UMessagePatternPartType of the i-th pattern "part".
+ * Convenience method for getPart(i).getType().
+ * @param i The index of the Part data. (0..countParts()-1)
+ * @return The UMessagePatternPartType of the i-th Part.
+ * @draft ICU 4.8
+ */
+ UMessagePatternPartType getPartType(int32_t i) const {
+ return getPart(i).type;
+ }
+
+ /**
+ * Returns the pattern index of the specified pattern "part".
+ * Convenience method for getPart(partIndex).getIndex().
+ * @param partIndex The index of the Part data. (0..countParts()-1)
+ * @return The pattern index of this Part.
+ * @draft ICU 4.8
+ */
+ int32_t getPatternIndex(int32_t partIndex) const {
+ return getPart(partIndex).index;
+ }
+
+ /**
+ * Returns the substring of the pattern string indicated by the Part.
+ * Convenience method for getPatternString().substring(part.getIndex(), part.getLimit()).
+ * @param part a part of this MessagePattern.
+ * @return the substring associated with part.
+ * @draft ICU 4.8
+ */
+ UnicodeString getSubstring(const Part &part) const {
+ return msg.tempSubString(part.index, part.length);
+ }
+
+ /**
+ * Compares the part's substring with the input string s.
+ * @param part a part of this MessagePattern.
+ * @param s a string.
+ * @return TRUE if getSubstring(part).equals(s).
+ * @draft ICU 4.8
+ */
+ UBool partSubstringMatches(const Part &part, const UnicodeString &s) const {
+ return 0==msg.compare(part.index, part.length, s);
+ }
+
+ /**
+ * Returns the numeric value associated with an ARG_INT or ARG_DOUBLE.
+ * @param part a part of this MessagePattern.
+ * @return the part's numeric value, or UMSGPAT_NO_NUMERIC_VALUE if this is not a numeric part.
+ * @draft ICU 4.8
+ */
+ double getNumericValue(const Part &part) const;
+
+ /**
+ * Returns the "offset:" value of a PluralFormat argument, or 0 if none is specified.
+ * @param pluralStart the index of the first PluralFormat argument style part. (0..countParts()-1)
+ * @return the "offset:" value.
+ * @draft ICU 4.8
+ */
+ double getPluralOffset(int32_t pluralStart) const;
+
+ /**
+ * Returns the index of the ARG|MSG_LIMIT part corresponding to the ARG|MSG_START at start.
+ * @param start The index of some Part data (0..countParts()-1);
+ * this Part should be of Type ARG_START or MSG_START.
+ * @return The first i>start where getPart(i).getType()==ARG|MSG_LIMIT at the same nesting level,
+ * or start itself if getPartType(msgStart)!=ARG|MSG_START.
+ * @draft ICU 4.8
+ */
+ int32_t getLimitPartIndex(int32_t start) const {
+ int32_t limit=getPart(start).limitPartIndex;
+ if(limit A U_ILLEGAL_ARGUMENT_ERROR if the pattern
@@ -590,8 +590,8 @@ public:
/**
* Modifies this set to represent the set specified by the given
- * pattern, optionally ignoring white space. See the class
- * description for the syntax of the pattern language.
+ * pattern, optionally ignoring Unicode Pattern_White_Space characters.
+ * See the class description for the syntax of the pattern language.
* A frozen set will not be modified.
* @param pattern a string specifying what characters are in the set
* @param options bitmask for options to apply to the pattern.
@@ -1540,8 +1540,8 @@ private:
* \\p{foo} \\P{foo} - white space not allowed within "\\p" or "\\P"
* \\N{name} - white space not allowed within "\\N"
*
- * Other than the above restrictions, white space is ignored. Case
- * is ignored except in "\\p" and "\\P" and "\\N". In 'name' leading
+ * Other than the above restrictions, Unicode Pattern_White_Space characters are ignored.
+ * Case is ignored except in "\\p" and "\\P" and "\\N". In 'name' leading
* and trailing space is deleted, and internal runs of whitespace
* are collapsed to a single space.
*
diff --git a/icu4c/source/common/uniset.cpp b/icu4c/source/common/uniset.cpp
index 4ff3f6b2717..ed50e1758c2 100644
--- a/icu4c/source/common/uniset.cpp
+++ b/icu4c/source/common/uniset.cpp
@@ -1,6 +1,6 @@
/*
**********************************************************************
-* Copyright (C) 1999-2009, International Business Machines
+* Copyright (C) 1999-2011, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* Date Name Description
@@ -15,6 +15,7 @@
#include "ruleiter.h"
#include "cmemory.h"
#include "cstring.h"
+#include "patternprops.h"
#include "uhash.h"
#include "util.h"
#include "uvector.h"
@@ -1926,7 +1927,7 @@ escapeUnprintable) {
break;
default:
// Escape whitespace
- if (uprv_isRuleWhiteSpace(c)) {
+ if (PatternProps::isWhiteSpace(c)) {
buf.append(BACKSLASH);
}
break;
diff --git a/icu4c/source/common/uniset_props.cpp b/icu4c/source/common/uniset_props.cpp
index 6f82dfb7dc8..95ed2640aa4 100644
--- a/icu4c/source/common/uniset_props.cpp
+++ b/icu4c/source/common/uniset_props.cpp
@@ -1,7 +1,7 @@
/*
*******************************************************************************
*
-* Copyright (C) 1999-2010, International Business Machines
+* Copyright (C) 1999-2011, International Business Machines
* Corporation and others. All Rights Reserved.
*
*******************************************************************************
@@ -399,20 +399,6 @@ UnicodeSet::UnicodeSet(const UnicodeString& pattern, ParsePosition& pos,
// Public API
//----------------------------------------------------------------
-/**
- * Modifies this set to represent the set specified by the given
- * pattern, optionally ignoring white space. See the class
- * description for the syntax of the pattern language.
- * @param pattern a string specifying what characters are in the set
- * @param ignoreSpaces if true, all spaces in the
- * pattern are ignored. Spaces are those characters for which
- * uprv_isRuleWhiteSpace() is true.
- * Characters preceded by '\\' are escaped, losing any special
- * meaning they otherwise have. Spaces may be included by
- * escaping them.
- * @exception IllegalArgumentException if the pattern
- * contains a syntax error.
- */
UnicodeSet& UnicodeSet::applyPattern(const UnicodeString& pattern,
UErrorCode& status) {
return applyPattern(pattern, USET_IGNORE_SPACE, NULL, status);
diff --git a/icu4c/source/i18n/choicfmt.cpp b/icu4c/source/i18n/choicfmt.cpp
index ae5387273e3..58b440a7e4c 100644
--- a/icu4c/source/i18n/choicfmt.cpp
+++ b/icu4c/source/i18n/choicfmt.cpp
@@ -1,6 +1,6 @@
/*
*******************************************************************************
-* Copyright (C) 1997-2009, International Business Machines Corporation and *
+* Copyright (C) 1997-2011, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*
@@ -32,7 +32,9 @@
#include "unicode/locid.h"
#include "cpputils.h"
#include "cstring.h"
+#include "messageimpl.h"
#include "putilimp.h"
+#include "uassert.h"
#include ChoiceFormat splits
- * the real number line -Inf to +Inf into two
+ * ChoiceFormat converts between ranges of numeric values and strings for those ranges.
+ * The strings must conform to the MessageFormat pattern syntax.
+ *
+ * ChoiceFormat is probably not what you need.
+ * Please use MessageFormat
+ * with plural arguments for proper plural selection,
+ * and select arguments for simple selection among a fixed set of choices!ChoiceFormat splits
+ * the real number line \htmlonly-∞ to
+ * +∞\endhtmlonly into two
* or more contiguous ranges. Each range is mapped to a
- * string. ChoiceFormat is generally used in a
- * MessageFormat for displaying grammatically correct
- * plurals such as "There are 2 files."
ChoiceFormat was originally intended
+ * for displaying grammatically correct
+ * plurals such as "There is one file." vs. "There are 2 files."
+ * However, plural rules for many languages
+ * are too complex for the capabilities of ChoiceFormat,
+ * and its requirement of specifying the precise rules for each message
+ * is unmanageable for translators.
There are two methods of defining a ChoiceFormat; both
* are equivalent. The first is by using a string pattern. This is the
* preferred method in most cases. The second method is through direct
- * specification of the arrays that make up the
+ * specification of the arrays that logically make up the
* ChoiceFormat.
Patterns
+ *Note: Typically, choice formatting is done (if done at all) via MessageFormat
+ * with a choice argument type,
+ * rather than using a stand-alone ChoiceFormat.
In most cases, the preferred way to define a
- * ChoiceFormat is with a pattern. Here is an example of a
- * ChoiceFormat pattern:
0≤are no files|1≤is one file|1<are many files\endhtmlonly + *
The pattern string defines the range boundaries and the strings for each number range. + * Syntax: + *
+ * choiceStyle = number separator message ('|' number separator message)*
+ * number = normal_number | ['-'] \htmlonly∞\endhtmlonly (U+221E, infinity)
+ * normal_number = double value (unlocalized ASCII string)
+ * separator = less_than | less_than_or_equal
+ * less_than = '<'
+ * less_than_or_equal = '#' | \htmlonly≤\endhtmlonly (U+2264)
+ * message: see {@link MessageFormat}
+ *
+ * Pattern_White_Space between syntax elements is ignored, except
+ * around each range's sub-message.
*
- * or equivalently,
+ *Each numeric sub-range extends from the current range's number
+ * to the next range's number.
+ * The number itself is included in its range if a less_than_or_equal sign is used,
+ * and excluded from its range (and instead included in the previous range)
+ * if a less_than sign is used.
0#are no files|1#is one file|1<are many files\endhtmlonly + *
When a ChoiceFormat is constructed from
+ * arrays of numbers, closure flags and strings,
+ * they are interpreted just like
+ * the sequence of (number separator string) in an equivalent pattern string.
+ * closure[i]==TRUE corresponds to a less_than separator sign.
+ * The equivalent pattern string will be constructed automatically.
The pattern consists of a number or range specifiers - * separated by vertical bars '|' (U+007C). There is no - * vertical bar after the last range. Each range specifier is of the - * form:
+ *During formatting, a number is mapped to the first range + * where the number is not greater than the range's upper limit. + * That range's message string is returned. A NaN maps to the very first range.
* - * \htmlonlyNumber Separator String\endhtmlonly + *
During parsing, a range is selected for the longest match of + * any range's message. That range's number is returned, ignoring the separator/closure. + * Only a simple string match is performed, without parsing of arguments that + * might be specified in the message strings.
* - *Number is a floating point number that can be parsed by a
- * default NumberFormat for the US locale. It gives the
- * lower limit of this range. The lower limit is either inclusive or
- * exclusive, depending on the separator. The upper limit is
- * given by the lower limit of the next range. The Unicode infinity
- * sign \htmlonly∞ \endhtmlonly (U+221E) is recognized for positive infinity. It may be preceded by
- * '-' (U+002D) to indicate negative infinity.
Note that the first range's number is ignored in formatting + * but may be returned from parsing.
* - *String is the format string for this range, with special
- * characters enclosed in single quotes ('The #
- * sign'). Single quotes themselves are indicated by two single
- * quotes in a row ('o''clock').
Separator is one of the following single characters: - * - *
FALSE.TRUE.
- * See below for more information about closures.
- * - *Arrays
- * - *A ChoiceFormat defining n intervals
- * (n >= 2) is specified by three arrays of
- * n items:
- *
- *
double limits[] gives the start of each
- * interval. This must be a non-decreasing list of values, none of
- * which may be NaN.UBool closures[] determines whether each limit
- * value is contained in the interval below it or in the interval
- * above it. If closures[i] is FALSE, then
- * limits[i] is a member of interval
- * i. Otherwise it is a member of interval
- * i+1. If no closures array is specified, this is
- * equivalent to having all closures be FALSE. Closures
- * allow one to specify half-open, open, or closed intervals.UnicodeString formats[] gives the string label
- * associated with each interval.Formatting and Parsing
- * - *During formatting, a number is converted to a
- * string. ChoiceFormat accomplishes this by mapping the
- * number to an interval using the following rule. Given a number
- * X and and index value j in the range
- * 0..n-1, where n is the number of ranges:
\endhtmlonly\endhtmlonly - * - *Xmatchesjif and only if - *limit[j] <= X < limit[j+1]- * \htmlonly
(This assumes that all closures are FALSE. If some
- * closures are TRUE then the relations must be changed to
- * <= or < as appropriate.) If there is
- * no match, then either the first or last index is used, depending on
- * whether the number is too low or too high. Once a number is mapped to
- * an interval j, the string formats[j] is
- * output.
During parsing, a string is converted to a
- * number. ChoiceFormat finds the element
- * formats[j] equal to the string, and returns
- * limits[j] as the parsed value.
Notes
- * - *The first limit value does not define a range boundary. For
- * example, in the pattern \htmlonly"1.0#a|2.0#b"\endhtmlonly, the
- * intervals are [-Inf, 2.0) and [2.0, +Inf]. It appears that the first
- * interval should be [1.0, 2.0). However, since all values that are too
- * small are mapped to range zero, the first interval is effectively
- * [-Inf, 2.0). However, the first limit value is used during
- * formatting. In this example, parse("a") returns
- * 1.0.
There are no gaps between intervals and the entire number line is
- * covered. A ChoiceFormat maps all possible
- * double values to a finite set of intervals.
The non-number NaN is mapped to interval zero during
- * formatting.
Examples
+ *Here is an example of two arrays that map the number
* 1..7 to the English day of the week abbreviations
@@ -183,13 +127,15 @@ class MessageFormat;
*
*
Here is an example that maps the ranges [-Inf, 1), [1, 1], and (1, * +Inf] to three strings. That is, the number line is split into three - * ranges: x < 1.0, x = 1.0, and x > 1.0.
+ * ranges: x < 1.0, x = 1.0, and x > 1.0. + * (The round parentheses in the notation above indicate an exclusive boundary, + * like the turned bracket in European notation: [-Inf, 1) == [-Inf, 1[ ) * * {0, 1, 1},
* {FALSE, FALSE, TRUE},
* {"no files", "one file", "many files"}
*
- * Here is a simple example that shows formatting and parsing:
+ *Here is an example that shows formatting and parsing:
* * \code * #includeHere is a more complex example using a ChoiceFormat
- * constructed from a pattern together with a
- * MessageFormat.
User subclasses are not supported. While clients may write
* subclasses, such code will not necessarily work and will not be
* guaranteed to work stably from release to release.
@@ -259,8 +168,7 @@ class MessageFormat;
class U_I18N_API ChoiceFormat: public NumberFormat {
public:
/**
- * Construct a new ChoiceFormat with the limits and the corresponding formats
- * based on the pattern.
+ * Constructs a new ChoiceFormat from the pattern string.
*
* @param pattern Pattern used to construct object.
* @param status Output param to receive success code. If the
@@ -272,32 +180,31 @@ public:
/**
- * Construct a new ChoiceFormat with the given limits and formats. Copy
- * the limits and formats instead of adopting them.
+ * Constructs a new ChoiceFormat with the given limits and message strings.
+ * All closure flags default to FALSE,
+ * equivalent to less_than_or_equal separators.
+ *
+ * Copies the limits and formats instead of adopting them.
*
* @param limits Array of limit values.
* @param formats Array of formats.
* @param count Size of 'limits' and 'formats' arrays.
* @stable ICU 2.0
*/
-
ChoiceFormat(const double* limits,
const UnicodeString* formats,
int32_t count );
/**
- * Construct a new ChoiceFormat with the given limits and formats.
- * Copy the limits and formats (instead of adopting them). By
- * default, each limit in the array specifies the inclusive lower
- * bound of its range, and the exclusive upper bound of the previous
- * range. However, if the isLimitOpen element corresponding to a
- * limit is TRUE, then the limit is the exclusive lower bound of its
- * range, and the inclusive upper bound of the previous range.
+ * Constructs a new ChoiceFormat with the given limits, closure flags and message strings.
+ *
+ * Copies the limits and formats instead of adopting them.
+ *
* @param limits Array of limit values
* @param closures Array of booleans specifying whether each
* element of 'limits' is open or closed. If FALSE, then the
- * corresponding limit is a member of the range above it. If TRUE,
- * then the limit belongs to the range below it.
+ * corresponding limit number is a member of its range.
+ * If TRUE, then the limit number belongs to the previous range it.
* @param formats Array of formats
* @param count Size of 'limits', 'closures', and 'formats' arrays
* @stable ICU 2.4
@@ -330,8 +237,8 @@ public:
virtual ~ChoiceFormat();
/**
- * Clone this Format object polymorphically. The caller owns the
- * result and should delete it when done.
+ * Clones this Format object. The caller owns the
+ * result and must delete it when done.
*
* @return a copy of this object
* @stable ICU 2.0
@@ -339,7 +246,7 @@ public:
virtual Format* clone(void) const;
/**
- * Return true if the given Format objects are semantically equal.
+ * Returns true if the given Format objects are semantically equal.
* Objects of different subclasses are considered unequal.
*
* @param other ChoiceFormat object to be compared
@@ -362,7 +269,7 @@ public:
/**
* Sets the pattern.
* @param pattern The pattern to be applied.
- * @param parseError Struct to recieve information on position
+ * @param parseError Struct to receive information on position
* of error if an error is encountered
* @param status Output param set to success/failure code on
* exit. If the pattern is invalid, this will be
@@ -375,7 +282,7 @@ public:
/**
* Gets the pattern.
*
- * @param pattern Output param which will recieve the pattern
+ * @param pattern Output param which will receive the pattern
* Previous contents are deleted.
* @return A reference to 'pattern'
* @stable ICU 2.0
@@ -383,7 +290,8 @@ public:
virtual UnicodeString& toPattern(UnicodeString &pattern) const;
/**
- * Set the choices to be used in formatting.
+ * Sets the choices to be used in formatting.
+ * For details see the constructor with the same parameter list.
*
* @param limitsToCopy Contains the top value that you want
* parsed with that format,and should be in
@@ -399,8 +307,9 @@ public:
int32_t count );
/**
- * Set the choices to be used in formatting. See class description
- * for documenatation of the limits, closures, and formats arrays.
+ * Sets the choices to be used in formatting.
+ * For details see the constructor with the same parameter list.
+ *
* @param limits Array of limits
* @param closures Array of limit booleans
* @param formats Array of format string
@@ -413,30 +322,32 @@ public:
int32_t count);
/**
- * Get the limits passed in the constructor.
+ * Returns NULL and 0.
+ * Before ICU 4.8, this used to return the choice limits array.
*
- * @param count The size of the limits arrays
- * @return the limits.
- * @stable ICU 2.0
+ * @param count Will be set to 0.
+ * @return NULL
+ * @deprecated ICU 4.8 Use the MessagePattern class to analyze a ChoiceFormat pattern.
*/
virtual const double* getLimits(int32_t& count) const;
/**
- * Get the limit booleans passed in the constructor. The caller
- * must not delete the result.
+ * Returns NULL and 0.
+ * Before ICU 4.8, this used to return the limit booleans array.
*
- * @param count The size of the arrays
- * @return the closures
- * @stable ICU 2.4
+ * @param count Will be set to 0.
+ * @return NULL
+ * @deprecated ICU 4.8 Use the MessagePattern class to analyze a ChoiceFormat pattern.
*/
virtual const UBool* getClosures(int32_t& count) const;
/**
- * Get the formats passed in the constructor.
+ * Returns NULL and 0.
+ * Before ICU 4.8, this used to return the array of choice strings.
*
- * @param count The size of the arrays
- * @return the formats.
- * @stable ICU 2.0
+ * @param count Will be set to 0.
+ * @return NULL
+ * @deprecated ICU 4.8 Use the MessagePattern class to analyze a ChoiceFormat pattern.
*/
virtual const UnicodeString* getFormats(int32_t& count) const;
@@ -444,7 +355,7 @@ public:
using NumberFormat::format;
/**
- * Format a double or long number using this object's choices.
+ * Formats a double number using this object's choices.
*
* @param number The value to be formatted.
* @param appendTo Output parameter to receive result.
@@ -458,7 +369,7 @@ public:
UnicodeString& appendTo,
FieldPosition& pos) const;
/**
- * Format a int_32t number using this object's choices.
+ * Formats an int32_t number using this object's choices.
*
* @param number The value to be formatted.
* @param appendTo Output parameter to receive result.
@@ -473,7 +384,7 @@ public:
FieldPosition& pos) const;
/**
- * Format an int64_t number using this object's choices.
+ * Formats an int64_t number using this object's choices.
*
* @param number The value to be formatted.
* @param appendTo Output parameter to receive result.
@@ -488,7 +399,7 @@ public:
FieldPosition& pos) const;
/**
- * Format an array of objects using this object's choices.
+ * Formats an array of objects using this object's choices.
*
* @param objs The array of objects to be formatted.
* @param cnt The size of objs.
@@ -507,7 +418,7 @@ public:
FieldPosition& pos,
UErrorCode& success) const;
/**
- * Format an object using this object's choices.
+ * Formats an object using this object's choices.
*
*
* @param obj The object to be formatted.
@@ -542,7 +453,7 @@ public:
/**
* Redeclared NumberFormat method.
- * Format a double number. These methods call the NumberFormat
+ * Formats a double number. These methods call the NumberFormat
* pure virtual format() methods with the default FieldPosition.
*
* @param number The value to be formatted.
@@ -556,7 +467,7 @@ public:
/**
* Redeclared NumberFormat method.
- * Format a long number. These methods call the NumberFormat
+ * Formats an int32_t number. These methods call the NumberFormat
* pure virtual format() methods with the default FieldPosition.
*
* @param number The value to be formatted.
@@ -569,13 +480,10 @@ public:
UnicodeString& appendTo) const;
/**
- * Return a long if possible (e.g. within range LONG_MAX,
- * LONG_MAX], and with no decimals), otherwise a double. If
- * IntegerOnly is set, will stop at a decimal point (or equivalent;
- * e.g. for rational numbers "1 2/3", will stop after the 1).
- *
- * If no object can be parsed, parsePosition is unchanged, and NULL is - * returned. + * Looks for the longest match of any message string on the input text and, + * if there is a match, sets the result object to the corresponding range's number. + * + * If no string matches, then the parsePosition is unchanged. * * @param text The text to be parsed. * @param result Formattable to be set to the parse result. @@ -583,7 +491,6 @@ public: * @param parsePosition The position to start parsing at on input. * On output, moved to after the last successfully * parse character. On parse failure, does not change. - * @see NumberFormat::isParseIntegerOnly * @stable ICU 2.0 */ virtual void parse(const UnicodeString& text, @@ -591,32 +498,23 @@ public: ParsePosition& parsePosition) const; /** - * Return a long if possible (e.g. within range LONG_MAX, - * LONG_MAX], and with no decimals), otherwise a double. If - * IntegerOnly is set, will stop at a decimal point (or equivalent; - * e.g. for rational numbers "1 2/3", will stop after the 1). - *
- * If no object can be parsed, parsePosition is unchanged, and NULL is - * returned. - * - * @param text The text to be parsed. - * @param result Formattable to be set to the parse result. - * If parse fails, return contents are undefined. - * @param status Output param with the formatted string. - * @see NumberFormat::isParseIntegerOnly - * @stable ICU 2.0 - */ + * Looks for the longest match of any message string on the input text and, + * if there is a match, sets the result object to the corresponding range's number. + * + * If no string matches, then the UErrorCode is set to U_INVALID_FORMAT_ERROR. + * + * @param text The text to be parsed. + * @param result Formattable to be set to the parse result. + * If parse fails, return contents are undefined. + * @param status Output param with the formatted string. + * @stable ICU 2.0 + */ virtual void parse(const UnicodeString& text, Formattable& result, UErrorCode& status) const; - -public: /** - * Returns a unique class ID POLYMORPHICALLY. Pure virtual override. - * This method is to implement a simple version of RTTI, since not all - * C++ compilers support genuine RTTI. Polymorphic operator==() and - * clone() methods call this method. + * Returns a unique class ID POLYMORPHICALLY. Part of ICU's "poor man's RTTI". * * @return The class ID for this object. All objects of a * given class have the same class ID. Objects of @@ -626,7 +524,7 @@ public: virtual UClassID getDynamicClassID(void) const; /** - * Return the class ID for this class. This is useful only for + * Returns the class ID for this class. This is useful only for * comparing to a return value from getDynamicClassID(). For example: *
* . Base* polymorphic_pointer = createPolymorphicObject();
@@ -639,22 +537,9 @@ public:
static UClassID U_EXPORT2 getStaticClassID(void);
private:
- // static cache management (thread-safe)
- // static NumberFormat* getNumberFormat(UErrorCode &status); // call this function to 'check out' a numberformat from the cache.
- // static void releaseNumberFormat(NumberFormat *adopt); // call this function to 'return' the number format to the cache.
-
/**
- * Converts a string to a double value using a default NumberFormat object
- * which is static (shared by all ChoiceFormat instances).
- * @param string the string to be converted with.
- * @return the converted double number.
- */
- static double stod(const UnicodeString& string);
-
- /**
- * Converts a double value to a string using a default NumberFormat object
- * which is static (shared by all ChoiceFormat instances).
- * @param value the double number to be converted with.
+ * Converts a double value to a string.
+ * @param value the double number to be converted.
* @param string the result string.
* @return the converted string.
*/
@@ -667,7 +552,7 @@ private:
* based on the pattern.
*
* @param newPattern Pattern used to construct object.
- * @param parseError Struct to recieve information on position
+ * @param parseError Struct to receive information on position
* of error if an error is encountered.
* @param status Output param to receive success code. If the
* pattern cannot be parsed, set to failure code.
@@ -678,7 +563,59 @@ private:
UErrorCode& status);
friend class MessageFormat;
+
+ virtual void setChoices(const double* limits,
+ const UBool* closures,
+ const UnicodeString* formats,
+ int32_t count,
+ UErrorCode &errorCode);
+
/**
+ * Finds the ChoiceFormat sub-message for the given number.
+ * @param pattern A MessagePattern.
+ * @param partIndex the index of the first ChoiceFormat argument style part.
+ * @param number a number to be mapped to one of the ChoiceFormat argument's intervals
+ * @return the sub-message start part index.
+ */
+ static int32_t findSubMessage(const MessagePattern &pattern, int32_t partIndex, double number);
+
+ static double parseArgument(
+ const MessagePattern &pattern, int32_t partIndex,
+ const UnicodeString &source, ParsePosition &pos);
+
+ /**
+ * Matches the pattern string from the end of the partIndex to
+ * the beginning of the limitPartIndex,
+ * including all syntax except SKIP_SYNTAX,
+ * against the source string starting at sourceOffset.
+ * If they match, returns the length of the source string match.
+ * Otherwise returns -1.
+ */
+ static int32_t matchStringUntilLimitPart(
+ const MessagePattern &pattern, int32_t partIndex, int32_t limitPartIndex,
+ const UnicodeString &source, int32_t sourceOffset);
+
+ /**
+ * Some of the ChoiceFormat constructors do not have a UErrorCode paramater.
+ * We need _some_ way to provide one for the MessagePattern constructor.
+ * Alternatively, the MessagePattern could be a pointer field, but that is
+ * not nice either.
+ */
+ UErrorCode constructorErrorCode;
+
+ /**
+ * The MessagePattern which contains the parsed structure of the pattern string.
+ *
+ * Starting with ICU 4.8, the MessagePattern contains a sequence of
+ * numeric/selector/message parts corresponding to the parsed pattern.
+ * For details see the MessagePattern class API docs.
+ */
+ MessagePattern msgPattern;
+
+ /**
+ * Docs & fields from before ICU 4.8, before MessagePattern was used.
+ * Commented out, and left only for explanation of semantics.
+ * --------
* Each ChoiceFormat divides the range -Inf..+Inf into fCount
* intervals. The intervals are:
*
@@ -713,12 +650,11 @@ private:
*
* Because of the nature of interval 0, fClosures[0] has no
* effect.
-
*/
- double* fChoiceLimits;
- UBool* fClosures;
- UnicodeString* fChoiceFormats;
- int32_t fCount;
+ // double* fChoiceLimits;
+ // UBool* fClosures;
+ // UnicodeString* fChoiceFormats;
+ // int32_t fCount;
};
inline UnicodeString&
diff --git a/icu4c/source/i18n/unicode/msgfmt.h b/icu4c/source/i18n/unicode/msgfmt.h
index 58c74f1cb1b..bc9b07cccc9 100644
--- a/icu4c/source/i18n/unicode/msgfmt.h
+++ b/icu4c/source/i18n/unicode/msgfmt.h
@@ -1,5 +1,5 @@
/*
-* Copyright (C) 2007-2010, International Business Machines Corporation and
+* Copyright (C) 2007-2011, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************************
*
@@ -28,106 +28,213 @@
#include "unicode/format.h"
#include "unicode/locid.h"
+#include "unicode/messagepattern.h"
#include "unicode/parseerr.h"
-#include "unicode/uchar.h"
+#include "unicode/plurfmt.h"
+#include "unicode/plurrule.h"
+
+U_CDECL_BEGIN
+// Forward declaration.
+struct UHashtable;
+typedef struct UHashtable UHashtable;
+U_CDECL_END
U_NAMESPACE_BEGIN
-class NumberFormat;
+class AppendableWrapper;
class DateFormat;
+class NumberFormat;
/**
+ * MessageFormat prepares strings for display to users,
+ * with optional arguments (variables/placeholders).
+ * The arguments can occur in any order, which is necessary for translation
+ * into languages with different grammars.
*
- * MessageFormat produces concatenated messages in a language-neutral
- * way. Use this whenever concatenating strings that are displayed to
- * end users.
+ *
A MessageFormat is constructed from a pattern string
+ * with arguments in {curly braces} which will be replaced by formatted values.
*
- *
A MessageFormat contains an array of subformats arranged
- * within a template string. Together, the subformats and
- * template string determine how the MessageFormat will operate during
- * formatting and parsing.
+ *
MessageFormat differs from the other Format
+ * classes in that you create a MessageFormat object with one
+ * of its constructors (not with a createInstance style factory
+ * method). Factory methods aren't necessary because MessageFormat
+ * itself doesn't implement locale-specific behavior. Any locale-specific
+ * behavior is defined by the pattern that you provide and the
+ * subformats used for inserted arguments.
*
- *
Typically, both the subformats and the template string are
- * specified at once in a pattern. By using different
- * patterns for different locales, messages may be localized.
+ *
Arguments can be named (using identifiers) or numbered (using small ASCII-digit integers).
+ * Some of the API methods work only with argument numbers and throw an exception
+ * if the pattern has named arguments (see {@link #usesNamedArguments()}).
*
- *
When formatting, MessageFormat takes an array of arguments
- * and produces a user-readable string. Each argument is a
- * Formattable object; they may be passed in in an array, or as a
- * single Formattable object which itself contains an array. Each
- * argument is matched up with its corresponding subformat, which then
- * formats it into a string. The resulting strings are then assembled
- * within the string template of the MessageFormat to produce the
- * final output string.
+ *
An argument might not specify any format type. In this case,
+ * a Number value is formatted with a default (for the locale) NumberFormat,
+ * a Date value is formatted with a default (for the locale) DateFormat,
+ * and for any other value its toString() value is used.
*
- *
Note:
- * In ICU 4.0 MessageFormat supports named arguments. If a named argument
- * is used, all arguments must be named. Names start with a character in
- * UCHAR_ID_START and continue with characters in
- * UCHARID_CONTINUE, in particular they do not start with a digit.
- * If named arguments are used, {@link #usesNamedArguments()} will return true.
+ *
An argument might specify a "simple" type for which the specified
+ * Format object is created, cached and used.
*
- *
The other new methods supporting named arguments are
- * {@link #getFormatNames(UErrorCode& status)},
- * {@link #getFormat(const UnicodeString& formatName, UErrorCode& status)}
- * {@link #setFormat(const UnicodeString& formatName, const Format& format, UErrorCode& status)},
- * {@link #adoptFormat(const UnicodeString& formatName, Format* formatToAdopt, UErrorCode& status)},
- * {@link #format(const UnicodeString* argumentNames, const Formattable* arguments,
- * int32_t count, UnicodeString& appendTo,UErrorCode& status)}.
- * These methods are all compatible with patterns that do not used named arguments--
- * in these cases the keys in the input or output use UnicodeStrings
- * that name the argument indices, e.g. "0", "1", "2"... etc.
+ *
An argument might have a "complex" type with nested MessageFormat sub-patterns.
+ * During formatting, one of these sub-messages is selected according to the argument value
+ * and recursively formatted.
*
- *
If this format uses named arguments, certain methods that take or
- * return arrays do not perform any action, since it is not possible to
- * identify positions in an array using a name. Of these methods,
- * UErrorCode is set to U_ILLEGAL_ARGUMENT_ERROR by format, and to
- * U_ARGUMENT_TYPE_MISMATCH by parse.
- * These methods are
- * {@link #adoptFormats(Format** formatsToAdopt, int32_t count)},
- * {@link #setFormats(const Format** newFormats,int32_t count)},
- * {@link #adoptFormat(int32_t n, Format *newFormat)},
- * {@link #setFormat(int32_t n, Format& newFormat)},
- * {@link #format(const Formattable* source, int32_t count, UnicodeString& appendTo, FieldPosition& ignore, UErrorCode& success)},
- * {@link #format(const UnicodeString& pattern,const Formattable* arguments,int32_t cnt,UnicodeString& appendTo,UErrorCode& success)},
- * {@link #format(const Formattable& source, UnicodeString& appendTo, FieldPosition& ignore, UErrorCode& success)},
- * {@link #format(const Formattable* arguments, int32_t cnt, UnicodeString& appendTo, FieldPosition& status, int32_t recursionProtection,UErrorCode& success)},
- * {@link #parse(const UnicodeString& source, ParsePosition& pos, int32_t& count)},
- * {@link #parse(const UnicodeString& source, int32_t& cnt, UErrorCode& status)}
+ *
After construction, a custom Format object can be set for
+ * a top-level argument, overriding the default formatting and parsing behavior
+ * for that argument.
+ * However, custom formatting can be achieved more simply by writing
+ * a typeless argument in the pattern string
+ * and supplying it with a preformatted string value.
*
- *
- * During parsing, an input string is matched against the string
- * template of the MessageFormat to produce an array of Formattable
- * objects. Plain text of the template string is matched directly
- * against input text. At each position in the template string where
- * a subformat is located, the subformat is called to parse the
- * corresponding segment of input text to produce an output argument.
- * In this way, an array of arguments is created which together
- * constitute the parse result.
- *
- * Parsing may fail or produce unexpected results in a number of
- * circumstances.
- *
+ *
When formatting, MessageFormat takes a collection of argument values + * and writes an output string. + * The argument values may be passed as an array + * (when the pattern contains only numbered arguments) + * or as an array of names and and an array of arguments (which works for both named + * and numbered arguments). + * + *
Each argument is matched with one of the input values by array index or argument name + * and formatted according to its pattern specification + * (or using a custom Format object if one was set). + * A numbered pattern argument is matched with an argument name that contains that number + * as an ASCII-decimal-digit string (without leading zero). + * + *
MessageFormat uses patterns of the following form:
+ *
+ * message = messageText (argument messageText)*
+ * argument = noneArg | simpleArg | complexArg
+ * complexArg = choiceArg | pluralArg | selectArg
+ *
+ * noneArg = '{' argNameOrNumber '}'
+ * simpleArg = '{' argNameOrNumber ',' argType [',' argStyle] '}'
+ * choiceArg = '{' argNameOrNumber ',' "choice" ',' choiceStyle '}'
+ * pluralArg = '{' argNameOrNumber ',' "plural" ',' pluralStyle '}'
+ * selectArg = '{' argNameOrNumber ',' "select" ',' selectStyle '}'
+ *
+ * choiceStyle: see {@link ChoiceFormat}
+ * pluralStyle: see {@link PluralFormat}
+ * selectStyle: see {@link SelectFormat}
+ *
+ * argNameOrNumber = argName | argNumber
+ * argName = [^[[:Pattern_Syntax:][:Pattern_White_Space:]]]+
+ * argNumber = '0' | ('1'..'9' ('0'..'9')*)
+ *
+ * argType = "number" | "date" | "time" | "spellout" | "ordinal" | "duration"
+ * argStyle = "short" | "medium" | "long" | "full" | "integer" | "currency" | "percent" | argStyleText
+ *
+ *
+ * Recommendation: Use the real apostrophe (single quote) character + * \htmlonly’\endhtmlonly (U+2019) for + * human-readable text, and use the ASCII apostrophe ' (U+0027) + * only in program syntax, like quoting in MessageFormat. + * See the annotations for U+0027 Apostrophe in The Unicode Standard. + * + *
The argType and argStyle values are used to create
+ * a Format instance for the format element. The following
+ * table shows how the values map to Format instances. Combinations not
+ * shown in the table are illegal. Any argStyleText must
+ * be a valid pattern string for the Format subclass used.
+ *
+ *
| argType + * | argStyle + * | resulting Format object + * | |||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| (none) + * | null
+ * | ||||||||||||||||||||||
number
+ * | (none) + * | NumberFormat.createInstance(getLocale(), status)
+ * | |||||||||||||||||||||
integer
+ * | NumberFormat.createInstance(getLocale(), kNumberStyle, status)
+ * | ||||||||||||||||||||||
currency
+ * | NumberFormat.createCurrencyInstance(getLocale(), status)
+ * | ||||||||||||||||||||||
percent
+ * | NumberFormat.createPercentInstance(getLocale(), status)
+ * | ||||||||||||||||||||||
| argStyleText + * | new DecimalFormat(argStyleText, new DecimalFormatSymbols(getLocale(), status), status)
+ * | ||||||||||||||||||||||
date
+ * | (none) + * | DateFormat.createDateInstance(kDefault, getLocale(), status)
+ * | |||||||||||||||||||||
short
+ * | DateFormat.createDateInstance(kShort, getLocale(), status)
+ * | ||||||||||||||||||||||
medium
+ * | DateFormat.createDateInstance(kDefault, getLocale(), status)
+ * | ||||||||||||||||||||||
long
+ * | DateFormat.createDateInstance(kLong, getLocale(), status)
+ * | ||||||||||||||||||||||
full
+ * | DateFormat.createDateInstance(kFull, getLocale(), status)
+ * | ||||||||||||||||||||||
| argStyleText + * | new SimpleDateFormat(argStyleText, getLocale(), status)
+ * | ||||||||||||||||||||||
+ * + *
Here are some examples of usage: * Example 1: + * *
* \code * UErrorCode success = U_ZERO_ERROR; @@ -148,10 +255,12 @@ class DateFormat; * // in the Force on planet 7. * \endcode *+ * * Typically, the message format will come from resources, and the * arguments will be dynamically set at runtime. - *
- * Example 2: + * + *
Example 2: + * *
* \code * success = U_ZERO_ERROR; @@ -171,122 +280,40 @@ class DateFormat; * \endcode ** - * The pattern is of the following form. Legend: - *
- * \code
- * {optional item}
- * (group that may be repeated)*
- * \endcode
- *
- * Do not confuse optional items with items inside quoted braces, such
- * as this: "{". Quoted braces are literals.
- *
- * \code
- * messageFormatPattern := string ( "{" messageFormatElement "}" string )*
*
- * messageFormatElement := argumentIndex | argumentName { "," elementFormat }
- *
- * elementFormat := "time" { "," datetimeStyle }
- * | "date" { "," datetimeStyle }
- * | "number" { "," numberStyle }
- * | "choice" "," choiceStyle
- * | "spellout" { "," spelloutStyle }
- * | "ordinal" { "," spelloutStyle }
- * | "duration" { "," spelloutStyle }
- * | "plural" "," pluralStyle
- * | "select" "," selectStyle
- *
- * datetimeStyle := "short"
- * | "medium"
- * | "long"
- * | "full"
- * | dateFormatPattern
- *
- * numberStyle := "currency"
- * | "percent"
- * | "integer"
- * | numberFormatPattern
- *
- * choiceStyle := choiceFormatPattern
- *
- * pluralStyle := pluralFormatPattern
- *
- * selectStyle := selectFormatPattern
- *
- * spelloutStyle := ruleSetName
- * \endcode
- *
- * If there is no elementFormat, then the argument must be a string,
- * which is substituted. If there is no dateTimeStyle or numberStyle,
- * then the default format is used (e.g. NumberFormat::createInstance(),
- * DateFormat::createTimeInstance(DateFormat::kDefault, ...) or
- * DateFormat::createDateInstance(DateFormat::kDefault, ...). For
- * a RuleBasedNumberFormat, if there is no ruleSetName, the default
- * rule set is used. For a ChoiceFormat or PluralFormat or SelectFormat, the pattern
- * must always be specified, since there is no default.
- * - * In strings, single quotes can be used to quote syntax characters. - * A literal single quote is represented by '', both within and outside - * of single-quoted segments. Inside a - * messageFormatElement, quotes are not removed. For example, - * {1,number,$'#',##} will produce a number format with the pound-sign - * quoted, with a result such as: "$#31,45". - *
- * If a pattern is used, then unquoted braces in the pattern, if any, - * must match: that is, "ab {0} de" and "ab '}' de" are ok, but "ab - * {0'}' de" and "ab } de" are not. - *
- *
- * The argumentIndex is a non-negative integer, which corresponds to the - * index of the arguments presented in an array to be formatted. The - * first argument has argumentIndex 0. - *
- * It is acceptable to have unused arguments in the array. With missing - * arguments, or arguments that are not of the right class for the - * specified format, a failing UErrorCode result is set. - *
- * Creating internationalized messages that include plural forms, you - * can use a PluralFormat: + *
For messages that include plural forms, you can use a plural argument: *
* \code
- * UErrorCode err = U_ZERO_ERROR;
- * UnicodeString t1("{0, plural, one{C''est # fichier} other{Ce sont # fichiers}} dans la liste.");
- * MessageFormat* msgFmt = new MessageFormat(t1, Locale("fr"), err);
- * if (U_FAILURE(err)) {
- * return err;
- * }
- *
- * Formattable args1[] = {(int32_t)0};
- * Formattable args2[] = {(int32_t)3};
- * FieldPosition ignore(FieldPosition::DONT_CARE);
+ * success = U_ZERO_ERROR;
+ * MessageFormat msgFmt(
+ * "{num_files, plural, "
+ * "=0{There are no files on disk \"{disk_name}\".}"
+ * "=1{There is one file on disk \"{disk_name}\".}"
+ * "other{There are # files on disk \"{disk_name}\".}}",
+ * Locale("en"),
+ * success);
+ * FieldPosition fpos = 0;
+ * Formattable testArgs[] = {0L, "MyDisk"};
+ * UnicodeString testArgsNames[] = {"num_files", "disk_name"};
* UnicodeString result;
- * msgFmt->format(args1, 1, result, ignore, status);
- * cout << result << endl;
- * result.remove();
- * msgFmt->format(args2, 1, result, ignore, status);
- * cout << result << endl;
- *
- * // output, with different args
- * // output: C'est 0,0 fichier dans la liste.
- * // output: Ce sont 3 fichiers dans la liste."
+ * cout << msgFmt.format(testArgs, testArgsNames, 2, result, fpos, 0, success);
+ * testArgs[0] = 3L;
+ * cout << msgFmt.format(testArgs, testArgsNames, 2, result, fpos, 0, success);
* \endcode
+ * output:
+ * There are no files on disk "MyDisk".
+ * There are 3 files on "MyDisk".
*
- * Please check PluralFormat and PluralRules for details.
- *
+ * See {@link PluralFormat} and {@link PluralRules} for details.
+ *
+ * MessageFormats are not synchronized. + * It is recommended to create separate format instances for each thread. + * If multiple threads access a format concurrently, it must be synchronized + * externally. + * + * @stable ICU 2.0 */ class U_I18N_API MessageFormat : public Format { public: @@ -331,8 +358,8 @@ public: * Constructs a new MessageFormat using the given pattern and locale. * @param pattern Pattern used to construct object. * @param newLocale The locale to use for formatting dates and numbers. - * @param parseError Struct to recieve information on position - * of error within the pattern. + * @param parseError Struct to receive information on the position + * of an error within the pattern. * @param status Input/output error code. If the * pattern cannot be parsed, set to failure code. * @stable ICU 2.0 @@ -376,15 +403,14 @@ public: virtual UBool operator==(const Format& other) const; /** - * Sets the locale. This locale is used for fetching default number or date - * format information. + * Sets the locale to be used for creating argument Format objects. * @param theLocale the new locale value to be set. * @stable ICU 2.0 */ virtual void setLocale(const Locale& theLocale); /** - * Gets the locale. This locale is used for fetching default number or date + * Gets the locale used for creating argument Format objects. * format information. * @return the locale of the object. * @stable ICU 2.0 @@ -405,8 +431,8 @@ public: * Applies the given pattern string to this message format. * * @param pattern The pattern to be applied. - * @param parseError Struct to recieve information on position - * of error within pattern. + * @param parseError Struct to receive information on the position + * of an error within the pattern. * @param status Input/output error code. If the * pattern cannot be parsed, set to failure code. * @stable ICU 2.0 @@ -415,6 +441,37 @@ public: UParseError& parseError, UErrorCode& status); + /** + * Sets the UMessagePatternApostropheMode and the pattern used by this message format. + * Parses the pattern and caches Format objects for simple argument types. + * Patterns and their interpretation are specified in the + * class description. + *
+ * This method is best used only once on a given object to avoid confusion about the mode,
+ * and after constructing the object with an empty pattern string to minimize overhead.
+ *
+ * @param pattern The pattern to be applied.
+ * @param aposMode The new apostrophe mode.
+ * @param parseError Struct to receive information on the position
+ * of an error within the pattern.
+ * Can be NULL.
+ * @param status Input/output error code. If the
+ * pattern cannot be parsed, set to failure code.
+ * @draft ICU 4.8
+ */
+ virtual void applyPattern(const UnicodeString& pattern,
+ UMessagePatternApostropheMode aposMode,
+ UParseError* parseError,
+ UErrorCode& status);
+
+ /**
+ * @return this instance's UMessagePatternApostropheMode.
+ * @draft ICU 4.8
+ */
+ UMessagePatternApostropheMode getApostropheMode() const {
+ return msgPattern.getApostropheMode();
+ }
+
/**
* Returns a pattern that can be used to recreate this object.
*
@@ -490,7 +547,7 @@ public:
/**
* Gets format names. This function returns formatNames in StringEnumerations
* which can be used with getFormat() and setFormat() to export formattable
- * array from current MessageFormat to another. It is caller's resposibility
+ * array from current MessageFormat to another. It is the caller's responsibility
* to delete the returned formatNames.
* @param status output param set to success/failure code.
* @stable ICU 4.0
@@ -747,6 +804,7 @@ public:
static UnicodeString autoQuoteApostrophe(const UnicodeString& pattern,
UErrorCode& status);
+
/**
* Returns true if this MessageFormat uses named arguments,
* and false otherwise. See class description.
@@ -795,33 +853,44 @@ public:
*/
static UClassID U_EXPORT2 getStaticClassID(void);
+ /**
+ * Compares two Format objects. This is used for constructing the hash
+ * tables.
+ *
+ * @param left pointer to a Format object. Must not be NULL.
+ * @param right pointer to a Format object. Must not be NULL.
+ *
+ * @return whether the two objects are the same
+ * @internal
+ */
+ static UBool equalFormats(const void* left, const void* right);
+
private:
Locale fLocale;
- UnicodeString fPattern;
+ MessagePattern msgPattern;
Format** formatAliases; // see getFormats
int32_t formatAliasesCapacity;
- UProperty idStart;
- UProperty idContinue;
MessageFormat(); // default constructor not implemented
- /*
- * A structure representing one subformat of this MessageFormat.
- * Each subformat has a Format object, an offset into the plain
- * pattern text fPattern, and an argument number. The argument
- * number corresponds to the array of arguments to be formatted.
- * @internal
- */
- class Subformat;
+ /**
+ * This provider helps defer instantiation of a PluralRules object
+ * until we actually need to select a keyword.
+ * For example, if the number matches an explicit-value selector like "=1"
+ * we do not need any PluralRules.
+ */
+ class PluralSelectorProvider : public PluralFormat::PluralSelector {
+ public:
+ PluralSelectorProvider(const Locale* loc);
+ virtual ~PluralSelectorProvider();
+ virtual UnicodeString select(double number, UErrorCode& ec) const;
- /**
- * A MessageFormat contains an array of subformats. This array
- * needs to grow dynamically if the MessageFormat is modified.
- */
- Subformat* subformats;
- int32_t subformatCount;
- int32_t subformatCapacity;
+ void reset(const Locale* loc);
+ private:
+ const Locale* locale;
+ PluralRules* rules;
+ };
/**
* A MessageFormat formats an array of arguments. Each argument
@@ -836,14 +905,14 @@ private:
int32_t argTypeCapacity;
/**
- * Is true iff all argument names are non-negative numbers.
- *
- */
- UBool isArgNumeric;
+ * TRUE if there are different argTypes for the same argument.
+ * This only matters when the MessageFormat is used in the plain C (umsg_xxx) API
+ * where the pattern argTypes determine how the va_arg list is read.
+ */
+ UBool hasArgTypeConflicts;
// Variable-size array management
- UBool allocateSubformats(int32_t capacity);
- UBool allocateArgTypes(int32_t capacity);
+ UBool allocateArgTypes(int32_t capacity, UErrorCode& status);
/**
* Default Format objects used when no format is specified and a
@@ -855,6 +924,11 @@ private:
NumberFormat* defaultNumberFormat;
DateFormat* defaultDateFormat;
+ UHashtable* cachedFormatters;
+ UHashtable* customFormatArgStarts;
+
+ PluralSelectorProvider pluralProvider;
+
/**
* Method to retrieve default formats (or NULL on failure).
* These are semantically const, but may modify *this.
@@ -872,57 +946,93 @@ private:
const UChar * const *list);
/**
- * Formats the array of arguments and copies the result into the
- * result buffer, updates the field position.
- *
- * @param arguments The formattable objects array.
- * @param cnt The array count.
- * @param appendTo Output parameter to receive result.
- * Result is appended to existing contents.
- * @param status Field position status.
- * @param recursionProtection
- * Initially zero. Bits 0..9 are used to indicate
- * that a parameter has already been seen, to
- * avoid recursion. Currently unused.
- * @param success The error code status.
- * @return Reference to 'appendTo' parameter.
+ * Thin wrapper around the format(... AppendableWrapper ...) variant.
+ * Wraps the destination UnicodeString into an AppendableWrapper and
+ * supplies default values for some other parameters.
*/
- UnicodeString& format( const Formattable* arguments,
- int32_t cnt,
- UnicodeString& appendTo,
- FieldPosition& status,
- int32_t recursionProtection,
- UErrorCode& success) const;
+ UnicodeString& format(const Formattable* arguments,
+ const UnicodeString *argumentNames,
+ int32_t cnt,
+ UnicodeString& appendTo,
+ FieldPosition* pos,
+ UErrorCode& status) const;
- UnicodeString& format( const Formattable* arguments,
- const UnicodeString *argumentNames,
- int32_t cnt,
- UnicodeString& appendTo,
- FieldPosition& status,
- int32_t recursionProtection,
- UErrorCode& success) const;
+ /**
+ * Formats the arguments and writes the result into the
+ * AppendableWrapper, updates the field position.
+ *
+ * @param msgStart Index to msgPattern part to start formatting from.
+ * @param pluralNumber Zero except when formatting a plural argument sub-message
+ * where a '#' is replaced by the format string for this number.
+ * @param arguments The formattable objects array. (Must not be NULL.)
+ * @param argumentNames NULL if numbered values are used. Otherwise the same
+ * length as "arguments", and each entry is the name of the
+ * corresponding argument in "arguments".
+ * @param cnt The length of arguments (and of argumentNames if that is not NULL).
+ * @param appendTo Output parameter to receive the result.
+ * The result string is appended to existing contents.
+ * @param pos Field position status.
+ * @param success The error code status.
+ */
+ void format(int32_t msgStart,
+ double pluralNumber,
+ const Formattable* arguments,
+ const UnicodeString *argumentNames,
+ int32_t cnt,
+ AppendableWrapper& appendTo,
+ FieldPosition* pos,
+ UErrorCode& success) const;
- void makeFormat(int32_t offsetNumber,
- UnicodeString* segments,
- UParseError& parseError,
- UErrorCode& success);
+ UnicodeString getArgName(int32_t partIndex);
+
+ void setArgStartFormat(int32_t argStart, Format* formatter, UErrorCode& status);
+
+ void setCustomArgStartFormat(int32_t argStart, Format* formatter, UErrorCode& status);
+
+ int32_t nextTopLevelArgStart(int32_t partIndex) const;
+
+ bool argNameMatches(int32_t partIndex, const UnicodeString& argName, int32_t argNumber);
+
+ void cacheExplicitFormats(UErrorCode& status);
+
+ Format* createAppropriateFormat(UnicodeString& type,
+ UnicodeString& style,
+ Formattable::Type& formattableType,
+ UParseError& parseError,
+ UErrorCode& ec);
+
+ const Formattable* getArgFromListByName(const Formattable* arguments,
+ const UnicodeString *argumentNames,
+ int32_t cnt, UnicodeString& name) const;
+
+ Formattable* parse(int32_t msgStart,
+ const UnicodeString& source,
+ ParsePosition& pos,
+ int32_t& count,
+ UErrorCode& ec) const;
+
+ FieldPosition* updateMetaData(AppendableWrapper& dest, int32_t prevLength,
+ FieldPosition* fp, const Formattable* argId) const;
+
+ Format* getCachedFormatter(int32_t argumentNumber) const;
+
+ UnicodeString getLiteralStringUntilNextArgument(int32_t from) const;
+
+ void copyObjects(const MessageFormat& that, UErrorCode& ec);
+
+ void formatComplexSubMessage(int32_t msgStart,
+ double pluralNumber,
+ const Formattable* arguments,
+ const UnicodeString *argumentNames,
+ int32_t cnt,
+ AppendableWrapper& appendTo,
+ UErrorCode& success) const;
/**
* Convenience method that ought to be in NumberFormat
*/
NumberFormat* createIntegerFormat(const Locale& locale, UErrorCode& status) const;
- /**
- * Checks the range of the source text to quote the special
- * characters, { and ' and copy to target buffer.
- * @param source
- * @param start the text offset to start the process of in the source string
- * @param end the text offset to end the process of in the source string
- * @param appendTo Output parameter to receive result.
- * Result is appended to existing contents.
- */
- static void copyAndFixQuotes(const UnicodeString& appendTo, int32_t start, int32_t end, UnicodeString& target);
-
/**
* Returns array of argument types in the parsed pattern
* for use in C API. Only for the use of umsg_vformat(). Not
@@ -937,11 +1047,25 @@ private:
}
/**
- * Returns FALSE if the argument name is not legal.
- * @param argName argument name.
- * @return TRUE if the argument name is legal, otherwise return FALSE.
+ * Resets the internal MessagePattern, and other associated caches.
*/
- UBool isLegalArgName(const UnicodeString& argName) const;
+ void resetPattern();
+
+ // A DummyFormatter that we use solely to store a NULL value. UHash does
+ // not support storing NULL values.
+ class U_I18N_API DummyFormat : public Format {
+ public:
+ virtual UBool operator==(const Format&) const;
+ virtual Format* clone() const;
+ virtual UnicodeString& format(const Formattable&,
+ UnicodeString& appendTo,
+ FieldPosition&,
+ UErrorCode& status) const;
+ virtual void parseObject(const UnicodeString&,
+ Formattable&,
+ ParsePosition&) const;
+ virtual UClassID getDynamicClassID() const;
+ };
friend class MessageFormatAdapter; // getFormatTypeList() access
};
@@ -953,6 +1077,7 @@ MessageFormat::format(const Formattable& obj,
return Format::format(obj, appendTo, status);
}
+
U_NAMESPACE_END
#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/icu4c/source/i18n/unicode/plurfmt.h b/icu4c/source/i18n/unicode/plurfmt.h
index 35a6172bbb1..b55fb61fe0b 100644
--- a/icu4c/source/i18n/unicode/plurfmt.h
+++ b/icu4c/source/i18n/unicode/plurfmt.h
@@ -1,6 +1,6 @@
/*
*******************************************************************************
-* Copyright (C) 2007-2010, International Business Machines Corporation and
+* Copyright (C) 2007-2011, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*
@@ -25,6 +25,7 @@
#if !UCONFIG_NO_FORMATTING
+#include "unicode/messagepattern.h"
#include "unicode/numfmt.h"
#include "unicode/plurrule.h"
@@ -37,7 +38,7 @@ class Hashtable;
* PluralFormat supports the creation of internationalized
* messages with plural inflection. It is based on plural
* selection, i.e. the caller specifies messages for each
- * plural case that can appear in the users language and the
+ * plural case that can appear in the user's language and the
* PluralFormat selects the appropriate message based on
* the number.
*
ChoiceFormat is not adequate.
* @@ -62,17 +63,20 @@ class Hashtable; * conditions for a plural case than just a single interval. These plural * rules define both what plural cases exist in a language, and to * which numbers these cases apply. - *
PluralFormat+ *
Note: Typically, plural formatting is done via MessageFormat
+ * with a plural argument type,
+ * rather than using a stand-alone PluralFormat.
+ *
* This discussion assumes that you use PluralFormat with
* a predefined set of plural rules. You can create one using one of
* the constructors that takes a locale object. To
@@ -85,82 +89,46 @@ class Hashtable;
*
* The pattern text defines the message output for each plural case of the
- * used locale. The pattern is a sequence of
- * caseKeyword{message} clauses, separated by white
- * space characters. Each clause assigns the message message
- * to the plural case identified by caseKeyword.
- *
- * There are 6 predefined casekeyword in ICU - 'zero', 'one', 'two', 'few', 'many' and
- * 'other'. You always have to define a message text for the default plural case
- * "other" which is contained in every rule set. If the plural
- * rules of the PluralFormat object do not contain a plural case
- * identified by caseKeyword, U_DEFAULT_KEYWORD_MISSING
- * will be set to status.
- * If you do not specify a message text for a particular plural case, the
- * message text of the plural case "other" gets assigned to this
- * plural case. If you specify more than one message for the same plural case,
- * U_DUPLICATE_KEYWORD will be set to status.
- *
- * Spaces between caseKeyword and
- * message will be ignored; spaces within
- * message will be preserved.
- *
- * The message text for a particular plural case may contain other message
- * format patterns. PluralFormat preserves these so that you
- * can use the strings produced by PluralFormat with other
- * formatters. If you are using PluralFormat inside a
- * MessageFormat pattern, MessageFormat will
- * automatically evaluate the resulting format pattern.
- * Thus, curly braces ({, }) are only allowed
- * in message texts to define a nested format pattern.
- * The pound sign (#) will be interpreted as the number placeholder
- * in the message text, if it is not contained in curly braces (to preserve
- * NumberFormat patterns). PluralFormat will
- * replace each of those pound signs by the number passed to the
- * format() method. It will be formatted using a
- * NumberFormat for the PluralFormat's locale. If you
- * need special number formatting, you have to explicitly specify a
- * NumberFormat for the PluralFormat to use.
- *
- * \code
- * UErrorCode status = U_ZERO_ERROR;
- * MessageFormat* msgFmt = new MessageFormat(UnicodeString("{0, plural,
- * one{{0, number, C''est #,##0.0# fichier}} other {Ce sont # fichiers}} dans la liste."),
- * Locale("fr"), status);
- * if (U_FAILURE(status)) {
- * return;
- * }
- * Formattable args1[] = {(int32_t)0};
- * Formattable args2[] = {(int32_t)3};
- * FieldPosition ignore(FieldPosition::DONT_CARE);
- * UnicodeString result;
- * msgFmt->format(args1, 1, result, ignore, status);
- * cout << result << endl;
- * result.remove();
- * msgFmt->format(args2, 1, result, ignore, status);
- * cout << result << endl;
- * \endcode
+ * pluralStyle = [offsetValue] (selector '{' message '}')+
+ * offsetValue = "offset:" number
+ * selector = explicitValue | keyword
+ * explicitValue = '=' number // adjacent, no white space in between
+ * keyword = [^[[:Pattern_Syntax:][:Pattern_White_Space:]]]+
+ * message: see {@link MessageFormat}
*
- * Produces the output:C'est 0,0 fichier dans la liste.Ce sont 3 fichiers dans la liste.
- *
- * Note:
- * Currently PluralFormat
- * does not make use of quotes like MessageFormat.
- * If you use plural format strings with MessageFormat and want
- * to use a quote sign ', you have to write ''.
- * MessageFormat unquotes this pattern and passes the unquoted
- * pattern to PluralFormat. It's a bit trickier if you use
- * nested formats that do quoting. In the example above, we wanted to insert
- * ' in the number format pattern. Since
- * NumberFormat supports quotes, we had to insert
- * ''. But since MessageFormat unquotes the
- * pattern before it gets passed to PluralFormat, we have to
- * double these quotes, i.e. write ''''.
+ * Pattern_White_Space between syntax elements is ignored, except
+ * between the {curly braces} and their sub-message,
+ * and between the '=' and the number of an explicitValue.
+ *
+ *
+ * There are 6 predefined casekeyword in CLDR/ICU - 'zero', 'one', 'two', 'few', 'many' and
+ * 'other'. You always have to define a message text for the default plural case
+ * other which is contained in every rule set.
+ * If you do not specify a message text for a particular plural case, the
+ * message text of the plural case other gets assigned to this
+ * plural case.
+ *
+ * When formatting, the input number is first matched against the explicitValue clauses.
+ * If there is no exact-number match, then a keyword is selected by calling
+ * the PluralRules with the input number minus the offset.
+ * (The offset defaults to 0 if it is omitted from the pattern string.)
+ * If there is no clause with that keyword, then the "other" clauses is returned.
+ *
+ * An unquoted pound sign (#) in the selected sub-message
+ * itself (i.e., outside of arguments nested in the sub-message)
+ * is replaced by the input number minus the offset.
+ * The number-minus-offset value is formatted using a
+ * NumberFormat for the PluralFormat's locale. If you
+ * need special number formatting, you have to use a MessageFormat
+ * and explicitly specify a NumberFormat argument.
+ * Note: That argument is formatting without subtracting the offset!
+ * If you need a custom format and have a non-zero offset, then you need to pass the
+ * number-minus-offset value as a separate parameter.
*
If you need to use PluralFormat with custom rules, you can
* create a PluralRules object and pass it to
@@ -511,34 +479,63 @@ public:
*/
virtual UClassID getDynamicClassID() const;
-private:
- typedef enum fmtToken {
- none,
- tLetter,
- tNumber,
- tSpace,
- tNumberSign,
- tLeftBrace,
- tRightBrace
- }fmtToken;
+ private:
+
+ class PluralSelector {
+ public:
+ /**
+ * Given a number, returns the appropriate PluralFormat keyword.
+ *
+ * @param number The number to be plural-formatted.
+ * @param ec Error code.
+ * @return The selected PluralFormat keyword.
+ */
+ virtual UnicodeString select(double number, UErrorCode& ec) const = 0;
+ };
+
+ class PluralSelectorAdapter : public PluralSelector {
+ public:
+ PluralSelectorAdapter() : pluralRules(NULL) {
+ }
+
+ virtual ~PluralSelectorAdapter();
+
+ virtual UnicodeString select(double number, UErrorCode& /*ec*/) const;
+
+ void reset();
+
+ PluralRules* pluralRules;
+ };
Locale locale;
- PluralRules* pluralRules;
- UnicodeString pattern;
- Hashtable *fParsedValuesHash;
+ MessagePattern msgPattern;
NumberFormat* numberFormat;
- NumberFormat* replacedNumberFormat;
+ double offset;
+ PluralSelectorAdapter pluralRulesWrapper;
PluralFormat(); // default constructor not implemented
- void init(const PluralRules* rules, const Locale& curlocale, UErrorCode& status);
- UBool inRange(UChar ch, fmtToken& type);
- UBool checkSufficientDefinition();
- void parsingFailure();
- UnicodeString insertFormattedNumber(double number,
- UnicodeString& message,
- UnicodeString& appendTo,
- FieldPosition& pos) const;
- void copyHashtable(Hashtable *other, UErrorCode& status);
+ void init(const PluralRules* rules, UErrorCode& status);
+ /**
+ * Copies dynamically allocated values (pointer fields).
+ * Others are copied using their copy constructors and assignment operators.
+ */
+ void copyObjects(const PluralFormat& other);
+
+ /**
+ * Finds the PluralFormat sub-message for the given number, or the "other" sub-message.
+ * @param pattern A MessagePattern.
+ * @param partIndex the index of the first PluralFormat argument style part.
+ * @param selector the PluralSelector for mapping the number (minus offset) to a keyword.
+ * @param number a number to be matched to one of the PluralFormat argument's explicit values,
+ * or mapped via the PluralSelector.
+ * @param ec ICU error code.
+ * @return the sub-message start part index.
+ */
+ static int32_t findSubMessage(
+ const MessagePattern& pattern, int32_t partIndex,
+ const PluralSelector& selector, double number, UErrorCode& ec);
+
+ friend class MessageFormat;
};
U_NAMESPACE_END
diff --git a/icu4c/source/i18n/unicode/plurrule.h b/icu4c/source/i18n/unicode/plurrule.h
index b96bbb57b7c..c0a5dace819 100644
--- a/icu4c/source/i18n/unicode/plurrule.h
+++ b/icu4c/source/i18n/unicode/plurrule.h
@@ -84,15 +84,18 @@ class PluralKeywordEnumeration;
* \endcode
*
- * The difference between 'in' and 'within' is that 'in' only includes - * integers in the specified range, while 'within' includes all values.
- *- * Keywords - * could be defined by users or from ICU locale data. There are 6 - * predefined values in ICU - 'zero', 'one', 'two', 'few', 'many' and - * 'other'. Callers need to check the value of keyword returned by - * {@link #select} method. - *
+ * An "identifier" is a sequence of characters that do not have the + * Unicode Pattern_Syntax or Pattern_White_Space properties. + *+ * The difference between 'in' and 'within' is that 'in' only includes + * integers in the specified range, while 'within' includes all values.
+ *+ * Keywords + * could be defined by users or from ICU locale data. There are 6 + * predefined values in ICU - 'zero', 'one', 'two', 'few', 'many' and + * 'other'. Callers need to check the value of keyword returned by + * {@link #select} method. + *
* * Examples:* UnicodeString keyword = pl->select(number); diff --git a/icu4c/source/i18n/unicode/selfmt.h b/icu4c/source/i18n/unicode/selfmt.h index e53f4ce633c..29b78f427be 100755 --- a/icu4c/source/i18n/unicode/selfmt.h +++ b/icu4c/source/i18n/unicode/selfmt.h @@ -1,6 +1,6 @@ /******************************************************************** * COPYRIGHT: - * Copyright (c) 1997-2010, International Business Machines Corporation and + * Copyright (c) 1997-2011, International Business Machines Corporation and * others. All Rights Reserved. * Copyright (C) 2010 , Yahoo! Inc. ******************************************************************** @@ -16,8 +16,9 @@ #ifndef SELFMT #define SELFMT -#include "unicode/utypes.h" +#include "unicode/messagepattern.h" #include "unicode/numfmt.h" +#include "unicode/utypes.h" /** * \file @@ -28,7 +29,7 @@ U_NAMESPACE_BEGIN -class Hashtable; +class MessageFormat; /** *
SelectFormatsupports the creation of internationalized @@ -40,6 +41,10 @@ class Hashtable; * *Using
* + *SelectFormatfor Gender AgreementNote: Typically, select formatting is done via
+ * *MessageFormat+ * with aselectargument type, + * rather than using a stand-aloneSelectFormat.The main use case for the select format is gender based inflection. * When names or nouns are inserted into sentences, their gender can affect pronouns, * verb forms, articles, and adjectives. Special care needs to be @@ -73,6 +78,9 @@ class Hashtable; * but similar in grammatical use. * Some African languages have around 20 noun classes.
* + *Note:For the gender of a person in a given sentence, + * we usually need to distinguish only between female, male and other/unknown.
+ * *To enable localizers to create sentence patterns that take their * language's gender dependencies into consideration, software has to provide * information about the gender associated with a noun or name to @@ -81,8 +89,8 @@ class Hashtable; * *
{0} went to {2}.
*
+ * Note: The entire sentence should be included (and partially repeated) + * inside each phrase. Otherwise translators would have to be trained on how to + * move bits of the sentence in and out of the select argument of a message. + * (The examples below do not follow this recommendation!)
+ * *The sentence pattern for French, where the gender of the person affects * the form of the participle, uses a select format based on argument 1:
* @@ -121,39 +134,24 @@ class Hashtable; * *The SelectFormat pattern text defines the phrase output
+ *
The SelectFormat pattern string defines the phrase output
* for each user-defined keyword.
- * The pattern is a sequence of keyword{phrase}
- * clauses.
- * Each clause assigns the phrase phrase
- * to the user-defined keyword.
Keywords must match the pattern [a-zA-Z][a-zA-Z0-9_-]*; keywords
- * that don't match this pattern result in the error code
- * U_ILLEGAL_CHARACTER.
- * You always have to define a phrase for the default keyword
+ *
Each message is a MessageFormat pattern string enclosed in {curly braces}.
+ * + *You always have to define a phrase for the default keyword
* other; this phrase is returned when the keyword
* provided to
* the format method matches no other keyword.
* If a pattern does not provide a phrase for other, the method
* it's provided to returns the error U_DEFAULT_KEYWORD_MISSING.
- * If a pattern provides more than one phrase for the same keyword, the
- * error U_DUPLICATE_KEYWORD is returned.
*
- * Spaces between keyword and
- * {phrase} will be ignored; spaces within
- * {phrase} will be preserved.
+ * Pattern_White_Space between keywords and messages is ignored. + * Pattern_White_Space within a message is preserved and output.
* - *The phrase for a particular select case may contain other message
- * format patterns. SelectFormat preserves these so that you
- * can use the strings produced by SelectFormat with other
- * formatters. If you are using SelectFormat inside a
- * MessageFormat pattern, MessageFormat will
- * automatically evaluate the resulting format pattern.
- * Thus, curly braces ({, }) are only allowed
- * in phrases to define a nested format pattern.
Example: + *
Example:
* \htmlonly
*
* UErrorCode status = U_ZERO_ERROR;
@@ -342,31 +340,22 @@ public:
virtual UClassID getDynamicClassID() const;
private:
- typedef enum classesForSelectFormat{
- tStartKeyword,
- tContinueKeyword,
- tLeftBrace,
- tRightBrace,
- tSpace,
- tOther
- }CharacterClass;
-
- UnicodeString pattern;
- //Hash to store the keyword, phrase pairs.
- Hashtable *parsedValuesHash;
+ friend class MessageFormat;
SelectFormat(); // default constructor not implemented.
- void initHashTable(UErrorCode &status);
- void cleanHashTable();
- //For the applyPattern , classifies char.s in one of the characterClass.
- CharacterClass classifyCharacter(UChar ch) const;
- //Checks if the "other" keyword is present in pattern.
- UBool checkSufficientDefinition();
- //Checks if the keyword passed is valid.
- UBool checkValidKeyword(const UnicodeString& argKeyword) const;
- void parsingFailure();
- void copyHashtable(Hashtable *other, UErrorCode& status);
+ /**
+ * Finds the SelectFormat sub-message for the given keyword, or the "other" sub-message.
+ * @param pattern A MessagePattern.
+ * @param partIndex the index of the first SelectFormat argument style part.
+ * @param keyword a keyword to be matched to one of the SelectFormat argument's keywords.
+ * @param ec Error code.
+ * @return the sub-message start part index.
+ */
+ static int32_t findSubMessage(const MessagePattern& pattern, int32_t partIndex,
+ const UnicodeString& keyword, UErrorCode& ec);
+
+ MessagePattern msgPattern;
};
U_NAMESPACE_END
diff --git a/icu4c/source/i18n/unicode/umsg.h b/icu4c/source/i18n/unicode/umsg.h
index 7d08fd3b79b..52fe90e2d6a 100644
--- a/icu4c/source/i18n/unicode/umsg.h
+++ b/icu4c/source/i18n/unicode/umsg.h
@@ -1,6 +1,6 @@
/********************************************************************
* COPYRIGHT:
- * Copyright (c) 1997-2010, International Business Machines Corporation and
+ * Copyright (c) 1997-2011, International Business Machines Corporation and
* others. All Rights Reserved.
* Copyright (C) 2010 , Yahoo! Inc.
********************************************************************
@@ -13,7 +13,6 @@
* Change history:
*
* 08/5/2001 Ram Added C wrappers for C++ API.
- *
********************************************************************/
#ifndef UMSG_H
@@ -27,19 +26,30 @@
#include "unicode/uloc.h"
#include "unicode/parseerr.h"
#include
+
/**
* \file
* \brief C API: MessageFormat
*
- * Message Format C API
+ * MessageFormat C API
*
- * Provides means to produce concatenated messages in language-neutral way.
- * Use this for all concatenations that show up to end users.
- *
- * Takes a set of objects, formats them, then inserts the formatted
- * strings into the pattern at the appropriate places.
- *
- * Here are some examples of usage:
+ *
MessageFormat prepares strings for display to users,
+ * with optional arguments (variables/placeholders).
+ * The arguments can occur in any order, which is necessary for translation
+ * into languages with different grammars.
+ *
+ *
The opaque UMessageFormat type is a thin C wrapper around
+ * a C++ MessageFormat. It is constructed from a pattern string
+ * with arguments in {curly braces} which will be replaced by formatted values.
+ *
+ *
Currently, the C API supports only numbered arguments.
+ *
+ *
For details about the pattern syntax and behavior,
+ * especially about the ASCII apostrophe vs. the
+ * real apostrophe (single quote) character \htmlonly’\endhtmlonly (U+2019),
+ * see the C++ MessageFormat class documentation.
+ *
+ *
Here are some examples of C API usage:
* Example 1:
*
* \code
@@ -143,102 +153,6 @@
* }
* \endcode
*
- *
-
- * The pattern is of the following form. Legend:
- *
- * \code
- * {optional item}
- * (group that may be repeated)*
- * \endcode
- *
- * Do not confuse optional items with items inside quotes braces, such
- * as this: "{". Quoted braces are literals.
- *
- * \code
- * messageFormatPattern := string ( "{" messageFormatElement "}" string )*
- *
- * messageFormatElement := argument { "," elementFormat }
- *
- * elementFormat := "time" { "," datetimeStyle }
- * | "date" { "," datetimeStyle }
- * | "number" { "," numberStyle }
- * | "choice" "," choiceStyle
- * | "select" "," selectStyle
- *
- * datetimeStyle := "short"
- * | "medium"
- * | "long"
- * | "full"
- * | dateFormatPattern
- *
- * numberStyle := "currency"
- * | "percent"
- * | "integer"
- * | numberFormatPattern
- *
- * choiceStyle := choiceFormatPattern
- *
- * selectStyle := selectFormatPattern
- * \endcode
- *
- * If there is no elementFormat, then the argument must be a string,
- * which is substituted. If there is no dateTimeStyle or numberStyle,
- * then the default format is used (e.g. NumberFormat.getInstance(),
- * DateFormat.getDefaultTime() or DateFormat.getDefaultDate(). For
- * a ChoiceFormat, the pattern must always be specified, since there
- * is no default.
- *
- * In strings, single quotes can be used to quote the "{" sign if
- * necessary. A real single quote is represented by ''. Inside a
- * messageFormatElement, quotes are [not] removed. For example,
- * {1,number,$'#',##} will produce a number format with the pound-sign
- * quoted, with a result such as: "$#31,45".
- *
- * If a pattern is used, then unquoted braces in the pattern, if any,
- * must match: that is, "ab {0} de" and "ab '}' de" are ok, but "ab
- * {0'}' de" and "ab } de" are not.
- *
- *
- Warning:
- The rules for using quotes within message
- * format patterns unfortunately have shown to be somewhat confusing.
- * In particular, it isn't always obvious to localizers whether single
- * quotes need to be doubled or not. Make sure to inform localizers about
- * the rules, and tell them (for example, by using comments in resource
- * bundle source files) which strings will be processed by MessageFormat.
- * Note that localizers may need to use single quotes in translated
- * strings where the original version doesn't have them.
- *
Note also that the simplest way to avoid the problem is to
- * use the real apostrophe (single quote) character U+2019 (') for
- * human-readable text, and to use the ASCII apostrophe (U+0027 ' )
- * only in program syntax, like quoting in MessageFormat.
- * See the annotations for U+0027 Apostrophe in The Unicode Standard.
- *
- *
- * The argument is a number from 0 to 9, which corresponds to the
- * arguments presented in an array to be formatted.
- *
- * It is ok to have unused arguments in the array. With missing
- * arguments or arguments that are not of the right class for the
- * specified format, a failing UErrorCode result is set.
- *
-
- *
- * [Note:] As we see above, the string produced by a choice Format in
- * MessageFormat is treated specially; occurances of '{' are used to
- * indicated subformats.
- *
- * [Note:] Formats are numbered by order of variable in the string.
- * This is [not] the same as the argument numbering!
- *
- * \code
- * For example: with "abc{2}def{3}ghi{0}...",
- *
- * format0 affects the first variable {2}
- * format1 affects the second variable {3}
- * format2 affects the second variable {0}
- * \endcode
- *
- * and so on.
*/
/**
diff --git a/icu4c/source/test/cintltst/cmsgtst.c b/icu4c/source/test/cintltst/cmsgtst.c
index 0d759105daf..9b337322b9c 100644
--- a/icu4c/source/test/cintltst/cmsgtst.c
+++ b/icu4c/source/test/cintltst/cmsgtst.c
@@ -1,6 +1,6 @@
/********************************************************************
* COPYRIGHT:
- * Copyright (c) 1997-2010, International Business Machines Corporation and
+ * Copyright (c) 1997-2011, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************
*
@@ -736,8 +736,14 @@ static void TestMsgFormatChoice(void)
str=(UChar*)malloc(sizeof(UChar) * 25);
u_uastrcpy(str, "MyDisk");
log_verbose("Testing message format with choice test #6\n:");
- /*There {0,choice,0#are no files|1#is one file|1applyPattern", possibleDataError);
tempBuffer.remove();
tempBuffer = messageFormatter->format(params, 1, tempBuffer, pos, status);
- if (tempBuffer != "Double ' Quotes 7 test and quoted {1} test plus other {2} stuff.")
+ if (tempBuffer != "Double ' Quotes 7 test and quoted {1} test plus 'other {2} stuff'.")
dataerrln("quote format test (w/ params) failed. - %s", u_errorName(status));
logln("Formatted with params : " + tempBuffer);
@@ -911,12 +913,21 @@ void MessageFormatRegressionTest::Test4142938()
*/
void MessageFormatRegressionTest::TestChoicePatternQuote()
{
+ // ICU 4.8 ChoiceFormat (like PluralFormat & SelectFormat)
+ // returns the chosen string unmodified, so that it is usable in a MessageFormat.
+ // We modified the test strings accordingly.
+ // Note: Without further formatting/trimming/etc., it is not possible
+ // to get a single apostrophe as the last character of a non-final choice sub-message
+ // because the single apostrophe before the pipe '|' would start quoted text.
+ // Normally, ChoiceFormat is used inside a MessageFormat, where a double apostrophe
+ // can be used in that case and will be formatted as a single one.
+ // (Better: Use a "real" apostrophe, U+2019.)
UnicodeString DATA [] = {
// Pattern 0 value 1 value
// {sfb} hacked - changed \u2264 to = (copied from Character Map)
- (UnicodeString)"0#can''t|1#can", (UnicodeString)"can't", (UnicodeString)"can",
- (UnicodeString)"0#'pound(#)=''#'''|1#xyz", (UnicodeString)"pound(#)='#'", (UnicodeString)"xyz",
- (UnicodeString)"0#'1<2 | 1=1'|1#''", (UnicodeString)"1<2 | 1=1", (UnicodeString)"'",
+ "0#can't|1#can", "can't", "can",
+ "0#pound(#)='#''|1#xyz", "pound(#)='#''", "xyz",
+ "0#1<2 '| 1=1'|1#'", "1<2 '| 1=1'", "'",
};
for (int i=0; i<9; i+=3) {
//try {
@@ -929,7 +940,7 @@ void MessageFormatRegressionTest::TestChoicePatternQuote()
out = cf->format((double)j, out, pos);
if (out != DATA[i+1+j])
errln("Fail: Pattern \"" + DATA[i] + "\" x "+j+" -> " +
- out + "; want \"" + DATA[i+1+j] + '"');
+ out + "; want \"" + DATA[i+1+j] + "\"");
}
UnicodeString pat;
pat = cf->toPattern(pat);
@@ -937,9 +948,9 @@ void MessageFormatRegressionTest::TestChoicePatternQuote()
ChoiceFormat *cf2 = new ChoiceFormat(pat, status);
pat2 = cf2->toPattern(pat2);
if (pat != pat2)
- errln("Fail: Pattern \"" + DATA[i] + "\" x toPattern -> \"" + pat + '"');
+ errln("Fail: Pattern \"" + DATA[i] + "\" x toPattern -> \"" + pat + "\"");
else
- logln("Ok: Pattern \"" + DATA[i] + "\" x toPattern -> \"" + pat + '"');
+ logln("Ok: Pattern \"" + DATA[i] + "\" x toPattern -> \"" + pat + "\"");
/*}
catch (IllegalArgumentException e) {
errln("Fail: Pattern \"" + DATA[i] + "\" -> " + e);
@@ -980,12 +991,12 @@ void MessageFormatRegressionTest::TestAPI() {
// Test adoptFormat
MessageFormat *fmt = new MessageFormat("",status);
- format->adoptFormat("",fmt,status);
+ format->adoptFormat("some_name",fmt,status); // Must at least pass a valid identifier.
failure(status, "adoptFormat");
// Test getFormat
format->setFormat((int32_t)0,*fmt);
- format->getFormat("",status);
+ format->getFormat("some_other_name",status); // Must at least pass a valid identifier.
failure(status, "getFormat");
delete format;
}
diff --git a/icu4c/source/test/intltest/plurfmts.cpp b/icu4c/source/test/intltest/plurfmts.cpp
index 30d1e287e3d..e1308582800 100644
--- a/icu4c/source/test/intltest/plurfmts.cpp
+++ b/icu4c/source/test/intltest/plurfmts.cpp
@@ -1,6 +1,6 @@
/********************************************************************
* COPYRIGHT:
- * Copyright (c) 2007-2010, International Business Machines Corporation and
+ * Copyright (c) 2007-2011, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
@@ -35,6 +35,8 @@ void PluralFormatTest::runIndexedTest( int32_t index, UBool exec, const char* &n
TESTCASE(0, pluralFormatBasicTest);
TESTCASE(1, pluralFormatUnitTest);
TESTCASE(2, pluralFormatLocaleTest);
+ TESTCASE(3, pluralFormatExtendedTest);
+ TESTCASE(4, pluralFormatExtendedParseTest);
default: name = "";
break;
}
@@ -159,26 +161,28 @@ void PluralFormatTest::pluralFormatUnitTest(/*char *par*/)
UNICODE_STRING_SIMPLE("odd {# is odd.} other{# is even.}"),
UNICODE_STRING_SIMPLE("other{# is odd or even.}"),
UNICODE_STRING_SIMPLE("odd{The number {0, number, #.#0} is odd.}other{The number {0, number, #.#0} is even.}"),
- UNICODE_STRING_SIMPLE("odd{The number {#} is odd.}other{The number {#} is even.}"),
+ UNICODE_STRING_SIMPLE("odd{The number {1, number, #} is odd.}other{The number {2, number, #} is even.}"),
};
UnicodeString patternOddTestResult[PLURAL_PATTERN_DATA] = {
UNICODE_STRING_SIMPLE(" is odd."),
UNICODE_STRING_SIMPLE(" is odd or even."),
UNICODE_STRING_SIMPLE("The number {0, number, #.#0} is odd."),
- UNICODE_STRING_SIMPLE("The number {#} is odd."),
+ UNICODE_STRING_SIMPLE("The number {1, number, #} is odd."),
};
UnicodeString patternEvenTestResult[PLURAL_PATTERN_DATA] = {
UNICODE_STRING_SIMPLE(" is even."),
UNICODE_STRING_SIMPLE(" is odd or even."),
UNICODE_STRING_SIMPLE("The number {0, number, #.#0} is even."),
- UNICODE_STRING_SIMPLE("The number {#} is even."),
+ UNICODE_STRING_SIMPLE("The number {2, number, #} is even."),
};
UnicodeString checkSyntaxtData[PLURAL_SYNTAX_DATA] = {
- UNICODE_STRING_SIMPLE("odd{foo} odd{bar} other{foobar}"),
- UNICODE_STRING_SIMPLE("odd{foo} other{bar} other{foobar}"),
+ // ICU 4.8 does not check for duplicate keywords any more.
+ //UNICODE_STRING_SIMPLE("odd{foo} odd{bar} other{foobar}"),
+ //UNICODE_STRING_SIMPLE("odd{foo} other{bar} other{foobar}"),
UNICODE_STRING_SIMPLE("odd{foo}"),
- UNICODE_STRING_SIMPLE("otto{foo} other{bar}"),
- UNICODE_STRING_SIMPLE("1odd{foo} other{bar}"),
+ // ICU 4.8 does not check for unknown keywords any more.
+ //UNICODE_STRING_SIMPLE("otto{foo} other{bar}"),
+ UNICODE_STRING_SIMPLE("*odd{foo} other{bar}"),
UNICODE_STRING_SIMPLE("odd{foo},other{bar}"),
UNICODE_STRING_SIMPLE("od d{foo} other{bar}"),
UNICODE_STRING_SIMPLE("odd{foo}{foobar}other{foo}"),
@@ -264,7 +268,7 @@ void PluralFormatTest::pluralFormatUnitTest(/*char *par*/)
}
numberFormatTest(&pluralFmt, numFmt, 5, 5, NULL, NULL, FALSE, &message);
pluralFmt.applyPattern(UNICODE_STRING_SIMPLE("odd__{odd} other{even}"), status);
- if (U_SUCCESS(status)) {
+ if (pluralFmt.format(1, status) != UNICODE_STRING_SIMPLE("even")) {
errln("SetLocale should reset rules but did not.");
}
status = U_ZERO_ERROR;
@@ -491,6 +495,73 @@ PluralFormatTest::pluralFormatLocaleTest(/*char *par*/)
}
}
+void
+PluralFormatTest::pluralFormatExtendedTest(void) {
+ const char *targets[] = {
+ "There are no widgets.",
+ "There is one widget.",
+ "There is a bling widget and one other widget.",
+ "There is a bling widget and 2 other widgets.",
+ "There is a bling widget and 3 other widgets.",
+ "Widgets, five (5-1=4) there be.",
+ "There is a bling widget and 5 other widgets.",
+ "There is a bling widget and 6 other widgets.",
+ };
+
+ const char* fmt =
+ "offset:1.0 "
+ "=0 {There are no widgets.} "
+ "=1.0 {There is one widget.} "
+ "=5 {Widgets, five (5-1=#) there be.} "
+ "one {There is a bling widget and one other widget.} "
+ "other {There is a bling widget and # other widgets.}";
+
+ UErrorCode status = U_ZERO_ERROR;
+ UnicodeString fmtString(fmt, -1, US_INV);
+ PluralFormat pf(fmtString, status);
+ if (U_FAILURE(status)) {
+ errln("Failed to apply pattern - %s\n", u_errorName(status));
+ return;
+ }
+ for (int i = 0; i < 7; ++i) {
+ UnicodeString result = pf.format(i, status);
+ if (U_FAILURE(status)) {
+ errln("Failed to format - %s\n", u_errorName(status));
+ }
+ UnicodeString expected(targets[i], -1, US_INV);
+ if (expected != result) {
+ UnicodeString message("Expected '", -1, US_INV);
+ message.append(expected);
+ message.append(UnicodeString("' but got '", -1, US_INV));
+ message.append(result);
+ message.append("'", -1, US_INV);
+ errln(message);
+ return;
+ }
+ }
+}
+
+void
+PluralFormatTest::pluralFormatExtendedParseTest(void) {
+ const char *failures[] = {
+ "offset:1..0 =0 {Foo}",
+ "offset:1.0 {Foo}",
+ "=0= {Foo}",
+ "=0 {Foo} =0.0 {Bar}",
+ " = {Foo}",
+ };
+ int len = sizeof(failures)/sizeof(failures[0]);
+
+ for (int i = 0; i < len; ++i) {
+ UErrorCode status = U_ZERO_ERROR;
+ UnicodeString fmt(failures[i], -1, US_INV);
+ PluralFormat pf(fmt, status);
+ if (U_SUCCESS(status)) {
+ errln("expected failure when parsing '" + fmt + "'");
+ }
+ }
+}
+
void
PluralFormatTest::numberFormatTest(PluralFormat* plFmt,
NumberFormat *numFmt,
diff --git a/icu4c/source/test/intltest/plurfmts.h b/icu4c/source/test/intltest/plurfmts.h
index d60170037bc..beea2e74308 100644
--- a/icu4c/source/test/intltest/plurfmts.h
+++ b/icu4c/source/test/intltest/plurfmts.h
@@ -1,6 +1,6 @@
/********************************************************************
* COPYRIGHT:
- * Copyright (c) 1997-2001, International Business Machines Corporation and
+ * Copyright (c) 1997-2011, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
@@ -29,6 +29,8 @@ private:
void pluralFormatBasicTest(/* char* par */);
void pluralFormatUnitTest(/* char* par */);
void pluralFormatLocaleTest(/* char* par */);
+ void pluralFormatExtendedTest();
+ void pluralFormatExtendedParseTest();
void numberFormatTest(PluralFormat* plFmt,
NumberFormat *numFmt,
int32_t start,
diff --git a/icu4c/source/test/intltest/selfmts.cpp b/icu4c/source/test/intltest/selfmts.cpp
index 46aca86c2de..3c7796d8bdb 100644
--- a/icu4c/source/test/intltest/selfmts.cpp
+++ b/icu4c/source/test/intltest/selfmts.cpp
@@ -1,6 +1,6 @@
/********************************************************************
* COPYRIGHT:
- * Copyright (c) 1997-2010, International Business Machines Corporation and
+ * Copyright (c) 1997-2011, International Business Machines Corporation and
* others. All Rights Reserved.
* Copyright (C) 2010 , Yahoo! Inc.
********************************************************************/
@@ -12,7 +12,8 @@
#include "selfmts.h"
#include "cmemory.h"
#include "unicode/selfmt.h"
-#include "stdio.h"
+
+#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
#define SIMPLE_PATTERN_STRING "feminine {feminineVerbValue} other{otherVerbValue}"
@@ -81,10 +82,8 @@ void SelectFormatTest::selectFormatUnitTest(/*char *par*/)
};
UnicodeString checkSyntaxData[SELECT_SYNTAX_DATA] = {
- UNICODE_STRING_SIMPLE("odd{foo} odd{bar} other{foobar}"),
- UNICODE_STRING_SIMPLE("odd{foo} other{bar} other{foobar}"),
UNICODE_STRING_SIMPLE("odd{foo}"),
- UNICODE_STRING_SIMPLE("1odd{foo} other{bar}"),
+ UNICODE_STRING_SIMPLE("*odd{foo} other{bar}"),
UNICODE_STRING_SIMPLE("odd{foo},other{bar}"),
UNICODE_STRING_SIMPLE("od d{foo} other{bar}"),
UNICODE_STRING_SIMPLE("odd{foo}{foobar}other{foo}"),
@@ -93,19 +92,6 @@ void SelectFormatTest::selectFormatUnitTest(/*char *par*/)
UNICODE_STRING_SIMPLE("odd{fo{o1}other{foo2}}")
};
- UErrorCode expErrorCodes[SELECT_SYNTAX_DATA]={
- U_DUPLICATE_KEYWORD,
- U_DUPLICATE_KEYWORD,
- U_DEFAULT_KEYWORD_MISSING,
- U_PATTERN_SYNTAX_ERROR,
- U_PATTERN_SYNTAX_ERROR,
- U_PATTERN_SYNTAX_ERROR,
- U_PATTERN_SYNTAX_ERROR,
- U_PATTERN_SYNTAX_ERROR,
- U_PATTERN_SYNTAX_ERROR,
- U_DEFAULT_KEYWORD_MISSING
- };
-
UErrorCode status = U_ZERO_ERROR;
VERBOSE_USTRING(SIMPLE_PATTERN);
SelectFormat* selFmt = new SelectFormat( SIMPLE_PATTERN , status);
@@ -113,7 +99,7 @@ void SelectFormatTest::selectFormatUnitTest(/*char *par*/)
dataerrln("ERROR: SelectFormat Unit Test constructor failed in unit tests.- exitting");
return;
}
-
+
// ======= Test SelectFormat pattern syntax.
logln("SelectFormat Unit Test : Testing SelectFormat pattern syntax.");
for (int32_t i=0; iapplyPattern(checkSyntaxData[i], status);
- if( status!= expErrorCodes[i] ){
- errln("\nERROR: Unexpected result - SelectFormat Unit Test failed to detect syntax error with pattern: "+checkSyntaxData[i]+" and expected status="+ u_errorName(expErrorCodes[i]) + " and resulted status="+u_errorName(status));
+ if (U_SUCCESS(status)){
+ errln("\nERROR: Unexpected result - SelectFormat Unit Test failed to detect syntax error with pattern: "+checkSyntaxData[i]);
}
}
+ // ICU 4.8 does not check for duplicate keywords any more.
+ status = U_ZERO_ERROR;
+ selFmt->applyPattern("odd{foo} odd{bar} other{foobar}", status);
+ FieldPosition format_ignore(FieldPosition::DONT_CARE);
+ UnicodeString format_result;
+ selFmt->format(UnicodeString("odd"), format_result, format_ignore, status);
+ assertEquals("should use first occurrence of the 'odd' keyword", "foo", format_result);
+ format_result.remove();
+ selFmt->applyPattern("odd{foo} other{bar} other{foobar}", status);
+ selFmt->format(UnicodeString("other"), format_result, format_ignore, status);
+ assertEquals("should use first occurrence of the 'other' keyword", "bar", format_result);
+
delete selFmt;
selFmt = NULL;
@@ -166,27 +164,31 @@ void SelectFormatTest::selectFormatUnitTest(/*char *par*/)
}
//Test with an invalid keyword
+ // one which contains Pattern_Syntax or Pattern_White_Space.
logln("SelectFormat Unit test: Testing format() with keyword method and with invalid keywords...");
status = U_ZERO_ERROR;
result.remove();
UnicodeString keywords[] = {
- "9Keyword-_", //Starts with a digit
- "-Keyword-_", //Starts with a hyphen
- "_Keyword-_", //Starts with a underscore
- "\\u00E9Keyword-_", //Starts with non-ASCII character
- "Key*word-_", //Contains a sepial character not allowed
- "*Keyword-_" //Starts with a sepial character not allowed
+ "9Keyword-_",
+ "-Keyword-_",
+ "_Keyword-_",
+ "\\u00E9Keyword-_",
+ "Key word-_",
+ " Keyword-_",
+ "Key*word-_",
+ "*Keyword-_"
};
delete selFmt;
selFmt = NULL;
selFmt = new SelectFormat( SIMPLE_PATTERN , status);
- for (int32_t i = 0; i< 6; i++ ){
+ for (int32_t i = 0; i < LENGTHOF(keywords); i++ ){
status = U_ZERO_ERROR;
selFmt->format( keywords[i], result , ignore , status);
if (!U_FAILURE(status)) {
- errln("ERROR: SelectFormat Unit test failed in format() with keyWord and with an invalid keyword as : "+ keywords[i]);
+ errln("ERROR: SelectFormat Unit test failed in format() with keyWord and with an invalid keyword as : "+
+ keywords[i]+" ("+u_errorName(status)+")");
}
}
diff --git a/icu4c/source/test/intltest/tchcfmt.cpp b/icu4c/source/test/intltest/tchcfmt.cpp
index c45ca837fb6..bd50389d4d8 100644
--- a/icu4c/source/test/intltest/tchcfmt.cpp
+++ b/icu4c/source/test/intltest/tchcfmt.cpp
@@ -1,7 +1,7 @@
/********************************************************************
* COPYRIGHT:
- * Copyright (c) 1997-2009, International Business Machines Corporation and
+ * Copyright (c) 1997-2011, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
@@ -80,11 +80,23 @@ TestChoiceFormat::TestSimpleExample( void )
}
delete formequal;
delete formnew;
-
+
//Testing getLimits()
- double *gotLimits=0;
int32_t count=0;
- gotLimits=(double*)form->getLimits(count);
+ const double *gotLimits=form->getLimits(count);
+#if 1 // ICU 4.8 deprecates and disables the ChoiceFormat getters.
+ if(count != 0 || gotLimits != NULL) {
+ errln("getLimits() returns something, should be disabled");
+ }
+ const UnicodeString *gotFormats=form->getFormats(count);
+ if(count != 0 || gotFormats != NULL) {
+ errln("getFormats() returns something, should be disabled");
+ }
+ const UBool *gotClosures=form->getClosures(count);
+ if(count != 0 || gotClosures != NULL) {
+ errln("getClosures() returns something, should be disabled");
+ }
+#else
if(count != 7){
errln("getLimits didn't update the count correctly\n");
}
@@ -93,10 +105,9 @@ TestChoiceFormat::TestSimpleExample( void )
errln((UnicodeString)"getLimits didn't get the limits correctly. Expected " + limits[ix] + " Got " + gotLimits[ix]);
}
}
- //Testing getFormat()
+ //Testing getFormats()
count=0;
- UnicodeString *gotFormats=0;
- gotFormats=(UnicodeString*)form->getFormats(count);
+ const UnicodeString *gotFormats=form->getFormats(count);
if(count != 7){
errln("getFormats didn't update the count correctly\n");
}
@@ -105,10 +116,9 @@ TestChoiceFormat::TestSimpleExample( void )
errln((UnicodeString)"getFormats didn't get the Formats correctly. Expected " + monthNames[ix] + " Got " + gotFormats[ix]);
}
}
-
-
+#endif
+
delete form;
-
}
void
@@ -216,6 +226,7 @@ TestChoiceFormat::TestComplexExample( void )
it_logln("------ additional testing in complex test ------");
it_logln();
//
+#if 0 // ICU 4.8 deprecates and disables the ChoiceFormat getters.
int32_t retCount;
const double* retLimits = fileform->getLimits( retCount );
if ((retCount == 4) && (retLimits)
@@ -238,6 +249,7 @@ TestChoiceFormat::TestComplexExample( void )
}else{
it_errln("*** getFormats unexpected result!");
}
+#endif
UnicodeString checkstr2[] = {
"There is no folder on Disk_A",
@@ -486,6 +498,7 @@ void TestChoiceFormat::TestClosures(void) {
errln("FAIL: fmt1 != fmt2");
}
+#if 0 // ICU 4.8 deprecates and disables the ChoiceFormat getters.
int32_t i;
int32_t count2 = 0;
const double *limits2 = fmt2.getLimits(count2);
@@ -507,6 +520,7 @@ void TestChoiceFormat::TestClosures(void) {
}
}
}
+#endif
// Now test both format objects
UnicodeString exp[] = {
@@ -596,6 +610,7 @@ void TestChoiceFormat::TestPatterns(void) {
1.0, "b",
1.0 + 1e-9, "c");
+#if 0 // ICU 4.8 only checks the pattern syntax, not whether the ranges make sense.
// Try an invalid pattern that isolates a single value.
// [-Inf,1.0) [1.0,1.0) [1.0,+Inf]
_testPattern("0.0#a|1.0#b|1.0#c", FALSE,
@@ -614,6 +629,7 @@ void TestChoiceFormat::TestPatterns(void) {
// [-Inf,2.0) [2.0,1.0) [1.0,+Inf]
_testPattern("0.0#a|2.0#b|1.0#c", FALSE,
0, 0, 0, 0, 0, 0);
+#endif
}
void TestChoiceFormat::TestChoiceFormatToPatternOverflow()
diff --git a/icu4c/source/test/intltest/tmsgfmt.cpp b/icu4c/source/test/intltest/tmsgfmt.cpp
index 3b08e8e66f1..dc7f291f1b4 100644
--- a/icu4c/source/test/intltest/tmsgfmt.cpp
+++ b/icu4c/source/test/intltest/tmsgfmt.cpp
@@ -1,6 +1,6 @@
/********************************************************************
* COPYRIGHT:
- * Copyright (c) 1997-2010, International Business Machines Corporation and
+ * Copyright (c) 1997-2011, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************
* File TMSGFMT.CPP
@@ -25,43 +25,46 @@
#include "unicode/msgfmt.h"
#include "unicode/numfmt.h"
#include "unicode/choicfmt.h"
+#include "unicode/messagepattern.h"
#include "unicode/selfmt.h"
#include "unicode/gregocal.h"
#include
-#define E_WITH_ACUTE ((char)0x00E9)
-static const char E_ACCENTED[]={E_WITH_ACUTE,0};
+#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
void
TestMessageFormat::runIndexedTest(int32_t index, UBool exec,
const char* &name, char* /*par*/) {
- switch (index) {
- TESTCASE(0,testBug1);
- TESTCASE(1,testBug2);
- TESTCASE(2,sample);
- TESTCASE(3,PatternTest);
- TESTCASE(4,testStaticFormat);
- TESTCASE(5,testSimpleFormat);
- TESTCASE(6,testMsgFormatChoice);
- TESTCASE(7,testCopyConstructor);
- TESTCASE(8,testAssignment);
- TESTCASE(9,testClone);
- TESTCASE(10,testEquals);
- TESTCASE(11,testNotEquals);
- TESTCASE(12,testSetLocale);
- TESTCASE(13,testFormat);
- TESTCASE(14,testParse);
- TESTCASE(15,testAdopt);
- TESTCASE(16,testCopyConstructor2);
- TESTCASE(17,TestUnlimitedArgsAndSubformats);
- TESTCASE(18,TestRBNF);
- TESTCASE(19,TestTurkishCasing);
- TESTCASE(20,testAutoQuoteApostrophe);
- TESTCASE(21,testMsgFormatPlural);
- TESTCASE(22,testCoverage);
- TESTCASE(23,testMsgFormatSelect);
- default: name = ""; break;
- }
+ TESTCASE_AUTO_BEGIN;
+ TESTCASE_AUTO(testBug1);
+ TESTCASE_AUTO(testBug2);
+ TESTCASE_AUTO(sample);
+ TESTCASE_AUTO(PatternTest);
+ TESTCASE_AUTO(testStaticFormat);
+ TESTCASE_AUTO(testSimpleFormat);
+ TESTCASE_AUTO(testMsgFormatChoice);
+ TESTCASE_AUTO(testCopyConstructor);
+ TESTCASE_AUTO(testAssignment);
+ TESTCASE_AUTO(testClone);
+ TESTCASE_AUTO(testEquals);
+ TESTCASE_AUTO(testNotEquals);
+ TESTCASE_AUTO(testSetLocale);
+ TESTCASE_AUTO(testFormat);
+ TESTCASE_AUTO(testParse);
+ TESTCASE_AUTO(testAdopt);
+ TESTCASE_AUTO(testCopyConstructor2);
+ TESTCASE_AUTO(TestUnlimitedArgsAndSubformats);
+ TESTCASE_AUTO(TestRBNF);
+ TESTCASE_AUTO(TestTurkishCasing);
+ TESTCASE_AUTO(testAutoQuoteApostrophe);
+ TESTCASE_AUTO(testMsgFormatPlural);
+ TESTCASE_AUTO(testMsgFormatSelect);
+ TESTCASE_AUTO(testApostropheInPluralAndSelect);
+ TESTCASE_AUTO(TestApostropheMode);
+ TESTCASE_AUTO(TestCompatibleApostrophe);
+ TESTCASE_AUTO(testCoverage);
+ TESTCASE_AUTO(TestTrimArgumentName);
+ TESTCASE_AUTO_END;
}
void TestMessageFormat::testBug3()
@@ -261,7 +264,9 @@ void TestMessageFormat::PatternTest()
"'{1,number,#,##}' {1,number,#,##}",
};
- UnicodeString testResultPatterns[] = {
+ // ICU 4.8 returns the original pattern (testCases),
+ // rather than toPattern() reconstituting a new, equivalent pattern string (testResultPatterns).
+ /*UnicodeString testResultPatterns[] = {
"Quotes '', '{', a {0} '{'0}",
"Quotes '', '{', a {0,number} '{'0}",
"'{'1,number,#,##} {1,number,'#'#,##}",
@@ -271,12 +276,12 @@ void TestMessageFormat::PatternTest()
"'{'1,date,full}, {1,date,full},",
"'{'3,date,full}, {3,date,full},",
"'{'1,number,#,##} {1,number,#,##}"
- };
+ };*/
UnicodeString testResultStrings[] = {
- "Quotes ', {, a 1 {0}",
- "Quotes ', {, a 1 {0}",
- "{1,number,#,##} #34,56",
+ "Quotes ', {, 'a' 1 {0}",
+ "Quotes ', {, 'a' 1 {0}",
+ "{1,number,'#',##} #34,56",
"There are 3,456 files on Disk at 1/12/70 5:46 AM.",
"On Disk, there are 3,456 files, with $1.00.",
"{1,number,percent}, 345,600%,",
@@ -298,11 +303,17 @@ void TestMessageFormat::PatternTest()
logln(((UnicodeString)"MessageFormat for ") + testCases[i] + " creation failed.\n");
continue;
}
- if (form->toPattern(buffer) != testResultPatterns[i]) {
+ // ICU 4.8 returns the original pattern (testCases),
+ // rather than toPattern() reconstituting a new, equivalent pattern string (testResultPatterns).
+ if (form->toPattern(buffer) != testCases[i]) {
+ // Note: An alternative test would be to build MessagePattern objects for
+ // both the input and output patterns and compare them, taking SKIP_SYNTAX etc.
+ // into account.
+ // (Too much trouble...)
errln(UnicodeString("TestMessageFormat::PatternTest failed test #2, i = ") + i);
//form->toPattern(buffer);
errln(((UnicodeString)" Orig: ") + testCases[i]);
- errln(((UnicodeString)" Exp: ") + testResultPatterns[i]);
+ errln(((UnicodeString)" Exp: ") + testCases[i]);
errln(((UnicodeString)" Got: ") + buffer);
}
@@ -322,7 +333,7 @@ void TestMessageFormat::PatternTest()
logln(UnicodeString(" Result: ") + result );
logln(UnicodeString(" Expected: ") + testResultStrings[i] );
}
-
+
//it_out << "Result: " << result);
#if 0
@@ -534,7 +545,7 @@ void TestMessageFormat::testMsgFormatPlural(/* char* par */)
UnicodeString t2("{argument, plural, one{C''est # fichier} other {Ce sont # fichiers}} dans la liste.");
UnicodeString t3("There {0, plural, one{is # zavod}few{are {0, number,###.0} zavoda} other{are # zavodov}} in the directory.");
UnicodeString t4("There {argument, plural, one{is # zavod}few{are {argument, number,###.0} zavoda} other{are #zavodov}} in the directory.");
- UnicodeString t5("{0, plural, one {{0, number,C''''est #,##0.0# fichier}} other {Ce sont # fichiers}} dans la liste.");
+ UnicodeString t5("{0, plural, one {{0, number,C''est #,##0.0# fichier}} other {Ce sont # fichiers}} dans la liste.");
MessageFormat* mfNum = new MessageFormat(t1, Locale("fr"), err);
if (U_FAILURE(err)) {
dataerrln("TestMessageFormat::testMsgFormatPlural #1 - argumentIndex - %s", u_errorName(err));
@@ -611,15 +622,32 @@ void TestMessageFormat::testMsgFormatPlural(/* char* par */)
errln("TestMessageFormat::test nested PluralFormat with argumentName");
}
if ( argNameResult!= UnicodeString("C'est 0,0 fichier dans la liste.")) {
- errln(UnicodeString("TestMessageFormat::test nested named PluralFormat."));
+ errln(UnicodeString("TestMessageFormat::test nested named PluralFormat: ") + argNameResult);
logln(UnicodeString("The unexpected nested named PluralFormat."));
}
delete msgFmt;
}
+void TestMessageFormat::testApostropheInPluralAndSelect() {
+ UErrorCode errorCode = U_ZERO_ERROR;
+ MessageFormat msgFmt(UNICODE_STRING_SIMPLE(
+ "abc_{0,plural,other{#'#'#'{'#''}}_def_{1,select,other{sel'}'ect''}}_xyz"),
+ Locale::getEnglish(),
+ errorCode);
+ if (U_FAILURE(errorCode)) {
+ errln("MessageFormat constructor failed - %s\n", u_errorName(errorCode));
+ return;
+ }
+ UnicodeString expected = UNICODE_STRING_SIMPLE("abc_3#3{3'_def_sel}ect'_xyz");
+ Formattable args[] = { 3, UNICODE_STRING_SIMPLE("x") };
+ internalFormat(
+ &msgFmt, args, 2, expected,
+ "MessageFormat with apostrophes in plural/select arguments failed:\n");
+}
+
void TestMessageFormat::internalFormat(MessageFormat* msgFmt ,
Formattable* args , int32_t numOfArgs ,
- UnicodeString expected ,char* errMsg)
+ UnicodeString expected, const char* errMsg)
{
UnicodeString result;
FieldPosition ignore(FieldPosition::DONT_CARE);
@@ -1236,7 +1264,12 @@ void TestMessageFormat::testAdopt()
}
assertEquals("msgCmp.toPattern()", formatStr, msgCmp.toPattern(patCmp.remove()));
- assertEquals("msg.toPattern()", formatStr, msg.toPattern(patAct.remove()));
+ // ICU 4.8 does not support toPattern() when there are custom formats (from setFormat() etc.).
+ // assertEquals("msg.toPattern()", formatStr, msg.toPattern(patAct.remove()));
+ msg.toPattern(patCmp.remove());
+ if (!patCmp.isBogus()) {
+ errln("msg.setFormat().toPattern() succeeds.");
+ }
for (i = 0; i < countAct; i++) {
a = formatsAct[i];
@@ -1279,7 +1312,8 @@ void TestMessageFormat::testAdopt()
delete[] formatsToAdopt;
assertEquals("msgCmp.toPattern()", formatStr, msgCmp.toPattern(patCmp.remove()));
- assertEquals("msg.toPattern()", formatStr, msg.toPattern(patAct.remove()));
+ // ICU 4.8 does not support toPattern() when there are custom formats (from setFormat() etc.).
+ // assertEquals("msg.toPattern()", formatStr, msg.toPattern(patAct.remove()));
formatsAct = msg.getFormats(countAct);
if (!formatsAct || (countAct <=0) || (countAct != countCmp)) {
@@ -1330,7 +1364,8 @@ void TestMessageFormat::testAdopt()
delete[] formatsToAdopt; // array itself not needed in this case;
assertEquals("msgCmp.toPattern()", formatStr, msgCmp.toPattern(patCmp.remove()));
- assertEquals("msg.toPattern()", formatStr, msg.toPattern(patAct.remove()));
+ // ICU 4.8 does not support toPattern() when there are custom formats (from setFormat() etc.).
+ // assertEquals("msg.toPattern()", formatStr, msg.toPattern(patAct.remove()));
formatsAct = msg.getFormats(countAct);
if (!formatsAct || (countAct <=0) || (countAct != countCmp)) {
@@ -1519,6 +1554,116 @@ void TestMessageFormat::TestRBNF(void) {
delete numFmt;
}
+UnicodeString TestMessageFormat::GetPatternAndSkipSyntax(const MessagePattern& pattern) {
+ UnicodeString us(pattern.getPatternString());
+ int count = pattern.countParts();
+ for (int i = count; i > 0;) {
+ const MessagePattern::Part& part = pattern.getPart(--i);
+ if (part.getType() == UMSGPAT_PART_TYPE_SKIP_SYNTAX) {
+ us.remove(part.getIndex(), part.getLimit() - part.getIndex());
+ }
+ }
+ return us;
+}
+
+void TestMessageFormat::TestApostropheMode() {
+ UErrorCode status = U_ZERO_ERROR;
+ MessagePattern *ado_mp = new MessagePattern(UMSGPAT_APOS_DOUBLE_OPTIONAL, status);
+ MessagePattern *adr_mp = new MessagePattern(UMSGPAT_APOS_DOUBLE_REQUIRED, status);
+ if (ado_mp->getApostropheMode() != UMSGPAT_APOS_DOUBLE_OPTIONAL) {
+ errln("wrong value from ado_mp->getApostropheMode().");
+ }
+ if (adr_mp->getApostropheMode() != UMSGPAT_APOS_DOUBLE_REQUIRED) {
+ errln("wrong value from adr_mp->getApostropheMode().");
+ }
+
+
+ UnicodeString tuples[] = {
+ // Desired output
+ // DOUBLE_OPTIONAL pattern
+ // DOUBLE_REQUIRED pattern (empty=same as DOUBLE_OPTIONAL)
+ "I see {many}", "I see '{many}'", "",
+ "I said {'Wow!'}", "I said '{''Wow!''}'", "",
+ "I dont know", "I dont know", "I don't know",
+ "I don't know", "I don't know", "I don''t know",
+ "I don't know", "I don''t know", "I don''t know"
+ };
+ int32_t tuples_count = LENGTHOF(tuples);
+
+ for (int i = 0; i < tuples_count; i += 3) {
+ UnicodeString& desired = tuples[i];
+ UnicodeString& ado_pattern = tuples[i + 1];
+ UErrorCode status = U_ZERO_ERROR;
+ assertEquals("DOUBLE_OPTIONAL failure",
+ desired,
+ GetPatternAndSkipSyntax(ado_mp->parse(ado_pattern, NULL, status)));
+ UnicodeString& adr_pattern = tuples[i + 2].isEmpty() ? ado_pattern : tuples[i + 2];
+ assertEquals("DOUBLE_REQUIRED failure", desired,
+ GetPatternAndSkipSyntax(adr_mp->parse(adr_pattern, NULL, status)));
+ }
+ delete adr_mp;
+ delete ado_mp;
+}
+
+
+// Compare behavior of DOUBLE_OPTIONAL (new default) and DOUBLE_REQUIRED JDK-compatibility mode.
+void TestMessageFormat::TestCompatibleApostrophe() {
+ // Message with choice argument which does not contain another argument.
+ // The JDK performs only one apostrophe-quoting pass on this pattern.
+ UnicodeString pattern = "ab{0,choice,0#1'2''3'''4''''.}yz";
+
+ UErrorCode ec = U_ZERO_ERROR;
+ MessageFormat compMsg("", Locale::getUS(), ec);
+ compMsg.applyPattern(pattern, UMSGPAT_APOS_DOUBLE_REQUIRED, NULL, ec);
+ if (compMsg.getApostropheMode() != UMSGPAT_APOS_DOUBLE_REQUIRED) {
+ errln("wrong value from compMsg.getApostropheMode().");
+ }
+
+ MessageFormat icuMsg("", Locale::getUS(), ec);
+ icuMsg.applyPattern(pattern, UMSGPAT_APOS_DOUBLE_OPTIONAL, NULL, ec);
+ if (icuMsg.getApostropheMode() != UMSGPAT_APOS_DOUBLE_OPTIONAL) {
+ errln("wrong value from icuMsg.getApostropheMode().");
+ }
+
+ Formattable zero0[] = { 0 };
+ FieldPosition fieldpos(0);
+ UnicodeString buffer1, buffer2;
+ assertEquals("incompatible ICU MessageFormat compatibility-apostrophe behavior",
+ "ab12'3'4''.yz",
+ compMsg.format(zero0, 1, buffer1, fieldpos, ec));
+ assertEquals("unexpected ICU MessageFormat double-apostrophe-optional behavior",
+ "ab1'2'3''4''.yz",
+ icuMsg.format(zero0, 1, buffer2, fieldpos, ec));
+
+ // Message with choice argument which contains a nested simple argument.
+ // The DOUBLE_REQUIRED version performs two apostrophe-quoting passes.
+ buffer1.remove();
+ buffer2.remove();
+ pattern = "ab{0,choice,0#1'2''3'''4''''.{0,number,'#x'}}yz";
+ compMsg.applyPattern(pattern, ec);
+ icuMsg.applyPattern(pattern, ec);
+ assertEquals("incompatible ICU MessageFormat compatibility-apostrophe behavior",
+ "ab1234'.0xyz",
+ compMsg.format(zero0, 1, buffer1, fieldpos, ec));
+ assertEquals("unexpected ICU MessageFormat double-apostrophe-optional behavior",
+ "ab1'2'3''4''.#x0yz",
+ icuMsg.format(zero0, 1, buffer2, fieldpos, ec));
+
+ // This part is copied over from Java tests but cannot be properly tested here
+ // because we do not have a live reference implementation with JDK behavior.
+ // The JDK ChoiceFormat itself always performs one apostrophe-quoting pass.
+ /*
+ ChoiceFormat choice = new ChoiceFormat("0#1'2''3'''4''''.");
+ assertEquals("unexpected JDK ChoiceFormat apostrophe behavior",
+ "12'3'4''.",
+ choice.format(0));
+ choice.applyPattern("0#1'2''3'''4''''.{0,number,'#x'}");
+ assertEquals("unexpected JDK ChoiceFormat apostrophe behavior",
+ "12'3'4''.{0,number,#x}",
+ choice.format(0));
+ */
+}
+
void TestMessageFormat::testAutoQuoteApostrophe(void) {
const char* patterns[] = { // pattern, expected pattern
"'", "''",
@@ -1595,7 +1740,10 @@ void TestMessageFormat::testCoverage(void) {
}
}
- msgfmt->adoptFormat("adopt", &cf, status);
+ // adoptFormat() takes ownership of the input Format object.
+ // We need to clone the stack-allocated cf so that we do not attempt to delete cf.
+ Format *cfClone = cf.clone();
+ msgfmt->adoptFormat("adopt", cfClone, status);
delete en;
delete msgfmt;
@@ -1609,18 +1757,38 @@ void TestMessageFormat::testCoverage(void) {
errln("FAIL: Unable to detect usage of named arguments.");
}
+ // Starting with ICU 4.8, we support setFormat(name, ...) and getFormatNames()
+ // on a MessageFormat without named arguments.
msgfmt->setFormat("formatName", cf, status);
- if (!U_FAILURE(status)) {
- errln("FAIL: Should fail to setFormat instead of passing.");
+ if (U_FAILURE(status)) {
+ errln("FAIL: Should work to setFormat(name, ...) regardless of pattern.");
}
status = U_ZERO_ERROR;
en = msgfmt->getFormatNames(status);
- if (!U_FAILURE(status)) {
- errln("FAIL: Should fail to get format names enumeration instead of passing.");
+ if (U_FAILURE(status)) {
+ errln("FAIL: Should work to get format names enumeration regardless of pattern.");
}
delete en;
delete msgfmt;
}
+void TestMessageFormat::TestTrimArgumentName() {
+ // ICU 4.8 allows and ignores white space around argument names and numbers.
+ IcuTestErrorCode errorCode(*this, "TestTrimArgumentName");
+ MessageFormat m("a { 0 , number , '#,#'#.0 } z", Locale::getEnglish(), errorCode);
+ Formattable args[1] = { 2 };
+ FieldPosition ignore(0);
+ UnicodeString result;
+ assertEquals("trim-numbered-arg format() failed", "a #,#2.0 z",
+ m.format(args, 1, result, ignore, errorCode));
+
+ m.applyPattern("x { _oOo_ , number , integer } y", errorCode);
+ UnicodeString argName = UNICODE_STRING_SIMPLE("_oOo_");
+ args[0].setLong(3);
+ result.remove();
+ assertEquals("trim-named-arg format() failed", "x 3 y",
+ m.format(&argName, args, 1, result, errorCode));
+}
+
#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/icu4c/source/test/intltest/tmsgfmt.h b/icu4c/source/test/intltest/tmsgfmt.h
index 9d47c860b83..80b31b4a90f 100644
--- a/icu4c/source/test/intltest/tmsgfmt.h
+++ b/icu4c/source/test/intltest/tmsgfmt.h
@@ -1,6 +1,6 @@
/********************************************************************
* COPYRIGHT:
- * Copyright (c) 1997-2010, International Business Machines Corporation and
+ * Copyright (c) 1997-2011, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
#ifndef _TESTMESSAGEFORMAT
@@ -65,12 +65,14 @@ public:
**/
void testMsgFormatSelect(/* char* par */);
+ void testApostropheInPluralAndSelect();
+
/**
* Internal method to format a MessageFormat object with passed args
**/
void internalFormat(MessageFormat* msgFmt ,
Formattable* args , int32_t numOfArgs ,
- UnicodeString expected ,char* errMsg);
+ UnicodeString expected, const char* errMsg);
/**
* Internal method to create a MessageFormat object with passed args
@@ -89,7 +91,10 @@ public:
*/
void TestRBNF();
- //
+ void TestApostropheMode();
+
+ void TestCompatibleApostrophe();
+
/**
* ------------ API tests ----------
* These routines test various API functionality.
@@ -108,11 +113,13 @@ public:
void testAdopt(void);
void TestTurkishCasing(void);
void testAutoQuoteApostrophe(void);
+ void TestTrimArgumentName();
/* Provide better code coverage */
void testCoverage(void);
private:
+ UnicodeString GetPatternAndSkipSyntax(const MessagePattern& pattern);
};
#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/icu4c/source/test/intltest/ucdtest.cpp b/icu4c/source/test/intltest/ucdtest.cpp
index 8393b9f447b..0daca0241f1 100644
--- a/icu4c/source/test/intltest/ucdtest.cpp
+++ b/icu4c/source/test/intltest/ucdtest.cpp
@@ -1,6 +1,6 @@
/********************************************************************
* COPYRIGHT:
- * Copyright (c) 1997-2010, International Business Machines Corporation and
+ * Copyright (c) 1997-2011, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
@@ -10,6 +10,7 @@
#include "unicode/putil.h"
#include "cstring.h"
#include "hash.h"
+#include "patternprops.h"
#include "normalizer2impl.h"
#include "uparse.h"
#include "ucdtest.h"
@@ -50,13 +51,15 @@ UnicodeTest::~UnicodeTest()
void UnicodeTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
{
- if (exec) logln("TestSuite UnicodeTest: ");
- switch (index) {
- case 0: name = "TestAdditionalProperties"; if(exec) TestAdditionalProperties(); break;
- case 1: name = "TestBinaryValues"; if(exec) TestBinaryValues(); break;
- case 2: name = "TestConsistency"; if(exec) TestConsistency(); break;
- default: name = ""; break; //needed to end loop
+ if(exec) {
+ logln("TestSuite UnicodeTest: ");
}
+ TESTCASE_AUTO_BEGIN;
+ TESTCASE_AUTO(TestAdditionalProperties);
+ TESTCASE_AUTO(TestBinaryValues);
+ TESTCASE_AUTO(TestConsistency);
+ TESTCASE_AUTO(TestPatternProperties);
+ TESTCASE_AUTO_END;
}
//====================================================
@@ -339,7 +342,7 @@ void UnicodeTest::TestConsistency() {
IcuTestErrorCode errorCode(*this, "TestConsistency");
const Normalizer2 *nfd=Normalizer2::getInstance(NULL, "nfc", UNORM2_DECOMPOSE, errorCode);
const Normalizer2Impl *nfcImpl=Normalizer2Factory::getNFCImpl(errorCode);
- if(errorCode.isFailure()) {
+ if(!nfcImpl->ensureCanonIterData(errorCode) || errorCode.isFailure()) {
dataerrln("Normalizer2::getInstance(NFD) or Normalizer2Factory::getNFCImpl() failed - %s\n",
errorCode.errorName());
errorCode.reset();
@@ -369,3 +372,57 @@ void UnicodeTest::TestConsistency() {
}
#endif
}
+
+/**
+ * Test various implementations of Pattern_Syntax & Pattern_White_Space.
+ */
+void UnicodeTest::TestPatternProperties() {
+ IcuTestErrorCode errorCode(*this, "TestPatternProperties()");
+ UnicodeSet syn_pp;
+ UnicodeSet syn_prop(UNICODE_STRING_SIMPLE("[:Pattern_Syntax:]"), errorCode);
+ UnicodeSet syn_list(UNICODE_STRING_SIMPLE(
+ "[!-/\\:-@\\[-\\^`\\{-~"
+ "\\u00A1-\\u00A7\\u00A9\\u00AB\\u00AC\\u00AE\\u00B0\\u00B1\\u00B6\\u00BB\\u00BF\\u00D7\\u00F7"
+ "\\u2010-\\u2027\\u2030-\\u203E\\u2041-\\u2053\\u2055-\\u205E\\u2190-\\u245F\\u2500-\\u2775"
+ "\\u2794-\\u2BFF\\u2E00-\\u2E7F\\u3001-\\u3003\\u3008-\\u3020\\u3030\\uFD3E\\uFD3F\\uFE45\\uFE46]"), errorCode);
+ UnicodeSet ws_pp;
+ UnicodeSet ws_prop(UNICODE_STRING_SIMPLE("[:Pattern_White_Space:]"), errorCode);
+ UnicodeSet ws_list(UNICODE_STRING_SIMPLE("[\\u0009-\\u000D\\ \\u0085\\u200E\\u200F\\u2028\\u2029]"), errorCode);
+ UnicodeSet syn_ws_pp;
+ UnicodeSet syn_ws_prop(syn_prop);
+ syn_ws_prop.addAll(ws_prop);
+ for(UChar32 c=0; c<=0xffff; ++c) {
+ if(PatternProps::isSyntax(c)) {
+ syn_pp.add(c);
+ }
+ if(PatternProps::isWhiteSpace(c)) {
+ ws_pp.add(c);
+ }
+ if(PatternProps::isSyntaxOrWhiteSpace(c)) {
+ syn_ws_pp.add(c);
+ }
+ }
+ compareUSets(syn_pp, syn_prop,
+ "PatternProps.isSyntax()", "[:Pattern_Syntax:]", TRUE);
+ compareUSets(syn_pp, syn_list,
+ "PatternProps.isSyntax()", "[Pattern_Syntax ranges]", TRUE);
+ compareUSets(ws_pp, ws_prop,
+ "PatternProps.isWhiteSpace()", "[:Pattern_White_Space:]", TRUE);
+ compareUSets(ws_pp, ws_list,
+ "PatternProps.isWhiteSpace()", "[Pattern_White_Space ranges]", TRUE);
+ compareUSets(syn_ws_pp, syn_ws_prop,
+ "PatternProps.isSyntaxOrWhiteSpace()",
+ "[[:Pattern_Syntax:][:Pattern_White_Space:]]", TRUE);
+}
+
+// So far only minimal port of Java & cucdtst.c compareUSets().
+UBool
+UnicodeTest::compareUSets(const UnicodeSet &a, const UnicodeSet &b,
+ const char *a_name, const char *b_name,
+ UBool diffIsError) {
+ UBool same= a==b;
+ if(!same && diffIsError) {
+ errln("Sets are different: %s vs. %s\n", a_name, b_name);
+ }
+ return same;
+}
diff --git a/icu4c/source/test/intltest/ucdtest.h b/icu4c/source/test/intltest/ucdtest.h
index 93a096c0030..38c7eca223d 100644
--- a/icu4c/source/test/intltest/ucdtest.h
+++ b/icu4c/source/test/intltest/ucdtest.h
@@ -1,6 +1,6 @@
/********************************************************************
* COPYRIGHT:
- * Copyright (c) 1997-2010, International Business Machines Corporation and
+ * Copyright (c) 1997-2011, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
@@ -36,6 +36,7 @@ public:
void TestAdditionalProperties();
void TestBinaryValues();
void TestConsistency();
+ void TestPatternProperties();
private:
@@ -50,5 +51,8 @@ private:
UnicodeSet derivedProps[30];
U_NAMESPACE_QUALIFIER Hashtable *unknownPropertyNames;
-};
+ UBool compareUSets(const UnicodeSet &a, const UnicodeSet &b,
+ const char *a_name, const char *b_name,
+ UBool diffIsError);
+};
diff --git a/icu4c/source/test/intltest/uobjtest.cpp b/icu4c/source/test/intltest/uobjtest.cpp
index ab6708608a7..a75c9a038ca 100644
--- a/icu4c/source/test/intltest/uobjtest.cpp
+++ b/icu4c/source/test/intltest/uobjtest.cpp
@@ -322,7 +322,6 @@ void UObjectTest::testIDs()
{
ids_count = 0;
UErrorCode status = U_ZERO_ERROR;
- static const UChar SMALL_STR[] = {0x51, 0x51, 0x51, 0}; // "QQQ"
#if !UCONFIG_NO_TRANSLITERATION || !UCONFIG_NO_FORMATTING
UParseError parseError;
@@ -364,6 +363,8 @@ void UObjectTest::testIDs()
TESTCLASSID_CTOR(DecimalFormatSymbols, (status));
TESTCLASSID_DEFAULT(FieldPosition);
TESTCLASSID_DEFAULT(Formattable);
+
+ static const UChar SMALL_STR[] = {0x51, 0x51, 0x51, 0}; // "QQQ"
TESTCLASSID_CTOR(CurrencyAmount, (1.0, SMALL_STR, status));
TESTCLASSID_CTOR(CurrencyUnit, (SMALL_STR, status));
TESTCLASSID_NONE_FACTORY(LocaleDisplayNames, LocaleDisplayNames::createInstance("de"));
@@ -570,6 +571,7 @@ void UObjectTest::TestMFCCompatibility() {
}
void UObjectTest::TestCompilerRTTI() {
+#if !UCONFIG_NO_FORMATTING
UErrorCode errorCode = U_ZERO_ERROR;
NumberFormat *nf = NumberFormat::createInstance("de", errorCode);
if (U_FAILURE(errorCode)) {
@@ -587,6 +589,7 @@ void UObjectTest::TestCompilerRTTI() {
errln("typeid(NumberFormat) failed");
}
delete nf;
+#endif
}
/* --------------- */
diff --git a/icu4c/source/test/iotest/filetst.c b/icu4c/source/test/iotest/filetst.c
index b65dc34e765..c0ddd5ed281 100644
--- a/icu4c/source/test/iotest/filetst.c
+++ b/icu4c/source/test/iotest/filetst.c
@@ -1,6 +1,6 @@
/*
**********************************************************************
- * Copyright (C) 2004-2010, International Business Machines
+ * Copyright (C) 2004-2011, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* file name: filetst.c
@@ -910,8 +910,8 @@ static void TestCodepage(void) {
}
static void TestCodepageFlush(void) {
-#if UCONFIG_NO_LEGACY_CONVERSION
- log_verbose("Skipping, legacy conversion is disabled.");
+#if UCONFIG_NO_LEGACY_CONVERSION || UCONFIG_NO_FORMATTING
+ log_verbose("Skipping, legacy conversion or formatting is disabled.");
#else
UChar utf16String[] = { 0x39, 0x39, 0x39, 0x20, 0x65E0, 0x6CD6, 0x5728, 0x0000 };
uint8_t inBuf[200];