Mercurial > hg > icedtea9-forest > jdk
changeset 2857:ee4d92fb6df3
6875847: Java Locale Enhancement
Reviewed-by: srl
Contributed-by: Yoshito Umaoka <y.umaoka@gmail.com>, Doug Felt <dougfelt@google.com>, Mark Davis <markdavis@google.com>
line wrap: on
line diff
--- a/make/java/java/FILES_java.gmk Fri Sep 10 20:48:17 2010 +0400 +++ b/make/java/java/FILES_java.gmk Fri Sep 10 15:29:40 2010 -0700 @@ -183,10 +183,22 @@ java/util/MissingFormatWidthException.java \ java/util/UnknownFormatConversionException.java \ java/util/UnknownFormatFlagsException.java \ + java/util/IllformedLocaleException.java \ java/util/FormatterClosedException.java \ java/util/ListResourceBundle.java \ sun/util/EmptyListResourceBundle.java \ java/util/Locale.java \ + sun/util/locale/AsciiUtil.java \ + sun/util/locale/BaseLocale.java \ + sun/util/locale/Extension.java \ + sun/util/locale/InternalLocaleBuilder.java \ + sun/util/locale/LanguageTag.java \ + sun/util/locale/LocaleExtensions.java \ + sun/util/locale/LocaleObjectCache.java \ + sun/util/locale/LocaleSyntaxException.java \ + sun/util/locale/ParseStatus.java \ + sun/util/locale/StringTokenIterator.java \ + sun/util/locale/UnicodeLocaleExtension.java \ java/util/LocaleISOData.java \ sun/util/LocaleServiceProviderPool.java \ sun/util/LocaleDataMetaInfo.java \
--- a/src/share/classes/java/text/DecimalFormatSymbols.java Fri Sep 10 20:48:17 2010 +0400 +++ b/src/share/classes/java/text/DecimalFormatSymbols.java Fri Sep 10 15:29:40 2010 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -43,10 +43,10 @@ import java.io.Serializable; import java.text.spi.DecimalFormatSymbolsProvider; import java.util.Currency; -import java.util.Hashtable; import java.util.Locale; import java.util.ResourceBundle; -import java.util.spi.LocaleServiceProvider; +import java.util.concurrent.ConcurrentHashMap; + import sun.util.LocaleServiceProviderPool; import sun.util.resources.LocaleData; @@ -527,10 +527,17 @@ // get resource bundle data - try the cache first boolean needCacheUpdate = false; - Object[] data = (Object[]) cachedLocaleData.get(locale); + Object[] data = cachedLocaleData.get(locale); if (data == null) { /* cache miss */ + // When numbering system is thai (Locale's extension contains u-nu-thai), + // we read the data from th_TH_TH. + Locale lookupLocale = locale; + String numberType = locale.getUnicodeLocaleType("nu"); + if (numberType != null && numberType.equals("thai")) { + lookupLocale = new Locale("th", "TH", "TH"); + } data = new Object[3]; - ResourceBundle rb = LocaleData.getNumberFormatData(locale); + ResourceBundle rb = LocaleData.getNumberFormatData(lookupLocale); data[0] = rb.getStringArray("NumberElements"); needCacheUpdate = true; } @@ -586,7 +593,7 @@ monetarySeparator = decimalSeparator; if (needCacheUpdate) { - cachedLocaleData.put(locale, data); + cachedLocaleData.putIfAbsent(locale, data); } } @@ -806,7 +813,7 @@ * cache to hold the NumberElements and the Currency * of a Locale. */ - private static final Hashtable cachedLocaleData = new Hashtable(3); + private static final ConcurrentHashMap<Locale, Object[]> cachedLocaleData = new ConcurrentHashMap<Locale, Object[]>(3); /** * Obtains a DecimalFormatSymbols instance from a DecimalFormatSymbolsProvider
--- a/src/share/classes/java/util/Calendar.java Fri Sep 10 20:48:17 2010 +0400 +++ b/src/share/classes/java/util/Calendar.java Fri Sep 10 15:29:40 2010 -0700 @@ -1013,19 +1013,30 @@ private static Calendar createCalendar(TimeZone zone, Locale aLocale) { - // If the specified locale is a Thai locale, returns a BuddhistCalendar - // instance. - if ("th".equals(aLocale.getLanguage()) - && ("TH".equals(aLocale.getCountry()))) { - return new sun.util.BuddhistCalendar(zone, aLocale); - } else if ("JP".equals(aLocale.getVariant()) - && "JP".equals(aLocale.getCountry()) - && "ja".equals(aLocale.getLanguage())) { - return new JapaneseImperialCalendar(zone, aLocale); + Calendar cal = null; + + String caltype = aLocale.getUnicodeLocaleType("ca"); + if (caltype == null) { + // Calendar type is not specified. + // If the specified locale is a Thai locale, + // returns a BuddhistCalendar instance. + if ("th".equals(aLocale.getLanguage()) + && ("TH".equals(aLocale.getCountry()))) { + cal = new BuddhistCalendar(zone, aLocale); + } else { + cal = new GregorianCalendar(zone, aLocale); + } + } else if (caltype.equals("japanese")) { + cal = new JapaneseImperialCalendar(zone, aLocale); + } else if (caltype.equals("buddhist")) { + cal = new BuddhistCalendar(zone, aLocale); + } else { + // Unsupported calendar type. + // Use Gregorian calendar as a fallback. + cal = new GregorianCalendar(zone, aLocale); } - // else create the default calendar - return new GregorianCalendar(zone, aLocale); + return cal; } /**
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/classes/java/util/IllformedLocaleException.java Fri Sep 10 15:29:40 2010 -0700 @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + ******************************************************************************* + * Copyright (C) 2009-2010, International Business Machines Corporation and * + * others. All Rights Reserved. * + ******************************************************************************* + */ + +package java.util; + +/** + * Thrown by methods in {@link Locale} and {@link Locale.Builder} to + * indicate that an argument is not a well-formed BCP 47 tag. + * + * @see Locale + * @since 1.7 + */ +public class IllformedLocaleException extends RuntimeException { + + private static final long serialVersionUID = -5245986824925681401L; + + private int _errIdx = -1; + + /** + * Constructs a new <code>IllformedLocaleException</code> with no + * detail message and -1 as the error index. + */ + public IllformedLocaleException() { + super(); + } + + /** + * Constructs a new <code>IllformedLocaleException</code> with the + * given message and -1 as the error index. + * + * @param message the message + */ + public IllformedLocaleException(String message) { + super(message); + } + + /** + * Constructs a new <code>IllformedLocaleException</code> with the + * given message and the error index. The error index is the approximate + * offset from the start of the ill-formed value to the point where the + * parse first detected an error. A negative error index value indicates + * either the error index is not applicable or unknown. + * + * @param message the message + * @param errorIndex the index + */ + public IllformedLocaleException(String message, int errorIndex) { + super(message + ((errorIndex < 0) ? "" : " [at index " + errorIndex + "]")); + _errIdx = errorIndex; + } + + /** + * Returns the index where the error was found. A negative value indicates + * either the error index is not applicable or unknown. + * + * @return the error index + */ + public int getErrorIndex() { + return _errIdx; + } +}
--- a/src/share/classes/java/util/Locale.java Fri Sep 10 20:48:17 2010 +0400 +++ b/src/share/classes/java/util/Locale.java Fri Sep 10 15:29:40 2010 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -40,86 +40,240 @@ package java.util; -import java.io.*; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.io.ObjectStreamField; +import java.io.Serializable; import java.security.AccessController; import java.text.MessageFormat; -import java.util.List; -import java.util.concurrent.ConcurrentHashMap; import java.util.spi.LocaleNameProvider; -import java.util.spi.LocaleServiceProvider; + import sun.security.action.GetPropertyAction; import sun.util.LocaleServiceProviderPool; +import sun.util.locale.AsciiUtil; +import sun.util.locale.BaseLocale; +import sun.util.locale.InternalLocaleBuilder; +import sun.util.locale.LanguageTag; +import sun.util.locale.LocaleExtensions; +import sun.util.locale.LocaleObjectCache; +import sun.util.locale.LocaleSyntaxException; +import sun.util.locale.ParseStatus; +import sun.util.locale.UnicodeLocaleExtension; import sun.util.resources.LocaleData; import sun.util.resources.OpenListResourceBundle; /** - * * A <code>Locale</code> object represents a specific geographical, political, * or cultural region. An operation that requires a <code>Locale</code> to perform * its task is called <em>locale-sensitive</em> and uses the <code>Locale</code> * to tailor information for the user. For example, displaying a number - * is a locale-sensitive operation--the number should be formatted - * according to the customs/conventions of the user's native country, + * is a locale-sensitive operation— the number should be formatted + * according to the customs and conventions of the user's native country, * region, or culture. * - * <P> - * Create a <code>Locale</code> object using the constructors in this class: + * <p> The <code>Locale</code> class implements identifiers + * interchangeable with BCP 47 (IETF BCP 47, "Tags for Identifying + * Languages"), with support for the LDML (UTS#35, "Unicode Locale + * Data Markup Language") BCP 47-compatible extensions for locale data + * exchange. + * + * <p> A <code>Locale</code> object logically consists of the fields + * described below. + * + * <dl> + * <dt><a name="def_language"/><b>language</b></dt> + * + * <dd>ISO 639 alpha-2 or alpha-3 language code, or registered + * language subtags up to 8 alpha letters (for future enhancements). + * When a language has both an alpha-2 code and an alpha-3 code, the + * alpha-2 code must be used. You can find a full list of valid + * language codes in the IANA Language Subtag Registry (search for + * "Type: language"). The language field is case insensitive, but + * <code>Locale</code> always canonicalizes to lower case.</dd><br> + * + * <dd>Well-formed language values have the form + * <code>[a-zA-Z]{2,8}</code>. Note that this is not the the full + * BCP47 language production, since it excludes extlang. They are + * not needed since modern three-letter language codes replace + * them.</dd><br> + * + * <dd>Example: "en" (English), "ja" (Japanese), "kok" (Konkani)</dd><br> + * + * <dt><a name="def_script"/><b>script</b></dt> + * + * <dd>ISO 15924 alpha-4 script code. You can find a full list of + * valid script codes in the IANA Language Subtag Registry (search + * for "Type: script"). The script field is case insensitive, but + * <code>Locale</code> always canonicalizes to title case (the first + * letter is upper case and the rest of the letters are lower + * case).</dd><br> + * + * <dd>Well-formed script values have the form + * <code>[a-zA-Z]{4}</code></dd><br> + * + * <dd>Example: "Latn" (Latin), "Cyrl" (Cyrillic)</dd><br> + * + * <dt><a name="def_region"/><b>country (region)</b></dt> + * + * <dd>ISO 3166 alpha-2 country code or UN M.49 numeric-3 area code. + * You can find a full list of valid country and region codes in the + * IANA Language Subtag Registry (search for "Type: region"). The + * country (region) field is case insensitive, but + * <code>Locale</code> always canonicalizes to upper case.</dd><br> + * + * <dd>Well-formed country/region values have + * the form <code>[a-zA-Z]{2} | [0-9]{3}</code></dd><br> + * + * <dd>Example: "US" (United States), "FR" (France), "029" + * (Caribbean)</dd><br> + * + * <dt><a name="def_variant"/><b>variant</b></dt> + * + * <dd>Any arbitrary value used to indicate a variation of a + * <code>Locale</code>. Where there are two or more variant values + * each indicating its own semantics, these values should be ordered + * by importance, with most important first, separated by + * underscore('_'). The variant field is case sensitive.</dd><br> + * + * <dd>Note: IETF BCP 47 places syntactic restrictions on variant + * subtags. Also BCP 47 subtags are strictly used to indicate + * additional variations that define a language or its dialects that + * are not covered by any combinations of language, script and + * region subtags. You can find a full list of valid variant codes + * in the IANA Language Subtag Registry (search for "Type: variant"). + * + * <p>However, the variant field in <code>Locale</code> has + * historically been used for any kind of variation, not just + * language variations. For example, some supported variants + * available in Java SE Runtime Environments indicate alternative + * cultural behaviors such as calendar type or number script. In + * BCP 47 this kind of information, which does not identify the + * language, is supported by extension subtags or private use + * subtags.</dd><br> + * + * <dd>Well-formed variant values have the form <code>SUBTAG + * (('_'|'-') SUBTAG)*</code> where <code>SUBTAG = + * [0-9][0-9a-zA-Z]{3} | [0-9a-zA-Z]{5,8}</code>. (Note: BCP 47 only + * uses hyphen ('-') as a delimiter, this is more lenient).</dd><br> + * + * <dd>Example: "polyton" (Polytonic Greek), "POSIX"</dd><br> + * + * <dt><a name="def_extensions"/><b>extensions</b></dt> + * + * <dd>A map from single character keys to string values, indicating + * extensions apart from language identification. The extensions in + * <code>Locale</code> implement the semantics and syntax of BCP 47 + * extension subtags and private use subtags. The extensions are + * case insensitive, but <code>Locale</code> canonicalizes all + * extension keys and values to lower case. Note that extensions + * cannot have empty values.</dd><br> + * + * <dd>Well-formed keys are single characters from the set + * <code>[0-9a-zA-Z]</code>. Well-formed values have the form + * <code>SUBTAG ('-' SUBTAG)*</code> where for the key 'x' + * <code>SUBTAG = [0-9a-zA-Z]{1,8}</code> and for other keys + * <code>SUBTAG = [0-9a-zA-Z]{2,8}</code> (that is, 'x' allows + * single-character subtags).</dd><br> + * + * <dd>Example: key="u"/value="ca-japanese" (Japanese Calendar), + * key="x"/value="java-1-7"</dd> + * </dl> + * + * <b>Note:</b> Although BCP 47 requires field values to be registered + * in the IANA Language Subtag Registry, the <code>Locale</code> class + * does not provide any validation features. The <code>Builder</code> + * only checks if an individual field satisfies the syntactic + * requirement (is well-formed), but does not validate the value + * itself. See {@link Builder} for details. + * + * <h4><a name="def_locale_extension">Unicode locale/language extension</h4> + * + * <p>UTS#35, "Unicode Locale Data Markup Language" defines optional + * attributes and keywords to override or refine the default behavior + * associated with a locale. A keyword is represented by a pair of + * key and type. For example, "nu-thai" indicates that Thai local + * digits (value:"thai") should be used for formatting numbers + * (key:"nu"). + * + * <p>The keywords are mapped to a BCP 47 extension value using the + * extension key 'u' ({@link #UNICODE_LOCALE_EXTENSION}). The above + * example, "nu-thai", becomes the extension "u-nu-thai".code + * + * <p>Thus, when a <code>Locale</code> object contains Unicode locale + * attributes and keywords, + * <code>getExtension(UNICODE_LOCALE_EXTENSION)</code> will return a + * String representing this information, for example, "nu-thai". The + * <code>Locale</code> class also provides {@link + * #getUnicodeLocaleAttributes}, {@link #getUnicodeLocaleKeys}, and + * {@link #getUnicodeLocaleType} which allow you to access Unicode + * locale attributes and key/type pairs directly. When represented as + * a string, the Unicode Locale Extension lists attributes + * alphabetically, followed by key/type sequences with keys listed + * alphabetically (the order of subtags comprising a key's type is + * fixed when the type is defined) + * + * <p>A well-formed locale key has the form + * <code>[0-9a-zA-Z]{2}</code>. A well-formed locale type has the + * form <code>"" | [0-9a-zA-Z]{3,8} ('-' [0-9a-zA-Z]{3,8})*</code> (it + * can be empty, or a series of subtags 3-8 alphanums in length). A + * well-formed locale attribute has the form + * <code>[0-9a-zA-Z]{3,8}</code> (it is a single subtag with the same + * form as a locale type subtag). + * + * <p>The Unicode locale extension specifies optional behavior in + * locale-sensitive services. Although the LDML specification defines + * various keys and values, actual locale-sensitive service + * implementations in a Java Runtime Environment might not support any + * particular Unicode locale attributes or key/type pairs. + * + * <h4>Creating a Locale</h4> + * + * <p>There are several different ways to create a <code>Locale</code> + * object. + * + * <h5>Builder</h5> + * + * <p>Using {@link Builder} you can construct a <code>Locale</code> object + * that conforms to BCP 47 syntax. + * + * <h5>Constructors</h5> + * + * <p>The <code>Locale</code> class provides three constructors: * <blockquote> * <pre> - * Locale(String language) - * Locale(String language, String country) - * Locale(String language, String country, String variant) + * {@link #Locale(String language)} + * {@link #Locale(String language, String country)} + * {@link #Locale(String language, String country, String variant)} * </pre> * </blockquote> - * The language argument is a valid <STRONG>ISO Language Code.</STRONG> - * These codes are the lower-case, two-letter codes as defined by ISO-639. - * You can find a full list of these codes at a number of sites, such as: - * <BR><a href ="http://www.loc.gov/standards/iso639-2/php/English_list.php"> - * <code>http://www.loc.gov/standards/iso639-2/php/English_list.php</code></a> + * These constructors allow you to create a <code>Locale</code> object + * with language, country and variant, but you cannot specify + * script or extensions. * - * <P> - * The country argument is a valid <STRONG>ISO Country Code.</STRONG> These - * codes are the upper-case, two-letter codes as defined by ISO-3166. - * You can find a full list of these codes at a number of sites, such as: - * <BR><a href="http://www.iso.ch/iso/en/prods-services/iso3166ma/02iso-3166-code-lists/list-en1.html"> - * <code>http://www.iso.ch/iso/en/prods-services/iso3166ma/02iso-3166-code-lists/list-en1.html</code></a> + * <h5>Factory Methods</h5> * - * <P> - * The variant argument is a vendor or browser-specific code. - * For example, use WIN for Windows, MAC for Macintosh, and POSIX for POSIX. - * Where there are two variants, separate them with an underscore, and - * put the most important one first. For example, a Traditional Spanish collation - * might construct a locale with parameters for language, country and variant as: - * "es", "ES", "Traditional_WIN". + * <p>The method {@link #forLanguageTag} creates a <code>Locale</code> + * object for a well-formed BCP 47 language tag. * - * <P> - * Because a <code>Locale</code> object is just an identifier for a region, - * no validity check is performed when you construct a <code>Locale</code>. - * If you want to see whether particular resources are available for the - * <code>Locale</code> you construct, you must query those resources. For - * example, ask the <code>NumberFormat</code> for the locales it supports - * using its <code>getAvailableLocales</code> method. - * <BR><STRONG>Note:</STRONG> When you ask for a resource for a particular - * locale, you get back the best available match, not necessarily - * precisely what you asked for. For more information, look at - * {@link ResourceBundle}. + * <h5>Locale Constants</h5> * - * <P> - * The <code>Locale</code> class provides a number of convenient constants + * <p>The <code>Locale</code> class provides a number of convenient constants * that you can use to create <code>Locale</code> objects for commonly used * locales. For example, the following creates a <code>Locale</code> object * for the United States: * <blockquote> * <pre> - * Locale.US + * Locale.US * </pre> * </blockquote> * - * <P> - * Once you've created a <code>Locale</code> you can query it for information about - * itself. Use <code>getCountry</code> to get the ISO Country Code and - * <code>getLanguage</code> to get the ISO Language Code. You can - * use <code>getDisplayCountry</code> to get the + * <h4>Use of Locale</h4> + * + * <p>Once you've created a <code>Locale</code> you can query it for information + * about itself. Use <code>getCountry</code> to get the country (or region) + * code and <code>getLanguage</code> to get the language code. + * You can use <code>getDisplayCountry</code> to get the * name of the country suitable for displaying to the user. Similarly, * you can use <code>getDisplayLanguage</code> to get the name of * the language suitable for displaying to the user. Interestingly, @@ -127,28 +281,27 @@ * and have two versions: one that uses the default locale and one * that uses the locale specified as an argument. * - * <P> - * The Java Platform provides a number of classes that perform locale-sensitive + * <p>The Java Platform provides a number of classes that perform locale-sensitive * operations. For example, the <code>NumberFormat</code> class formats - * numbers, currency, or percentages in a locale-sensitive manner. Classes - * such as <code>NumberFormat</code> have a number of convenience methods + * numbers, currency, and percentages in a locale-sensitive manner. Classes + * such as <code>NumberFormat</code> have several convenience methods * for creating a default object of that type. For example, the * <code>NumberFormat</code> class provides these three convenience methods * for creating a default <code>NumberFormat</code> object: * <blockquote> * <pre> - * NumberFormat.getInstance() - * NumberFormat.getCurrencyInstance() - * NumberFormat.getPercentInstance() + * NumberFormat.getInstance() + * NumberFormat.getCurrencyInstance() + * NumberFormat.getPercentInstance() * </pre> * </blockquote> - * These methods have two variants; one with an explicit locale - * and one without; the latter using the default locale. + * Each of these methods has two variants; one with an explicit locale + * and one without; the latter uses the default locale: * <blockquote> * <pre> - * NumberFormat.getInstance(myLocale) - * NumberFormat.getCurrencyInstance(myLocale) - * NumberFormat.getPercentInstance(myLocale) + * NumberFormat.getInstance(myLocale) + * NumberFormat.getCurrencyInstance(myLocale) + * NumberFormat.getPercentInstance(myLocale) * </pre> * </blockquote> * A <code>Locale</code> is the mechanism for identifying the kind of object @@ -156,75 +309,162 @@ * <STRONG>just</STRONG> a mechanism for identifying objects, * <STRONG>not</STRONG> a container for the objects themselves. * - * @see ResourceBundle - * @see java.text.Format - * @see java.text.NumberFormat - * @see java.text.Collator - * @author Mark Davis - * @since 1.1 + * <h4>Compatibility</h4> + * + * <p>In order to maintain compatibility with existing usage, Locale's + * constructors retain their behavior prior to the Java Runtime + * Environment version 1.7. The same is largely true for the + * <code>toString</code> method. Thus Locale objects can continue to + * be used as they were. In particular, clients who parse the output + * of toString into language, country, and variant fields can continue + * to do so (although this is strongly discouraged), although the + * variant field will have additional information in it if script or + * extensions are present. + * + * <p>In addition, BCP 47 imposes syntax restrictions that are not + * imposed by Locale's constructors. This means that conversions + * between some Locales and BCP 47 language tags cannot be made without + * losing information. Thus <code>toLanguageTag</code> cannot + * represent the state of locales whose language, country, or variant + * do not conform to BCP 47. + * + * <p>Because of these issues, it is recommended that clients migrate + * away from constructing non-conforming locales and use the + * <code>forLanguageTag</code> and <code>Locale.Builder</code> APIs instead. + * Clients desiring a string representation of the complete locale can + * then always rely on <code>toLanguageTag</code> for this purpose. + * + * <h5><a name="special_cases_constructor"/>Special cases</h5> + * + * <p>For compatibility reasons, two + * non-conforming locales are treated as special cases. These are + * <b><tt>ja_JP_JP</tt></b> and <b><tt>th_TH_TH</tt></b>. These are ill-formed + * in BCP 47 since the variants are too short. To ease migration to BCP 47, + * these are treated specially during construction. These two cases (and only + * these) cause a constructor to generate an extension, all other values behave + * exactly as they did prior to Java 7. + * + * <p>Java has used <tt>ja_JP_JP</tt> to represent Japanese as used in + * Japan together with the Japanese Imperial calendar. This is now + * representable using a Unicode locale extension, by specifying the + * Unicode locale key <tt>ca</tt> (for "calendar") and type + * <tt>japanese</tt>. When the Locale constructor is called with the + * arguments "ja", "JP", "JP", the extension "u-ca-japanese" is + * automatically added. + * + * <p>Java has used <tt>th_TH_TH</tt> to represent Thai as used in + * Thailand together with Thai digits. This is also now representable using + * a Unicode locale extension, by specifying the Unicode locale key + * <tt>nu</tt> (for "number") and value <tt>thai</tt>. When the Locale + * constructor is called with the arguments "th", "TH", "TH", the + * extension "u-nu-thai" is automatically added. + * + * <h5>Serialization</h5> + * + * <p>During serialization, writeObject writes all fields to the output + * stream, including extensions. + * + * <p>During deserialization, readResolve adds extensions as described + * in <a href="#special_cases_constructor">Special Cases</a>, only + * for the two cases th_TH_TH and ja_JP_JP. + * + * <h5>Legacy language codes</h5> + * + * <p>Locale's constructor has always converted three language codes to + * their earlier, obsoleted forms: <tt>he</tt> maps to <tt>iw</tt>, + * <tt>yi</tt> maps to <tt>ji</tt>, and <tt>id</tt> maps to + * <tt>in</tt>. This continues to be the case, in order to not break + * backwards compatibility. + * + * <p>The APIs added in 1.7 map between the old and new language codes, + * maintaining the old codes internal to Locale (so that + * <code>getLanguage</code> and <code>toString</code> reflect the old + * code), but using the new codes in the BCP 47 language tag APIs (so + * that <code>toLanguageTag</code> reflects the new one). This + * preserves the equivalence between Locales no matter which code or + * API is used to construct them. Java's default resource bundle + * lookup mechanism also implements this mapping, so that resources + * can be named using either convention, see {@link ResourceBundle.Control}. + * + * <h5>Three-letter language/country(region) codes</h5> + * + * <p>The Locale constructors have always specified that the language + * and the country param be two characters in length, although in + * practice they have accepted any length. The specification has now + * been relaxed to allow language codes of two to eight characters and + * country (region) codes of two to three characters, and in + * particular, three-letter language codes and three-digit region + * codes as specified in the IANA Language Subtag Registry. For + * compatibility, the implementation still does not impose a length + * constraint. + * + * @see Builder + * @see ResourceBundle + * @see java.text.Format + * @see java.text.NumberFormat + * @see java.text.Collator + * @author Mark Davis + * @since 1.1 */ - public final class Locale implements Cloneable, Serializable { - // cache to store singleton Locales - private final static ConcurrentHashMap<String, Locale> cache = - new ConcurrentHashMap<String, Locale>(32); - - /** Useful constant for language. - */ - static public final Locale ENGLISH = createSingleton("en__", "en", ""); - - /** Useful constant for language. - */ - static public final Locale FRENCH = createSingleton("fr__", "fr", ""); - - /** Useful constant for language. - */ - static public final Locale GERMAN = createSingleton("de__", "de", ""); - - /** Useful constant for language. - */ - static public final Locale ITALIAN = createSingleton("it__", "it", ""); + static private final Cache LOCALECACHE = new Cache(); /** Useful constant for language. */ - static public final Locale JAPANESE = createSingleton("ja__", "ja", ""); + static public final Locale ENGLISH = getInstance("en", "", ""); + + /** Useful constant for language. + */ + static public final Locale FRENCH = getInstance("fr", "", ""); /** Useful constant for language. */ - static public final Locale KOREAN = createSingleton("ko__", "ko", ""); + static public final Locale GERMAN = getInstance("de", "", ""); /** Useful constant for language. */ - static public final Locale CHINESE = createSingleton("zh__", "zh", ""); + static public final Locale ITALIAN = getInstance("it", "", ""); /** Useful constant for language. */ - static public final Locale SIMPLIFIED_CHINESE = createSingleton("zh_CN_", "zh", "CN"); + static public final Locale JAPANESE = getInstance("ja", "", ""); + + /** Useful constant for language. + */ + static public final Locale KOREAN = getInstance("ko", "", ""); /** Useful constant for language. */ - static public final Locale TRADITIONAL_CHINESE = createSingleton("zh_TW_", "zh", "TW"); + static public final Locale CHINESE = getInstance("zh", "", ""); - /** Useful constant for country. + /** Useful constant for language. */ - static public final Locale FRANCE = createSingleton("fr_FR_", "fr", "FR"); + static public final Locale SIMPLIFIED_CHINESE = getInstance("zh", "CN", ""); + + /** Useful constant for language. + */ + static public final Locale TRADITIONAL_CHINESE = getInstance("zh", "TW", ""); /** Useful constant for country. */ - static public final Locale GERMANY = createSingleton("de_DE_", "de", "DE"); + static public final Locale FRANCE = getInstance("fr", "FR", ""); + + /** Useful constant for country. + */ + static public final Locale GERMANY = getInstance("de", "DE", ""); /** Useful constant for country. */ - static public final Locale ITALY = createSingleton("it_IT_", "it", "IT"); + static public final Locale ITALY = getInstance("it", "IT", ""); /** Useful constant for country. */ - static public final Locale JAPAN = createSingleton("ja_JP_", "ja", "JP"); + static public final Locale JAPAN = getInstance("ja", "JP", ""); /** Useful constant for country. */ - static public final Locale KOREA = createSingleton("ko_KR_", "ko", "KR"); + static public final Locale KOREA = getInstance("ko", "KR", ""); /** Useful constant for country. */ @@ -240,19 +480,19 @@ /** Useful constant for country. */ - static public final Locale UK = createSingleton("en_GB_", "en", "GB"); + static public final Locale UK = getInstance("en", "GB", ""); /** Useful constant for country. */ - static public final Locale US = createSingleton("en_US_", "en", "US"); + static public final Locale US = getInstance("en", "US", ""); /** Useful constant for country. */ - static public final Locale CANADA = createSingleton("en_CA_", "en", "CA"); + static public final Locale CANADA = getInstance("en", "CA", ""); /** Useful constant for country. */ - static public final Locale CANADA_FRENCH = createSingleton("fr_CA_", "fr", "CA"); + static public final Locale CANADA_FRENCH = getInstance("fr", "CA", ""); /** * Useful constant for the root locale. The root locale is the locale whose @@ -262,7 +502,25 @@ * * @since 1.6 */ - static public final Locale ROOT = createSingleton("__", "", ""); + static public final Locale ROOT = getInstance("", "", ""); + + /** + * The key for the private use extension ('x'). + * + * @see #getExtension(char) + * @see Builder#setExtension(char, String) + * @since 1.7 + */ + static public final char PRIVATE_USE_EXTENSION = 'x'; + + /** + * The key for Unicode locale extension ('u'). + * + * @see #getExtension(char) + * @see Builder#setExtension(char, String) + * @since 1.7 + */ + static public final char UNICODE_LOCALE_EXTENSION = 'u'; /** serialization ID */ @@ -274,32 +532,67 @@ private static final int DISPLAY_LANGUAGE = 0; private static final int DISPLAY_COUNTRY = 1; private static final int DISPLAY_VARIANT = 2; + private static final int DISPLAY_SCRIPT = 3; + + /** + * Private constructor used by getInstance method + */ + private Locale(BaseLocale baseLocale, LocaleExtensions extensions) { + _baseLocale = baseLocale; + _extensions = extensions; + } /** - * Construct a locale from language, country, variant. - * NOTE: ISO 639 is not a stable standard; some of the language codes it defines - * (specifically iw, ji, and in) have changed. This constructor accepts both the - * old codes (iw, ji, and in) and the new codes (he, yi, and id), but all other + * Construct a locale from language, country and variant. + * This constructor normalizes the language value to lowercase and + * the country value to uppercase. + * <p> + * <b>Note:</b> + * <ul> + * <li>ISO 639 is not a stable standard; some of the language codes it defines + * (specifically "iw", "ji", and "in") have changed. This constructor accepts both the + * old codes ("iw", "ji", and "in") and the new codes ("he", "yi", and "id"), but all other * API on Locale will return only the OLD codes. - * @param language lowercase two-letter ISO-639 code. - * @param country uppercase two-letter ISO-3166 code. - * @param variant vendor and browser specific code. See class description. + * <li>For backward compatibility reasons, this constructor does not make + * any syntactic checks on the input. + * <li>The two cases ("ja", "JP", "JP") and ("th", "TH", "TH") are handled specially, + * see <a href="#special_cases_constructor">Special Cases</a> for more information. + * </ul> + * + * @param language An ISO 639 alpha-2 or alpha-3 language code, or a language subtag + * up to 8 characters in length. See the <code>Locale</code> class description about + * valid language values. + * @param country An ISO 3166 alpha-2 country code or a UN M.49 numeric-3 area code. + * See the <code>Locale</code> class description about valid country values. + * @param variant Any arbitrary value used to indicate a variation of a <code>Locale</code>. + * See the <code>Locale</code> class description for the details. * @exception NullPointerException thrown if any argument is null. */ public Locale(String language, String country, String variant) { - this.language = convertOldISOCodes(language); - this.country = toUpperCase(country).intern(); - this.variant = variant.intern(); + _baseLocale = BaseLocale.getInstance(convertOldISOCodes(language), "", country, variant); + _extensions = getCompatibilityExtensions(language, "", country, variant); } /** - * Construct a locale from language, country. - * NOTE: ISO 639 is not a stable standard; some of the language codes it defines - * (specifically iw, ji, and in) have changed. This constructor accepts both the - * old codes (iw, ji, and in) and the new codes (he, yi, and id), but all other + * Construct a locale from language and country. + * This constructor normalizes the language value to lowercase and + * the country value to uppercase. + * <p> + * <b>Note:</b> + * <ul> + * <li>ISO 639 is not a stable standard; some of the language codes it defines + * (specifically "iw", "ji", and "in") have changed. This constructor accepts both the + * old codes ("iw", "ji", and "in") and the new codes ("he", "yi", and "id"), but all other * API on Locale will return only the OLD codes. - * @param language lowercase two-letter ISO-639 code. - * @param country uppercase two-letter ISO-3166 code. + * <li>For backward compatibility reasons, this constructor does not make + * any syntactic checks on the input. + * </ul> + * + * @param language An ISO 639 alpha-2 or alpha-3 language code, or a language subtag + * up to 8 characters in length. See the <code>Locale</code> class description about + * valid language values. + * @param country An ISO 3166 alpha-2 country code or a UN M.49 numeric-3 area code. + * See the <code>Locale</code> class description about valid country values. * @exception NullPointerException thrown if either argument is null. */ public Locale(String language, String country) { @@ -308,11 +601,21 @@ /** * Construct a locale from a language code. - * NOTE: ISO 639 is not a stable standard; some of the language codes it defines - * (specifically iw, ji, and in) have changed. This constructor accepts both the - * old codes (iw, ji, and in) and the new codes (he, yi, and id), but all other + * This constructor normalizes the language value to lowercase. + * <p> + * <b>Note:</b> + * <ul> + * <li>ISO 639 is not a stable standard; some of the language codes it defines + * (specifically "iw", "ji", and "in") have changed. This constructor accepts both the + * old codes ("iw", "ji", and "in") and the new codes ("he", "yi", and "id"), but all other * API on Locale will return only the OLD codes. - * @param language lowercase two-letter ISO-639 code. + * <li>For backward compatibility reasons, this constructor does not make + * any syntactic checks on the input. + * </ul> + * + * @param language An ISO 639 alpha-2 or alpha-3 language code, or a language subtag + * up to 8 characters in length. See the <code>Locale</code> class description about + * valid language values. * @exception NullPointerException thrown if argument is null. * @since 1.4 */ @@ -321,32 +624,6 @@ } /** - * Constructs a <code>Locale</code> using <code>language</code> - * and <code>country</code>. This constructor assumes that - * <code>language</code> and <code>contry</code> are interned and - * it is invoked by createSingleton only. (flag is just for - * avoiding the conflict with the public constructors. - */ - private Locale(String language, String country, boolean flag) { - this.language = language; - this.country = country; - this.variant = ""; - } - - /** - * Creates a <code>Locale</code> instance with the given - * <code>language</code> and <code>counry</code> and puts the - * instance under the given <code>key</code> in the cache. This - * method must be called only when initializing the Locale - * constants. - */ - private static Locale createSingleton(String key, String language, String country) { - Locale locale = new Locale(language, country, false); - cache.put(key, locale); - return locale; - } - - /** * Returns a <code>Locale</code> constructed from the given * <code>language</code>, <code>country</code> and * <code>variant</code>. If the same <code>Locale</code> instance @@ -354,29 +631,70 @@ * returned. Otherwise, a new <code>Locale</code> instance is * created and cached. * - * @param language lowercase two-letter ISO-639 code. - * @param country uppercase two-letter ISO-3166 code. + * @param language lowercase 2 to 8 language code. + * @param country uppercase two-letter ISO-3166 code and numric-3 UN M.49 area code. * @param variant vendor and browser specific code. See class description. * @return the <code>Locale</code> instance requested * @exception NullPointerException if any argument is null. */ static Locale getInstance(String language, String country, String variant) { - if (language== null || country == null || variant == null) { + return getInstance(language, "", country, variant, LocaleExtensions.EMPTY_EXTENSIONS); + } + + static Locale getInstance(String language, String script, String country, + String variant, LocaleExtensions extensions) { + if (language== null || script == null || country == null || variant == null) { throw new NullPointerException(); } - StringBuilder sb = new StringBuilder(); - sb.append(language).append('_').append(country).append('_').append(variant); - String key = sb.toString(); - Locale locale = cache.get(key); - if (locale == null) { - locale = new Locale(language, country, variant); - Locale l = cache.putIfAbsent(key, locale); - if (l != null) { - locale = l; + if (extensions == null) { + extensions = LocaleExtensions.EMPTY_EXTENSIONS; + } + + if (extensions.equals(LocaleExtensions.EMPTY_EXTENSIONS)) { + extensions = getCompatibilityExtensions(language, script, country, variant); + } + + BaseLocale baseloc = BaseLocale.getInstance(language, script, country, variant); + return getInstance(baseloc, extensions); + } + + static Locale getInstance(BaseLocale baseloc, LocaleExtensions extensions) { + LocaleKey key = new LocaleKey(baseloc, extensions); + return LOCALECACHE.get(key); + } + + private static class Cache extends LocaleObjectCache<LocaleKey, Locale> { + public Cache() { + } + protected Locale createObject(LocaleKey key) { + return new Locale(key._base, key._exts); + } + } + + private static class LocaleKey { + private BaseLocale _base; + private LocaleExtensions _exts; + + private LocaleKey(BaseLocale baseLocale, LocaleExtensions extensions) { + _base = baseLocale; + _exts = extensions; + } + + public boolean equals(Object obj) { + if (this == obj) { + return true; } + if (!(obj instanceof LocaleKey)) { + return false; + } + LocaleKey other = (LocaleKey)obj; + return _base.equals(other._base) && _exts.equals(other._exts); } - return locale; + + public int hashCode() { + return _base.hashCode() ^ _exts.hashCode(); + } } /** @@ -595,6 +913,11 @@ /** * Returns a list of all 2-letter country codes defined in ISO 3166. * Can be used to create Locales. + * <p> + * <b>Note:</b> The <code>Locale</code> class also supports other codes for + * country (region), such as 3-letter numeric UN M.49 area codes. + * Therefore, the list returned by this method does not contain ALL valid + * codes that can be used to create Locales. */ public static String[] getISOCountries() { if (isoCountries == null) { @@ -608,9 +931,16 @@ /** * Returns a list of all 2-letter language codes defined in ISO 639. * Can be used to create Locales. - * [NOTE: ISO 639 is not a stable standard-- some languages' codes have changed. + * <p> + * <b>Note:</b> + * <ul> + * <li>ISO 639 is not a stable standard— some languages' codes have changed. * The list this function returns includes both the new and the old codes for the - * languages whose codes have changed.] + * languages whose codes have changed. + * <li>The <code>Locale</code> class also supports language codes up to + * 8 characters in length. Therefore, the list returned by this method does + * not contain ALL valid codes that can be used to create Locales. + * </ul> */ public static String[] getISOLanguages() { if (isoLanguages == null) { @@ -631,100 +961,516 @@ } /** - * Returns the language code for this locale, which will either be the empty string - * or a lowercase ISO 639 code. - * <p>NOTE: ISO 639 is not a stable standard-- some languages' codes have changed. + * Returns the language code of this Locale. + * + * <p><b>Note:</b> ISO 639 is not a stable standard— some languages' codes have changed. * Locale's constructor recognizes both the new and the old codes for the languages * whose codes have changed, but this function always returns the old code. If you - * want to check for a specific language whose code has changed, don't do <pre> - * if (locale.getLanguage().equals("he")) + * want to check for a specific language whose code has changed, don't do + * <pre> + * if (locale.getLanguage().equals("he")) // BAD! * ... - * </pre>Instead, do<pre> - * if (locale.getLanguage().equals(new Locale("he", "", "").getLanguage())) - * ...</pre> + * </pre> + * Instead, do + * <pre> + * if (locale.getLanguage().equals(new Locale("he").getLanguage())) + * ... + * </pre> + * @return The language code, or the empty string if none is defined. * @see #getDisplayLanguage */ public String getLanguage() { - return language; + return _baseLocale.getLanguage(); } /** - * Returns the country/region code for this locale, which will - * either be the empty string or an uppercase ISO 3166 2-letter code. + * Returns the script for this locale, which should + * either be the empty string or an ISO 15924 4-letter script + * code. The first letter is uppercase and the rest are + * lowercase, for example, 'Latn', 'Cyrl'. + * + * @return The script code, or the empty string if none is defined. + * @see #getDisplayScript + * @since 1.7 + */ + public String getScript() { + return _baseLocale.getScript(); + } + + /** + * Returns the country/region code for this locale, which should + * either be the empty string, an uppercase ISO 3166 2-letter code, + * or a UN M.49 3-digit code. + * + * @return The country/region code, or the empty string if none is defined. * @see #getDisplayCountry */ public String getCountry() { - return country; + return _baseLocale.getRegion(); } /** * Returns the variant code for this locale. + * + * @return The variant code, or the empty string if none is defined. * @see #getDisplayVariant */ public String getVariant() { - return variant; + return _baseLocale.getVariant(); + } + + /** + * Returns the extension (or private use) value associated with + * the specified key, or null if there is no extension + * associated with the key. To be well-formed, the key must be one + * of <code>[0-9A-Za-z]</code>. Keys are case-insensitive, so + * for example 'z' and 'Z' represent the same extension. + * + * @param key the extension key + * @return The extension, or null if this locale defines no + * extension for the specified key. + * @throws IllegalArgumentException if key is not well-formed + * @see #PRIVATE_USE_EXTENSION + * @see #UNICODE_LOCALE_EXTENSION + * @since 1.7 + */ + public String getExtension(char key) { + if (!LocaleExtensions.isValidKey(key)) { + throw new IllegalArgumentException("Ill-formed extension key: " + key); + } + return _extensions.getExtensionValue(key); + } + + /** + * Returns the set of extension keys associated with this locale, or the + * empty set if it has no extensions. The returned set is unmodifiable. + * The keys will all be lower-case. + * + * @return The set of extension keys, or the empty set if this locale has + * no extensions. + * @since 1.7 + */ + public Set<Character> getExtensionKeys() { + return _extensions.getKeys(); + } + + /** + * Returns the set of unicode locale attributes associated with + * this locale, or the empty set if it has no attributes. The + * returned set is unmodifiable. + * + * @return The set of attributes. + * @since 1.7 + */ + public Set<String> getUnicodeLocaleAttributes() { + return _extensions.getUnicodeLocaleAttributes(); + } + + /** + * Returns the Unicode locale type associated with the specified Unicode locale key + * for this locale. Returns the empty string for keys that are defined with no type. + * Returns null if the key is not defined. Keys are case-insensitive. The key must + * be two alphanumeric characters ([0-9a-zA-Z]), or an IllegalArgumentException is + * thrown. + * + * @param key the Unicode locale key + * @return The Unicode locale type associated with the key, or null if the + * locale does not define the key. + * @throws IllegalArgumentException if the key is not well-formed + * @throws NullPointerException if <code>key</code> is null + * @since 1.7 + */ + public String getUnicodeLocaleType(String key) { + if (!UnicodeLocaleExtension.isKey(key)) { + throw new IllegalArgumentException("Ill-formed Unicode locale key: " + key); + } + return _extensions.getUnicodeLocaleType(key); + } + + /** + * Returns the set of Unicode locale keys defined by this locale, or the empty set if + * this locale has none. The returned set is immutable. Keys are all lower case. + * + * @return The set of Unicode locale keys, or the empty set if this locale has + * no Unicode locale keywords. + * @since 1.7 + */ + public Set<String> getUnicodeLocaleKeys() { + return _extensions.getUnicodeLocaleKeys(); } /** - * Getter for the programmatic name of the entire locale, - * with the language, country and variant separated by underbars. - * Language is always lower case, and country is always upper case. - * If the language is missing, the string will begin with an underbar. - * If both the language and country fields are missing, this function - * will return the empty string, even if the variant field is filled in - * (you can't have a locale with just a variant-- the variant must accompany - * a valid language or country code). - * Examples: "en", "de_DE", "_GB", "en_US_WIN", "de__POSIX", "fr__MAC" + * Package locale method returning the Locale's BaseLocale, + * used by ResourceBundle + * @return base locale of this Locale + */ + BaseLocale getBaseLocale() { + return _baseLocale; + } + + /** + * Package local method returning the Locale's LocaleExtensions, + * used by ResourceBundle + * @return locale exnteions of this Locale + */ + LocaleExtensions getLocaleExtensions() { + return _extensions; + } + + /** + * Returns a string representation of this <code>Locale</code> + * object, consisting of language, country, variant, script, + * and extensions as below: + * <p><blockquote> + * language + "_" + country + "_" + (variant + "_#" | "#") + script + "-" + extensions + * </blockquote> + * + * Language is always lower case, country is always upper case, script is always title + * case, and extensions are always lower case. Extensions and private use subtags + * will be in canonical order as explained in {@link #toLanguageTag}. + * + * <p>When the locale has neither script nor extensions, the result is the same as in + * Java 6 and prior. + * + * <p>If both the language and country fields are missing, this function will return + * the empty string, even if the variant, script, or extensions field is present (you + * can't have a locale with just a variant, the variant must accompany a well-formed + * language or country code). + * + * <p>If script or extensions are present and variant is missing, no underscore is + * added before the "#". + * + * <p>This behavior is designed to support debugging and to be compatible with + * previous uses of <code>toString</code> that expected language, country, and variant + * fields only. To represent a Locale as a String for interchange purposes, use + * {@link #toLanguageTag}. + * + * <p>Examples: <ul><tt> + * <li>en + * <li>de_DE + * <li>_GB + * <li>en_US_WIN + * <li>de__POSIX + * <li>zh_CN_#Hans + * <li>zh_TW_#Hant-x-java + * <li>th_TH_TH_#u-nu-thai</tt></ul> + * + * @return A string representation of the Locale, for debugging. * @see #getDisplayName + * @see #toLanguageTag */ public final String toString() { - boolean l = language.length() != 0; - boolean c = country.length() != 0; - boolean v = variant.length() != 0; - StringBuilder result = new StringBuilder(language); - if (c||(l&&v)) { - result.append('_').append(country); // This may just append '_' + boolean l = (_baseLocale.getLanguage().length() != 0); + boolean s = (_baseLocale.getScript().length() != 0); + boolean r = (_baseLocale.getRegion().length() != 0); + boolean v = (_baseLocale.getVariant().length() != 0); + boolean e = (_extensions.getID().length() != 0); + + StringBuilder result = new StringBuilder(_baseLocale.getLanguage()); + if (r || (l && v)) { + result.append('_') + .append(_baseLocale.getRegion()); // This may just append '_' + } + if (v && (l || r)) { + result.append('_') + .append(_baseLocale.getVariant()); } - if (v&&(l||c)) { - result.append('_').append(variant); + + if (s && (l || r)) { + result.append("_#") + .append(_baseLocale.getScript()); } + + if (e && (l || r)) { + result.append('_'); + if (!s) { + result.append('#'); + } + result.append(_extensions.getID()); + } + return result.toString(); } /** - * Returns a three-letter abbreviation for this locale's language. If the locale - * doesn't specify a language, this will be the empty string. Otherwise, this will - * be a lowercase ISO 639-2/T language code. - * The ISO 639-2 language codes can be found on-line at - * <a href="http://www.loc.gov/standards/iso639-2/englangn.html"> - * <code>http://www.loc.gov/standards/iso639-2/englangn.html</code>.</a> - * @exception MissingResourceException Throws MissingResourceException if the + * Returns a well-formed IETF BCP 47 language tag representing + * this locale. + * + * <p>If this <code>Locale</code> has a language, country, or + * variant that does not satisfy the IETF BCP 47 language tag + * syntax requirements, this method handles these fields as + * described below: + * + * <p><b>Language:</b> If language is empty, or not <a + * href="#def_language" >well-formed</a> (for example "a" or + * "e2"), it will be emitted as "und" (Undetermined). + * + * <p><b>Country:</b> If country is not <a + * href="#def_region">well-formed</a> (for example "12" or "USA"), + * it will be omitted. + * + * <p><b>Variant:</b> If variant <b>is</b> <a + * href="#def_variant">well-formed</a>, each sub-segment + * (delimited by '-' or '_') is emitted as a subtag. Otherwise: + * <ul> + * + * <li>if all sub-segments match <code>[0-9a-zA-Z]{1,8}</code> + * (for example "WIN" or "Oracle_JDK_Standard_Edition"), the first + * ill-formed sub-segment and all following will be appended to + * the private use subtag. The first appended subtag will be + * "lvariant", followed by the sub-segments in order, separated by + * hyphen. For example, "x-lvariant-WIN", + * "Oracle-x-lvariant-JDK-Standard-Edition". + * + * <li>if any sub-segment does not match + * <code>[0-9a-zA-Z]{1,8}</code>, the variant will be truncated + * and the problematic sub-segment and all following sub-segments + * will be omitted. If the remainder is non-empty, it will be + * emitted as a private use subtag as above (even if the remainder + * turns out to be well-formed). For example, + * "Solaris_isjustthecoolestthing" is emitted as + * "x-lvariant-Solaris", not as "solaris".</li></ul> + * + * <p><b>Compatibility special cases:</b><ul> + * + * <li>The language codes "iw", "ji", and "in" are handled + * specially. Java uses these deprecated codes for compatibility + * reasons. The <code>toLanguageTag</code> method converts these + * three codes (and only these three) to "he", "yi", and "id" + * respectively. + * + * <li>A locale with language "no", country "NO", and variant + * "NY", representing Norwegian Nynorsk, will be represented as + * having language "nn", country "NO", and empty variant. This is + * because some JVMs used the deprecated form to represent the + * user's default locale, and for compatibility reasons that Take a has + * not been changed.</ul> + * + * <p><b>Note:</b> Although the language tag created by this + * method is well-formed (satisfies the syntax requirements + * defined by the IETF BCP 47 specification), it is not + * necessarily a valid BCP 47 language tag. For example, + * <pre> + * new Locale("xx", "YY").toLanguageTag();</pre> + * + * will return "xx-YY", but the language subtag "xx" and the + * region subtag "YY" are invalid because they are not registered + * in the IANA Language Subtag Registry. + * + * @return a BCP47 language tag representing the locale + * @see #forLanguageTag(String) + * @since 1.7 + */ + public String toLanguageTag() { + LanguageTag tag = LanguageTag.parseLocale(_baseLocale, _extensions); + StringBuilder buf = new StringBuilder(); + + String subtag = tag.getLanguage(); + buf.append(LanguageTag.canonicalizeLanguage(subtag)); + + subtag = tag.getScript(); + if (subtag.length() > 0) { + buf.append(LanguageTag.SEP); + buf.append(LanguageTag.canonicalizeScript(subtag)); + } + + subtag = tag.getRegion(); + if (subtag.length() > 0) { + buf.append(LanguageTag.SEP); + buf.append(LanguageTag.canonicalizeRegion(subtag)); + } + + List<String>subtags = tag.getVariants(); + for (String s : subtags) { + buf.append(LanguageTag.SEP); + // preserve casing + buf.append(s); + } + + subtags = tag.getExtensions(); + for (String s : subtags) { + buf.append(LanguageTag.SEP); + buf.append(LanguageTag.canonicalizeExtension(s)); + } + + subtag = tag.getPrivateuse(); + if (subtag.length() > 0) { + buf.append(LanguageTag.SEP).append(LanguageTag.PRIVATEUSE).append(LanguageTag.SEP); + // preserve casing + buf.append(subtag); + } + + return buf.toString(); + } + + /** + * Returns a locale for the specified IETF BCP 47 language tag string. + * + * <p>If the specified language tag contains any ill-formed subtags, + * the first such subtag and all following subtags are ignored. Compare + * to {@link Locale.Builder#setLanguageTag} which throws an exception + * in this case. + * + * <p>The following <b>conversions</b> are performed:<ul> + * + * <li>The language code "und" is mapped to language "". + * + * <li>The language codes "he", "yi", and "id" are mapped to "iw", + * "ji", and "in" respectively. (This is the same canonicalization + * that's done in Locale's constructors.) + * + * <li>The portion of a private use subtag prefixed by "lvariant", + * if any, is removed and appended to the variant field in the + * result locale (without case normalization). If it is then + * empty, the private use subtag is discarded: + * + * <pre> + * Locale loc; + * loc = Locale.forLanguageTag("en-US-x-lvariant-POSIX); + * loc.getVariant(); // returns "POSIX" + * loc.getExtension('x'); // returns null + * + * loc = Locale.forLanguageTag("de-POSIX-x-URP-lvariant-Abc-Def"); + * loc.getVariant(); // returns "POSIX_Abc_Def" + * loc.getExtension('x'); // returns "urp" + * </pre> + * + * <li>When the languageTag argument contains an extlang subtag, + * the first such subtag is used as the language, and the primary + * language subtag and other extlang subtags are ignored: + * + * <pre> + * Locale.forLanguageTag("ar-aao").getLanguage(); // returns "aao" + * Locale.forLanguageTag("en-abc-def-us").toString(); // returns "abc_US" + * </pre> + * + * <li>Case is normalized except for variant tags, which are left + * unchanged. Language is normalized to lower case, script to + * title case, country to upper case, and extensions to lower + * case. + * + * <li>If, after processing, the locale would exactly match either + * ja_JP_JP or th_TH_TH with no extensions, the appropriate + * extensions are added as though the constructor had been called: + * + * <pre> + * Locale.forLanguageTag("ja-JP-x-lvariant-JP).toLanguageTag(); + * // returns ja-JP-u-ca-japanese-x-lvariant-JP + * Locale.forLanguageTag("th-TH-x-lvariant-TH).toLanguageTag(); + * // returns th-TH-u-nu-thai-x-lvariant-TH + * <pre></ul> + * + * <p>This implements the 'Language-Tag' production of BCP47, and + * so supports grandfathered (regular and irregular) as well as + * private use language tags. Stand alone private use tags are + * represented as empty language and extension 'x-whatever', + * and grandfathered tags are converted to their canonical replacements + * where they exist. + * + * <p>Grandfathered tags with canonical replacements are as follows: + * + * <table> + * <tbody align="center"> + * <tr><th>grandfathered tag</th><th> </th><th>modern replacement</th></tr> + * <tr><td>art-lojban</td><td> </td><td>jbo</td></tr> + * <tr><td>i-ami</td><td> </td><td>ami</td></tr> + * <tr><td>i-bnn</td><td> </td><td>bnn</td></tr> + * <tr><td>i-hak</td><td> </td><td>hak</td></tr> + * <tr><td>i-klingon</td><td> </td><td>tlh</td></tr> + * <tr><td>i-lux</td><td> </td><td>lb</td></tr> + * <tr><td>i-navajo</td><td> </td><td>nv</td></tr> + * <tr><td>i-pwn</td><td> </td><td>pwn</td></tr> + * <tr><td>i-tao</td><td> </td><td>tao</td></tr> + * <tr><td>i-tay</td><td> </td><td>tay</td></tr> + * <tr><td>i-tsu</td><td> </td><td>tsu</td></tr> + * <tr><td>no-bok</td><td> </td><td>nb</td></tr> + * <tr><td>no-nyn</td><td> </td><td>nn</td></tr> + * <tr><td>sgn-BE-FR</td><td> </td><td>sfb</td></tr> + * <tr><td>sgn-BE-NL</td><td> </td><td>vgt</td></tr> + * <tr><td>sgn-CH-DE</td><td> </td><td>sgg</td></tr> + * <tr><td>zh-guoyu</td><td> </td><td>cmn</td></tr> + * <tr><td>zh-hakka</td><td> </td><td>hak</td></tr> + * <tr><td>zh-min-nan</td><td> </td><td>nan</td></tr> + * <tr><td>zh-xiang</td><td> </td><td>hsn</td></tr> + * </tbody> + * </table> + * + * <p>Grandfathered tags with no modern replacement will be + * converted as follows: + * + * <table> + * <tbody align="center"> + * <tr><th>grandfathered tag</th><th> </th><th>converts to</th></tr> + * <tr><td>cel-gaulish</td><td> </td><td>xtg-x-cel-gaulish</td></tr> + * <tr><td>en-GB-oed</td><td> </td><td>en-GB-x-oed</td></tr> + * <tr><td>i-default</td><td> </td><td>en-x-i-default</td></tr> + * <tr><td>i-enochian</td><td> </td><td>und-x-i-enochian</td></tr> + * <tr><td>i-mingo</td><td> </td><td>see-x-i-mingo</td></tr> + * <tr><td>zh-min</td><td> </td><td>nan-x-zh-min</td></tr> + * </tbody> + * </table> + * + * <p>For a list of all grandfathered tags, see the + * IANA Language Subtag Registry (search for "Type: grandfathered"). + * + * <p><b>Note</b>: there is no guarantee that <code>toLanguageTag</code> + * and <code>forLanguageTag</code> will round-trip. + * + * @param languageTag the language tag + * @return The locale that best represents the language tag. + * @throws NullPointerException if <code>languageTag</code> is <code>null</code> + * @see #toLanguageTag() + * @see java.util.Locale.Builder#setLanguageTag(String) + * @since 1.7 + */ + public static Locale forLanguageTag(String languageTag) { + LanguageTag tag = LanguageTag.parse(languageTag, null); + InternalLocaleBuilder bldr = new InternalLocaleBuilder(); + bldr.setLanguageTag(tag); + return getInstance(bldr.getBaseLocale(), bldr.getLocaleExtensions()); + } + + /** + * Returns a three-letter abbreviation of this locale's language. + * If the language matches an ISO 639-1 two-letter code, the + * corresponding ISO 639-2/T three-letter lowercase code is + * returned. The ISO 639-2 language codes can be found on-line, + * see "Codes for the Representation of Names of Languages Part 2: + * Alpha-3 Code". If the locale specifies a three-letter + * language, the language is returned as is. If the locale does + * not specify a language the empty string is returned. + * + * @return A three-letter abbreviation of this locale's language. + * @exception MissingResourceException Throws MissingResourceException if * three-letter language abbreviation is not available for this locale. */ public String getISO3Language() throws MissingResourceException { - String language3 = getISO3Code(language, LocaleISOData.isoLanguageTable); + String language3 = getISO3Code(_baseLocale.getLanguage(), LocaleISOData.isoLanguageTable); if (language3 == null) { throw new MissingResourceException("Couldn't find 3-letter language code for " - + language, "FormatData_" + toString(), "ShortLanguage"); + + _baseLocale.getLanguage(), "FormatData_" + toString(), "ShortLanguage"); } return language3; } /** - * Returns a three-letter abbreviation for this locale's country. If the locale - * doesn't specify a country, this will be the empty string. Otherwise, this will - * be an uppercase ISO 3166 3-letter country code. - * The ISO 3166-2 country codes can be found on-line at - * <a href="http://www.davros.org/misc/iso3166.txt"> - * <code>http://www.davros.org/misc/iso3166.txt</code>.</a> + * Returns a three-letter abbreviation for this locale's country. + * If the country matches an ISO 3166-1 alpha-2 code, the + * corresponding ISO 3166-1 alpha-3 uppercase code is returned. + * If the locale doesn't specify a country, this will be the empty + * string. + * + * <p>The ISO 3166-1 codes can be found on-line. + * + * @return A three-letter abbreviation of this locale's country. * @exception MissingResourceException Throws MissingResourceException if the * three-letter country abbreviation is not available for this locale. */ public String getISO3Country() throws MissingResourceException { - String country3 = getISO3Code(country, LocaleISOData.isoCountryTable); + String country3 = getISO3Code(_baseLocale.getRegion(), LocaleISOData.isoCountryTable); if (country3 == null) { throw new MissingResourceException("Couldn't find 3-letter country code for " - + country, "FormatData_" + toString(), "ShortCountry"); + + _baseLocale.getRegion(), "FormatData_" + toString(), "ShortCountry"); } return country3; } @@ -782,7 +1528,33 @@ * @exception NullPointerException if <code>inLocale</code> is <code>null</code> */ public String getDisplayLanguage(Locale inLocale) { - return getDisplayString(language, inLocale, DISPLAY_LANGUAGE); + return getDisplayString(_baseLocale.getLanguage(), inLocale, DISPLAY_LANGUAGE); + } + + /** + * Returns a name for the the locale's script that is appropriate for display to + * the user. If possible, the name will be localized for the default locale. Returns + * the empty string if this locale doesn't specify a script code. + * + * @return the display name of the script code for the current default locale + * @since 1.7 + */ + public String getDisplayScript() { + return getDisplayScript(getDefault()); + } + + /** + * Returns a name for the locale's script that is appropriate + * for display to the user. If possible, the name will be + * localized for the given locale. Returns the empty string if + * this locale doesn't specify a script code. + * + * @return the display name of the script code for the current default locale + * @throws NullPointerException if <code>inLocale</code> is <code>null</code> + * @since 1.7 + */ + public String getDisplayScript(Locale inLocale) { + return getDisplayString(_baseLocale.getScript(), inLocale, DISPLAY_SCRIPT); } /** @@ -817,7 +1589,7 @@ * @exception NullPointerException if <code>inLocale</code> is <code>null</code> */ public String getDisplayCountry(Locale inLocale) { - return getDisplayString(country, inLocale, DISPLAY_COUNTRY); + return getDisplayString(_baseLocale.getRegion(), inLocale, DISPLAY_COUNTRY); } private String getDisplayString(String code, Locale inLocale, int type) { @@ -876,7 +1648,7 @@ * @exception NullPointerException if <code>inLocale</code> is <code>null</code> */ public String getDisplayVariant(Locale inLocale) { - if (variant.length() == 0) + if (_baseLocale.getVariant().length() == 0) return ""; OpenListResourceBundle bundle = LocaleData.getLocaleNames(inLocale); @@ -897,39 +1669,44 @@ /** * Returns a name for the locale that is appropriate for display to the - * user. This will be the values returned by getDisplayLanguage(), getDisplayCountry(), - * and getDisplayVariant() assembled into a single string. The display name will have - * one of the following forms:<p><blockquote> - * language (country, variant)<p> - * language (country)<p> - * language (variant)<p> - * country (variant)<p> - * language<p> - * country<p> - * variant<p></blockquote> - * depending on which fields are specified in the locale. If the language, country, - * and variant fields are all empty, this function returns the empty string. + * user. This will be the values returned by getDisplayLanguage(), + * getDisplayScript(), getDisplayCountry(), and getDisplayVariant() assembled + * into a single string. The the non-empty values are used in order, + * with the second and subsequent names in parentheses. For example: + * <blockquote> + * language (script, country, variant)<br> + * language (country)<br> + * language (variant)<br> + * script (country)<br> + * country<br> + * </blockquote> + * depending on which fields are specified in the locale. If the + * language, sacript, country, and variant fields are all empty, + * this function returns the empty string. */ public final String getDisplayName() { return getDisplayName(getDefault(Category.DISPLAY)); } /** - * Returns a name for the locale that is appropriate for display to the - * user. This will be the values returned by getDisplayLanguage(), getDisplayCountry(), - * and getDisplayVariant() assembled into a single string. The display name will have - * one of the following forms:<p><blockquote> - * language (country, variant)<p> - * language (country)<p> - * language (variant)<p> - * country (variant)<p> - * language<p> - * country<p> - * variant<p></blockquote> - * depending on which fields are specified in the locale. If the language, country, - * and variant fields are all empty, this function returns the empty string. + * Returns a name for the locale that is appropriate for display + * to the user. This will be the values returned by + * getDisplayLanguage(), getDisplayScript(),getDisplayCountry(), + * and getDisplayVariant() assembled into a single string. + * The non-empty values are used in order, + * with the second and subsequent names in parentheses. For example: + * <blockquote> + * language (script, country, variant)<br> + * language (country)<br> + * language (variant)<br> + * script (country)<br> + * country<br> + * </blockquote> + * depending on which fields are specified in the locale. If the + * language, script, country, and variant fields are all empty, + * this function returns the empty string. * - * @exception NullPointerException if <code>inLocale</code> is <code>null</code> + * @throws NullPointerException if <code>inLocale</code> is <code>null</code> */ public String getDisplayName(Locale inLocale) { OpenListResourceBundle bundle = LocaleData.getLocaleNames(inLocale); @@ -1009,7 +1786,7 @@ } /** - * Overrides Cloneable + * Overrides Cloneable. */ public Object clone() { @@ -1029,7 +1806,7 @@ public int hashCode() { int hc = hashCodeValue; if (hc == 0) { - hc = (language.hashCode() << 8) ^ country.hashCode() ^ (variant.hashCode() << 4); + hc = _baseLocale.hashCode() ^ _extensions.hashCode(); hashCodeValue = hc; } return hc; @@ -1039,8 +1816,8 @@ /** * Returns true if this Locale is equal to another object. A Locale is - * deemed equal to another Locale with identical language, country, - * and variant, and unequal to all other objects. + * deemed equal to another Locale with identical language, script, country, + * variant and extensions, and unequal to all other objects. * * @return true if this Locale is equal to the specified object. */ @@ -1050,43 +1827,18 @@ return true; if (!(obj instanceof Locale)) return false; - Locale other = (Locale) obj; - return language == other.language - && country == other.country - && variant == other.variant; + BaseLocale otherBase = ((Locale)obj)._baseLocale; + LocaleExtensions otherExt = ((Locale)obj)._extensions; + return _baseLocale.equals(otherBase) && _extensions.equals(otherExt); } // ================= privates ===================================== - // XXX instance and class variables. For now keep these separate, since it is - // faster to match. Later, make into single string. - - /** - * @serial - * @see #getLanguage - */ - private final String language; + private transient BaseLocale _baseLocale; + private transient LocaleExtensions _extensions; /** - * @serial - * @see #getCountry - */ - private final String country; - - /** - * @serial - * @see #getVariant - */ - private final String variant; - - /** - * Placeholder for the object's hash code. Always -1. - * @serial - */ - private volatile int hashcode = -1; // lazy evaluate - - /** - * Calculated hashcode to fix 4518797. + * Calculated hashcode */ private transient volatile int hashCodeValue = 0; @@ -1101,7 +1853,7 @@ */ private String[] getDisplayVariantArray(OpenListResourceBundle bundle, Locale inLocale) { // Split the variant name into tokens separated by '_'. - StringTokenizer tokenizer = new StringTokenizer(variant, "_"); + StringTokenizer tokenizer = new StringTokenizer(_baseLocale.getVariant(), "_"); String[] names = new String[tokenizer.countTokens()]; // For each variant token, lookup the display name. If @@ -1179,49 +1931,102 @@ } /** - * Replace the deserialized Locale object with a newly - * created object. Newer language codes are replaced with older ISO - * codes. The country and variant codes are replaced with internalized - * String copies. + * @serialField language String + * language subtag in lower case. (See <a href="java/util/Locale.html#getLanguage()">getLanguage()</a>) + * @serialField country String + * country subtag in upper case. (See <a href="java/util/Locale.html#getCountry()">getCountry()</a>) + * @serialField variant String + * variant subtags separated by LOWLINE characters. (See <a href="java/util/Locale.html#getVariant()">getVariant()</a>) + * @serialField hashcode int + * deprectated, for forward compatibility only + * @serialField script String + * script subtag in title case (See <a href="java/util/Locale.html#getScript()">getScript()</a>) + * @serialField extensions String + * canonical representation of extensions, that is, + * BCP47 extensions in alphabetical order followed by + * BCP47 private use subtags, all in lower case letters + * separated by HYPHEN-MINUS characters. + * (See <a href="java/util/Locale.html#getExtensionKeys()">getExtensionKeys()</a>, + * <a href="java/util/Locale.html#getExtension(char)">getExtension(char)</a>) + */ + private static final ObjectStreamField[] serialPersistentFields = { + new ObjectStreamField("language", String.class), + new ObjectStreamField("country", String.class), + new ObjectStreamField("variant", String.class), + new ObjectStreamField("hashcode", int.class), + new ObjectStreamField("script", String.class), + new ObjectStreamField("extensions", String.class), + }; + + /** + * Serializes this <code>Locale</code> to the specified <code>ObjectOutputStream</code>. + * @param out the <code>ObjectOutputStream</code> to write + * @throws IOException + * @since 1.7 + */ + private void writeObject(ObjectOutputStream out) throws IOException { + ObjectOutputStream.PutField fields = out.putFields(); + fields.put("language", _baseLocale.getLanguage()); + fields.put("script", _baseLocale.getScript()); + fields.put("country", _baseLocale.getRegion()); + fields.put("variant", _baseLocale.getVariant()); + fields.put("extensions", _extensions.getID()); + fields.put("hashcode", -1); // place holder just for backward support + out.writeFields(); + } + + /** + * Deserialize this <code>Locale</code>. + * @param in the <code>ObjectInputStream</code> to read + * @throws IOException + * @throws ClassNotFoundException + * @throws IllformdLocaleException + * @since 1.7 + */ + private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { + ObjectInputStream.GetField fields = in.readFields(); + String language = (String)fields.get("language", ""); + String script = (String)fields.get("script", ""); + String country = (String)fields.get("country", ""); + String variant = (String)fields.get("variant", ""); + String extStr = (String)fields.get("extensions", ""); + _baseLocale = BaseLocale.getInstance(convertOldISOCodes(language), script, country, variant); + try { + InternalLocaleBuilder bldr = new InternalLocaleBuilder(); + bldr.setExtensions(extStr); + _extensions = bldr.getLocaleExtensions(); + } catch (LocaleSyntaxException e) { + throw new IllformedLocaleException(e.getMessage()); + } + } + + /** + * Returns a cached <code>Locale</code> instance equivalent to + * the deserialized <code>Locale</code>. When serialized + * language, country and variant fields read from the object data stream + * are exactly "ja", "JP", "JP" or "th", "TH", "TH" and script/extensions + * fields are empty, this method supplies <code>UNICODE_LOCALE_EXTENSION</code> + * "ca"/"japanese" (calendar type is "japanese") or "nu"/"thai" (number script + * type is "thai"). See <a href="Locale.html#special_cases_constructor"/>Special Cases</a> + * for more information. + * + * @return an instance of <code>Locale</code> equivalent to + * the deserialized <code>Locale</code>. + * @throws java.io.ObjectStreamException */ private Object readResolve() throws java.io.ObjectStreamException { - return getInstance(language, country, variant); + return getInstance(_baseLocale.getLanguage(), _baseLocale.getScript(), + _baseLocale.getRegion(), _baseLocale.getVariant(), _extensions); } private static volatile String[] isoLanguages = null; private static volatile String[] isoCountries = null; - /* - * Locale needs its own, locale insensitive version of toLowerCase to - * avoid circularity problems between Locale and String. - * The most straightforward algorithm is used. Look at optimizations later. - */ - private String toLowerCase(String str) { - char[] buf = new char[str.length()]; - for (int i = 0; i < buf.length; i++) { - buf[i] = Character.toLowerCase(str.charAt(i)); - } - return new String( buf ); - } - - /* - * Locale needs its own, locale insensitive version of toUpperCase to - * avoid circularity problems between Locale and String. - * The most straightforward algorithm is used. Look at optimizations later. - */ - private String toUpperCase(String str) { - char[] buf = new char[str.length()]; - for (int i = 0; i < buf.length; i++) { - buf[i] = Character.toUpperCase(str.charAt(i)); - } - return new String( buf ); - } - - private String convertOldISOCodes(String language) { + private static String convertOldISOCodes(String language) { // we accept both the old and the new ISO codes for the languages whose ISO // codes have changed, but we always store the OLD code, for backward compatibility - language = toLowerCase(language).intern(); + language = AsciiUtil.toLowerString(language).intern(); if (language == "he") { return "iw"; } else if (language == "yi") { @@ -1233,6 +2038,25 @@ } } + private static LocaleExtensions getCompatibilityExtensions(String language, String script, String country, String variant) { + LocaleExtensions extensions = LocaleExtensions.EMPTY_EXTENSIONS; + // Special cases for backward compatibility support + if (AsciiUtil.caseIgnoreMatch(language, "ja") + && script.length() == 0 + && AsciiUtil.caseIgnoreMatch(country, "JP") + && AsciiUtil.caseIgnoreMatch(variant, "JP")) { + // ja_JP_JP -> u-ca-japanese (calendar = japanese) + extensions = LocaleExtensions.CALENDAR_JAPANESE; + } else if (AsciiUtil.caseIgnoreMatch(language, "th") + && script.length() == 0 + && AsciiUtil.caseIgnoreMatch(country, "TH") + && AsciiUtil.caseIgnoreMatch(variant, "TH")) { + // th_TH_TH -> u-nu-thai (numbersystem = thai) + extensions = LocaleExtensions.NUMBER_THAI; + } + return extensions; + } + /** * Obtains a localized locale names from a LocaleNameProvider * implementation. @@ -1256,6 +2080,8 @@ return localeNameProvider.getDisplayCountry(code, locale); case DISPLAY_VARIANT: return localeNameProvider.getDisplayVariant(code, locale); + case DISPLAY_SCRIPT: + return localeNameProvider.getDisplayScript(code, locale); default: assert false; // shouldn't happen } @@ -1287,4 +2113,346 @@ */ FORMAT, } + + /** + * <code>Builder</code> is used to build instances of <code>Locale</code> + * from values configured by the setters. Unlike the <code>Locale</code> + * constructors, the <code>Builder</code> checks if a value configured by a + * setter satisfies the syntax requirements defined by the <code>Locale</code> + * class. A <code>Locale</code> object created by a <code>Builder</code> is + * well-formed and can be transformed to a well-formed IETF BCP 47 language tag + * without losing information. + * + * <p><b>Note:</b> The <code>Locale</code> class does not provide any + * syntactic restrictions on variant, while BCP 47 requires each variant + * subtag to be 5 to 8 alphanumerics or a single numeric followed by 3 + * alphanumerics. The method <code>setVariant</code> throws + * <code>IllformedLocaleException</code> for a variant that does not satisfy + * this restriction. If it is necessary to support such a variant, use a + * Locale constructor. However, keep in mind that a <code>Locale</code> + * object created this way might lose the variant information when + * transformed to a BCP 47 language tag. + * + * <p>The following example shows how to create a <code>Locale</code> object + * with the <code>Builder</code>. + * <blockquote> + * <pre> + * Locale aLocale = new Builder().setLanguage("sr").setScript("Latn").setRegion("RS").build(); + * </pre> + * </blockquote> + * + * <p>Builders can be reused; <code>clear()</code> resets all + * fields to their default values. + * + * @see Locale#forLanguageTag + * @since 1.7 + */ + public static final class Builder { + private InternalLocaleBuilder _locbld; + + /** + * Constructs an empty Builder. The default value of all + * fields, extensions, and private use information is the + * empty string. + */ + public Builder() { + _locbld = new InternalLocaleBuilder(); + } + + /** + * Resets the <code>Builder</code> to match the provided + * <code>locale</code>. Existing state is discarded. + * + * <p>All fields of the locale must be well-formed, see {@link Locale}. + * + * <p>Locales with any ill-formed fields cause + * <code>IllformedLocaleException</code> to be thrown, except for the + * following three cases which are accepted for compatibility + * reasons:<ul> + * <li>Locale("ja", "JP", "JP") is treated as "ja-JP-u-ca-japanese" + * <li>Locale("th", "TH", "TH") is treated as "th-TH-u-nu-thai" + * <li>Locale("no", "NO", "NY") is treated as "nn-NO"</ul> + * + * @param locale the locale + * @return This builder. + * @throws IllformedLocaleException if <code>locale</code> has + * any ill-formed fields. + * @throws NullPointerException if <code>locale</code> is null. + */ + public Builder setLocale(Locale locale) { + try { + _locbld.setLocale(locale._baseLocale, locale._extensions); + } catch (LocaleSyntaxException e) { + throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex()); + } + return this; + } + + /** + * Resets the Builder to match the provided IETF BCP 47 + * language tag. Discards the existing state. Null and the + * empty string cause the builder to be reset, like {@link + * #clear}. Grandfathered tags (see {@link + * Locale#forLanguageTag}) are converted to their canonical + * form before being processed. Otherwise, the language tag + * must be well-formed (see {@link Locale}) or an exception is + * thrown (unlike <code>Locale.forLanguageTag</code>, which + * just discards ill-formed and following portions of the + * tag). + * + * @param languageTag the language tag + * @return This builder. + * @throws IllformedLocaleException if <code>languageTag</code> is ill-formed + * @see Locale#forLanguageTag(String) + */ + public Builder setLanguageTag(String languageTag) { + ParseStatus sts = new ParseStatus(); + LanguageTag tag = LanguageTag.parse(languageTag, sts); + if (sts.isError()) { + throw new IllformedLocaleException(sts.getErrorMessage(), sts.getErrorIndex()); + } + _locbld.setLanguageTag(tag); + + return this; + } + + /** + * Sets the language. If <code>language</code> is the empty string or + * null, the language in this <code>Builder</code> is removed. Otherwise, + * the language must be <a href="./Locale.html#def_language">well-formed</a> + * or an exception is thrown. + * + * <p>The typical language value is a two or three-letter language + * code as defined in ISO639. + * + * @param language the language + * @return This builder. + * @throws IllformedLocaleException if <code>language</code> is ill-formed + */ + public Builder setLanguage(String language) { + try { + _locbld.setLanguage(language); + } catch (LocaleSyntaxException e) { + throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex()); + } + return this; + } + + /** + * Sets the script. If <code>script</code> is null or the empty string, + * the script in this <code>Builder</code> is removed. + * Otherwise, the script must be <a href="./Locale.html#def_script">well-formed</a> or an + * exception is thrown. + * + * <p>The typical script value is a four-letter script code as defined by ISO 15924. + * + * @param script the script + * @return This builder. + * @throws IllformedLocaleException if <code>script</code> is ill-formed + */ + public Builder setScript(String script) { + try { + _locbld.setScript(script); + } catch (LocaleSyntaxException e) { + throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex()); + } + return this; + } + + /** + * Sets the region. If region is null or the empty string, the region + * in this <code>Builder</code> is removed. Otherwise, + * the region must be <a href="./Locale.html#def_region">well-formed</a> or an + * exception is thrown. + * + * <p>The typical region value is a two-letter ISO 3166 code or a + * three-digit UN M.49 area code. + * + * <p>The country value in the <code>Locale</code> created by the + * <code>Builder</code> is always normalized to upper case. + * + * @param region the region + * @return This builder. + * @throws IllformedLocaleException if <code>region</code> is ill-formed + */ + public Builder setRegion(String region) { + try { + _locbld.setRegion(region); + } catch (LocaleSyntaxException e) { + throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex()); + } + return this; + } + + /** + * Sets the variant. If variant is null or the empty string, the + * variant in this <code>Builder</code> is removed. Otherwise, it + * must consist of one or more <a href="./Locale.html#def_variant">well-formed</a> + * subtags, or an exception is thrown. + * + * <p><b>Note:</b> This method checks if <code>variant</code> + * satisfies the IETF BCP 47 variant subtag's syntax requirements, + * and normalizes the value to lowercase letters. However, + * the <code>Locale</code> class does not impose any syntactic + * restriction on variant, and the variant value in + * <code>Locale</code> is case sensitive. To set such a variant, + * use a Locale constructor. + * + * @param variant the variant + * @return This builder. + * @throws IllformedLocaleException if <code>variant</code> is ill-formed + */ + public Builder setVariant(String variant) { + try { + _locbld.setVariant(variant); + } catch (LocaleSyntaxException e) { + throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex()); + } + return this; + } + + /** + * Sets the extension for the given key. If the value is null or the + * empty string, the extension is removed. Otherwise, the extension + * must be <a href="./Locale.html#def_extensions">well-formed</a> or an exception + * is thrown. + * + * <p><b>Note:</b> The key {@link Locale#UNICODE_LOCALE_EXTENSION + * UNICODE_LOCALE_EXTENSION} ('u') is used for the Unicode locale extension. + * Setting a value for this key replaces any existing Unicode locale key/type + * pairs with those defined in the extension. + * + * <p><b>Note:</b> The key {@link Locale#PRIVATE_USE_EXTENSION + * PRIVATE_USE_EXTENSION} ('x') is used for the private use code. To be + * well-formed, the value for this key needs only to have subtags of one to + * eight alphanumeric characters, not two to eight as in the general case. + * + * @param key the extension key + * @param value the extension value + * @return This builder. + * @throws IllformedLocaleException if <code>key</code> is illegal + * or <code>value</code> is ill-formed + * @see #setUnicodeLocaleKeyword(String, String) + */ + public Builder setExtension(char key, String value) { + try { + _locbld.setExtension(key, value); + } catch (LocaleSyntaxException e) { + throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex()); + } + return this; + } + + /** + * Sets the Unicode locale keyword type for the given key. If the type + * is null, the Unicode keyword is removed. Otherwise, the key must be + * non-null and both key and type must be <a + * href="./Locale.html#def_locale_extension">well-formed</a> or an exception + * is thrown. + * + * <p>Keys and types are converted to lower case. + * + * <p><b>Note</b>:Setting the 'u' extension via {@link #setExtension} + * replaces all Unicode locale keywords with those defined in the + * extension. + * + * @param key the Unicode locale key + * @param type the Unicode locale type + * @return This builder. + * @throws IllformedLocaleException if <code>key</code> or <code>type</code> + * is ill-formed + * @throws NullPointerException if <code>key</code> is null + * @see #setExtension(char, String) + */ + public Builder setUnicodeLocaleKeyword(String key, String type) { + try { + _locbld.setUnicodeLocaleKeyword(key, type); + } catch (LocaleSyntaxException e) { + throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex()); + } + return this; + } + + /** + * Adds a unicode locale attribute, if not already present, otherwise + * has no effect. The attribute must not be null and must be <a + * href="./Locale.html#def_locale_extension">well-formed</a> or an exception + * is thrown. + * + * @param attribute the attribute + * @return This builder. + * @throws NullPointerException if <code>attribute</code> is null + * @throws IllformedLocaleException if <code>attribute</code> is ill-formed + * @see #setExtension(char, String) + */ + public Builder addUnicodeLocaleAttribute(String attribute) { + try { + _locbld.addUnicodeLocaleAttribute(attribute); + } catch (LocaleSyntaxException e) { + throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex()); + } + return this; + } + + /** + * Removes a unicode locale attribute, if present, otherwise has no + * effect. The attribute must not be null and must be <a + * href="./Locale.html#def_locale_extension">well-formed</a> or an exception + * is thrown. + * + * <p>Attribute comparision for removal is case-insensitive. + * + * @param attribute the attribute + * @return This builder. + * @throws NullPointerException if <code>attribute</code> is null + * @throws IllformedLocaleException if <code>attribute</code> is ill-formed + * @see #setExtension(char, String) + */ + public Builder removeUnicodeLocaleAttribute(String attribute) { + try { + _locbld.removeUnicodeLocaleAttribute(attribute); + } catch (LocaleSyntaxException e) { + throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex()); + } + return this; + } + + /** + * Resets the builder to its initial, empty state. + * + * @return This builder. + */ + public Builder clear() { + _locbld.clear(); + return this; + } + + /** + * Resets the extensions to their initial, empty state. + * Language, script, region and variant are unchanged. + * + * @return This builder. + * @see #setExtension(char, String) + */ + public Builder clearExtensions() { + _locbld.clearExtensions(); + return this; + } + + /** + * Returns an instance of <code>Locale</code> created from the fields set + * on this builder. + * + * <p>This applies the conversions listed in {@link Locale#forLanguageTag} + * when constructing a Locale. (Grandfathered tags are handled in + * {@link #setLanguageTag}.) + * + * @return A Locale. + */ + public Locale build() { + BaseLocale baseloc = _locbld.getBaseLocale(); + LocaleExtensions extensions = _locbld.getLocaleExtensions(); + return Locale.getInstance(baseloc, extensions); + } + } }
--- a/src/share/classes/java/util/ResourceBundle.java Fri Sep 10 20:48:17 2010 +0400 +++ b/src/share/classes/java/util/ResourceBundle.java Fri Sep 10 15:29:40 2010 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -56,16 +56,18 @@ import java.util.concurrent.ConcurrentMap; import java.util.jar.JarEntry; +import sun.util.locale.BaseLocale; +import sun.util.locale.LocaleExtensions; +import sun.util.locale.LocaleObjectCache; + /** * - * Resource bundles contain locale-specific objects. - * When your program needs a locale-specific resource, - * a <code>String</code> for example, your program can load it - * from the resource bundle that is appropriate for the - * current user's locale. In this way, you can write - * program code that is largely independent of the user's - * locale isolating most, if not all, of the locale-specific + * Resource bundles contain locale-specific objects. When your program needs a + * locale-specific resource, a <code>String</code> for example, your program can + * load it from the resource bundle that is appropriate for the current user's + * locale. In this way, you can write program code that is largely independent + * of the user's locale isolating most, if not all, of the locale-specific * information in resource bundles. * * <p> @@ -854,87 +856,140 @@ } /** - * Gets a resource bundle using the specified base name, locale, and class loader. + * Gets a resource bundle using the specified base name, locale, and class + * loader. + * + * <p><a name="default_behavior"/>This method behaves the same as calling + * {@link #getBundle(String, Locale, ClassLoader, Control)} passing a + * default instance of {@link Control}. The following describes this behavior. + * + * <p><code>getBundle</code> uses the base name, the specified locale, and + * the default locale (obtained from {@link java.util.Locale#getDefault() + * Locale.getDefault}) to generate a sequence of <a + * name="candidates"><em>candidate bundle names</em></a>. If the specified + * locale's language, script, country, and variant are all empty strings, + * then the base name is the only candidate bundle name. Otherwise, a list + * of candidate locales is generated from the attribute values of the + * specified locale (language, script, country and variant) and appended to + * the base name. Typically, this will look like the following: + * + * <pre> + * baseName + "_" + language + "_" + script + "_" + country + "_" + variant + * baseName + "_" + language + "_" + script + "_" + country + * baseName + "_" + language + "_" + script + * baseName + "_" + language + "_" + country + "_" + variant + * baseName + "_" + language + "_" + country + * baseName + "_" + language + * </pre> * - * <p><a name="default_behavior"/> - * Conceptually, <code>getBundle</code> uses the following strategy for locating and instantiating - * resource bundles: - * <p> - * <code>getBundle</code> uses the base name, the specified locale, and the default - * locale (obtained from {@link java.util.Locale#getDefault() Locale.getDefault}) - * to generate a sequence of <a name="candidates"><em>candidate bundle names</em></a>. - * If the specified locale's language, country, and variant are all empty - * strings, then the base name is the only candidate bundle name. - * Otherwise, the following sequence is generated from the attribute - * values of the specified locale (language1, country1, and variant1) - * and of the default locale (language2, country2, and variant2): - * <ul> - * <li> baseName + "_" + language1 + "_" + country1 + "_" + variant1 - * <li> baseName + "_" + language1 + "_" + country1 - * <li> baseName + "_" + language1 - * <li> baseName + "_" + language2 + "_" + country2 + "_" + variant2 - * <li> baseName + "_" + language2 + "_" + country2 - * <li> baseName + "_" + language2 - * <li> baseName - * </ul> - * <p> - * Candidate bundle names where the final component is an empty string are omitted. - * For example, if country1 is an empty string, the second candidate bundle name is omitted. + * <p>Candidate bundle names where the final component is an empty string + * are omitted, along with the underscore. For example, if country is an + * empty string, the second and the fifth candidate bundle names above + * would be omitted. Also, if script is an empty string, the candidate names + * including script are omitted. For example, a locale with language "de" + * and variant "JAVA" will produce candidate names with base name + * "MyResource" below. + * + * <pre> + * MyResource_de__JAVA + * MyResource_de + * </pre> + * + * In the case that the variant contains one or more underscores ('_'), a + * sequence of bundle names generated by truncating the last underscore and + * the part following it is inserted after a candidate bundle name with the + * original variant. For example, for a locale with language "en", script + * "Latn, country "US" and variant "WINDOWS_VISTA", and bundle base name + * "MyResource", the list of candidate bundle names below is generated: + * + * <pre> + * MyResource_en_Latn_US_WINDOWS_VISTA + * MyResource_en_Latn_US_WINDOWS + * MyResource_en_Latn_US + * MyResource_en_Latn + * MyResource_en_US_WINDOWS_VISTA + * MyResource_en_US_WINDOWS + * MyResource_en_US + * MyResource_en + * </pre> + * + * <blockquote><b>Note:</b> For some <code>Locale</code>s, the list of + * candidate bundle names contains extra names, or the order of bundle names + * is slightly modified. See the description of the default implementation + * of {@link Control#getCandidateLocales(String, Locale) + * getCandidateLocales} for details.</blockquote> * - * <p> - * <code>getBundle</code> then iterates over the candidate bundle names to find the first - * one for which it can <em>instantiate</em> an actual resource bundle. For each candidate - * bundle name, it attempts to create a resource bundle: - * <ul> - * <li> - * First, it attempts to load a class using the candidate bundle name. - * If such a class can be found and loaded using the specified class loader, is assignment - * compatible with ResourceBundle, is accessible from ResourceBundle, and can be instantiated, - * <code>getBundle</code> creates a new instance of this class and uses it as the <em>result - * resource bundle</em>. - * <li> - * Otherwise, <code>getBundle</code> attempts to locate a property resource file. - * It generates a path name from the candidate bundle name by replacing all "." characters - * with "/" and appending the string ".properties". - * It attempts to find a "resource" with this name using - * {@link java.lang.ClassLoader#getResource(java.lang.String) ClassLoader.getResource}. - * (Note that a "resource" in the sense of <code>getResource</code> has nothing to do with - * the contents of a resource bundle, it is just a container of data, such as a file.) - * If it finds a "resource", it attempts to create a new - * {@link PropertyResourceBundle} instance from its contents. - * If successful, this instance becomes the <em>result resource bundle</em>. - * </ul> + * <p><code>getBundle</code> then iterates over the candidate bundle names + * to find the first one for which it can <em>instantiate</em> an actual + * resource bundle. It uses the default controls' {@link Control#getFormats + * getFormats} method, which generates two bundle names for each generated + * name, the first a class name and the second a properties file name. For + * each candidate bundle name, it attempts to create a resource bundle: + * + * <ul><li>First, it attempts to load a class using the generated class name. + * If such a class can be found and loaded using the specified class + * loader, is assignment compatible with ResourceBundle, is accessible from + * ResourceBundle, and can be instantiated, <code>getBundle</code> creates a + * new instance of this class and uses it as the <em>result resource + * bundle</em>. + * + * <li>Otherwise, <code>getBundle</code> attempts to locate a property + * resource file using the generated properties file name. It generates a + * path name from the candidate bundle name by replacing all "." characters + * with "/" and appending the string ".properties". It attempts to find a + * "resource" with this name using {@link + * java.lang.ClassLoader#getResource(java.lang.String) + * ClassLoader.getResource}. (Note that a "resource" in the sense of + * <code>getResource</code> has nothing to do with the contents of a + * resource bundle, it is just a container of data, such as a file.) If it + * finds a "resource", it attempts to create a new {@link + * PropertyResourceBundle} instance from its contents. If successful, this + * instance becomes the <em>result resource bundle</em>. </ul> * - * <p> - * If no result resource bundle has been found, a <code>MissingResourceException</code> - * is thrown. + * <p>This continues until a result resource bundle is instantiated or the + * list of candidate bundle names is exhausted. If no matching resource + * bundle is found, the default control's {@link Control#getFallbackLocale + * getFallbackLocale} method is called, which returns the current default + * locale. A new sequence of candidate locale names is generated using this + * locale and and searched again, as above. + * + * <p>If still no result bundle is found, the base name alone is looked up. If + * this still fails, a <code>MissingResourceException</code> is thrown. * - * <p><a name="parent_chain"/> - * Once a result resource bundle has been found, its <em>parent chain</em> is instantiated. - * <code>getBundle</code> iterates over the candidate bundle names that can be - * obtained by successively removing variant, country, and language - * (each time with the preceding "_") from the bundle name of the result resource bundle. - * As above, candidate bundle names where the final component is an empty string are omitted. - * With each of the candidate bundle names it attempts to instantiate a resource bundle, as - * described above. - * Whenever it succeeds, it calls the previously instantiated resource + * <p><a name="parent_chain"/> Once a result resource bundle has been found, + * its <em>parent chain</em> is instantiated. If the result bundle already + * has a parent (perhaps because it was returned from a cache) the chain is + * complete. + * + * <p>Otherwise, <code>getBundle</code> examines the remainder of the + * candidate locale list that was used during the pass that generated the + * result resource bundle. (As before, candidate bundle names where the + * final component is an empty string are omitted.) When it comes to the + * end of the candidate list, it tries the plain bundle name. With each of the + * candidate bundle names it attempts to instantiate a resource bundle (first + * looking for a class and then a properties file, as described above). + * + * <p>Whenever it succeeds, it calls the previously instantiated resource * bundle's {@link #setParent(java.util.ResourceBundle) setParent} method - * with the new resource bundle, unless the previously instantiated resource - * bundle already has a non-null parent. + * with the new resource bundle. This continues until the list of names + * is exhausted or the current bundle already has a non-null parent. + * + * <p>Once the parent chain is complete, the bundle is returned. * - * <p> - * <code>getBundle</code> caches instantiated resource bundles and - * may return the same resource bundle instance multiple - * times. + * <p><b>Note:</b> <code>getBundle</code> caches instantiated resource + * bundles and might return the same resource bundle instance multiple times. * - * <p> - * The <code>baseName</code> argument should be a fully qualified class name. However, for - * compatibility with earlier versions, Sun's Java SE Runtime Environments do not verify this, - * and so it is possible to access <code>PropertyResourceBundle</code>s by specifying a - * path name (using "/") instead of a fully qualified class name (using "."). + * <p><b>Note:</b>The <code>baseName</code> argument should be a fully + * qualified class name. However, for compatibility with earlier versions, + * Sun's Java SE Runtime Environments do not verify this, and so it is + * possible to access <code>PropertyResourceBundle</code>s by specifying a + * path name (using "/") instead of a fully qualified class name (using + * "."). * * <p><a name="default_behavior_example"/> - * <strong>Example:</strong><br>The following class and property files are provided: + * <strong>Example:</strong> + * <p> + * The following class and property files are provided: * <pre> * MyResources.class * MyResources.properties @@ -944,22 +999,26 @@ * MyResources_en.properties * MyResources_es_ES.class * </pre> - * The contents of all files are valid (that is, public non-abstract subclasses of <code>ResourceBundle</code> for - * the ".class" files, syntactically correct ".properties" files). - * The default locale is <code>Locale("en", "GB")</code>. - * <p> - * Calling <code>getBundle</code> with the shown locale argument values instantiates - * resource bundles from the following sources: - * <ul> - * <li>Locale("fr", "CH"): result MyResources_fr_CH.class, parent MyResources_fr.properties, parent MyResources.class - * <li>Locale("fr", "FR"): result MyResources_fr.properties, parent MyResources.class - * <li>Locale("de", "DE"): result MyResources_en.properties, parent MyResources.class - * <li>Locale("en", "US"): result MyResources_en.properties, parent MyResources.class - * <li>Locale("es", "ES"): result MyResources_es_ES.class, parent MyResources.class - * </ul> - * <p>The file MyResources_fr_CH.properties is never used because it is hidden by - * MyResources_fr_CH.class. Likewise, MyResources.properties is also hidden by - * MyResources.class. + * + * The contents of all files are valid (that is, public non-abstract + * subclasses of <code>ResourceBundle</code> for the ".class" files, + * syntactically correct ".properties" files). The default locale is + * <code>Locale("en", "GB")</code>. + * + * <p>Calling <code>getBundle</code> with the locale arguments below will + * instantiate resource bundles as follows: + * + * <table> + * <tr><td>Locale("fr", "CH")</td><td>MyResources_fr_CH.class, parent MyResources_fr.properties, parent MyResources.class</td></tr> + * <tr><td>Locale("fr", "FR")</td><td>MyResources_fr.properties, parent MyResources.class</td></tr> + * <tr><td>Locale("de", "DE")</td><td>MyResources_en.properties, parent MyResources.class</td></tr> + * <tr><td>Locale("en", "US")</td><td>MyResources_en.properties, parent MyResources.class</td></tr> + * <tr><td>Locale("es", "ES")</td><td>MyResources_es_ES.class, parent MyResources.class</td></tr> + * </table> + * + * <p>The file MyResources_fr_CH.properties is never used because it is + * hidden by the MyResources_fr_CH.class. Likewise, MyResources.properties + * is also hidden by MyResources.class. * * @param baseName the base name of the resource bundle, a fully qualified class name * @param locale the locale for which a resource bundle is desired @@ -1095,8 +1154,6 @@ * href="./ResourceBundle.html#parent_chain">parent chain</a> is * instantiated based on the list of candidate locales from which it was * found. Finally, the bundle is returned to the caller.</li> - * - * * </ol> * * <p>During the resource bundle loading process above, this factory @@ -1119,7 +1176,6 @@ * {@link Control#getTimeToLive(String,Locale) * control.getTimeToLive} for details. * - * * <p>The following is an example of the bundle loading process with the * default <code>ResourceBundle.Control</code> implementation. * @@ -1131,7 +1187,6 @@ * <li>Available resource bundles: * <code>foo/bar/Messages_fr.properties</code> and * <code>foo/bar/Messages.properties</code></li> - * * </ul> * * <p>First, <code>getBundle</code> tries loading a resource bundle in @@ -1811,8 +1866,8 @@ * handleGetObject} method returns <code>null</code>. Once the * <code>Set</code> has been created, the value is kept in this * <code>ResourceBundle</code> in order to avoid producing the - * same <code>Set</code> in the next calls. Override this method - * in subclass implementations for faster handling. + * same <code>Set</code> in subsequent calls. Subclasses can + * override this method for faster handling. * * @return a <code>Set</code> of the keys contained only in this * <code>ResourceBundle</code> @@ -2177,24 +2232,133 @@ * <code>ResourceBundle.getBundle</code> factory method loads only * the base bundle as the resulting resource bundle. * - * <p>It is not a requirement to return an immutable - * (unmodifiable) <code>List</code>. However, the returned - * <code>List</code> must not be mutated after it has been - * returned by <code>getCandidateLocales</code>. + * <p>It is not a requirement to return an immutable (unmodifiable) + * <code>List</code>. However, the returned <code>List</code> must not + * be mutated after it has been returned by + * <code>getCandidateLocales</code>. * * <p>The default implementation returns a <code>List</code> containing - * <code>Locale</code>s in the following sequence: - * <pre> - * Locale(language, country, variant) - * Locale(language, country) - * Locale(language) - * Locale.ROOT - * </pre> - * where <code>language</code>, <code>country</code> and - * <code>variant</code> are the language, country and variant values - * of the given <code>locale</code>, respectively. Locales where the + * <code>Locale</code>s using the rules described below. In the + * description below, <em>L</em>, <em>S</em>, <em>C</em> and <em>V</em> + * respectively represent non-empty language, script, country, and + * variant. For example, [<em>L</em>, <em>C</em>] represents a + * <code>Locale</code> that has non-empty values only for language and + * country. The form <em>L</em>("xx") represents the (non-empty) + * language value is "xx". For all cases, <code>Locale</code>s whose * final component values are empty strings are omitted. * + * <ol><li>For an input <code>Locale</code> with an empty script value, + * append candidate <code>Locale</code>s by omitting the final component + * one by one as below: + * + * <ul> + * <li> [<em>L</em>, <em>C</em>, <em>V</em>] + * <li> [<em>L</em>, <em>C</em>] + * <li> [<em>L</em>] + * <li> <code>Locale.ROOT</code> + * </ul> + * + * <li>For an input <code>Locale</code> with a non-empty script value, + * append candidate <code>Locale</code>s by omitting the final component + * up to language, then append candidates generated from the + * <code>Locale</code> with country and variant restored: + * + * <ul> + * <li> [<em>L</em>, <em>S</em>, <em>C</em>, <em>V</em>] + * <li> [<em>L</em>, <em>S</em>, <em>C</em>] + * <li> [<em>L</em>, <em>S</em>] + * <li> [<em>L</em>, <em>C</em>, <em>V</em>] + * <li> [<em>L</em>, <em>C</em>] + * <li> [<em>L</em>] + * <li> <code>Locale.ROOT</code> + * </ul> + * + * <li>For an input <code>Locale</code> with a variant value consisting + * of multiple subtags separated by underscore, generate candidate + * <code>Locale</code>s by omitting the variant subtags one by one, then + * insert them after every occurence of <code> Locale</code>s with the + * full variant value in the original list. For example, if the + * the variant consists of two subtags <em>V1</em> and <em>V2</em>: + * + * <ul> + * <li> [<em>L</em>, <em>S</em>, <em>C</em>, <em>V1</em>, <em>V2</em>] + * <li> [<em>L</em>, <em>S</em>, <em>C</em>, <em>V1</em>] + * <li> [<em>L</em>, <em>S</em>, <em>C</em>] + * <li> [<em>L</em>, <em>S</em>] + * <li> [<em>L</em>, <em>C</em>, <em>V1</em>, <em>V2</em>] + * <li> [<em>L</em>, <em>C</em>, <em>V1</em>] + * <li> [<em>L</em>, <em>C</em>] + * <li> [<em>L</em>] + * <li> <code>Locale.ROOT</code> + * </ul> + * + * <li>Special cases for Chinese. When an input <code>Locale</code> has the + * language "zh" (Chinese) and an empty script value, either "Hans" (Simplified) or + * "Hant" (Traditional) might be supplied, depending on the country. + * When the country is "CN" (China) or "SG" (Singapore), "Hans" is supplied. + * When the country is "HK" (Hong Kong SAR China), "MO" (Macau SAR China), + * or "TW" (Taiwan), "Hant" is supplied. For all other countries or when the country + * is empty, no script is supplied. For example, for <code>Locale("zh", "CN") + * </code>, the candidate list will be: + * <ul> + * <li> [<em>L</em>("zh"), <em>S</em>("Hans"), <em>C</em>("CN")] + * <li> [<em>L</em>("zh"), <em>S</em>("Hans")] + * <li> [<em>L</em>("zh"), <em>C</em>("CN")] + * <li> [<em>L</em>("zh")] + * <li> <code>Locale.ROOT</code> + * </ul> + * + * For <code>Locale("zh", "TW")</code>, the candidate list will be: + * <ul> + * <li> [<em>L</em>("zh"), <em>S</em>("Hant"), <em>C</em>("TW")] + * <li> [<em>L</em>("zh"), <em>S</em>("Hant")] + * <li> [<em>L</em>("zh"), <em>C</em>("TW")] + * <li> [<em>L</em>("zh")] + * <li> <code>Locale.ROOT</code> + * </ul> + * + * <li>Special cases for Norwegian. Both <code>Locale("no", "NO", + * "NY")</code> and <code>Locale("nn", "NO")</code> represent Norwegian + * Nynorsk. When a locale's language is "nn", the standard candidate + * list is generated up to [<em>L</em>("nn")], and then the following + * candidates are added: + * + * <ul><li> [<em>L</em>("no"), <em>C</em>("NO"), <em>V</em>("NY")] + * <li> [<em>L</em>("no"), <em>C</em>("NO")] + * <li> [<em>L</em>("no")] + * <li> <code>Locale.ROOT</code> + * </ul> + * + * If the locale is exactly <code>Locale("no", "NO", "NY")</code>, it is first + * converted to <code>Locale("nn", "NO")</code> and then the above procedure is + * followed. + * + * <p>Also, Java treats the language "no" as a synonym of Norwegian + * Bokmål "nb". Except for the single case <code>Locale("no", + * "NO", "NY")</code> (handled above), when an input <code>Locale</code> + * has language "no" or "nb", candidate <code>Locale</code>s with + * language code "no" and "nb" are interleaved, first using the + * requested language, then using its synonym. For example, + * <code>Locale("nb", "NO", "POSIX")</code> generates the following + * candidate list: + * + * <ul> + * <li> [<em>L</em>("nb"), <em>C</em>("NO"), <em>V</em>("POSIX")] + * <li> [<em>L</em>("no"), <em>C</em>("NO"), <em>V</em>("POSIX")] + * <li> [<em>L</em>("nb"), <em>C</em>("NO")] + * <li> [<em>L</em>("no"), <em>C</em>("NO")] + * <li> [<em>L</em>("nb")] + * <li> [<em>L</em>("no")] + * <li> <code>Locale.ROOT</code> + * </ul> + * + * <code>Locale("no", "NO", "POSIX")</code> would generate the same list + * except that locales with "no" would appear before the corresponding + * locales with "nb".</li> + * + * </li> + * </ol> + * * <p>The default implementation uses an {@link ArrayList} that * overriding implementations may modify before returning it to the * caller. However, a subclass must not modify it after it has @@ -2231,24 +2395,119 @@ if (baseName == null) { throw new NullPointerException(); } - String language = locale.getLanguage(); - String country = locale.getCountry(); - String variant = locale.getVariant(); + return new ArrayList<Locale>(CANDIDATES_CACHE.get(locale.getBaseLocale())); + } + + private static final CandidateListCache CANDIDATES_CACHE = new CandidateListCache(); + + private static class CandidateListCache extends LocaleObjectCache<BaseLocale, List<Locale>> { + protected List<Locale> createObject(BaseLocale base) { + String language = base.getLanguage(); + String script = base.getScript(); + String region = base.getRegion(); + String variant = base.getVariant(); - List<Locale> locales = new ArrayList<Locale>(4); - if (variant.length() > 0) { - locales.add(locale); + // Special handling for Norwegian + boolean isNorwegianBokmal = false; + boolean isNorwegianNynorsk = false; + if (language.equals("no")) { + if (region.equals("NO") && variant.equals("NY")) { + variant = ""; + isNorwegianNynorsk = true; + } else { + isNorwegianBokmal = true; + } + } + if (language.equals("nb") || isNorwegianBokmal) { + List<Locale> tmpList = getDefaultList("nb", script, region, variant); + // Insert a locale replacing "nb" with "no" for every list entry + List<Locale> bokmalList = new LinkedList<Locale>(); + for (Locale l : tmpList) { + bokmalList.add(l); + if (l.getLanguage().length() == 0) { + break; + } + bokmalList.add(Locale.getInstance("no", l.getScript(), l.getCountry(), + l.getVariant(), LocaleExtensions.EMPTY_EXTENSIONS)); + } + return bokmalList; + } else if (language.equals("nn") || isNorwegianNynorsk) { + // Insert no_NO_NY, no_NO, no after nn + List<Locale> nynorskList = getDefaultList("nn", script, region, variant); + int idx = nynorskList.size() - 1; + nynorskList.add(idx++, Locale.getInstance("no", "NO", "NY")); + nynorskList.add(idx++, Locale.getInstance("no", "NO", "")); + nynorskList.add(idx++, Locale.getInstance("no", "", "")); + return nynorskList; + } + // Special handling for Chinese + else if (language.equals("zh")) { + if (script.length() == 0 && region.length() > 0) { + // Supply script for users who want to use zh_Hans/zh_Hant + // as bundle names (recommended for Java7+) + if (region.equals("TW") || region.equals("HK") || region.equals("MO")) { + script = "Hant"; + } else if (region.equals("CN") || region.equals("SG")) { + script = "Hans"; + } + } else if (script.length() > 0 && region.length() == 0) { + // Supply region(country) for users who still package Chinese + // bundles using old convension. + if (script.equals("Hans")) { + region = "CN"; + } else if (script.equals("Hant")) { + region = "TW"; + } + } + } + + return getDefaultList(language, script, region, variant); } - if (country.length() > 0) { - locales.add((locales.size() == 0) ? - locale : Locale.getInstance(language, country, "")); + + private static List<Locale> getDefaultList(String language, String script, String region, String variant) { + List<String> variants = null; + + if (variant.length() > 0) { + variants = new LinkedList<String>(); + int idx = variant.length(); + while (idx != -1) { + variants.add(variant.substring(0, idx)); + idx = variant.lastIndexOf('_', --idx); + } + } + + LinkedList<Locale> list = new LinkedList<Locale>(); + + if (variants != null) { + for (String v : variants) { + list.add(Locale.getInstance(language, script, region, v, LocaleExtensions.EMPTY_EXTENSIONS)); + } + } + if (region.length() > 0) { + list.add(Locale.getInstance(language, script, region, "", LocaleExtensions.EMPTY_EXTENSIONS)); + } + if (script.length() > 0) { + list.add(Locale.getInstance(language, script, "", "", LocaleExtensions.EMPTY_EXTENSIONS)); + + // With script, after truncating variant, region and script, + // start over without script. + if (variants != null) { + for (String v : variants) { + list.add(Locale.getInstance(language, "", region, v, LocaleExtensions.EMPTY_EXTENSIONS)); + } + } + if (region.length() > 0) { + list.add(Locale.getInstance(language, "", region, "", LocaleExtensions.EMPTY_EXTENSIONS)); + } + } + if (language.length() > 0) { + list.add(Locale.getInstance(language, "", "", "", LocaleExtensions.EMPTY_EXTENSIONS)); + } + // Add root locale at the end + list.add(Locale.ROOT); + + return list; } - if (language.length() > 0) { - locales.add((locales.size() == 0) ? - locale : Locale.getInstance(language, "", "")); - } - locales.add(Locale.ROOT); - return locales; } /** @@ -2606,13 +2865,14 @@ * * <p>This implementation returns the following value: * <pre> - * baseName + "_" + language + "_" + country + "_" + variant + * baseName + "_" + language + "_" + script + "_" + country + "_" + variant * </pre> - * where <code>language</code>, <code>country</code> and - * <code>variant</code> are the language, country and variant values - * of <code>locale</code>, respectively. Final component values that - * are empty Strings are omitted along with the preceding '_'. If - * all of the values are empty strings, then <code>baseName</code> + * where <code>language</code>, <code>script</code>, <code>country</code>, + * and <code>variant</code> are the language, script, country, and variant + * values of <code>locale</code>, respectively. Final component values that + * are empty Strings are omitted along with the preceding '_'. When the + * script is empty, the script value is ommitted along with the preceding '_'. + * If all of the values are empty strings, then <code>baseName</code> * is returned. * * <p>For example, if <code>baseName</code> is @@ -2643,6 +2903,7 @@ } String language = locale.getLanguage(); + String script = locale.getScript(); String country = locale.getCountry(); String variant = locale.getVariant(); @@ -2652,12 +2913,22 @@ StringBuilder sb = new StringBuilder(baseName); sb.append('_'); - if (variant != "") { - sb.append(language).append('_').append(country).append('_').append(variant); - } else if (country != "") { - sb.append(language).append('_').append(country); + if (script != "") { + if (variant != "") { + sb.append(language).append('_').append(script).append('_').append(country).append('_').append(variant); + } else if (country != "") { + sb.append(language).append('_').append(script).append('_').append(country); + } else { + sb.append(language).append('_').append(script); + } } else { - sb.append(language); + if (variant != "") { + sb.append(language).append('_').append(country).append('_').append(variant); + } else if (country != "") { + sb.append(language).append('_').append(country); + } else { + sb.append(language); + } } return sb.toString();
--- a/src/share/classes/java/util/spi/LocaleNameProvider.java Fri Sep 10 20:48:17 2010 +0400 +++ b/src/share/classes/java/util/spi/LocaleNameProvider.java Fri Sep 10 15:29:40 2010 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -44,22 +44,23 @@ } /** - * Returns a localized name for the given ISO 639 language code and the - * given locale that is appropriate for display to the user. + * Returns a localized name for the given <a href="http://www.rfc-editor.org/rfc/bcp/bcp47.txt"> + * IETF BCP47</a> language code and the given locale that is appropriate for + * display to the user. * For example, if <code>languageCode</code> is "fr" and <code>locale</code> * is en_US, getDisplayLanguage() will return "French"; if <code>languageCode</code> * is "en" and <code>locale</code> is fr_FR, getDisplayLanguage() will return "anglais". * If the name returned cannot be localized according to <code>locale</code>, * (say, the provider does not have a Japanese name for Croatian), * this method returns null. - * @param languageCode the ISO 639 language code string in the form of two + * @param languageCode the language code string in the form of two to eight * lower-case letters between 'a' (U+0061) and 'z' (U+007A) * @param locale the desired locale * @return the name of the given language code for the specified locale, or null if it's not * available. * @exception NullPointerException if <code>languageCode</code> or <code>locale</code> is null * @exception IllegalArgumentException if <code>languageCode</code> is not in the form of - * two lower-case letters, or <code>locale</code> isn't + * two or three lower-case letters, or <code>locale</code> isn't * one of the locales returned from * {@link java.util.spi.LocaleServiceProvider#getAvailableLocales() * getAvailableLocales()}. @@ -68,22 +69,52 @@ public abstract String getDisplayLanguage(String languageCode, Locale locale); /** - * Returns a localized name for the given ISO 3166 country code and the - * given locale that is appropriate for display to the user. + * Returns a localized name for the given <a href="http://www.rfc-editor.org/rfc/bcp/bcp47.txt"> + * IETF BCP47</a> script code and the given locale that is appropriate for + * display to the user. + * For example, if <code>scriptCode</code> is "Latn" and <code>locale</code> + * is en_US, getDisplayScript() will return "Latin"; if <code>scriptCode</code> + * is "Cyrl" and <code>locale</code> is fr_FR, getDisplayScript() will return "cyrillique". + * If the name returned cannot be localized according to <code>locale</code>, + * (say, the provider does not have a Japanese name for Cyrillic), + * this method returns null. + * @param scriptCode the four letter script code string in the form of title-case + * letters (the first letter is upper-case character between 'A' (U+0041) and + * 'Z' (U+005A) followed by three lower-case character between 'a' (U+0061) + * and 'z' (U+007A)). + * @param locale the desired locale + * @return the name of the given script code for the specified locale, or null if it's not + * available. + * @exception NullPointerException if <code>scriptCode</code> or <code>locale</code> is null + * @exception IllegalArgumentException if <code>scriptCode</code> is not in the form of + * four title case letters, or <code>locale</code> isn't + * one of the locales returned from + * {@link java.util.spi.LocaleServiceProvider#getAvailableLocales() + * getAvailableLocales()}. + * @see java.util.Locale#getDisplayScript(java.util.Locale) + * @since 1.7 + */ + public abstract String getDisplayScript(String scriptCode, Locale locale); + + /** + * Returns a localized name for the given <a href="http://www.rfc-editor.org/rfc/bcp/bcp47.txt"> + * IETF BCP47</a> region code (either ISO 3166 country code or UN M.49 area + * codes) and the given locale that is appropriate for display to the user. * For example, if <code>countryCode</code> is "FR" and <code>locale</code> * is en_US, getDisplayCountry() will return "France"; if <code>countryCode</code> * is "US" and <code>locale</code> is fr_FR, getDisplayCountry() will return "Etats-Unis". * If the name returned cannot be localized according to <code>locale</code>, * (say, the provider does not have a Japanese name for Croatia), * this method returns null. - * @param countryCode the ISO 3166 country code string in the form of two - * upper-case letters between 'A' (U+0041) and 'Z' (U+005A) + * @param countryCode the country(region) code string in the form of two + * upper-case letters between 'A' (U+0041) and 'Z' (U+005A) or the UN M.49 area code + * in the form of three digit letters between '0' (U+0030) and '9' (U+0039). * @param locale the desired locale * @return the name of the given country code for the specified locale, or null if it's not * available. * @exception NullPointerException if <code>countryCode</code> or <code>locale</code> is null * @exception IllegalArgumentException if <code>countryCode</code> is not in the form of - * two upper-case letters, or <code>locale</code> isn't + * two upper-case letters or three digit letters, or <code>locale</code> isn't * one of the locales returned from * {@link java.util.spi.LocaleServiceProvider#getAvailableLocales() * getAvailableLocales()}.
--- a/src/share/classes/java/util/spi/LocaleServiceProvider.java Fri Sep 10 20:48:17 2010 +0400 +++ b/src/share/classes/java/util/spi/LocaleServiceProvider.java Fri Sep 10 15:29:40 2010 -0700 @@ -86,18 +86,19 @@ * Otherwise, they call the <code>getAvailableLocales()</code> methods of * installed providers for the appropriate interface to find one that * supports the requested locale. If such a provider is found, its other - * methods are called to obtain the requested object or name. If neither - * the Java runtime environment itself nor an installed provider supports - * the requested locale, a fallback locale is constructed by replacing the - * first of the variant, country, or language strings of the locale that's - * not an empty string with an empty string, and the lookup process is - * restarted. In the case that the variant contains one or more '_'s, the - * fallback locale is constructed by replacing the variant with a new variant - * which eliminates the last '_' and the part following it. Even if a - * fallback occurs, methods that return requested objects or name are - * invoked with the original locale before the fallback.The Java runtime - * environment must support the root locale for all locale sensitive services - * in order to guarantee that this process terminates. + * methods are called to obtain the requested object or name. When checking + * whether a locale is supported, the locale's extensions are ignored. + * If neither the Java runtime environment itself nor an installed provider + * supports the requested locale, the methods go through a list of candidate + * locales and repeat the availability check for each until a match is found. + * The algorithm used for creating a list of candidate locales is same as + * the one used by <code>ResourceBunlde</code> by default (see + * {@link java.util.ResourceBundle.Control#getCandidateLocales getCandidateLocales} + * for the details). Even if a locale is resolved from the candidate list, + * methods that return requested objects or names are invoked with the original + * requested locale including extensions. The Java runtime environment must + * support the root locale for all locale sensitive services in order to + * guarantee that this process terminates. * <p> * Providers of names (but not providers of other objects) are allowed to * return null for some name requests even for locales that they claim to @@ -124,6 +125,11 @@ /** * Returns an array of all locales for which this locale service provider * can provide localized objects or names. + * <p> + * <b>Note:</b> Extensions in a <code>Locale</code> are ignored during + * service provider lookup. So the array returned by this method should + * not include two or more <code>Locale</code> objects only differing in + * their extensions. * * @return An array of all locales for which this locale service provider * can provide localized objects or names.
--- a/src/share/classes/sun/util/LocaleServiceProviderPool.java Fri Sep 10 20:48:17 2010 +0400 +++ b/src/share/classes/sun/util/LocaleServiceProviderPool.java Fri Sep 10 15:29:40 2010 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -28,18 +28,20 @@ import java.security.AccessController; import java.security.PrivilegedActionException; import java.security.PrivilegedExceptionAction; -import java.util.Arrays; +import java.util.ArrayList; import java.util.HashSet; -import java.util.Iterator; +import java.util.IllformedLocaleException; import java.util.LinkedHashSet; import java.util.List; import java.util.Locale; +import java.util.Locale.Builder; import java.util.Map; +import java.util.ResourceBundle.Control; import java.util.ServiceLoader; -import java.util.ServiceConfigurationError; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import java.util.spi.LocaleServiceProvider; + import sun.util.logging.PlatformLogger; import sun.util.resources.LocaleData; import sun.util.resources.OpenListResourceBundle; @@ -90,6 +92,16 @@ private Set<Locale> providerLocales = null; /** + * Special locale for ja_JP with Japanese calendar + */ + private static Locale locale_ja_JP_JP = new Locale("ja", "JP", "JP"); + + /** + * Special locale for th_TH with Thai numbering system + */ + private static Locale locale_th_TH_TH = new Locale("th", "TH", "TH"); + + /** * A factory method that returns a singleton instance */ public static LocaleServiceProviderPool getPool(Class<? extends LocaleServiceProvider> providerClass) { @@ -153,14 +165,20 @@ java.util.spi.CurrencyNameProvider.class, java.util.spi.LocaleNameProvider.class, java.util.spi.TimeZoneNameProvider.class }; - Set<Locale> all = new HashSet<Locale>(Arrays.asList( - LocaleData.getAvailableLocales()) - ); + + // Normalize locales for look up + Locale[] allLocales = LocaleData.getAvailableLocales(); + Set<Locale> all = new HashSet<Locale>(allLocales.length); + for (Locale locale : allLocales) { + all.add(getLookupLocale(locale)); + } + for (Class providerClass : providerClasses) { LocaleServiceProviderPool pool = LocaleServiceProviderPool.getPool(providerClass); all.addAll(pool.getProviderLocales()); } + allAvailableLocales = all.toArray(new Locale[0]); } } @@ -196,7 +214,8 @@ } /** - * Returns an array of available locales from providers. + * Returns an array of available locales (already normalized + * for service lookup) from providers. * Note that this method does not return a defensive copy. * * @return list of the provider locales @@ -208,7 +227,7 @@ for (LocaleServiceProvider lsp : providers) { Locale[] locales = lsp.getAvailableLocales(); for (Locale locale: locales) { - providerLocales.add(locale); + providerLocales.add(getLookupLocale(locale)); } } } @@ -227,15 +246,19 @@ } /** - * Returns an array of available locales supported by the JRE. + * Returns an array of available locales (already normalized for + * service lookup) supported by the JRE. * Note that this method does not return a defensive copy. * * @return list of the available JRE locales */ private synchronized List<Locale> getJRELocales() { if (availableJRELocales == null) { - availableJRELocales = - Arrays.asList(LocaleData.getAvailableLocales()); + Locale[] allLocales = LocaleData.getAvailableLocales(); + availableJRELocales = new ArrayList<Locale>(allLocales.length); + for (Locale locale : allLocales) { + availableJRELocales.add(getLookupLocale(locale)); + } } return availableJRELocales; } @@ -249,7 +272,7 @@ */ private boolean isJRESupported(Locale locale) { List<Locale> locales = getJRELocales(); - return locales.contains(locale); + return locales.contains(getLookupLocale(locale)); } /** @@ -325,7 +348,7 @@ bundleKey = key; } Locale bundleLocale = (bundle != null ? bundle.getLocale() : null); - Locale requested = locale; + List<Locale> lookupLocales = getLookupLocales(locale); P lsp; S providersObj = null; @@ -333,21 +356,30 @@ // to the requested locale than the bundle we've found (for // localized names), or Java runtime's supported locale // (for localized objects) - while ((locale = findProviderLocale(locale, bundleLocale)) != null) { - - lsp = (P)findProvider(locale); - - if (lsp != null) { - providersObj = getter.getObject(lsp, requested, key, params); - if (providersObj != null) { - return providersObj; - } else if (isObjectProvider) { - config( - "A locale sensitive service provider returned null for a localized objects, which should not happen. provider: " + lsp + " locale: " + requested); + Set<Locale> provLoc = getProviderLocales(); + for (int i = 0; i < lookupLocales.size(); i++) { + Locale current = lookupLocales.get(i); + if (bundleLocale != null) { + if (current.equals(bundleLocale)) { + break; + } + } else { + if (isJRESupported(current)) { + break; } } - - locale = getParentLocale(locale); + if (provLoc.contains(current)) { + lsp = (P)findProvider(current); + if (lsp != null) { + providersObj = getter.getObject(lsp, locale, key, params); + if (providersObj != null) { + return providersObj; + } else if (isObjectProvider) { + config( + "A locale sensitive service provider returned null for a localized objects, which should not happen. provider: " + lsp + " locale: " + locale); + } + } + } } // look up the JRE bundle and its parent chain. Only @@ -361,7 +393,7 @@ } else { lsp = (P)findProvider(bundleLocale); if (lsp != null) { - providersObj = getter.getObject(lsp, requested, key, params); + providersObj = getter.getObject(lsp, locale, key, params); if (providersObj != null) { return providersObj; } @@ -399,6 +431,8 @@ for (LocaleServiceProvider lsp : providers) { Locale[] locales = lsp.getAvailableLocales(); for (Locale available: locales) { + // normalize + available = getLookupLocale(available); if (locale.equals(available)) { LocaleServiceProvider providerInCache = providersCache.put(locale, lsp); @@ -414,66 +448,51 @@ } /** - * Returns the provider's locale that is the most appropriate - * within the range - * - * @param start the given locale that is used as the starting one - * @param end the given locale that is used as the end one (exclusive), - * or null if it reaching any of the JRE supported locale should - * terminate the look up. - * @return the most specific locale within the range, or null - * if no provider locale found in that range. + * Returns a list of candidate locales for service look up. + * @param locale the input locale + * @return the list of candiate locales for the given locale */ - private Locale findProviderLocale(Locale start, Locale end) { - Set<Locale> provLoc = getProviderLocales(); - Locale current = start; - - while (current != null) { - if (end != null) { - if (current.equals(end)) { - current = null; - break; - } - } else { - if (isJRESupported(current)) { - current = null; - break; - } - } - - if (provLoc.contains(current)) { - break; - } - - current = getParentLocale(current); - } - - return current; + private static List<Locale> getLookupLocales(Locale locale) { + // Note: We currently use the default implementation of + // ResourceBundle.Control.getCandidateLocales. The result + // returned by getCandidateLocales are already normalized + // (no extensions) for service look up. + List<Locale> lookupLocales = new Control(){}.getCandidateLocales("", locale); + return lookupLocales; } /** - * Returns the parent locale. + * Returns an instance of Locale used for service look up. + * The result Locale has no extensions except for ja_JP_JP + * and th_TH_TH * * @param locale the locale - * @return the parent locale + * @return the locale used for service look up */ - private static Locale getParentLocale(Locale locale) { - String variant = locale.getVariant(); - if (variant != "") { - int underscoreIndex = variant.lastIndexOf('_'); - if (underscoreIndex != (-1)) { - return new Locale(locale.getLanguage(), locale.getCountry(), - variant.substring(0, underscoreIndex)); - } else { - return new Locale(locale.getLanguage(), locale.getCountry()); + private static Locale getLookupLocale(Locale locale) { + Locale lookupLocale = locale; + Set<Character> extensions = locale.getExtensionKeys(); + if (!extensions.isEmpty() + && !locale.equals(locale_ja_JP_JP) + && !locale.equals(locale_th_TH_TH)) { + // remove extensions + Builder locbld = new Builder(); + try { + locbld.setLocale(locale); + locbld.clearExtensions(); + lookupLocale = locbld.build(); + } catch (IllformedLocaleException e) { + // A Locale with non-empty extensions + // should have well-formed fields except + // for ja_JP_JP and th_TH_TH. Therefore, + // it should never enter in this catch clause. + config("A locale(" + locale + ") has non-empty extensions, but has illformed fields."); + + // Fallback - script field will be lost. + lookupLocale = new Locale(locale.getLanguage(), locale.getCountry(), locale.getVariant()); } - } else if (locale.getCountry() != "") { - return new Locale(locale.getLanguage()); - } else if (locale.getLanguage() != "") { - return Locale.ROOT; - } else { - return null; } + return lookupLocale; } /**
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/classes/sun/util/locale/AsciiUtil.java Fri Sep 10 15:29:40 2010 -0700 @@ -0,0 +1,208 @@ +/* + * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + ******************************************************************************* + * Copyright (C) 2009, International Business Machines Corporation and * + * others. All Rights Reserved. * + ******************************************************************************* + */ +package sun.util.locale; + +public final class AsciiUtil { + public static boolean caseIgnoreMatch(String s1, String s2) { + if (s1 == s2) { + return true; + } + int len = s1.length(); + if (len != s2.length()) { + return false; + } + int i = 0; + while (i < len) { + char c1 = s1.charAt(i); + char c2 = s2.charAt(i); + if (c1 != c2 && toLower(c1) != toLower(c2)) { + break; + } + i++; + } + return (i == len); + } + + public static int caseIgnoreCompare(String s1, String s2) { + if (s1 == s2) { + return 0; + } + return AsciiUtil.toLowerString(s1).compareTo(AsciiUtil.toLowerString(s2)); + } + + + public static char toUpper(char c) { + if (c >= 'a' && c <= 'z') { + c -= 0x20; + } + return c; + } + + public static char toLower(char c) { + if (c >= 'A' && c <= 'Z') { + c += 0x20; + } + return c; + } + + public static String toLowerString(String s) { + int idx = 0; + for (; idx < s.length(); idx++) { + char c = s.charAt(idx); + if (c >= 'A' && c <= 'Z') { + break; + } + } + if (idx == s.length()) { + return s; + } + StringBuilder buf = new StringBuilder(s.substring(0, idx)); + for (; idx < s.length(); idx++) { + buf.append(toLower(s.charAt(idx))); + } + return buf.toString(); + } + + public static String toUpperString(String s) { + int idx = 0; + for (; idx < s.length(); idx++) { + char c = s.charAt(idx); + if (c >= 'a' && c <= 'z') { + break; + } + } + if (idx == s.length()) { + return s; + } + StringBuilder buf = new StringBuilder(s.substring(0, idx)); + for (; idx < s.length(); idx++) { + buf.append(toUpper(s.charAt(idx))); + } + return buf.toString(); + } + + public static String toTitleString(String s) { + if (s.length() == 0) { + return s; + } + int idx = 0; + char c = s.charAt(idx); + if (!(c >= 'a' && c <= 'z')) { + for (idx = 1; idx < s.length(); idx++) { + if (c >= 'A' && c <= 'Z') { + break; + } + } + } + if (idx == s.length()) { + return s; + } + StringBuilder buf = new StringBuilder(s.substring(0, idx)); + if (idx == 0) { + buf.append(toUpper(s.charAt(idx))); + idx++; + } + for (; idx < s.length(); idx++) { + buf.append(toLower(s.charAt(idx))); + } + return buf.toString(); + } + + public static boolean isAlpha(char c) { + return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'); + } + + public static boolean isAlphaString(String s) { + boolean b = true; + for (int i = 0; i < s.length(); i++) { + if (!isAlpha(s.charAt(i))) { + b = false; + break; + } + } + return b; + } + + public static boolean isNumeric(char c) { + return (c >= '0' && c <= '9'); + } + + public static boolean isNumericString(String s) { + boolean b = true; + for (int i = 0; i < s.length(); i++) { + if (!isNumeric(s.charAt(i))) { + b = false; + break; + } + } + return b; + } + + public static boolean isAlphaNumeric(char c) { + return isAlpha(c) || isNumeric(c); + } + + public static boolean isAlphaNumericString(String s) { + boolean b = true; + for (int i = 0; i < s.length(); i++) { + if (!isAlphaNumeric(s.charAt(i))) { + b = false; + break; + } + } + return b; + } + + public static class CaseInsensitiveKey { + private String _key; + private int _hash; + + public CaseInsensitiveKey(String key) { + _key = key; + _hash = AsciiUtil.toLowerString(key).hashCode(); + } + + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o instanceof CaseInsensitiveKey) { + return AsciiUtil.caseIgnoreMatch(_key, ((CaseInsensitiveKey)o)._key); + } + return false; + } + + public int hashCode() { + return _hash; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/classes/sun/util/locale/BaseLocale.java Fri Sep 10 15:29:40 2010 -0700 @@ -0,0 +1,253 @@ +/* + * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + ******************************************************************************* + * Copyright (C) 2009-2010, International Business Machines Corporation and * + * others. All Rights Reserved. * + ******************************************************************************* + */ + +package sun.util.locale; + + +public final class BaseLocale { + + public static final String SEP = "_"; + + private static final Cache CACHE = new Cache(); + public static final BaseLocale ROOT = BaseLocale.getInstance("", "", "", ""); + + private String _language = ""; + private String _script = ""; + private String _region = ""; + private String _variant = ""; + + private transient volatile int _hash = 0; + + private BaseLocale(String language, String script, String region, String variant) { + if (language != null) { + _language = AsciiUtil.toLowerString(language).intern(); + } + if (script != null) { + _script = AsciiUtil.toTitleString(script).intern(); + } + if (region != null) { + _region = AsciiUtil.toUpperString(region).intern(); + } + if (variant != null) { + _variant = variant.intern(); + } + } + + public static BaseLocale getInstance(String language, String script, String region, String variant) { + // JDK uses deprecated ISO639.1 language codes for he, yi and id + if (AsciiUtil.caseIgnoreMatch(language, "he")) { + language = "iw"; + } else if (AsciiUtil.caseIgnoreMatch(language, "yi")) { + language = "ji"; + } else if (AsciiUtil.caseIgnoreMatch(language, "id")) { + language = "in"; + } + + Key key = new Key(language, script, region, variant); + BaseLocale baseLocale = CACHE.get(key); + return baseLocale; + } + + public String getLanguage() { + return _language; + } + + public String getScript() { + return _script; + } + + public String getRegion() { + return _region; + } + + public String getVariant() { + return _variant; + } + + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (!(obj instanceof BaseLocale)) { + return false; + } + BaseLocale other = (BaseLocale)obj; + return hashCode() == other.hashCode() + && _language.equals(other._language) + && _script.equals(other._script) + && _region.equals(other._region) + && _variant.equals(other._variant); + } + + public String toString() { + StringBuilder buf = new StringBuilder(); + if (_language.length() > 0) { + buf.append("language="); + buf.append(_language); + } + if (_script.length() > 0) { + if (buf.length() > 0) { + buf.append(", "); + } + buf.append("script="); + buf.append(_script); + } + if (_region.length() > 0) { + if (buf.length() > 0) { + buf.append(", "); + } + buf.append("region="); + buf.append(_region); + } + if (_variant.length() > 0) { + if (buf.length() > 0) { + buf.append(", "); + } + buf.append("variant="); + buf.append(_variant); + } + return buf.toString(); + } + + public int hashCode() { + int h = _hash; + if (h == 0) { + // Generating a hash value from language, script, region and variant + for (int i = 0; i < _language.length(); i++) { + h = 31*h + _language.charAt(i); + } + for (int i = 0; i < _script.length(); i++) { + h = 31*h + _script.charAt(i); + } + for (int i = 0; i < _region.length(); i++) { + h = 31*h + _region.charAt(i); + } + for (int i = 0; i < _variant.length(); i++) { + h = 31*h + _variant.charAt(i); + } + _hash = h; + } + return h; + } + + private static class Key implements Comparable<Key> { + private String _lang = ""; + private String _scrt = ""; + private String _regn = ""; + private String _vart = ""; + + private volatile int _hash; // Default to 0 + + public Key(String language, String script, String region, String variant) { + if (language != null) { + _lang = language; + } + if (script != null) { + _scrt = script; + } + if (region != null) { + _regn = region; + } + if (variant != null) { + _vart = variant; + } + } + + public boolean equals(Object obj) { + return (this == obj) || + (obj instanceof Key) + && AsciiUtil.caseIgnoreMatch(((Key)obj)._lang, this._lang) + && AsciiUtil.caseIgnoreMatch(((Key)obj)._scrt, this._scrt) + && AsciiUtil.caseIgnoreMatch(((Key)obj)._regn, this._regn) + && ((Key)obj)._vart.equals(_vart); // variant is case sensitive in JDK! + } + + public int compareTo(Key other) { + int res = AsciiUtil.caseIgnoreCompare(this._lang, other._lang); + if (res == 0) { + res = AsciiUtil.caseIgnoreCompare(this._scrt, other._scrt); + if (res == 0) { + res = AsciiUtil.caseIgnoreCompare(this._regn, other._regn); + if (res == 0) { + res = this._vart.compareTo(other._vart); + } + } + } + return res; + } + + public int hashCode() { + int h = _hash; + if (h == 0) { + // Generating a hash value from language, script, region and variant + for (int i = 0; i < _lang.length(); i++) { + h = 31*h + AsciiUtil.toLower(_lang.charAt(i)); + } + for (int i = 0; i < _scrt.length(); i++) { + h = 31*h + AsciiUtil.toLower(_scrt.charAt(i)); + } + for (int i = 0; i < _regn.length(); i++) { + h = 31*h + AsciiUtil.toLower(_regn.charAt(i)); + } + for (int i = 0; i < _vart.length(); i++) { + h = 31*h + _vart.charAt(i); + } + _hash = h; + } + return h; + } + + public static Key normalize(Key key) { + String lang = AsciiUtil.toLowerString(key._lang).intern(); + String scrt = AsciiUtil.toTitleString(key._scrt).intern(); + String regn = AsciiUtil.toUpperString(key._regn).intern(); + String vart = key._vart.intern(); // preserve upper/lower cases + + return new Key(lang, scrt, regn, vart); + } + } + + private static class Cache extends LocaleObjectCache<Key, BaseLocale> { + + public Cache() { + } + + protected Key normalizeKey(Key key) { + return Key.normalize(key); + } + + protected BaseLocale createObject(Key key) { + return new BaseLocale(key._lang, key._scrt, key._regn, key._vart); + } + + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/classes/sun/util/locale/Extension.java Fri Sep 10 15:29:40 2010 -0700 @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + ******************************************************************************* + * Copyright (C) 2009-2010, International Business Machines Corporation and * + * others. All Rights Reserved. * + ******************************************************************************* + */ +package sun.util.locale; + + +public class Extension { + private char _key; + protected String _value; + + protected Extension(char key) { + _key = key; + } + + Extension(char key, String value) { + _key = key; + _value = value; + } + + public char getKey() { + return _key; + } + + public String getValue() { + return _value; + } + + public String getID() { + return _key + LanguageTag.SEP + _value; + } + + public String toString() { + return getID(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/classes/sun/util/locale/InternalLocaleBuilder.java Fri Sep 10 15:29:40 2010 -0700 @@ -0,0 +1,705 @@ +/* + * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + ******************************************************************************* + * Copyright (C) 2009-2010, International Business Machines Corporation and * + * others. All Rights Reserved. * + ******************************************************************************* + */ +package sun.util.locale; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +public final class InternalLocaleBuilder { + + private String _language = ""; + private String _script = ""; + private String _region = ""; + private String _variant = ""; + + private static final CaseInsensitiveChar PRIVUSE_KEY = new CaseInsensitiveChar(LanguageTag.PRIVATEUSE.charAt(0)); + + private HashMap<CaseInsensitiveChar, String> _extensions; + private HashSet<CaseInsensitiveString> _uattributes; + private HashMap<CaseInsensitiveString, String> _ukeywords; + + + public InternalLocaleBuilder() { + } + + public InternalLocaleBuilder setLanguage(String language) throws LocaleSyntaxException { + if (language == null || language.length() == 0) { + _language = ""; + } else { + if (!LanguageTag.isLanguage(language)) { + throw new LocaleSyntaxException("Ill-formed language: " + language, 0); + } + _language = language; + } + return this; + } + + public InternalLocaleBuilder setScript(String script) throws LocaleSyntaxException { + if (script == null || script.length() == 0) { + _script = ""; + } else { + if (!LanguageTag.isScript(script)) { + throw new LocaleSyntaxException("Ill-formed script: " + script, 0); + } + _script = script; + } + return this; + } + + public InternalLocaleBuilder setRegion(String region) throws LocaleSyntaxException { + if (region == null || region.length() == 0) { + _region = ""; + } else { + if (!LanguageTag.isRegion(region)) { + throw new LocaleSyntaxException("Ill-formed region: " + region, 0); + } + _region = region; + } + return this; + } + + public InternalLocaleBuilder setVariant(String variant) throws LocaleSyntaxException { + if (variant == null || variant.length() == 0) { + _variant = ""; + } else { + // normalize separators to "_" + String var = variant.replaceAll(LanguageTag.SEP, BaseLocale.SEP); + int errIdx = checkVariants(var, BaseLocale.SEP); + if (errIdx != -1) { + throw new LocaleSyntaxException("Ill-formed variant: " + variant, errIdx); + } + _variant = var; + } + return this; + } + + public InternalLocaleBuilder addUnicodeLocaleAttribute(String attribute) throws LocaleSyntaxException { + if (!UnicodeLocaleExtension.isAttribute(attribute)) { + throw new LocaleSyntaxException("Ill-formed Unicode locale attribute: " + attribute); + } + // Use case insensitive string to prevent duplication + if (_uattributes == null) { + _uattributes = new HashSet<CaseInsensitiveString>(4); + } + _uattributes.add(new CaseInsensitiveString(attribute)); + return this; + } + + public InternalLocaleBuilder removeUnicodeLocaleAttribute(String attribute) throws LocaleSyntaxException { + if (attribute == null || !UnicodeLocaleExtension.isAttribute(attribute)) { + throw new LocaleSyntaxException("Ill-formed Unicode locale attribute: " + attribute); + } + if (_uattributes != null) { + _uattributes.remove(new CaseInsensitiveString(attribute)); + } + return this; + } + + public InternalLocaleBuilder setUnicodeLocaleKeyword(String key, String type) throws LocaleSyntaxException { + if (!UnicodeLocaleExtension.isKey(key)) { + throw new LocaleSyntaxException("Ill-formed Unicode locale keyword key: " + key); + } + + CaseInsensitiveString cikey = new CaseInsensitiveString(key); + if (type == null) { + if (_ukeywords != null) { + // null type is used for remove the key + _ukeywords.remove(cikey); + } + } else { + if (type.length() != 0) { + // normalize separator to "-" + String tp = type.replaceAll(BaseLocale.SEP, LanguageTag.SEP); + // validate + StringTokenIterator itr = new StringTokenIterator(tp, LanguageTag.SEP); + while (!itr.isDone()) { + String s = itr.current(); + if (!UnicodeLocaleExtension.isTypeSubtag(s)) { + throw new LocaleSyntaxException("Ill-formed Unicode locale keyword type: " + type, itr.currentStart()); + } + itr.next(); + } + } + if (_ukeywords == null) { + _ukeywords = new HashMap<CaseInsensitiveString, String>(4); + } + _ukeywords.put(cikey, type); + } + return this; + } + + public InternalLocaleBuilder setExtension(char singleton, String value) throws LocaleSyntaxException { + // validate key + boolean isBcpPrivateuse = LanguageTag.isPrivateusePrefixChar(singleton); + if (!isBcpPrivateuse && !LanguageTag.isExtensionSingletonChar(singleton)) { + throw new LocaleSyntaxException("Ill-formed extension key: " + singleton); + } + + boolean remove = (value == null || value.length() == 0); + CaseInsensitiveChar key = new CaseInsensitiveChar(singleton); + + if (remove) { + if (UnicodeLocaleExtension.isSingletonChar(key.value())) { + // clear entire Unicode locale extension + if (_uattributes != null) { + _uattributes.clear(); + } + if (_ukeywords != null) { + _ukeywords.clear(); + } + } else { + if (_extensions != null && _extensions.containsKey(key)) { + _extensions.remove(key); + } + } + } else { + // validate value + String val = value.replaceAll(BaseLocale.SEP, LanguageTag.SEP); + StringTokenIterator itr = new StringTokenIterator(val, LanguageTag.SEP); + while (!itr.isDone()) { + String s = itr.current(); + boolean validSubtag; + if (isBcpPrivateuse) { + validSubtag = LanguageTag.isPrivateuseSubtag(s); + } else { + validSubtag = LanguageTag.isExtensionSubtag(s); + } + if (!validSubtag) { + throw new LocaleSyntaxException("Ill-formed extension value: " + s, itr.currentStart()); + } + itr.next(); + } + + if (UnicodeLocaleExtension.isSingletonChar(key.value())) { + setUnicodeLocaleExtension(val); + } else { + if (_extensions == null) { + _extensions = new HashMap<CaseInsensitiveChar, String>(4); + } + _extensions.put(key, val); + } + } + return this; + } + + /* + * Set extension/private subtags in a single string representation + */ + public InternalLocaleBuilder setExtensions(String subtags) throws LocaleSyntaxException { + if (subtags == null || subtags.length() == 0) { + clearExtensions(); + return this; + } + subtags = subtags.replaceAll(BaseLocale.SEP, LanguageTag.SEP); + StringTokenIterator itr = new StringTokenIterator(subtags, LanguageTag.SEP); + + List<String> extensions = null; + String privateuse = null; + + int parsed = 0; + int start; + + // Make a list of extension subtags + while (!itr.isDone()) { + String s = itr.current(); + if (LanguageTag.isExtensionSingleton(s)) { + start = itr.currentStart(); + String singleton = s; + StringBuilder sb = new StringBuilder(singleton); + + itr.next(); + while (!itr.isDone()) { + s = itr.current(); + if (LanguageTag.isExtensionSubtag(s)) { + sb.append(LanguageTag.SEP).append(s); + parsed = itr.currentEnd(); + } else { + break; + } + itr.next(); + } + + if (parsed < start) { + throw new LocaleSyntaxException("Incomplete extension '" + singleton + "'", start); + } + + if (extensions == null) { + extensions = new ArrayList<String>(4); + } + extensions.add(sb.toString()); + } else { + break; + } + } + if (!itr.isDone()) { + String s = itr.current(); + if (LanguageTag.isPrivateusePrefix(s)) { + start = itr.currentStart(); + StringBuilder sb = new StringBuilder(s); + + itr.next(); + while (!itr.isDone()) { + s = itr.current(); + if (!LanguageTag.isPrivateuseSubtag(s)) { + break; + } + sb.append(LanguageTag.SEP).append(s); + parsed = itr.currentEnd(); + + itr.next(); + } + if (parsed <= start) { + throw new LocaleSyntaxException("Incomplete privateuse:" + subtags.substring(start), start); + } else { + privateuse = sb.toString(); + } + } + } + + if (!itr.isDone()) { + throw new LocaleSyntaxException("Ill-formed extension subtags:" + subtags.substring(itr.currentStart()), itr.currentStart()); + } + + return setExtensions(extensions, privateuse); + } + + /* + * Set a list of BCP47 extensions and private use subtags + * BCP47 extensions are already validated and well-formed, but may contain duplicates + */ + private InternalLocaleBuilder setExtensions(List<String> bcpExtensions, String privateuse) { + clearExtensions(); + + if (bcpExtensions != null && bcpExtensions.size() > 0) { + HashSet<CaseInsensitiveChar> processedExntensions = new HashSet<CaseInsensitiveChar>(bcpExtensions.size()); + for (String bcpExt : bcpExtensions) { + CaseInsensitiveChar key = new CaseInsensitiveChar(bcpExt.charAt(0)); + // ignore duplicates + if (!processedExntensions.contains(key)) { + // each extension string contains singleton, e.g. "a-abc-def" + if (UnicodeLocaleExtension.isSingletonChar(key.value())) { + setUnicodeLocaleExtension(bcpExt.substring(2)); + } else { + if (_extensions == null) { + _extensions = new HashMap<CaseInsensitiveChar, String>(4); + } + _extensions.put(key, bcpExt.substring(2)); + } + } + } + } + if (privateuse != null && privateuse.length() > 0) { + // privateuse string contains prefix, e.g. "x-abc-def" + if (_extensions == null) { + _extensions = new HashMap<CaseInsensitiveChar, String>(1); + } + _extensions.put(new CaseInsensitiveChar(privateuse.charAt(0)), privateuse.substring(2)); + } + + return this; + } + + /* + * Reset Builder's internal state with the given language tag + */ + public InternalLocaleBuilder setLanguageTag(LanguageTag langtag) { + clear(); + if (langtag.getExtlangs().size() > 0) { + _language = langtag.getExtlangs().get(0); + } else { + String language = langtag.getLanguage(); + if (!language.equals(LanguageTag.UNDETERMINED)) { + _language = language; + } + } + _script = langtag.getScript(); + _region = langtag.getRegion(); + + List<String> bcpVariants = langtag.getVariants(); + if (bcpVariants.size() > 0) { + StringBuilder var = new StringBuilder(bcpVariants.get(0)); + for (int i = 1; i < bcpVariants.size(); i++) { + var.append(BaseLocale.SEP).append(bcpVariants.get(i)); + } + _variant = var.toString(); + } + + setExtensions(langtag.getExtensions(), langtag.getPrivateuse()); + + return this; + } + + public InternalLocaleBuilder setLocale(BaseLocale base, LocaleExtensions extensions) throws LocaleSyntaxException { + String language = base.getLanguage(); + String script = base.getScript(); + String region = base.getRegion(); + String variant = base.getVariant(); + + // Special backward compatibility support + + // Exception 1 - ja_JP_JP + if (language.equals("ja") && region.equals("JP") && variant.equals("JP")) { + // When locale ja_JP_JP is created, ca-japanese is always there. + // The builder ignores the variant "JP" + assert("japanese".equals(extensions.getUnicodeLocaleType("ca"))); + variant = ""; + } + // Exception 2 - th_TH_TH + else if (language.equals("th") && region.equals("TH") && variant.equals("TH")) { + // When locale th_TH_TH is created, nu-thai is always there. + // The builder ignores the variant "TH" + assert("thai".equals(extensions.getUnicodeLocaleType("nu"))); + variant = ""; + } + // Exception 3 - no_NO_NY + else if (language.equals("no") && region.equals("NO") && variant.equals("NY")) { + // no_NO_NY is a valid locale and used by Java 6 or older versions. + // The build ignores the variant "NY" and change the language to "nn". + language = "nn"; + variant = ""; + } + + // Validate base locale fields before updating internal state. + // LocaleExtensions always store validated/canonicalized values, + // so no checks are necessary. + if (language.length() > 0 && !LanguageTag.isLanguage(language)) { + throw new LocaleSyntaxException("Ill-formed language: " + language); + } + + if (script.length() > 0 && !LanguageTag.isScript(script)) { + throw new LocaleSyntaxException("Ill-formed script: " + script); + } + + if (region.length() > 0 && !LanguageTag.isRegion(region)) { + throw new LocaleSyntaxException("Ill-formed region: " + region); + } + + if (variant.length() > 0) { + int errIdx = checkVariants(variant, BaseLocale.SEP); + if (errIdx != -1) { + throw new LocaleSyntaxException("Ill-formed variant: " + variant, errIdx); + } + } + + // The input locale is validated at this point. + // Now, updating builder's internal fields. + _language = language; + _script = script; + _region = region; + _variant = variant; + clearExtensions(); + + Set<Character> extKeys = (extensions == null) ? null : extensions.getKeys(); + if (extKeys != null) { + // map extensions back to builder's internal format + for (Character key : extKeys) { + Extension e = extensions.getExtension(key); + if (e instanceof UnicodeLocaleExtension) { + UnicodeLocaleExtension ue = (UnicodeLocaleExtension)e; + for (String uatr : ue.getUnicodeLocaleAttributes()) { + if (_uattributes == null) { + _uattributes = new HashSet<CaseInsensitiveString>(4); + } + _uattributes.add(new CaseInsensitiveString(uatr)); + } + for (String ukey : ue.getUnicodeLocaleKeys()) { + if (_ukeywords == null) { + _ukeywords = new HashMap<CaseInsensitiveString, String>(4); + } + _ukeywords.put(new CaseInsensitiveString(ukey), ue.getUnicodeLocaleType(ukey)); + } + } else { + if (_extensions == null) { + _extensions = new HashMap<CaseInsensitiveChar, String>(4); + } + _extensions.put(new CaseInsensitiveChar(key.charValue()), e.getValue()); + } + } + } + return this; + } + + public InternalLocaleBuilder clear() { + _language = ""; + _script = ""; + _region = ""; + _variant = ""; + clearExtensions(); + return this; + } + + public InternalLocaleBuilder clearExtensions() { + if (_extensions != null) { + _extensions.clear(); + } + if (_uattributes != null) { + _uattributes.clear(); + } + if (_ukeywords != null) { + _ukeywords.clear(); + } + return this; + } + + public BaseLocale getBaseLocale() { + String language = _language; + String script = _script; + String region = _region; + String variant = _variant; + + // Special private use subtag sequence identified by "lvariant" will be + // interpreted as Java variant. + if (_extensions != null) { + String privuse = _extensions.get(PRIVUSE_KEY); + if (privuse != null) { + StringTokenIterator itr = new StringTokenIterator(privuse, LanguageTag.SEP); + boolean sawPrefix = false; + int privVarStart = -1; + while (!itr.isDone()) { + if (sawPrefix) { + privVarStart = itr.currentStart(); + break; + } + if (AsciiUtil.caseIgnoreMatch(itr.current(), LanguageTag.PRIVUSE_VARIANT_PREFIX)) { + sawPrefix = true; + } + itr.next(); + } + if (privVarStart != -1) { + StringBuilder sb = new StringBuilder(variant); + if (sb.length() != 0) { + sb.append(BaseLocale.SEP); + } + sb.append(privuse.substring(privVarStart).replaceAll(LanguageTag.SEP, BaseLocale.SEP)); + variant = sb.toString(); + } + } + } + + return BaseLocale.getInstance(language, script, region, variant); + } + + public LocaleExtensions getLocaleExtensions() { + if ((_extensions == null || _extensions.size() == 0) + && (_uattributes == null || _uattributes.size() == 0) + && (_ukeywords == null || _ukeywords.size() == 0)) { + return LocaleExtensions.EMPTY_EXTENSIONS; + } + + return new LocaleExtensions(_extensions, _uattributes, _ukeywords); + } + + /* + * Remove special private use subtag sequence identified by "lvariant" + * and return the rest. Only used by LocaleExtensions + */ + static String removePrivateuseVariant(String privuseVal) { + StringTokenIterator itr = new StringTokenIterator(privuseVal, LanguageTag.SEP); + + // Note: privateuse value "abc-lvariant" is unchanged + // because no subtags after "lvariant". + + int prefixStart = -1; + boolean sawPrivuseVar = false; + while (!itr.isDone()) { + if (prefixStart != -1) { + // Note: privateuse value "abc-lvariant" is unchanged + // because no subtags after "lvariant". + sawPrivuseVar = true; + break; + } + if (AsciiUtil.caseIgnoreMatch(itr.current(), LanguageTag.PRIVUSE_VARIANT_PREFIX)) { + prefixStart = itr.currentStart(); + } + itr.next(); + } + if (!sawPrivuseVar) { + return privuseVal; + } + + assert(prefixStart == 0 || prefixStart > 1); + return (prefixStart == 0) ? null : privuseVal.substring(0, prefixStart -1); + } + + /* + * Check if the given variant subtags separated by the given + * separator(s) are valid + */ + private int checkVariants(String variants, String sep) { + StringTokenIterator itr = new StringTokenIterator(variants, sep); + while (!itr.isDone()) { + String s = itr.current(); + if (!LanguageTag.isVariant(s)) { + return itr.currentStart(); + } + itr.next(); + } + return -1; + } + + /* + * Private methods parsing Unicode Locale Extension subtags. + * Duplicated attributes/keywords will be ignored. + * The input must be a valid extension subtags (excluding singleton). + */ + private void setUnicodeLocaleExtension(String subtags) { + // wipe out existing attributes/keywords + if (_uattributes != null) { + _uattributes.clear(); + } + if (_ukeywords != null) { + _ukeywords.clear(); + } + + StringTokenIterator itr = new StringTokenIterator(subtags, LanguageTag.SEP); + + // parse attributes + while (!itr.isDone()) { + if (!UnicodeLocaleExtension.isAttribute(itr.current())) { + break; + } + if (_uattributes == null) { + _uattributes = new HashSet<CaseInsensitiveString>(4); + } + _uattributes.add(new CaseInsensitiveString(itr.current())); + itr.next(); + } + + // parse keywords + CaseInsensitiveString key = null; + String type; + int typeStart = -1; + int typeEnd = -1; + while (!itr.isDone()) { + if (key != null) { + if (UnicodeLocaleExtension.isKey(itr.current())) { + // next keyword - emit previous one + assert(typeStart == -1 || typeEnd != -1); + type = (typeStart == -1) ? "" : subtags.substring(typeStart, typeEnd); + if (_ukeywords == null) { + _ukeywords = new HashMap<CaseInsensitiveString, String>(4); + } + _ukeywords.put(key, type); + + // reset keyword info + CaseInsensitiveString tmpKey = new CaseInsensitiveString(itr.current()); + key = _ukeywords.containsKey(tmpKey) ? null : tmpKey; + typeStart = typeEnd = -1; + } else { + if (typeStart == -1) { + typeStart = itr.currentStart(); + } + typeEnd = itr.currentEnd(); + } + } else if (UnicodeLocaleExtension.isKey(itr.current())) { + // 1. first keyword or + // 2. next keyword, but previous one was duplicate + key = new CaseInsensitiveString(itr.current()); + if (_ukeywords != null && _ukeywords.containsKey(key)) { + // duplicate + key = null; + } + } + + if (!itr.hasNext()) { + if (key != null) { + // last keyword + assert(typeStart == -1 || typeEnd != -1); + type = (typeStart == -1) ? "" : subtags.substring(typeStart, typeEnd); + if (_ukeywords == null) { + _ukeywords = new HashMap<CaseInsensitiveString, String>(4); + } + _ukeywords.put(key, type); + } + break; + } + + itr.next(); + } + } + + static class CaseInsensitiveString { + private String _s; + + CaseInsensitiveString(String s) { + _s = s; + } + + public String value() { + return _s; + } + + public int hashCode() { + return AsciiUtil.toLowerString(_s).hashCode(); + } + + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (!(obj instanceof CaseInsensitiveString)) { + return false; + } + return AsciiUtil.caseIgnoreMatch(_s, ((CaseInsensitiveString)obj).value()); + } + } + + static class CaseInsensitiveChar { + private char _c; + + CaseInsensitiveChar(char c) { + _c = c; + } + + public char value() { + return _c; + } + + public int hashCode() { + return AsciiUtil.toLower(_c); + } + + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (!(obj instanceof CaseInsensitiveChar)) { + return false; + } + return _c == AsciiUtil.toLower(((CaseInsensitiveChar)obj).value()); + } + + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/classes/sun/util/locale/LanguageTag.java Fri Sep 10 15:29:40 2010 -0700 @@ -0,0 +1,726 @@ +/* + * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + ******************************************************************************* + * Copyright (C) 2010, International Business Machines Corporation and * + * others. All Rights Reserved. * + ******************************************************************************* + */ +package sun.util.locale; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +public class LanguageTag { + // + // static fields + // + public static final String SEP = "-"; + public static final String PRIVATEUSE = "x"; + public static String UNDETERMINED = "und"; + public static final String PRIVUSE_VARIANT_PREFIX = "lvariant"; + + // + // Language subtag fields + // + private String _language = ""; // language subtag + private String _script = ""; // script subtag + private String _region = ""; // region subtag + private String _privateuse = ""; // privateuse + + private List<String> _extlangs = Collections.emptyList(); // extlang subtags + private List<String> _variants = Collections.emptyList(); // variant subtags + private List<String> _extensions = Collections.emptyList(); // extensions + + // Map contains grandfathered tags and its preferred mappings from + // http://www.ietf.org/rfc/rfc5646.txt + private static final Map<AsciiUtil.CaseInsensitiveKey, String[]> GRANDFATHERED = + new HashMap<AsciiUtil.CaseInsensitiveKey, String[]>(); + + static { + // grandfathered = irregular ; non-redundant tags registered + // / regular ; during the RFC 3066 era + // + // irregular = "en-GB-oed" ; irregular tags do not match + // / "i-ami" ; the 'langtag' production and + // / "i-bnn" ; would not otherwise be + // / "i-default" ; considered 'well-formed' + // / "i-enochian" ; These tags are all valid, + // / "i-hak" ; but most are deprecated + // / "i-klingon" ; in favor of more modern + // / "i-lux" ; subtags or subtag + // / "i-mingo" ; combination + // / "i-navajo" + // / "i-pwn" + // / "i-tao" + // / "i-tay" + // / "i-tsu" + // / "sgn-BE-FR" + // / "sgn-BE-NL" + // / "sgn-CH-DE" + // + // regular = "art-lojban" ; these tags match the 'langtag' + // / "cel-gaulish" ; production, but their subtags + // / "no-bok" ; are not extended language + // / "no-nyn" ; or variant subtags: their meaning + // / "zh-guoyu" ; is defined by their registration + // / "zh-hakka" ; and all of these are deprecated + // / "zh-min" ; in favor of a more modern + // / "zh-min-nan" ; subtag or sequence of subtags + // / "zh-xiang" + + final String[][] entries = { + //{"tag", "preferred"}, + {"art-lojban", "jbo"}, + {"cel-gaulish", "xtg-x-cel-gaulish"}, // fallback + {"en-GB-oed", "en-GB-x-oed"}, // fallback + {"i-ami", "ami"}, + {"i-bnn", "bnn"}, + {"i-default", "en-x-i-default"}, // fallback + {"i-enochian", "und-x-i-enochian"}, // fallback + {"i-hak", "hak"}, + {"i-klingon", "tlh"}, + {"i-lux", "lb"}, + {"i-mingo", "see-x-i-mingo"}, // fallback + {"i-navajo", "nv"}, + {"i-pwn", "pwn"}, + {"i-tao", "tao"}, + {"i-tay", "tay"}, + {"i-tsu", "tsu"}, + {"no-bok", "nb"}, + {"no-nyn", "nn"}, + {"sgn-BE-FR", "sfb"}, + {"sgn-BE-NL", "vgt"}, + {"sgn-CH-DE", "sgg"}, + {"zh-guoyu", "cmn"}, + {"zh-hakka", "hak"}, + {"zh-min", "nan-x-zh-min"}, // fallback + {"zh-min-nan", "nan"}, + {"zh-xiang", "hsn"}, + }; + for (String[] e : entries) { + GRANDFATHERED.put(new AsciiUtil.CaseInsensitiveKey(e[0]), e); + } + } + + private LanguageTag() { + } + + /* + * BNF in RFC5464 + * + * Language-Tag = langtag ; normal language tags + * / privateuse ; private use tag + * / grandfathered ; grandfathered tags + * + * + * langtag = language + * ["-" script] + * ["-" region] + * *("-" variant) + * *("-" extension) + * ["-" privateuse] + * + * language = 2*3ALPHA ; shortest ISO 639 code + * ["-" extlang] ; sometimes followed by + * ; extended language subtags + * / 4ALPHA ; or reserved for future use + * / 5*8ALPHA ; or registered language subtag + * + * extlang = 3ALPHA ; selected ISO 639 codes + * *2("-" 3ALPHA) ; permanently reserved + * + * script = 4ALPHA ; ISO 15924 code + * + * region = 2ALPHA ; ISO 3166-1 code + * / 3DIGIT ; UN M.49 code + * + * variant = 5*8alphanum ; registered variants + * / (DIGIT 3alphanum) + * + * extension = singleton 1*("-" (2*8alphanum)) + * + * ; Single alphanumerics + * ; "x" reserved for private use + * singleton = DIGIT ; 0 - 9 + * / %x41-57 ; A - W + * / %x59-5A ; Y - Z + * / %x61-77 ; a - w + * / %x79-7A ; y - z + * + * privateuse = "x" 1*("-" (1*8alphanum)) + * + */ + public static LanguageTag parse(String languageTag, ParseStatus sts) { + if (sts == null) { + sts = new ParseStatus(); + } else { + sts.reset(); + } + + StringTokenIterator itr; + + // Check if the tag is grandfathered + String[] gfmap = GRANDFATHERED.get(new AsciiUtil.CaseInsensitiveKey(languageTag)); + if (gfmap != null) { + // use preferred mapping + itr = new StringTokenIterator(gfmap[1], SEP); + } else { + itr = new StringTokenIterator(languageTag, SEP); + } + + LanguageTag tag = new LanguageTag(); + + // langtag must start with either language or privateuse + if (tag.parseLanguage(itr, sts)) { + tag.parseExtlangs(itr, sts); + tag.parseScript(itr, sts); + tag.parseRegion(itr, sts); + tag.parseVariants(itr, sts); + tag.parseExtensions(itr, sts); + } + tag.parsePrivateuse(itr, sts); + + if (!itr.isDone() && !sts.isError()) { + String s = itr.current(); + sts._errorIndex = itr.currentStart(); + if (s.length() == 0) { + sts._errorMsg = "Empty subtag"; + } else { + sts._errorMsg = "Invalid subtag: " + s; + } + } + + return tag; + } + + // + // Language subtag parsers + // + + private boolean parseLanguage(StringTokenIterator itr, ParseStatus sts) { + if (itr.isDone() || sts.isError()) { + return false; + } + + boolean found = false; + + String s = itr.current(); + if (isLanguage(s)) { + found = true; + _language = s; + sts._parseLength = itr.currentEnd(); + itr.next(); + } + + return found; + } + + private boolean parseExtlangs(StringTokenIterator itr, ParseStatus sts) { + if (itr.isDone() || sts.isError()) { + return false; + } + + boolean found = false; + + while (!itr.isDone()) { + String s = itr.current(); + if (!isExtlang(s)) { + break; + } + found = true; + if (_extlangs.isEmpty()) { + _extlangs = new ArrayList<String>(3); + } + _extlangs.add(s); + sts._parseLength = itr.currentEnd(); + itr.next(); + + if (_extlangs.size() == 3) { + // Maximum 3 extlangs + break; + } + } + + return found; + } + + private boolean parseScript(StringTokenIterator itr, ParseStatus sts) { + if (itr.isDone() || sts.isError()) { + return false; + } + + boolean found = false; + + String s = itr.current(); + if (isScript(s)) { + found = true; + _script = s; + sts._parseLength = itr.currentEnd(); + itr.next(); + } + + return found; + } + + private boolean parseRegion(StringTokenIterator itr, ParseStatus sts) { + if (itr.isDone() || sts.isError()) { + return false; + } + + boolean found = false; + + String s = itr.current(); + if (isRegion(s)) { + found = true; + _region = s; + sts._parseLength = itr.currentEnd(); + itr.next(); + } + + return found; + } + + private boolean parseVariants(StringTokenIterator itr, ParseStatus sts) { + if (itr.isDone() || sts.isError()) { + return false; + } + + boolean found = false; + + while (!itr.isDone()) { + String s = itr.current(); + if (!isVariant(s)) { + break; + } + found = true; + if (_variants.isEmpty()) { + _variants = new ArrayList<String>(3); + } + _variants.add(s); + sts._parseLength = itr.currentEnd(); + itr.next(); + } + + return found; + } + + private boolean parseExtensions(StringTokenIterator itr, ParseStatus sts) { + if (itr.isDone() || sts.isError()) { + return false; + } + + boolean found = false; + + while (!itr.isDone()) { + String s = itr.current(); + if (isExtensionSingleton(s)) { + int start = itr.currentStart(); + String singleton = s; + StringBuilder sb = new StringBuilder(singleton); + + itr.next(); + while (!itr.isDone()) { + s = itr.current(); + if (isExtensionSubtag(s)) { + sb.append(SEP).append(s); + sts._parseLength = itr.currentEnd(); + } else { + break; + } + itr.next(); + } + + if (sts._parseLength <= start) { + sts._errorIndex = start; + sts._errorMsg = "Incomplete extension '" + singleton + "'"; + break; + } + + if (_extensions.size() == 0) { + _extensions = new ArrayList<String>(4); + } + _extensions.add(sb.toString()); + found = true; + } else { + break; + } + } + return found; + } + + private boolean parsePrivateuse(StringTokenIterator itr, ParseStatus sts) { + if (itr.isDone() || sts.isError()) { + return false; + } + + boolean found = false; + + String s = itr.current(); + if (isPrivateusePrefix(s)) { + int start = itr.currentStart(); + StringBuilder sb = new StringBuilder(s); + + itr.next(); + while (!itr.isDone()) { + s = itr.current(); + if (!isPrivateuseSubtag(s)) { + break; + } + sb.append(SEP).append(s); + sts._parseLength = itr.currentEnd(); + + itr.next(); + } + + if (sts._parseLength <= start) { + // need at least 1 private subtag + sts._errorIndex = start; + sts._errorMsg = "Incomplete privateuse"; + } else { + _privateuse = sb.toString(); + found = true; + } + } + + return found; + } + + public static LanguageTag parseLocale(BaseLocale baseLocale, LocaleExtensions localeExtensions) { + LanguageTag tag = new LanguageTag(); + + String language = baseLocale.getLanguage(); + String script = baseLocale.getScript(); + String region = baseLocale.getRegion(); + String variant = baseLocale.getVariant(); + + String privuseVar = null; // store ill-formed variant subtags + + if (language.length() == 0 || !isLanguage(language)) { + tag._language = UNDETERMINED; + } else { + // Convert a deprecated language code used by Java to + // a new code + if (language.equals("iw")) { + language = "he"; + } else if (language.equals("ji")) { + language = "yi"; + } else if (language.equals("in")) { + language = "id"; + } + tag._language = language; + } + + if (script.length() > 0 && isScript(script)) { + tag._script = canonicalizeScript(script); + } + + if (region.length() > 0 && isRegion(region)) { + tag._region = canonicalizeRegion(region); + } + + // Special handling for no_NO_NY - use nn_NO for language tag + if (tag._language.equals("no") && tag._region.equals("NO") && variant.equals("NY")) { + tag._language = "nn"; + variant = ""; + } + + if (variant.length() > 0) { + List<String> variants = null; + StringTokenIterator varitr = new StringTokenIterator(variant, BaseLocale.SEP); + while (!varitr.isDone()) { + String var = varitr.current(); + if (!isVariant(var)) { + break; + } + if (variants == null) { + variants = new ArrayList<String>(); + } + variants.add(var); // Do not canonicalize! + varitr.next(); + } + if (variants != null) { + tag._variants = variants; + } + if (!varitr.isDone()) { + // ill-formed variant subtags + StringBuilder buf = new StringBuilder(); + while (!varitr.isDone()) { + String prvv = varitr.current(); + if (!isPrivateuseSubtag(prvv)) { + // cannot use private use subtag - truncated + break; + } + if (buf.length() > 0) { + buf.append(SEP); + } + buf.append(prvv); + varitr.next(); + } + if (buf.length() > 0) { + privuseVar = buf.toString(); + } + } + } + + List<String> extensions = null; + String privateuse = null; + + Set<Character> locextKeys = localeExtensions.getKeys(); + for (Character locextKey : locextKeys) { + Extension ext = localeExtensions.getExtension(locextKey); + if (isPrivateusePrefixChar(locextKey.charValue())) { + privateuse = ext.getValue(); + } else { + if (extensions == null) { + extensions = new ArrayList<String>(); + } + extensions.add(locextKey.toString() + SEP + ext.getValue()); + } + } + + if (extensions != null) { + tag._extensions = extensions; + } + + // append ill-formed variant subtags to private use + if (privuseVar != null) { + if (privateuse == null) { + privateuse = PRIVUSE_VARIANT_PREFIX + SEP + privuseVar; + } else { + privateuse = privateuse + SEP + PRIVUSE_VARIANT_PREFIX + SEP + privuseVar.replace(BaseLocale.SEP, SEP); + } + } + + if (privateuse != null) { + tag._privateuse = privateuse; + } else if (tag._language.length() == 0) { + // use "und" if neither language nor privateuse is available + tag._language = UNDETERMINED; + } + + return tag; + } + + // + // Getter methods for language subtag fields + // + + public String getLanguage() { + return _language; + } + + public List<String> getExtlangs() { + return Collections.unmodifiableList(_extlangs); + } + + public String getScript() { + return _script; + } + + public String getRegion() { + return _region; + } + + public List<String> getVariants() { + return Collections.unmodifiableList(_variants); + } + + public List<String> getExtensions() { + return Collections.unmodifiableList(_extensions); + } + + public String getPrivateuse() { + return _privateuse; + } + + // + // Language subtag syntax checking methods + // + + public static boolean isLanguage(String s) { + // language = 2*3ALPHA ; shortest ISO 639 code + // ["-" extlang] ; sometimes followed by + // ; extended language subtags + // / 4ALPHA ; or reserved for future use + // / 5*8ALPHA ; or registered language subtag + return (s.length() >= 2) && (s.length() <= 8) && AsciiUtil.isAlphaString(s); + } + + public static boolean isExtlang(String s) { + // extlang = 3ALPHA ; selected ISO 639 codes + // *2("-" 3ALPHA) ; permanently reserved + return (s.length() == 3) && AsciiUtil.isAlphaString(s); + } + + public static boolean isScript(String s) { + // script = 4ALPHA ; ISO 15924 code + return (s.length() == 4) && AsciiUtil.isAlphaString(s); + } + + public static boolean isRegion(String s) { + // region = 2ALPHA ; ISO 3166-1 code + // / 3DIGIT ; UN M.49 code + return ((s.length() == 2) && AsciiUtil.isAlphaString(s)) + || ((s.length() == 3) && AsciiUtil.isNumericString(s)); + } + + public static boolean isVariant(String s) { + // variant = 5*8alphanum ; registered variants + // / (DIGIT 3alphanum) + int len = s.length(); + if (len >= 5 && len <= 8) { + return AsciiUtil.isAlphaNumericString(s); + } + if (len == 4) { + return AsciiUtil.isNumeric(s.charAt(0)) + && AsciiUtil.isAlphaNumeric(s.charAt(1)) + && AsciiUtil.isAlphaNumeric(s.charAt(2)) + && AsciiUtil.isAlphaNumeric(s.charAt(3)); + } + return false; + } + + public static boolean isExtensionSingleton(String s) { + // singleton = DIGIT ; 0 - 9 + // / %x41-57 ; A - W + // / %x59-5A ; Y - Z + // / %x61-77 ; a - w + // / %x79-7A ; y - z + + return (s.length() == 1) + && AsciiUtil.isAlphaString(s) + && !AsciiUtil.caseIgnoreMatch(PRIVATEUSE, s); + } + + public static boolean isExtensionSingletonChar(char c) { + return isExtensionSingleton(String.valueOf(c)); + } + + public static boolean isExtensionSubtag(String s) { + // extension = singleton 1*("-" (2*8alphanum)) + return (s.length() >= 2) && (s.length() <= 8) && AsciiUtil.isAlphaNumericString(s); + } + + public static boolean isPrivateusePrefix(String s) { + // privateuse = "x" 1*("-" (1*8alphanum)) + return (s.length() == 1) + && AsciiUtil.caseIgnoreMatch(PRIVATEUSE, s); + } + + public static boolean isPrivateusePrefixChar(char c) { + return (AsciiUtil.caseIgnoreMatch(PRIVATEUSE, String.valueOf(c))); + } + + public static boolean isPrivateuseSubtag(String s) { + // privateuse = "x" 1*("-" (1*8alphanum)) + return (s.length() >= 1) && (s.length() <= 8) && AsciiUtil.isAlphaNumericString(s); + } + + // + // Language subtag canonicalization methods + // + + public static String canonicalizeLanguage(String s) { + return AsciiUtil.toLowerString(s); + } + + public static String canonicalizeExtlang(String s) { + return AsciiUtil.toLowerString(s); + } + + public static String canonicalizeScript(String s) { + return AsciiUtil.toTitleString(s); + } + + public static String canonicalizeRegion(String s) { + return AsciiUtil.toUpperString(s); + } + + public static String canonicalizeVariant(String s) { + return AsciiUtil.toLowerString(s); + } + + public static String canonicalizeExtension(String s) { + return AsciiUtil.toLowerString(s); + } + + public static String canonicalizeExtensionSingleton(String s) { + return AsciiUtil.toLowerString(s); + } + + public static String canonicalizeExtensionSubtag(String s) { + return AsciiUtil.toLowerString(s); + } + + public static String canonicalizePrivateuse(String s) { + return AsciiUtil.toLowerString(s); + } + + public static String canonicalizePrivateuseSubtag(String s) { + return AsciiUtil.toLowerString(s); + } + + public String toString() { + StringBuilder sb = new StringBuilder(); + + if (_language.length() > 0) { + sb.append(_language); + + for (String extlang : _extlangs) { + sb.append(SEP).append(extlang); + } + + if (_script.length() > 0) { + sb.append(SEP).append(_script); + } + + if (_region.length() > 0) { + sb.append(SEP).append(_region); + } + + for (String variant : _extlangs) { + sb.append(SEP).append(variant); + } + + for (String extension : _extensions) { + sb.append(SEP).append(extension); + } + } + if (_privateuse.length() > 0) { + if (sb.length() > 0) { + sb.append(SEP); + } + sb.append(_privateuse); + } + + return sb.toString(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/classes/sun/util/locale/LocaleExtensions.java Fri Sep 10 15:29:40 2010 -0700 @@ -0,0 +1,246 @@ +/* + * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + ******************************************************************************* + * Copyright (C) 2009-2010, International Business Machines Corporation and * + * others. All Rights Reserved. * + ******************************************************************************* + */ +package sun.util.locale; + +import java.util.Collections; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import java.util.SortedMap; +import java.util.TreeMap; +import java.util.TreeSet; + +import sun.util.locale.InternalLocaleBuilder.CaseInsensitiveChar; +import sun.util.locale.InternalLocaleBuilder.CaseInsensitiveString; + + +public class LocaleExtensions { + + private SortedMap<Character, Extension> _map; + private String _id; + + private static final SortedMap<Character, Extension> EMPTY_MAP = + Collections.unmodifiableSortedMap(new TreeMap<Character, Extension>()); + + public static final LocaleExtensions EMPTY_EXTENSIONS; + public static final LocaleExtensions CALENDAR_JAPANESE; + public static final LocaleExtensions NUMBER_THAI; + + static { + EMPTY_EXTENSIONS = new LocaleExtensions(); + EMPTY_EXTENSIONS._id = ""; + EMPTY_EXTENSIONS._map = EMPTY_MAP; + + CALENDAR_JAPANESE = new LocaleExtensions(); + CALENDAR_JAPANESE._id = "u-ca-japanese"; + CALENDAR_JAPANESE._map = new TreeMap<Character, Extension>(); + CALENDAR_JAPANESE._map.put(Character.valueOf(UnicodeLocaleExtension.SINGLETON), UnicodeLocaleExtension.CA_JAPANESE); + + NUMBER_THAI = new LocaleExtensions(); + NUMBER_THAI._id = "u-nu-thai"; + NUMBER_THAI._map = new TreeMap<Character, Extension>(); + NUMBER_THAI._map.put(Character.valueOf(UnicodeLocaleExtension.SINGLETON), UnicodeLocaleExtension.NU_THAI); + } + + private LocaleExtensions() { + } + + /* + * Package local constructor, only used by InternalLocaleBuilder. + */ + LocaleExtensions(Map<CaseInsensitiveChar, String> extensions, + Set<CaseInsensitiveString> uattributes, Map<CaseInsensitiveString, String> ukeywords) { + boolean hasExtension = (extensions != null && extensions.size() > 0); + boolean hasUAttributes = (uattributes != null && uattributes.size() > 0); + boolean hasUKeywords = (ukeywords != null && ukeywords.size() > 0); + + if (!hasExtension && !hasUAttributes && !hasUKeywords) { + _map = EMPTY_MAP; + _id = ""; + return; + } + + // Build extension map + _map = new TreeMap<Character, Extension>(); + if (hasExtension) { + for (Entry<CaseInsensitiveChar, String> ext : extensions.entrySet()) { + char key = AsciiUtil.toLower(ext.getKey().value()); + String value = ext.getValue(); + + if (LanguageTag.isPrivateusePrefixChar(key)) { + // we need to exclude special variant in privuateuse, e.g. "x-abc-lvariant-DEF" + value = InternalLocaleBuilder.removePrivateuseVariant(value); + if (value == null) { + continue; + } + } + + Extension e = new Extension(key, AsciiUtil.toLowerString(value)); + _map.put(Character.valueOf(key), e); + } + } + + if (hasUAttributes || hasUKeywords) { + TreeSet<String> uaset = null; + TreeMap<String, String> ukmap = null; + + if (hasUAttributes) { + uaset = new TreeSet<String>(); + for (CaseInsensitiveString cis : uattributes) { + uaset.add(AsciiUtil.toLowerString(cis.value())); + } + } + + if (hasUKeywords) { + ukmap = new TreeMap<String, String>(); + for (Entry<CaseInsensitiveString, String> kwd : ukeywords.entrySet()) { + String key = AsciiUtil.toLowerString(kwd.getKey().value()); + String type = AsciiUtil.toLowerString(kwd.getValue()); + ukmap.put(key, type); + } + } + + UnicodeLocaleExtension ule = new UnicodeLocaleExtension(uaset, ukmap); + _map.put(Character.valueOf(UnicodeLocaleExtension.SINGLETON), ule); + } + + if (_map.size() == 0) { + // this could happen when only privuateuse with special variant + _map = EMPTY_MAP; + _id = ""; + } else { + _id = toID(_map); + } + } + + public Set<Character> getKeys() { + return Collections.unmodifiableSet(_map.keySet()); + } + + public Extension getExtension(Character key) { + return _map.get(Character.valueOf(AsciiUtil.toLower(key.charValue()))); + } + + public String getExtensionValue(Character key) { + Extension ext = _map.get(Character.valueOf(AsciiUtil.toLower(key.charValue()))); + if (ext == null) { + return null; + } + return ext.getValue(); + } + + public Set<String> getUnicodeLocaleAttributes() { + Extension ext = _map.get(Character.valueOf(UnicodeLocaleExtension.SINGLETON)); + if (ext == null) { + return Collections.emptySet(); + } + assert (ext instanceof UnicodeLocaleExtension); + return ((UnicodeLocaleExtension)ext).getUnicodeLocaleAttributes(); + } + + public Set<String> getUnicodeLocaleKeys() { + Extension ext = _map.get(Character.valueOf(UnicodeLocaleExtension.SINGLETON)); + if (ext == null) { + return Collections.emptySet(); + } + assert (ext instanceof UnicodeLocaleExtension); + return ((UnicodeLocaleExtension)ext).getUnicodeLocaleKeys(); + } + + public String getUnicodeLocaleType(String unicodeLocaleKey) { + Extension ext = _map.get(Character.valueOf(UnicodeLocaleExtension.SINGLETON)); + if (ext == null) { + return null; + } + assert (ext instanceof UnicodeLocaleExtension); + return ((UnicodeLocaleExtension)ext).getUnicodeLocaleType(AsciiUtil.toLowerString(unicodeLocaleKey)); + } + + public boolean isEmpty() { + return _map.isEmpty(); + } + + public static boolean isValidKey(char c) { + return LanguageTag.isExtensionSingletonChar(c) || LanguageTag.isPrivateusePrefixChar(c); + } + + public static boolean isValidUnicodeLocaleKey(String ukey) { + return UnicodeLocaleExtension.isKey(ukey); + } + + private static String toID(SortedMap<Character, Extension> map) { + StringBuilder buf = new StringBuilder(); + Extension privuse = null; + for (Entry<Character, Extension> entry : map.entrySet()) { + char singleton = entry.getKey().charValue(); + Extension extension = entry.getValue(); + if (LanguageTag.isPrivateusePrefixChar(singleton)) { + privuse = extension; + } else { + if (buf.length() > 0) { + buf.append(LanguageTag.SEP); + } + buf.append(extension); + } + } + if (privuse != null) { + if (buf.length() > 0) { + buf.append(LanguageTag.SEP); + } + buf.append(privuse); + } + return buf.toString(); + } + + + public String toString() { + return _id; + } + + public String getID() { + return _id; + } + + public int hashCode() { + return _id.hashCode(); + } + + public boolean equals(Object other) { + if (this == other) { + return true; + } + if (!(other instanceof LocaleExtensions)) { + return false; + } + return this._id.equals(((LocaleExtensions)other)._id); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/classes/sun/util/locale/LocaleObjectCache.java Fri Sep 10 15:29:40 2010 -0700 @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + ******************************************************************************* + * Copyright (C) 2009-2010, International Business Machines Corporation and * + * others. All Rights Reserved. * + ******************************************************************************* + */ +package sun.util.locale; + +import java.lang.ref.ReferenceQueue; +import java.lang.ref.SoftReference; +import java.util.concurrent.ConcurrentHashMap; + +public abstract class LocaleObjectCache<K, V> { + private ConcurrentHashMap<K, CacheEntry<K, V>> _map; + private ReferenceQueue<V> _queue = new ReferenceQueue<V>(); + + public LocaleObjectCache() { + this(16, 0.75f, 16); + } + + public LocaleObjectCache(int initialCapacity, float loadFactor, int concurrencyLevel) { + _map = new ConcurrentHashMap<K, CacheEntry<K, V>>(initialCapacity, loadFactor, concurrencyLevel); + } + + public V get(K key) { + V value = null; + + cleanStaleEntries(); + CacheEntry<K, V> entry = _map.get(key); + if (entry != null) { + value = entry.get(); + } + if (value == null) { + key = normalizeKey(key); + V newVal = createObject(key); + if (key == null || newVal == null) { + // subclass must return non-null key/value object + return null; + } + + CacheEntry<K, V> newEntry = new CacheEntry<K, V>(key, newVal, _queue); + + while (value == null) { + cleanStaleEntries(); + entry = _map.putIfAbsent(key, newEntry); + if (entry == null) { + value = newVal; + break; + } else { + value = entry.get(); + } + } + } + return value; + } + + @SuppressWarnings("unchecked") + private void cleanStaleEntries() { + CacheEntry<K, V> entry; + while ((entry = (CacheEntry<K, V>)_queue.poll()) != null) { + _map.remove(entry.getKey()); + } + } + + protected abstract V createObject(K key); + + protected K normalizeKey(K key) { + return key; + } + + private static class CacheEntry<K, V> extends SoftReference<V> { + private K _key; + + CacheEntry(K key, V value, ReferenceQueue<V> queue) { + super(value, queue); + _key = key; + } + + K getKey() { + return _key; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/classes/sun/util/locale/LocaleSyntaxException.java Fri Sep 10 15:29:40 2010 -0700 @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + ******************************************************************************* + * Copyright (C) 2009, International Business Machines Corporation and * + * others. All Rights Reserved. * + ******************************************************************************* + */ +package sun.util.locale; + +public class LocaleSyntaxException extends Exception { + + private static final long serialVersionUID = 1L; + + private int _index = -1; + + public LocaleSyntaxException(String msg) { + this(msg, 0); + } + + public LocaleSyntaxException(String msg, int errorIndex) { + super(msg); + _index = errorIndex; + } + + public int getErrorIndex() { + return _index; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/classes/sun/util/locale/ParseStatus.java Fri Sep 10 15:29:40 2010 -0700 @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + ******************************************************************************* + * Copyright (C) 2010, International Business Machines Corporation and * + * others. All Rights Reserved. * + ******************************************************************************* + */ +package sun.util.locale; + +public class ParseStatus { + int _parseLength = 0; + int _errorIndex = -1; + String _errorMsg = null; + + public void reset() { + _parseLength = 0; + _errorIndex = -1; + _errorMsg = null; + } + + public boolean isError() { + return (_errorIndex >= 0); + } + + public int getErrorIndex() { + return _errorIndex; + } + + public int getParseLength() { + return _parseLength; + } + + public String getErrorMessage() { + return _errorMsg; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/classes/sun/util/locale/StringTokenIterator.java Fri Sep 10 15:29:40 2010 -0700 @@ -0,0 +1,117 @@ +/* + * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +/* + ******************************************************************************* + * Copyright (C) 2009, International Business Machines Corporation and * + * others. All Rights Reserved. * + ******************************************************************************* + */ +package sun.util.locale; + +public class StringTokenIterator { + private String _text; + private String _dlms; + + private String _token; + private int _start; + private int _end; + private boolean _done; + + public StringTokenIterator(String text, String dlms) { + _text = text; + _dlms = dlms; + setStart(0); + } + + public String first() { + setStart(0); + return _token; + } + + public String current() { + return _token; + } + + public int currentStart() { + return _start; + } + + public int currentEnd() { + return _end; + } + + public boolean isDone() { + return _done; + } + + public String next() { + if (hasNext()) { + _start = _end + 1; + _end = nextDelimiter(_start); + _token = _text.substring(_start, _end); + } else { + _start = _end; + _token = null; + _done = true; + } + return _token; + } + + public boolean hasNext() { + return (_end < _text.length()); + } + + public StringTokenIterator setStart(int offset) { + if (offset > _text.length()) { + throw new IndexOutOfBoundsException(); + } + _start = offset; + _end = nextDelimiter(_start); + _token = _text.substring(_start, _end); + _done = false; + return this; + } + + public StringTokenIterator setText(String text) { + _text = text; + setStart(0); + return this; + } + + private int nextDelimiter(int start) { + int idx = start; + outer: while (idx < _text.length()) { + char c = _text.charAt(idx); + for (int i = 0; i < _dlms.length(); i++) { + if (c == _dlms.charAt(i)) { + break outer; + } + } + idx++; + } + return idx; + } +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/classes/sun/util/locale/UnicodeLocaleExtension.java Fri Sep 10 15:29:40 2010 -0700 @@ -0,0 +1,127 @@ +/* + * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + ******************************************************************************* + * Copyright (C) 2009-2010, International Business Machines Corporation and * + * others. All Rights Reserved. * + ******************************************************************************* + */ +package sun.util.locale; + +import java.util.Collections; +import java.util.Map.Entry; +import java.util.Set; +import java.util.SortedMap; +import java.util.SortedSet; +import java.util.TreeMap; +import java.util.TreeSet; + +public class UnicodeLocaleExtension extends Extension { + public static final char SINGLETON = 'u'; + + private static final SortedSet<String> EMPTY_SORTED_SET = new TreeSet<String>(); + private static final SortedMap<String, String> EMPTY_SORTED_MAP = new TreeMap<String, String>(); + + private SortedSet<String> _attributes = EMPTY_SORTED_SET; + private SortedMap<String, String> _keywords = EMPTY_SORTED_MAP; + + public static final UnicodeLocaleExtension CA_JAPANESE; + public static final UnicodeLocaleExtension NU_THAI; + + static { + CA_JAPANESE = new UnicodeLocaleExtension(); + CA_JAPANESE._keywords = new TreeMap<String, String>(); + CA_JAPANESE._keywords.put("ca", "japanese"); + CA_JAPANESE._value = "ca-japanese"; + + NU_THAI = new UnicodeLocaleExtension(); + NU_THAI._keywords = new TreeMap<String, String>(); + NU_THAI._keywords.put("nu", "thai"); + NU_THAI._value = "nu-thai"; + } + + private UnicodeLocaleExtension() { + super(SINGLETON); + } + + UnicodeLocaleExtension(SortedSet<String> attributes, SortedMap<String, String> keywords) { + this(); + if (attributes != null && attributes.size() > 0) { + _attributes = attributes; + } + if (keywords != null && keywords.size() > 0) { + _keywords = keywords; + } + + if (_attributes.size() > 0 || _keywords.size() > 0) { + StringBuilder sb = new StringBuilder(); + for (String attribute : _attributes) { + sb.append(LanguageTag.SEP).append(attribute); + } + for (Entry<String, String> keyword : _keywords.entrySet()) { + String key = keyword.getKey(); + String value = keyword.getValue(); + + sb.append(LanguageTag.SEP).append(key); + if (value.length() > 0) { + sb.append(LanguageTag.SEP).append(value); + } + } + _value = sb.substring(1); // skip leading '-' + } + } + + public Set<String> getUnicodeLocaleAttributes() { + return Collections.unmodifiableSet(_attributes); + } + + public Set<String> getUnicodeLocaleKeys() { + return Collections.unmodifiableSet(_keywords.keySet()); + } + + public String getUnicodeLocaleType(String unicodeLocaleKey) { + return _keywords.get(unicodeLocaleKey); + } + + public static boolean isSingletonChar(char c) { + return (SINGLETON == AsciiUtil.toLower(c)); + } + + public static boolean isAttribute(String s) { + // 3*8alphanum + return (s.length() >= 3) && (s.length() <= 8) && AsciiUtil.isAlphaNumericString(s); + } + + public static boolean isKey(String s) { + // 2alphanum + return (s.length() == 2) && AsciiUtil.isAlphaNumericString(s); + } + + public static boolean isTypeSubtag(String s) { + // 3*8alphanum + return (s.length() >= 3) && (s.length() <= 8) && AsciiUtil.isAlphaNumericString(s); + } +}
--- a/src/share/classes/sun/util/resources/LocaleData.java Fri Sep 10 20:48:17 2010 +0400 +++ b/src/share/classes/sun/util/resources/LocaleData.java Fri Sep 10 15:29:40 2010 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1996, 2005, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -177,6 +177,11 @@ for (Iterator<Locale> l = candidates.iterator(); l.hasNext(); ) { String lstr = l.next().toString(); + /* truncate extra segment introduced by Java 7 for script and extesions */ + int idx = lstr.indexOf("_#"); + if (idx >= 0) { + lstr = lstr.substring(0, idx); + } /* Every locale string in the locale string list returned from the above getSupportedLocaleString is enclosed within two white spaces so that we could check some locale
--- a/src/share/classes/sun/util/resources/LocaleNames.properties Fri Sep 10 20:48:17 2010 +0400 +++ b/src/share/classes/sun/util/resources/LocaleNames.properties Fri Sep 10 15:29:40 2010 -0700 @@ -228,6 +228,157 @@ zh=Chinese zu=Zulu +# script names +# key is ISO 15924 script code + +Arab=Arabic +Armi=Imperial Aramaic +Armn=Armenian +Avst=Avestan +Bali=Balinese +Bamu=Bamum +Bass=Bassa Vah +Batk=Batak +Beng=Bengali +Blis=Blissymbols +Bopo=Bopomofo +Brah=Brahmi +Brai=Braille +Bugi=Buginese +Buhd=Buhid +Cakm=Chakma +Cans=Unified Canadian Aboriginal Syllabics +Cari=Carian +Cham=Cham +Cher=Cherokee +Cirt=Cirth +Copt=Coptic +Cprt=Cypriot +Cyrl=Cyrillic +Cyrs=Old Church Slavonic Cyrillic +Deva=Devanagari +Dsrt=Deseret +Dupl=Duployan shorthand +Egyd=Egyptian demotic +Egyh=Egyptian hieratic +Egyp=Egyptian hieroglyphs +Elba=Elbasan +Ethi=Ethiopic +Geok=Khutsuri +Geor=Georgian +Glag=Glagolitic +Goth=Gothic +Gran=Grantha +Grek=Greek +Gujr=Gujarati +Guru=Gurmukhi +Hang=Hangul +Hani=Han +Hano=Hanunoo +Hans=Simplified Han +Hant=Traditional Han +Hebr=Hebrew +Hira=Hiragana +Hmng=Pahawh Hmong +Hrkt=Katakana or Hiragana +Hung=Old Hungarian +Inds=Indus +Ital=Old Italic +Java=Javanese +Jpan=Japanese +Kali=Kayah Li +Kana=Katakana +Khar=Kharoshthi +Khmr=Khmer +Knda=Kannada +Kore=Korean +Kpel=Kpelle +Kthi=Kaithi +Lana=Tai Tham +Laoo=Lao +Latf=Fraktur Latin +Latg=Gaelic Latin +Latn=Latin +Lepc=Lepcha +Limb=Limbu +Lina=Linear A +Linb=Linear B +Lisu=Lisu +Loma=Loma +Lyci=Lycian +Lydi=Lydian +Mand=Mandaic +Mani=Manichaean +Maya=Mayan hieroglyphs +Mend=Mende +Merc=Meroitic Cursive +Mero=Meroitic +Mlym=Malayalam +Mong=Mongolian +Moon=Moon +Mtei=Meitei Mayek +Mymr=Myanmar +Narb=Old North Arabian +Nbat=Nabataean +Nkgb=Nakhi Geba +Nkoo=N\u2019Ko +Ogam=Ogham +Olck=Ol Chiki +Orkh=Orkhon +Orya=Oriya +Osma=Osmanya +Palm=Palmyrene +Perm=Old Permic +Phag=Phags-pa +Phli=Inscriptional Pahlavi +Phlp=Psalter Pahlavi +Phlv=Book Pahlavi +Phnx=Phoenician +Plrd=Miao +Prti=Inscriptional Parthian +Rjng=Rejang +Roro=Rongorongo +Runr=Runic +Samr=Samaritan +Sara=Sarati +Sarb=Old South Arabian +Saur=Saurashtra +Sgnw=SignWriting +Shaw=Shavian +Sind=Sindhi +Sinh=Sinhala +Sund=Sundanese +Sylo=Syloti Nagri +Syrc=Syriac +Syre=Estrangelo Syriac +Syrj=Western Syriac +Syrn=Eastern Syriac +Tagb=Tagbanwa +Tale=Tai Le +Talu=New Tai Lue +Taml=Tamil +Tavt=Tai Viet +Telu=Telugu +Teng=Tengwar +Tfng=Tifinagh +Tglg=Tagalog +Thaa=Thaana +Thai=Thai +Tibt=Tibetan +Ugar=Ugaritic +Vaii=Vai +Visp=Visible Speech +Wara=Warang Citi +Xpeo=Old Persian +Xsux=Sumero-Akkadian Cuneiform +Yiii=Yi +Zinh=Inherited script +Zmth=Mathematical Notation +Zsym=Symbols +Zxxx=Unwritten +Zyyy=Undetermined script +Zzzz=Uncoded script + # country names # key is ISO 3166 country code @@ -479,6 +630,39 @@ ZM=Zambia ZW=Zimbabwe +# territory names +# key is UN M.49 country and area code + +001=World +002=Africa +003=North America +005=South America +009=Oceania +011=Western Africa +013=Central America +014=Eastern Africa +015=Northern Africa +017=Middle Africa +018=Southern Africa +019=Americas +021=Northern America +029=Caribbean +030=Eastern Asia +034=Southern Asia +035=South-Eastern Asia +039=Southern Europe +053=Australia and New Zealand +054=Melanesia +057=Micronesian Region +061=Polynesia +142=Asia +143=Central Asia +145=Western Asia +150=Europe +151=Eastern Europe +154=Northern Europe +155=Western Europe +419=Latin America and the Caribbean # variant names # key is %%variant
--- a/src/share/classes/sun/util/resources/LocaleNames_zh.properties Fri Sep 10 20:48:17 2010 +0400 +++ b/src/share/classes/sun/util/resources/LocaleNames_zh.properties Fri Sep 10 15:29:40 2010 -0700 @@ -227,6 +227,12 @@ zh=\u4e2d\u6587 zu=\u7956\u9c81\u6587 +# script names +# key is ISO 15924 script code + +Hans=\u7b80\u4f53\u4e2d\u6587 +Hant=\u7e41\u4f53\u4e2d\u6587 + # country names # key is ISO 3166 country code
--- a/src/share/classes/sun/util/resources/LocaleNames_zh_TW.properties Fri Sep 10 20:48:17 2010 +0400 +++ b/src/share/classes/sun/util/resources/LocaleNames_zh_TW.properties Fri Sep 10 15:29:40 2010 -0700 @@ -227,6 +227,12 @@ zh=\u4e2d\u6587 zu=\u7956\u9b6f\u6587 +# script names +# key is ISO 15924 script code + +Hans=\u7c21\u9ad4\u4e2d\u6587 +Hant=\u7e41\u9ad4\u4e2d\u6587 + # country names # key is ISO 3166 country code
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/java/util/Locale/LocaleEnhanceTest.java Fri Sep 10 15:29:40 2010 -0700 @@ -0,0 +1,1293 @@ +/* + * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +import java.io.BufferedReader; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.InputStreamReader; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.net.URISyntaxException; +import java.net.URL; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.IllformedLocaleException; +import java.util.List; +import java.util.Locale; +import java.util.Locale.Builder; +import java.util.Set; + +/** + * @test + * @bug 6875847 + * @summary test API changes to Locale + */ +public class LocaleEnhanceTest extends LocaleTestFmwk { + + public static void main(String[] args) throws Exception { + List<String> argList = new ArrayList<String>(); + argList.addAll(Arrays.asList(args)); + argList.add("-nothrow"); + new LocaleEnhanceTest().run(argList.toArray(new String[argList.size()])); + } + + public LocaleEnhanceTest() { + } + + /// + /// Generic sanity tests + /// + + /** A canonical language code. */ + private static final String l = "en"; + + /** A canonical script code.. */ + private static final String s = "Latn"; + + /** A canonical region code. */ + private static final String c = "US"; + + /** A canonical variant code. */ + private static final String v = "NewYork"; + + /** + * Ensure that Builder builds locales that have the expected + * tag and java6 ID. Note the odd cases for the ID. + */ + public void testCreateLocaleCanonicalValid() { + String[] valids = { + "en-Latn-US-NewYork", "en_US_NewYork_#Latn", + "en-Latn-US", "en_US_#Latn", + "en-Latn-NewYork", "en__NewYork_#Latn", // double underscore + "en-Latn", "en_#Latn", + "en-US-NewYork", "en_US_NewYork", + "en-US", "en_US", + "en-NewYork", "en__NewYork", // double underscore + "en", "en", + "und-Latn-US-NewYork", "_US_NewYork_#Latn", + "und-Latn-US", "_US_#Latn", + "und-Latn-NewYork", "", // variant only not supported + "und-Latn", "", + "und-US-NewYork", "_US_NewYork", + "und-US", "_US", + "und-NewYork", "", // variant only not supported + "und", "" + }; + + Builder builder = new Builder(); + + for (int i = 0; i < valids.length; i += 2) { + String tag = valids[i]; + String id = valids[i+1]; + + String idl = (i & 16) == 0 ? l : ""; + String ids = (i & 8) == 0 ? s : ""; + String idc = (i & 4) == 0 ? c : ""; + String idv = (i & 2) == 0 ? v : ""; + + String msg = String.valueOf(i/2) + ": '" + tag + "' "; + + try { + Locale l = builder + .setLanguage(idl) + .setScript(ids) + .setRegion(idc) + .setVariant(idv) + .build(); + assertEquals(msg + "language", idl, l.getLanguage()); + assertEquals(msg + "script", ids, l.getScript()); + assertEquals(msg + "country", idc, l.getCountry()); + assertEquals(msg + "variant", idv, l.getVariant()); + assertEquals(msg + "tag", tag, l.toLanguageTag()); + assertEquals(msg + "id", id, l.toString()); + } + catch (IllegalArgumentException e) { + errln(msg + e.getMessage()); + } + } + } + + /** + * Test that locale construction works with 'multiple variants'. + * <p> + * The string "Newer__Yorker" is treated as three subtags, + * "Newer", "", and "Yorker", and concatenated into one + * subtag by omitting empty subtags and joining the remainer + * with underscores. So the resulting variant tag is "Newer_Yorker". + * Note that 'New' and 'York' are invalid BCP47 variant subtags + * because they are too short. + */ + public void testCreateLocaleMultipleVariants() { + + String[] valids = { + "en-Latn-US-Newer-Yorker", "en_US_Newer_Yorker_#Latn", + "en-Latn-Newer-Yorker", "en__Newer_Yorker_#Latn", + "en-US-Newer-Yorker", "en_US_Newer_Yorker", + "en-Newer-Yorker", "en__Newer_Yorker", + "und-Latn-US-Newer-Yorker", "_US_Newer_Yorker_#Latn", + "und-Latn-Newer-Yorker", "", + "und-US-Newer-Yorker", "_US_Newer_Yorker", + "und-Newer-Yorker", "", + }; + + Builder builder = new Builder(); // lenient variant + + final String idv = "Newer_Yorker"; + for (int i = 0; i < valids.length; i += 2) { + String tag = valids[i]; + String id = valids[i+1]; + + String idl = (i & 8) == 0 ? l : ""; + String ids = (i & 4) == 0 ? s : ""; + String idc = (i & 2) == 0 ? c : ""; + + String msg = String.valueOf(i/2) + ": " + tag + " "; + try { + Locale l = builder + .setLanguage(idl) + .setScript(ids) + .setRegion(idc) + .setVariant(idv) + .build(); + + assertEquals(msg + " language", idl, l.getLanguage()); + assertEquals(msg + " script", ids, l.getScript()); + assertEquals(msg + " country", idc, l.getCountry()); + assertEquals(msg + " variant", idv, l.getVariant()); + + assertEquals(msg + "tag", tag, l.toLanguageTag()); + assertEquals(msg + "id", id, l.toString()); + } + catch (IllegalArgumentException e) { + errln(msg + e.getMessage()); + } + } + } + + /** + * Ensure that all these invalid formats are not recognized by + * forLanguageTag. + */ + public void testCreateLocaleCanonicalInvalidSeparator() { + String[] invalids = { + // trailing separator + "en_Latn_US_NewYork_", + "en_Latn_US_", + "en_Latn_", + "en_", + "_", + + // double separator + "en_Latn_US__NewYork", + "_Latn_US__NewYork", + "en_US__NewYork", + "_US__NewYork", + + // are these OK? + // "en_Latn__US_NewYork", // variant is 'US_NewYork' + // "_Latn__US_NewYork", // variant is 'US_NewYork' + // "en__Latn_US_NewYork", // variant is 'Latn_US_NewYork' + // "en__US_NewYork", // variant is 'US_NewYork' + + // double separator without language or script + "__US", + "__NewYork", + + // triple separator anywhere except within variant + "en___NewYork", + "en_Latn___NewYork", + "_Latn___NewYork", + "___NewYork", + }; + + for (int i = 0; i < invalids.length; ++i) { + String id = invalids[i]; + Locale l = Locale.forLanguageTag(id); + assertEquals(id, "und", l.toLanguageTag()); + } + } + + /** + * Ensure that all current locale ids parse. Use DateFormat as a proxy + * for all current locale ids. + */ + public void testCurrentLocales() { + Locale[] locales = java.text.DateFormat.getAvailableLocales(); + Builder builder = new Builder(); + + for (Locale target : locales) { + String tag = target.toLanguageTag(); + + // the tag recreates the original locale, + // except no_NO_NY + Locale tagResult = Locale.forLanguageTag(tag); + if (!target.getVariant().equals("NY")) { + assertEquals("tagResult", target, tagResult); + } + + // the builder also recreates the original locale, + // except ja_JP_JP, th_TH_TH and no_NO_NY + Locale builderResult = builder.setLocale(target).build(); + if (target.getVariant().length() != 2) { + assertEquals("builderResult", target, builderResult); + } + } + } + + /** + * Ensure that all icu locale ids parse. + */ + public void testIcuLocales() throws Exception { + BufferedReader br = new BufferedReader( + new InputStreamReader( + LocaleEnhanceTest.class.getResourceAsStream("icuLocales.txt"), + "UTF-8")); + String id = null; + while (null != (id = br.readLine())) { + Locale result = Locale.forLanguageTag(id); + assertEquals("ulocale", id, result.toLanguageTag()); + } + } + + /// + /// Compatibility tests + /// + + public void testConstructor() { + // all the old weirdness still holds, no new weirdness + String[][] tests = { + // language to lower case, region to upper, variant unchanged + // short + { "X", "y", "z", "x", "Y" }, + // long + { "xXxXxXxXxXxX", "yYyYyYyYyYyYyYyY", "zZzZzZzZzZzZzZzZ", + "xxxxxxxxxxxx", "YYYYYYYYYYYYYYYY" }, + // mapped language ids + { "he", "IW", "", "iw" }, + { "iw", "IW", "", "iw" }, + { "yi", "DE", "", "ji" }, + { "ji", "DE", "", "ji" }, + { "id", "ID", "", "in" }, + { "in", "ID", "", "in" }, + // special variants + { "ja", "JP", "JP" }, + { "th", "TH", "TH" }, + { "no", "NO", "NY" }, + { "no", "NO", "NY" }, + // no canonicalization of 3-letter language codes + { "eng", "US", "" } + }; + for (int i = 0; i < tests.length; ++ i) { + String[] test = tests[i]; + String id = String.valueOf(i); + Locale locale = new Locale(test[0], test[1], test[2]); + assertEquals(id + " lang", test.length > 3 ? test[3] : test[0], locale.getLanguage()); + assertEquals(id + " region", test.length > 4 ? test[4] : test[1], locale.getCountry()); + assertEquals(id + " variant", test.length > 5 ? test[5] : test[2], locale.getVariant()); + } + } + + /// + /// Locale API tests. + /// + + public void testGetScript() { + // forLanguageTag normalizes case + Locale locale = Locale.forLanguageTag("und-latn"); + assertEquals("forLanguageTag", "Latn", locale.getScript()); + + // Builder normalizes case + locale = new Builder().setScript("LATN").build(); + assertEquals("builder", "Latn", locale.getScript()); + + // empty string is returned, not null, if there is no script + locale = Locale.forLanguageTag("und"); + assertEquals("script is empty string", "", locale.getScript()); + } + + public void testGetExtension() { + // forLanguageTag does NOT normalize to hyphen + Locale locale = Locale.forLanguageTag("und-a-some_ex-tension"); + assertEquals("some_ex-tension", null, locale.getExtension('a')); + + // regular extension + locale = new Builder().setExtension('a', "some-ex-tension").build(); + assertEquals("builder", "some-ex-tension", locale.getExtension('a')); + + // returns null if extension is not present + assertEquals("empty b", null, locale.getExtension('b')); + + // throws exception if extension tag is illegal + new ExpectIAE() { public void call() { Locale.forLanguageTag("").getExtension('\uD800'); }}; + + // 'x' is not an extension, it's a private use tag, but it's accessed through this API + locale = Locale.forLanguageTag("x-y-z-blork"); + assertEquals("x", "y-z-blork", locale.getExtension('x')); + } + + public void testGetExtensionKeys() { + Locale locale = Locale.forLanguageTag("und-a-xx-yy-b-zz-ww"); + Set<Character> result = locale.getExtensionKeys(); + assertEquals("result size", 2, result.size()); + assertTrue("'a','b'", result.contains('a') && result.contains('b')); + + // result is not mutable + try { + result.add('x'); + errln("expected exception on add to extension key set"); + } + catch (UnsupportedOperationException e) { + // ok + } + + // returns empty set if no extensions + locale = Locale.forLanguageTag("und"); + assertTrue("empty result", locale.getExtensionKeys().isEmpty()); + } + + public void testGetUnicodeLocaleAttributes() { + Locale locale = Locale.forLanguageTag("en-US-u-abc-def"); + Set<String> attributes = locale.getUnicodeLocaleAttributes(); + assertEquals("number of attributes", 2, attributes.size()); + assertTrue("attribute abc", attributes.contains("abc")); + assertTrue("attribute def", attributes.contains("def")); + + locale = Locale.forLanguageTag("en-US-u-ca-gregory"); + attributes = locale.getUnicodeLocaleAttributes(); + assertTrue("empty attributes", attributes.isEmpty()); + } + + public void testGetUnicodeLocaleType() { + Locale locale = Locale.forLanguageTag("und-u-co-japanese-nu-thai"); + assertEquals("collation", "japanese", locale.getUnicodeLocaleType("co")); + assertEquals("numbers", "thai", locale.getUnicodeLocaleType("nu")); + + // Unicode locale extension key is case insensitive + assertEquals("key case", "japanese", locale.getUnicodeLocaleType("Co")); + + // if keyword is not present, returns null + assertEquals("locale keyword not present", null, locale.getUnicodeLocaleType("xx")); + + // if no locale extension is set, returns null + locale = Locale.forLanguageTag("und"); + assertEquals("locale extension not present", null, locale.getUnicodeLocaleType("co")); + + // typeless keyword + locale = Locale.forLanguageTag("und-u-kn"); + assertEquals("typeless keyword", "", locale.getUnicodeLocaleType("kn")); + + // invalid keys throw exception + new ExpectIAE() { public void call() { Locale.forLanguageTag("").getUnicodeLocaleType("q"); }}; + new ExpectIAE() { public void call() { Locale.forLanguageTag("").getUnicodeLocaleType("abcdefghi"); }}; + + // null argument throws exception + new ExpectNPE() { public void call() { Locale.forLanguageTag("").getUnicodeLocaleType(null); }}; + } + + public void testGetUnicodeLocaleKeys() { + Locale locale = Locale.forLanguageTag("und-u-co-japanese-nu-thai"); + Set<String> result = locale.getUnicodeLocaleKeys(); + assertEquals("two keys", 2, result.size()); + assertTrue("co and nu", result.contains("co") && result.contains("nu")); + + // result is not modifiable + try { + result.add("frobozz"); + errln("expected exception when add to locale key set"); + } + catch (UnsupportedOperationException e) { + // ok + } + } + + public void testPrivateUseExtension() { + Locale locale = Locale.forLanguageTag("x-y-x-blork-"); + assertEquals("blork", "y-x-blork", locale.getExtension(Locale.PRIVATE_USE_EXTENSION)); + + locale = Locale.forLanguageTag("und"); + assertEquals("no privateuse", null, locale.getExtension(Locale.PRIVATE_USE_EXTENSION)); + } + + public void testToLanguageTag() { + // lots of normalization to test here + // test locales created using the constructor + String[][] tests = { + // empty locale canonicalizes to 'und' + { "", "", "", "und" }, + // variant alone is not a valid Locale, but has a valid language tag + { "", "", "NewYork", "und-NewYork" }, + // standard valid locales + { "", "Us", "", "und-US" }, + { "", "US", "NewYork", "und-US-NewYork" }, + { "EN", "", "", "en" }, + { "EN", "", "NewYork", "en-NewYork" }, + { "EN", "US", "", "en-US" }, + { "EN", "US", "NewYork", "en-US-NewYork" }, + // underscore in variant will be emitted as multiple variant subtags + { "en", "US", "Newer_Yorker", "en-US-Newer-Yorker" }, + // invalid variant subtags are appended as private use + { "en", "US", "new_yorker", "en-US-x-lvariant-new-yorker" }, + // the first invalid variant subtags and following variant subtags are appended as private use + { "en", "US", "Windows_XP_Home", "en-US-Windows-x-lvariant-XP-Home" }, + // too long variant and following variant subtags disappear + { "en", "US", "WindowsVista_SP2", "en-US" }, + // invalid region subtag disappears + { "en", "USA", "", "en" }, + // invalid language tag disappears + { "e", "US", "", "und-US" }, + // three-letter language tags are not canonicalized + { "Eng", "", "", "eng" }, + // legacy languages canonicalize to modern equivalents + { "he", "IW", "", "he-IW" }, + { "iw", "IW", "", "he-IW" }, + { "yi", "DE", "", "yi-DE" }, + { "ji", "DE", "", "yi-DE" }, + { "id", "ID", "", "id-ID" }, + { "in", "ID", "", "id-ID" }, + // special values are converted on output + { "ja", "JP", "JP", "ja-JP-u-ca-japanese-x-lvariant-JP" }, + { "th", "TH", "TH", "th-TH-u-nu-thai-x-lvariant-TH" }, + { "no", "NO", "NY", "nn-NO" } + }; + for (int i = 0; i < tests.length; ++i) { + String[] test = tests[i]; + Locale locale = new Locale(test[0], test[1], test[2]); + assertEquals("case " + i, test[3], locale.toLanguageTag()); + } + } + + public void testForLanguageTag() { + // forLanguageTag implements the 'Language-Tag' production of + // BCP47, so it handles private use and grandfathered tags, + // unlike locale builder. Tags listed below (except for the + // sample private use tags) come from 4646bis Feb 29, 2009. + + String[][] tests = { + // private use tags only + { "x-abc", "und-x-abc" }, + { "x-a-b-c", "und-x-a-b-c" }, + { "x-a-12345678", "und-x-a-12345678" }, + + // grandfathered tags with preferred mappings + { "i-ami", "ami" }, + { "i-bnn", "bnn" }, + { "i-hak", "hak" }, + { "i-klingon", "tlh" }, + { "i-lux", "lb" }, // two-letter tag + { "i-navajo", "nv" }, // two-letter tag + { "i-pwn", "pwn" }, + { "i-tao", "tao" }, + { "i-tay", "tay" }, + { "i-tsu", "tsu" }, + { "art-lojban", "jbo" }, + { "no-bok", "nb" }, + { "no-nyn", "nn" }, + { "sgn-BE-FR", "sfb" }, + { "sgn-BE-NL", "vgt" }, + { "sgn-CH-DE", "sgg" }, + { "zh-guoyu", "cmn" }, + { "zh-hakka", "hak" }, + { "zh-min-nan", "nan" }, + { "zh-xiang", "hsn" }, + + // grandfathered irregular tags, no preferred mappings, drop illegal fields + // from end. If no subtag is mappable, fallback to 'und' + { "i-default", "en-x-i-default" }, + { "i-enochian", "und-x-i-enochian" }, + { "i-mingo", "see-x-i-mingo" }, + { "en-GB-oed", "en-GB-x-oed" }, + { "zh-min", "nan-x-zh-min" }, + { "cel-gaulish", "xtg-x-cel-gaulish" }, + }; + for (int i = 0; i < tests.length; ++i) { + String[] test = tests[i]; + Locale locale = Locale.forLanguageTag(test[0]); + assertEquals("grandfathered case " + i, test[1], locale.toLanguageTag()); + } + + // forLanguageTag ignores everything past the first place it encounters + // a syntax error + tests = new String[][] { + { "valid", + "en-US-Newer-Yorker-a-bb-cc-dd-u-aa-abc-bb-def-x-y-12345678-z", + "en-US-Newer-Yorker-a-bb-cc-dd-u-aa-abc-bb-def-x-y-12345678-z" }, + { "segment of private use tag too long", + "en-US-Newer-Yorker-a-bb-cc-dd-u-aa-abc-bb-def-x-y-123456789-z", + "en-US-Newer-Yorker-a-bb-cc-dd-u-aa-abc-bb-def-x-y" }, + { "segment of private use tag is empty", + "en-US-Newer-Yorker-a-bb-cc-dd-u-aa-abc-bb-def-x-y--12345678-z", + "en-US-Newer-Yorker-a-bb-cc-dd-u-aa-abc-bb-def-x-y" }, + { "first segment of private use tag is empty", + "en-US-Newer-Yorker-a-bb-cc-dd-u-aa-abc-bb-def-x--y-12345678-z", + "en-US-Newer-Yorker-a-bb-cc-dd-u-aa-abc-bb-def" }, + { "illegal extension tag", + "en-US-Newer-Yorker-a-bb-cc-dd-u-aa-abc-bb-def-\uD800-y-12345678-z", + "en-US-Newer-Yorker-a-bb-cc-dd-u-aa-abc-bb-def" }, + { "locale subtag with no value", + "en-US-Newer-Yorker-a-bb-cc-dd-u-aa-abc-bb-x-y-12345678-z", + "en-US-Newer-Yorker-a-bb-cc-dd-u-aa-abc-bb-x-y-12345678-z" }, + { "locale key subtag invalid", + "en-US-Newer-Yorker-a-bb-cc-dd-u-aa-abc-123456789-def-x-y-12345678-z", + "en-US-Newer-Yorker-a-bb-cc-dd-u-aa-abc" }, + // locale key subtag invalid in earlier position, all following subtags + // dropped (and so the locale extension dropped as well) + { "locale key subtag invalid in earlier position", + "en-US-Newer-Yorker-a-bb-cc-dd-u-123456789-abc-bb-def-x-y-12345678-z", + "en-US-Newer-Yorker-a-bb-cc-dd" }, + }; + for (int i = 0; i < tests.length; ++i) { + String[] test = tests[i]; + String msg = "syntax error case " + i + " " + test[0]; + try { + Locale locale = Locale.forLanguageTag(test[1]); + assertEquals(msg, test[2], locale.toLanguageTag()); + } + catch (IllegalArgumentException e) { + errln(msg + " caught exception: " + e); + } + } + + // duplicated extension are just ignored + Locale locale = Locale.forLanguageTag("und-d-aa-00-bb-01-D-AA-10-cc-11-c-1234"); + assertEquals("extension", "aa-00-bb-01", locale.getExtension('d')); + assertEquals("extension c", "1234", locale.getExtension('c')); + + // redundant Unicode locale keys in an extension are ignored + locale = Locale.forLanguageTag("und-u-aa-000-bb-001-bB-002-cc-003-c-1234"); + assertEquals("Unicode keywords", "aa-000-bb-001-cc-003", locale.getExtension(Locale.UNICODE_LOCALE_EXTENSION)); + assertEquals("Duplicated Unicode locake key followed by an extension", "1234", locale.getExtension('c')); + } + + public void testGetDisplayScript() { + Locale latnLocale = Locale.forLanguageTag("und-latn"); + Locale hansLocale = Locale.forLanguageTag("und-hans"); + + Locale oldLocale = Locale.getDefault(); + + Locale.setDefault(Locale.US); + assertEquals("latn US", "Latin", latnLocale.getDisplayScript()); + assertEquals("hans US", "Simplified Han", hansLocale.getDisplayScript()); + + // note, no localization data yet other than US + // this should break when we have localization data for DE + Locale.setDefault(Locale.GERMANY); + assertEquals("latn DE", "Latin", latnLocale.getDisplayScript()); + assertEquals("hans DE", "Simplified Han", hansLocale.getDisplayScript()); + + Locale.setDefault(oldLocale); + } + + public void testGetDisplayScriptWithLocale() { + Locale latnLocale = Locale.forLanguageTag("und-latn"); + Locale hansLocale = Locale.forLanguageTag("und-hans"); + + assertEquals("latn US", "Latin", latnLocale.getDisplayScript(Locale.US)); + assertEquals("hans US", "Simplified Han", hansLocale.getDisplayScript(Locale.US)); + + // note, no localization data yet other than US + // this should break when we have localization data for DE + assertEquals("latn DE", "Latin", latnLocale.getDisplayScript(Locale.GERMANY)); + assertEquals("hans DE", "Simplified Han", hansLocale.getDisplayScript(Locale.GERMANY)); + } + + /// + /// Builder tests + /// + + public void testBuilderSetLocale() { + Builder builder = new Builder(); + Builder lenientBuilder = new Builder(); + + String languageTag = "en-Latn-US-NewYork-a-bb-ccc-u-co-japanese-x-y-z"; + String target = "en-Latn-US-NewYork-a-bb-ccc-u-co-japanese-x-y-z"; + + Locale locale = Locale.forLanguageTag(languageTag); + Locale result = lenientBuilder + .setLocale(locale) + .build(); + assertEquals("long tag", target, result.toLanguageTag()); + assertEquals("long tag", locale, result); + + // null is illegal + new BuilderNPE("locale") { + public void call() { b.setLocale(null); } + }; + + // builder canonicalizes the three legacy locales: + // ja_JP_JP, th_TH_TH, no_NY_NO. + locale = builder.setLocale(new Locale("ja", "JP", "JP")).build(); + assertEquals("ja_JP_JP languagetag", "ja-JP-u-ca-japanese", locale.toLanguageTag()); + assertEquals("ja_JP_JP variant", "", locale.getVariant()); + + locale = builder.setLocale(new Locale("th", "TH", "TH")).build(); + assertEquals("th_TH_TH languagetag", "th-TH-u-nu-thai", locale.toLanguageTag()); + assertEquals("th_TH_TH variant", "", locale.getVariant()); + + locale = builder.setLocale(new Locale("no", "NO", "NY")).build(); + assertEquals("no_NO_NY languagetag", "nn-NO", locale.toLanguageTag()); + assertEquals("no_NO_NY language", "nn", locale.getLanguage()); + assertEquals("no_NO_NY variant", "", locale.getVariant()); + + // non-canonical, non-legacy locales are invalid + new BuilderILE("123_4567_89") { + public void call() { + b.setLocale(new Locale("123", "4567", "89")); + } + }; + } + + public void testBuilderSetLanguageTag() { + String source = "eN-LaTn-Us-NewYork-A-Xx-B-Yy-X-1-2-3"; + String target = "en-Latn-US-NewYork-a-xx-b-yy-x-1-2-3"; + Builder builder = new Builder(); + String result = builder + .setLanguageTag(source) + .build() + .toLanguageTag(); + assertEquals("language", target, result); + + // redundant extensions cause a failure + new BuilderILE() { public void call() { b.setLanguageTag("und-a-xx-yy-b-ww-A-00-11-c-vv"); }}; + + // redundant Unicode locale extension keys within an Unicode locale extension cause a failure + new BuilderILE() { public void call() { b.setLanguageTag("und-u-nu-thai-NU-chinese-xx-1234"); }}; + } + + public void testBuilderSetLanguage() { + // language is normalized to lower case + String source = "eN"; + String target = "en"; + String defaulted = ""; + Builder builder = new Builder(); + String result = builder + .setLanguage(source) + .build() + .getLanguage(); + assertEquals("en", target, result); + + // setting with empty resets + result = builder + .setLanguage(target) + .setLanguage("") + .build() + .getLanguage(); + assertEquals("empty", defaulted, result); + + // setting with null resets too + result = builder + .setLanguage(target) + .setLanguage(null) + .build() + .getLanguage(); + assertEquals("null", defaulted, result); + + // language codes must be 2-8 alpha + // for forwards compatibility, 4-alpha and 5-8 alpha (registered) + // languages are accepted syntax + new BuilderILE("q", "abcdefghi", "13") { public void call() { b.setLanguage(arg); }}; + + // language code validation is NOT performed, any 2-8-alpha passes + assertNotNull("2alpha", builder.setLanguage("zz").build()); + assertNotNull("8alpha", builder.setLanguage("abcdefgh").build()); + + // three-letter language codes are NOT canonicalized to two-letter + result = builder + .setLanguage("eng") + .build() + .getLanguage(); + assertEquals("eng", "eng", result); + } + + public void testBuilderSetScript() { + // script is normalized to title case + String source = "lAtN"; + String target = "Latn"; + String defaulted = ""; + Builder builder = new Builder(); + String result = builder + .setScript(source) + .build() + .getScript(); + assertEquals("script", target, result); + + // setting with empty resets + result = builder + .setScript(target) + .setScript("") + .build() + .getScript(); + assertEquals("empty", defaulted, result); + + // settting with null also resets + result = builder + .setScript(target) + .setScript(null) + .build() + .getScript(); + assertEquals("null", defaulted, result); + + // ill-formed script codes throw IAE + // must be 4alpha + new BuilderILE("abc", "abcde", "l3tn") { public void call() { b.setScript(arg); }}; + + // script code validation is NOT performed, any 4-alpha passes + assertEquals("4alpha", "Wxyz", builder.setScript("wxyz").build().getScript()); + } + + public void testBuilderSetRegion() { + // region is normalized to upper case + String source = "uS"; + String target = "US"; + String defaulted = ""; + Builder builder = new Builder(); + String result = builder + .setRegion(source) + .build() + .getCountry(); + assertEquals("us", target, result); + + // setting with empty resets + result = builder + .setRegion(target) + .setRegion("") + .build() + .getCountry(); + assertEquals("empty", defaulted, result); + + // setting with null also resets + result = builder + .setRegion(target) + .setRegion(null) + .build() + .getCountry(); + assertEquals("null", defaulted, result); + + // ill-formed region codes throw IAE + // 2 alpha or 3 numeric + new BuilderILE("q", "abc", "12", "1234", "a3", "12a") { public void call() { b.setRegion(arg); }}; + + // region code validation is NOT performed, any 2-alpha or 3-digit passes + assertEquals("2alpha", "ZZ", builder.setRegion("ZZ").build().getCountry()); + assertEquals("3digit", "000", builder.setRegion("000").build().getCountry()); + } + + public void testBuilderSetVariant() { + // Variant case is not normalized in lenient variant mode + String source = "NewYork"; + String target = source; + String defaulted = ""; + Builder builder = new Builder(); + String result = builder + .setVariant(source) + .build() + .getVariant(); + assertEquals("NewYork", target, result); + + result = builder + .setVariant("NeWeR_YoRkEr") + .build() + .toLanguageTag(); + assertEquals("newer yorker", "und-NeWeR-YoRkEr", result); + + // subtags of variant are NOT reordered + result = builder + .setVariant("zzzzz_yyyyy_xxxxx") + .build() + .getVariant(); + assertEquals("zyx", "zzzzz_yyyyy_xxxxx", result); + + // setting to empty resets + result = builder + .setVariant(target) + .setVariant("") + .build() + .getVariant(); + assertEquals("empty", defaulted, result); + + // setting to null also resets + result = builder + .setVariant(target) + .setVariant(null) + .build() + .getVariant(); + assertEquals("null", defaulted, result); + + // ill-formed variants throw IAE + // digit followed by 3-7 characters, or alpha followed by 4-8 characters. + new BuilderILE("abcd", "abcdefghi", "1ab", "1abcdefgh") { public void call() { b.setVariant(arg); }}; + + // 4 characters is ok as long as the first is a digit + assertEquals("digit+3alpha", "1abc", builder.setVariant("1abc").build().getVariant()); + + // all subfields must conform + new BuilderILE("abcde-fg") { public void call() { b.setVariant(arg); }}; + } + + public void testBuilderSetExtension() { + // upper case characters are normalized to lower case + final char sourceKey = 'a'; + final String sourceValue = "aB-aBcdefgh-12-12345678"; + String target = "ab-abcdefgh-12-12345678"; + Builder builder = new Builder(); + String result = builder + .setExtension(sourceKey, sourceValue) + .build() + .getExtension(sourceKey); + assertEquals("extension", target, result); + + // setting with empty resets + result = builder + .setExtension(sourceKey, sourceValue) + .setExtension(sourceKey, "") + .build() + .getExtension(sourceKey); + assertEquals("empty", null, result); + + // setting with null also resets + result = builder + .setExtension(sourceKey, sourceValue) + .setExtension(sourceKey, null) + .build() + .getExtension(sourceKey); + assertEquals("null", null, result); + + // ill-formed extension keys throw IAE + // must be in [0-9a-ZA-Z] + new BuilderILE("$") { public void call() { b.setExtension('$', sourceValue); }}; + + // each segment of value must be 2-8 alphanum + new BuilderILE("ab-cd-123456789") { public void call() { b.setExtension(sourceKey, arg); }}; + + // no multiple hyphens. + new BuilderILE("ab--cd") { public void call() { b.setExtension(sourceKey, arg); }}; + + // locale extension key has special handling + Locale locale = builder + .setExtension('u', "co-japanese") + .build(); + assertEquals("locale extension", "japanese", locale.getUnicodeLocaleType("co")); + + // locale extension has same behavior with set locale keyword + Locale locale2 = builder + .setUnicodeLocaleKeyword("co", "japanese") + .build(); + assertEquals("locales with extension", locale, locale2); + + // setting locale extension overrides all previous calls to setLocaleKeyword + Locale locale3 = builder + .setExtension('u', "xxx-nu-thai") + .build(); + assertEquals("remove co", null, locale3.getUnicodeLocaleType("co")); + assertEquals("override thai", "thai", locale3.getUnicodeLocaleType("nu")); + assertEquals("override attribute", 1, locale3.getUnicodeLocaleAttributes().size()); + + // setting locale keyword extends values already set by the locale extension + Locale locale4 = builder + .setUnicodeLocaleKeyword("co", "japanese") + .build(); + assertEquals("extend", "japanese", locale4.getUnicodeLocaleType("co")); + assertEquals("extend", "thai", locale4.getUnicodeLocaleType("nu")); + + // locale extension subtags are reordered + result = builder + .clear() + .setExtension('u', "456-123-zz-123-yy-456-xx-789") + .build() + .toLanguageTag(); + assertEquals("reorder", "und-u-123-456-xx-789-yy-456-zz-123", result); + + // multiple keyword types + result = builder + .clear() + .setExtension('u', "nu-thai-foobar") + .build() + .getUnicodeLocaleType("nu"); + assertEquals("multiple types", "thai-foobar", result); + + // redundant locale extensions are ignored + result = builder + .clear() + .setExtension('u', "nu-thai-NU-chinese-xx-1234") + .build() + .toLanguageTag(); + assertEquals("duplicate keys", "und-u-nu-thai-xx-1234", result); + } + + public void testBuilderAddUnicodeLocaleAttribute() { + Builder builder = new Builder(); + Locale locale = builder + .addUnicodeLocaleAttribute("def") + .addUnicodeLocaleAttribute("abc") + .build(); + + Set<String> uattrs = locale.getUnicodeLocaleAttributes(); + assertEquals("number of attributes", 2, uattrs.size()); + assertTrue("attribute abc", uattrs.contains("abc")); + assertTrue("attribute def", uattrs.contains("def")); + + // remove attribute + locale = builder.removeUnicodeLocaleAttribute("xxx") + .build(); + + assertEquals("remove bogus", 2, uattrs.size()); + + // add duplicate + locale = builder.addUnicodeLocaleAttribute("abc") + .build(); + assertEquals("add duplicate", 2, uattrs.size()); + + // null attribute throws NPE + new BuilderNPE("null attribute") { public void call() { b.addUnicodeLocaleAttribute(null); }}; + + // illformed attribute throws IllformedLocaleException + new BuilderILE("invalid attribute") { public void call() { b.addUnicodeLocaleAttribute("ca"); }}; + } + + public void testBuildersetUnicodeLocaleKeyword() { + // Note: most behavior is tested in testBuilderSetExtension + Builder builder = new Builder(); + Locale locale = builder + .setUnicodeLocaleKeyword("co", "japanese") + .setUnicodeLocaleKeyword("nu", "thai") + .build(); + assertEquals("co", "japanese", locale.getUnicodeLocaleType("co")); + assertEquals("nu", "thai", locale.getUnicodeLocaleType("nu")); + assertEquals("keys", 2, locale.getUnicodeLocaleKeys().size()); + + // can clear a keyword by setting to null, others remain + String result = builder + .setUnicodeLocaleKeyword("co", null) + .build() + .toLanguageTag(); + assertEquals("empty co", "und-u-nu-thai", result); + + // locale keyword extension goes when all keywords are gone + result = builder + .setUnicodeLocaleKeyword("nu", null) + .build() + .toLanguageTag(); + assertEquals("empty nu", "und", result); + + // locale keywords are ordered independent of order of addition + result = builder + .setUnicodeLocaleKeyword("zz", "012") + .setUnicodeLocaleKeyword("aa", "345") + .build() + .toLanguageTag(); + assertEquals("reordered", "und-u-aa-345-zz-012", result); + + // null keyword throws NPE + new BuilderNPE("keyword") { public void call() { b.setUnicodeLocaleKeyword(null, "thai"); }}; + + // well-formed keywords are two alphanum + new BuilderILE("a", "abc") { public void call() { b.setUnicodeLocaleKeyword(arg, "value"); }}; + + // well-formed values are 3-8 alphanum + new BuilderILE("ab", "abcdefghi") { public void call() { b.setUnicodeLocaleKeyword("ab", arg); }}; + } + + public void testBuilderPrivateUseExtension() { + // normalizes hyphens to underscore, case to lower + String source = "c-B-a"; + String target = "c-b-a"; + Builder builder = new Builder(); + String result = builder + .setExtension(Locale.PRIVATE_USE_EXTENSION, source) + .build() + .getExtension(Locale.PRIVATE_USE_EXTENSION); + assertEquals("abc", target, result); + + // multiple hyphens are ill-formed + new BuilderILE("a--b") { public void call() { b.setExtension(Locale.PRIVATE_USE_EXTENSION, arg); }}; + } + + public void testBuilderClear() { + String monster = "en-latn-US-NewYork-a-bb-cc-u-co-japanese-x-z-y-x-x"; + Builder builder = new Builder(); + Locale locale = Locale.forLanguageTag(monster); + String result = builder + .setLocale(locale) + .clear() + .build() + .toLanguageTag(); + assertEquals("clear", "und", result); + } + + public void testBuilderRemoveUnicodeAttribute() { + // tested in testBuilderAddUnicodeAttribute + } + + public void testBuilderBuild() { + // tested in other test methods + } + + public void testSerialize() { + final Locale[] testLocales = { + Locale.ROOT, + new Locale("en"), + new Locale("en", "US"), + new Locale("en", "US", "Win"), + new Locale("en", "US", "Win_XP"), + new Locale("ja", "JP"), + new Locale("ja", "JP", "JP"), + new Locale("th", "TH"), + new Locale("th", "TH", "TH"), + new Locale("no", "NO"), + new Locale("nb", "NO"), + new Locale("nn", "NO"), + new Locale("no", "NO", "NY"), + new Locale("nn", "NO", "NY"), + new Locale("he", "IL"), + new Locale("he", "IL", "var"), + new Locale("Language", "Country", "Variant"), + new Locale("", "US"), + new Locale("", "", "Java"), + Locale.forLanguageTag("en-Latn-US"), + Locale.forLanguageTag("zh-Hans"), + Locale.forLanguageTag("zh-Hant-TW"), + Locale.forLanguageTag("ja-JP-u-ca-japanese"), + Locale.forLanguageTag("und-Hant"), + Locale.forLanguageTag("und-a-123-456"), + Locale.forLanguageTag("en-x-java"), + Locale.forLanguageTag("th-TH-u-ca-buddist-nu-thai-x-lvariant-TH"), + }; + + for (Locale locale : testLocales) { + try { + // write + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + ObjectOutputStream oos = new ObjectOutputStream(bos); + oos.writeObject(locale); + + // read + ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); + ObjectInputStream ois = new ObjectInputStream(bis); + Object o = ois.readObject(); + + assertEquals("roundtrip " + locale, locale, o); + } catch (Exception e) { + errln(locale + " encountered exception:" + e.getLocalizedMessage()); + } + } + } + + public void testDeserialize6() { + final String TESTFILEPREFIX = "java6locale_"; + + File dataDir = null; + String dataDirName = System.getProperty("serialized.data.dir"); + if (dataDirName == null) { + URL resdirUrl = getClass().getClassLoader().getResource("serialized"); + if (resdirUrl != null) { + try { + dataDir = new File(resdirUrl.toURI()); + } catch (URISyntaxException urie) { + } + } + } else { + dataDir = new File(dataDirName); + } + + if (dataDir == null || !dataDir.isDirectory()) { + errln("Could not locate the serialized test case data location"); + return; + } + + File[] files = dataDir.listFiles(); + for (File testfile : files) { + if (testfile.isDirectory()) { + continue; + } + String name = testfile.getName(); + if (!name.startsWith(TESTFILEPREFIX)) { + continue; + } + Locale locale; + String locStr = name.substring(TESTFILEPREFIX.length()); + if (locStr.equals("ROOT")) { + locale = Locale.ROOT; + } else { + String[] fields = locStr.split("_", 3); + String lang = fields[0]; + String country = (fields.length >= 2) ? fields[1] : ""; + String variant = (fields.length == 3) ? fields[2] : ""; + locale = new Locale(lang, country, variant); + } + + // desrialize + try { + FileInputStream fis = new FileInputStream(testfile); + ObjectInputStream ois = new ObjectInputStream(fis); + + Object o = ois.readObject(); + assertEquals("Deserialize Java 6 Locale " + locale, o, locale); + ois.close(); + } catch (Exception e) { + errln("Exception while reading " + testfile.getAbsolutePath() + " - " + e.getMessage()); + } + } + } + + /// + /// utility asserts + /// + + private void assertTrue(String msg, boolean v) { + if (!v) { + errln(msg + ": expected true"); + } + } + + private void assertFalse(String msg, boolean v) { + if (v) { + errln(msg + ": expected false"); + } + } + + private void assertEquals(String msg, Object e, Object v) { + if (e == null ? v != null : !e.equals(v)) { + if (e != null) { + e = "'" + e + "'"; + } + if (v != null) { + v = "'" + v + "'"; + } + errln(msg + ": expected " + e + " but got " + v); + } + } + + private void assertNotEquals(String msg, Object e, Object v) { + if (e == null ? v == null : e.equals(v)) { + if (e != null) { + e = "'" + e + "'"; + } + errln(msg + ": expected not equal " + e); + } + } + + private void assertNull(String msg, Object o) { + if (o != null) { + errln(msg + ": expected null but got '" + o + "'"); + } + } + + private void assertNotNull(String msg, Object o) { + if (o == null) { + errln(msg + ": expected non null"); + } + } + + // not currently used, might get rid of exceptions from the API + private abstract class ExceptionTest { + private final Class<? extends Exception> exceptionClass; + + ExceptionTest(Class<? extends Exception> exceptionClass) { + this.exceptionClass = exceptionClass; + } + + public void run() { + String failMsg = null; + try { + call(); + failMsg = "expected " + exceptionClass.getName() + " but no exception thrown."; + } + catch (Exception e) { + if (!exceptionClass.isAssignableFrom(e.getClass())) { + failMsg = "expected " + exceptionClass.getName() + " but caught " + e; + } + } + if (failMsg != null) { + String msg = message(); + msg = msg == null ? "" : msg + " "; + errln(msg + failMsg); + } + } + + public String message() { + return null; + } + + public abstract void call(); + } + + private abstract class ExpectNPE extends ExceptionTest { + ExpectNPE() { + super(NullPointerException.class); + run(); + } + } + + private abstract class BuilderNPE extends ExceptionTest { + protected final String msg; + protected final Builder b = new Builder(); + + BuilderNPE(String msg) { + super(NullPointerException.class); + + this.msg = msg; + + run(); + } + + public String message() { + return msg; + } + } + + private abstract class ExpectIAE extends ExceptionTest { + ExpectIAE() { + super(IllegalArgumentException.class); + run(); + } + } + + private abstract class BuilderILE extends ExceptionTest { + protected final String[] args; + protected final Builder b = new Builder(); + + protected String arg; // mutates during call + + BuilderILE(String... args) { + super(IllformedLocaleException.class); + + this.args = args; + + run(); + } + + public void run() { + for (String arg : args) { + this.arg = arg; + super.run(); + } + } + + public String message() { + return "arg: '" + arg + "'"; + } + } +}
--- a/test/java/util/Locale/LocaleTestFmwk.java Fri Sep 10 20:48:17 2010 +0400 +++ b/test/java/util/Locale/LocaleTestFmwk.java Fri Sep 10 15:29:40 2010 -0700 @@ -1,10 +1,12 @@ /* - * Copyright (c) 2007, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or @@ -20,6 +22,7 @@ * or visit www.oracle.com if you need additional information or have any * questions. */ + /* * * @@ -112,6 +115,8 @@ prompt = true; } else if (args[i].equals("-nothrow")) { nothrow = true; + } else if (args[i].equals("-exitcode")) { + exitcode = true; } else { Object m = testMethods.get( args[i] ); if( m != null ) { @@ -165,7 +170,12 @@ } } if (nothrow) { - System.exit(errorCount); + if (exitcode) { + System.exit(errorCount); + } + if (errorCount > 0) { + throw new IllegalArgumentException("encountered " + errorCount + " errors"); + } } } @@ -235,7 +245,7 @@ */ void usage() { System.out.println(getClass().getName() + - ": [-verbose] [-nothrow] [-prompt] [test names]"); + ": [-verbose] [-nothrow] [-exitcode] [-prompt] [test names]"); System.out.println("test names:"); Enumeration methodNames = testMethods.keys(); @@ -246,6 +256,7 @@ private boolean prompt = false; private boolean nothrow = false; + private boolean exitcode = false; protected boolean verbose = false; private PrintWriter log;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/java/util/Locale/icuLocales.txt Fri Sep 10 15:29:40 2010 -0700 @@ -0,0 +1,292 @@ +af +af-NA +af-ZA +am +am-ET +ar +ar-AE +ar-BH +ar-DZ +ar-EG +ar-IQ +ar-JO +ar-KW +ar-LB +ar-LY +ar-MA +ar-OM +ar-QA +ar-SA +ar-SD +ar-SY +ar-TN +ar-YE +as +as-IN +az +az-Cyrl +az-Cyrl-AZ +az-Latn +az-Latn-AZ +be +be-BY +bg +bg-BG +bn +bn-BD +bn-IN +bo +bo-CN +bo-IN +ca +ca-ES +cs +cs-CZ +cy +cy-GB +da +da-DK +de +de-AT +de-BE +de-CH +de-DE +de-LI +de-LU +el +el-CY +el-GR +en +en-AU +en-BE +en-BW +en-BZ +en-CA +en-GB +en-HK +en-IE +en-IN +en-JM +en-MH +en-MT +en-NA +en-NZ +en-PH +en-PK +en-SG +en-TT +en-US +en-US-posix +en-VI +en-ZA +en-ZW +eo +es +es-AR +es-BO +es-CL +es-CO +es-CR +es-DO +es-EC +es-ES +es-GT +es-HN +es-MX +es-NI +es-PA +es-PE +es-PR +es-PY +es-SV +es-US +es-UY +es-VE +et +et-EE +eu +eu-ES +fa +fa-AF +fa-IR +fi +fi-FI +fo +fo-FO +fr +fr-BE +fr-CA +fr-CH +fr-FR +fr-LU +fr-MC +fr-SN +ga +ga-IE +gl +gl-ES +gsw +gsw-CH +gu +gu-IN +gv +gv-GB +ha +ha-Latn +ha-Latn-GH +ha-Latn-NE +ha-Latn-NG +haw +haw-US +he +he-IL +hi +hi-IN +hr +hr-HR +hu +hu-HU +hy +hy-AM +hy-AM-revised +id +id-ID +ii +ii-CN +is +is-IS +it +it-CH +it-IT +ja +ja-JP +ka +ka-GE +kk +kk-Cyrl +kk-Cyrl-KZ +kl +kl-GL +km +km-KH +kn +kn-IN +ko +ko-KR +kok +kok-IN +kw +kw-GB +lt +lt-LT +lv +lv-LV +mk +mk-MK +ml +ml-IN +mr +mr-IN +ms +ms-BN +ms-MY +mt +mt-MT +nb +nb-NO +ne +ne-IN +ne-NP +nl +nl-BE +nl-NL +nn +nn-NO +om +om-ET +om-KE +or +or-IN +pa +pa-Arab +pa-Arab-PK +pa-Guru +pa-Guru-IN +pl +pl-PL +ps +ps-AF +pt +pt-BR +pt-PT +ro +ro-MD +ro-RO +ru +ru-RU +ru-UA +si +si-LK +sk +sk-SK +sl +sl-SI +so +so-DJ +so-ET +so-KE +so-SO +sq +sq-AL +sr +sr-Cyrl +sr-Cyrl-BA +sr-Cyrl-ME +sr-Cyrl-RS +sr-Latn +sr-Latn-BA +sr-Latn-ME +sr-Latn-RS +sv +sv-FI +sv-SE +sw +sw-KE +sw-TZ +ta +ta-IN +te +te-IN +th +th-TH +ti +ti-ER +ti-ET +tr +tr-TR +uk +uk-UA +ur +ur-IN +ur-PK +uz +uz-Arab +uz-Arab-AF +uz-Cyrl +uz-Cyrl-UZ +uz-Latn +uz-Latn-UZ +vi +vi-VN +zh +zh-Hans +zh-Hans-CN +zh-Hans-HK +zh-Hans-MO +zh-Hans-SG +zh-Hant +zh-Hant-HK +zh-Hant-MO +zh-Hant-TW +zu +zu-ZA