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>
--- a/jdk/make/java/java/FILES_java.gmk Fri Sep 10 20:48:17 2010 +0400
+++ b/jdk/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/jdk/src/share/classes/java/text/DecimalFormatSymbols.java Fri Sep 10 20:48:17 2010 +0400
+++ b/jdk/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/jdk/src/share/classes/java/util/Calendar.java Fri Sep 10 20:48:17 2010 +0400
+++ b/jdk/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/jdk/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/jdk/src/share/classes/java/util/Locale.java Fri Sep 10 20:48:17 2010 +0400
+++ b/jdk/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/jdk/src/share/classes/java/util/ResourceBundle.java Fri Sep 10 20:48:17 2010 +0400
+++ b/jdk/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/jdk/src/share/classes/java/util/spi/LocaleNameProvider.java Fri Sep 10 20:48:17 2010 +0400
+++ b/jdk/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/jdk/src/share/classes/java/util/spi/LocaleServiceProvider.java Fri Sep 10 20:48:17 2010 +0400
+++ b/jdk/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/jdk/src/share/classes/sun/util/LocaleServiceProviderPool.java Fri Sep 10 20:48:17 2010 +0400
+++ b/jdk/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/jdk/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/jdk/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/jdk/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/jdk/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/jdk/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/jdk/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/jdk/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/jdk/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/jdk/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/jdk/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/jdk/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/jdk/src/share/classes/sun/util/resources/LocaleData.java Fri Sep 10 20:48:17 2010 +0400
+++ b/jdk/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/jdk/src/share/classes/sun/util/resources/LocaleNames.properties Fri Sep 10 20:48:17 2010 +0400
+++ b/jdk/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/jdk/src/share/classes/sun/util/resources/LocaleNames_zh.properties Fri Sep 10 20:48:17 2010 +0400
+++ b/jdk/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/jdk/src/share/classes/sun/util/resources/LocaleNames_zh_TW.properties Fri Sep 10 20:48:17 2010 +0400
+++ b/jdk/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/jdk/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/jdk/test/java/util/Locale/LocaleTestFmwk.java Fri Sep 10 20:48:17 2010 +0400
+++ b/jdk/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/jdk/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
Binary file jdk/test/java/util/Locale/serialized/java6locale_ROOT has changed
Binary file jdk/test/java/util/Locale/serialized/java6locale__US has changed
Binary file jdk/test/java/util/Locale/serialized/java6locale___Java has changed
Binary file jdk/test/java/util/Locale/serialized/java6locale_en has changed
Binary file jdk/test/java/util/Locale/serialized/java6locale_en_US has changed
Binary file jdk/test/java/util/Locale/serialized/java6locale_en_US_Java has changed
Binary file jdk/test/java/util/Locale/serialized/java6locale_iw_IL has changed
Binary file jdk/test/java/util/Locale/serialized/java6locale_ja_JP_JP has changed
Binary file jdk/test/java/util/Locale/serialized/java6locale_no_NO_NY has changed
Binary file jdk/test/java/util/Locale/serialized/java6locale_th_TH_TH has changed