| /* |
| * Copyright (c) 2012, 2013, 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. |
| */ |
| |
| package build.tools.cldrconverter; |
| |
| import build.tools.cldrconverter.BundleGenerator.BundleType; |
| import java.io.File; |
| import java.nio.file.DirectoryStream; |
| import java.nio.file.FileSystems; |
| import java.nio.file.Files; |
| import java.nio.file.Path; |
| import java.util.*; |
| import javax.xml.parsers.SAXParser; |
| import javax.xml.parsers.SAXParserFactory; |
| import org.xml.sax.SAXNotRecognizedException; |
| import org.xml.sax.SAXNotSupportedException; |
| |
| |
| /** |
| * Converts locale data from "Locale Data Markup Language" format to |
| * JRE resource bundle format. LDML is the format used by the Common |
| * Locale Data Repository maintained by the Unicode Consortium. |
| */ |
| public class CLDRConverter { |
| |
| static final String LDML_DTD_SYSTEM_ID = "http://www.unicode.org/cldr/dtd/2.0/ldml.dtd"; |
| static final String SPPL_LDML_DTD_SYSTEM_ID = "http://www.unicode.org/cldr/dtd/2.0/ldmlSupplemental.dtd"; |
| |
| private static String CLDR_BASE = "../CLDR/21.0.1/"; |
| static String LOCAL_LDML_DTD; |
| static String LOCAL_SPPL_LDML_DTD; |
| private static String SOURCE_FILE_DIR; |
| private static String SPPL_SOURCE_FILE; |
| private static String NUMBERING_SOURCE_FILE; |
| private static String METAZONES_SOURCE_FILE; |
| static String DESTINATION_DIR = "build/gensrc"; |
| |
| static final String LOCALE_NAME_PREFIX = "locale.displayname."; |
| static final String CURRENCY_SYMBOL_PREFIX = "currency.symbol."; |
| static final String CURRENCY_NAME_PREFIX = "currency.displayname."; |
| static final String CALENDAR_NAME_PREFIX = "calendarname."; |
| static final String TIMEZONE_ID_PREFIX = "timezone.id."; |
| static final String ZONE_NAME_PREFIX = "timezone.displayname."; |
| static final String METAZONE_ID_PREFIX = "metazone.id."; |
| |
| private static SupplementDataParseHandler handlerSuppl; |
| static NumberingSystemsParseHandler handlerNumbering; |
| static MetaZonesParseHandler handlerMetaZones; |
| private static BundleGenerator bundleGenerator; |
| |
| static enum DraftType { |
| UNCONFIRMED, |
| PROVISIONAL, |
| CONTRIBUTED, |
| APPROVED; |
| |
| private static final Map<String, DraftType> map = new HashMap<>(); |
| static { |
| for (DraftType dt : values()) { |
| map.put(dt.getKeyword(), dt); |
| } |
| } |
| static private DraftType defaultType = CONTRIBUTED; |
| |
| private final String keyword; |
| |
| private DraftType() { |
| keyword = this.name().toLowerCase(Locale.ROOT); |
| |
| } |
| |
| static DraftType forKeyword(String keyword) { |
| return map.get(keyword); |
| } |
| |
| static DraftType getDefault() { |
| return defaultType; |
| } |
| |
| static void setDefault(String keyword) { |
| defaultType = Objects.requireNonNull(forKeyword(keyword)); |
| } |
| |
| String getKeyword() { |
| return keyword; |
| } |
| } |
| |
| static boolean USE_UTF8 = false; |
| private static boolean verbose; |
| |
| private CLDRConverter() { |
| // no instantiation |
| } |
| |
| @SuppressWarnings("AssignmentToForLoopParameter") |
| public static void main(String[] args) throws Exception { |
| if (args.length != 0) { |
| String currentArg = null; |
| try { |
| for (int i = 0; i < args.length; i++) { |
| currentArg = args[i]; |
| switch (currentArg) { |
| case "-draft": |
| String draftDataType = args[++i]; |
| try { |
| DraftType.setDefault(draftDataType); |
| } catch (NullPointerException e) { |
| severe("Error: incorrect draft value: %s%n", draftDataType); |
| System.exit(1); |
| } |
| info("Using the specified data type: %s%n", draftDataType); |
| break; |
| |
| case "-base": |
| // base directory for input files |
| CLDR_BASE = args[++i]; |
| if (!CLDR_BASE.endsWith("/")) { |
| CLDR_BASE += "/"; |
| } |
| break; |
| |
| case "-o": |
| // output directory |
| DESTINATION_DIR = args[++i]; |
| break; |
| |
| case "-utf8": |
| USE_UTF8 = true; |
| break; |
| |
| case "-verbose": |
| verbose = true; |
| break; |
| |
| case "-help": |
| usage(); |
| System.exit(0); |
| break; |
| |
| default: |
| throw new RuntimeException(); |
| } |
| } |
| } catch (RuntimeException e) { |
| severe("unknown or imcomplete arg(s): " + currentArg); |
| usage(); |
| System.exit(1); |
| } |
| } |
| |
| // Set up path names |
| LOCAL_LDML_DTD = CLDR_BASE + "common/dtd/ldml.dtd"; |
| LOCAL_SPPL_LDML_DTD = CLDR_BASE + "common/dtd/ldmlSupplemental.dtd"; |
| SOURCE_FILE_DIR = CLDR_BASE + "common/main"; |
| SPPL_SOURCE_FILE = CLDR_BASE + "common/supplemental/supplementalData.xml"; |
| NUMBERING_SOURCE_FILE = CLDR_BASE + "common/supplemental/numberingSystems.xml"; |
| METAZONES_SOURCE_FILE = CLDR_BASE + "common/supplemental/metaZones.xml"; |
| |
| bundleGenerator = new ResourceBundleGenerator(); |
| |
| List<Bundle> bundles = readBundleList(); |
| convertBundles(bundles); |
| } |
| |
| private static void usage() { |
| errout("Usage: java CLDRConverter [options]%n" |
| + "\t-help output this usage message and exit%n" |
| + "\t-verbose output information%n" |
| + "\t-draft [approved | provisional | unconfirmed]%n" |
| + "\t\t draft level for using data (default: approved)%n" |
| + "\t-base dir base directory for CLDR input files%n" |
| + "\t-o dir output directory (defaut: ./build/gensrc)%n" |
| + "\t-utf8 use UTF-8 rather than \\uxxxx (for debug)%n"); |
| } |
| |
| static void info(String fmt, Object... args) { |
| if (verbose) { |
| System.out.printf(fmt, args); |
| } |
| } |
| |
| static void info(String msg) { |
| if (verbose) { |
| System.out.println(msg); |
| } |
| } |
| |
| static void warning(String fmt, Object... args) { |
| System.err.print("Warning: "); |
| System.err.printf(fmt, args); |
| } |
| |
| static void warning(String msg) { |
| System.err.print("Warning: "); |
| errout(msg); |
| } |
| |
| static void severe(String fmt, Object... args) { |
| System.err.print("Error: "); |
| System.err.printf(fmt, args); |
| } |
| |
| static void severe(String msg) { |
| System.err.print("Error: "); |
| errout(msg); |
| } |
| |
| private static void errout(String msg) { |
| if (msg.contains("%n")) { |
| System.err.printf(msg); |
| } else { |
| System.err.println(msg); |
| } |
| } |
| |
| /** |
| * Configure the parser to allow access to DTDs on the file system. |
| */ |
| private static void enableFileAccess(SAXParser parser) throws SAXNotSupportedException { |
| try { |
| parser.setProperty("http://javax.xml.XMLConstants/property/accessExternalDTD", "file"); |
| } catch (SAXNotRecognizedException ignore) { |
| // property requires >= JAXP 1.5 |
| } |
| } |
| |
| private static List<Bundle> readBundleList() throws Exception { |
| ResourceBundle.Control defCon = ResourceBundle.Control.getControl(ResourceBundle.Control.FORMAT_DEFAULT); |
| List<Bundle> retList = new ArrayList<>(); |
| Path path = FileSystems.getDefault().getPath(SOURCE_FILE_DIR); |
| try (DirectoryStream<Path> dirStr = Files.newDirectoryStream(path)) { |
| for (Path entry : dirStr) { |
| String fileName = entry.getFileName().toString(); |
| if (fileName.endsWith(".xml")) { |
| String id = fileName.substring(0, fileName.indexOf('.')); |
| Locale cldrLoc = Locale.forLanguageTag(toLanguageTag(id)); |
| List<Locale> candList = defCon.getCandidateLocales("", cldrLoc); |
| StringBuilder sb = new StringBuilder(); |
| for (Locale loc : candList) { |
| if (!loc.equals(Locale.ROOT)) { |
| sb.append(toLocaleName(loc.toLanguageTag())); |
| sb.append(","); |
| } |
| } |
| if (sb.indexOf("root") == -1) { |
| sb.append("root"); |
| } |
| Bundle b = new Bundle(id, sb.toString(), null, null); |
| // Insert the bundle for en at the top so that it will get |
| // processed first. |
| if ("en".equals(id)) { |
| retList.add(0, b); |
| } else { |
| retList.add(b); |
| } |
| } |
| } |
| } |
| return retList; |
| } |
| |
| private static Map<String, Map<String, Object>> cldrBundles = new HashMap<>(); |
| |
| static Map<String, Object> getCLDRBundle(String id) throws Exception { |
| Map<String, Object> bundle = cldrBundles.get(id); |
| if (bundle != null) { |
| return bundle; |
| } |
| SAXParserFactory factory = SAXParserFactory.newInstance(); |
| factory.setValidating(true); |
| SAXParser parser = factory.newSAXParser(); |
| enableFileAccess(parser); |
| LDMLParseHandler handler = new LDMLParseHandler(id); |
| File file = new File(SOURCE_FILE_DIR + File.separator + id + ".xml"); |
| if (!file.exists()) { |
| // Skip if the file doesn't exist. |
| return Collections.emptyMap(); |
| } |
| |
| info("..... main directory ....."); |
| info("Reading file " + file); |
| parser.parse(file, handler); |
| |
| bundle = handler.getData(); |
| cldrBundles.put(id, bundle); |
| String country = getCountryCode(id); |
| if (country != null) { |
| bundle = handlerSuppl.getData(country); |
| if (bundle != null) { |
| //merge two maps into one map |
| Map<String, Object> temp = cldrBundles.remove(id); |
| bundle.putAll(temp); |
| cldrBundles.put(id, bundle); |
| } |
| } |
| return bundle; |
| } |
| |
| private static void convertBundles(List<Bundle> bundles) throws Exception { |
| // Parse SupplementalData file and store the information in the HashMap |
| // Calendar information such as firstDay and minDay are stored in |
| // supplementalData.xml as of CLDR1.4. Individual territory is listed |
| // with its ISO 3166 country code while default is listed using UNM49 |
| // region and composition numerical code (001 for World.) |
| SAXParserFactory factorySuppl = SAXParserFactory.newInstance(); |
| factorySuppl.setValidating(true); |
| SAXParser parserSuppl = factorySuppl.newSAXParser(); |
| enableFileAccess(parserSuppl); |
| handlerSuppl = new SupplementDataParseHandler(); |
| File fileSupply = new File(SPPL_SOURCE_FILE); |
| parserSuppl.parse(fileSupply, handlerSuppl); |
| |
| // Parse numberingSystems to get digit zero character information. |
| SAXParserFactory numberingParser = SAXParserFactory.newInstance(); |
| numberingParser.setValidating(true); |
| SAXParser parserNumbering = numberingParser.newSAXParser(); |
| enableFileAccess(parserNumbering); |
| handlerNumbering = new NumberingSystemsParseHandler(); |
| File fileNumbering = new File(NUMBERING_SOURCE_FILE); |
| parserNumbering.parse(fileNumbering, handlerNumbering); |
| |
| // Parse metaZones to create mappings between Olson tzids and CLDR meta zone names |
| SAXParserFactory metazonesParser = SAXParserFactory.newInstance(); |
| metazonesParser.setValidating(true); |
| SAXParser parserMetaZones = metazonesParser.newSAXParser(); |
| enableFileAccess(parserMetaZones); |
| handlerMetaZones = new MetaZonesParseHandler(); |
| File fileMetaZones = new File(METAZONES_SOURCE_FILE); |
| parserNumbering.parse(fileMetaZones, handlerMetaZones); |
| |
| // For generating information on supported locales. |
| Map<String, SortedSet<String>> metaInfo = new HashMap<>(); |
| metaInfo.put("LocaleNames", new TreeSet<String>()); |
| metaInfo.put("CurrencyNames", new TreeSet<String>()); |
| metaInfo.put("TimeZoneNames", new TreeSet<String>()); |
| metaInfo.put("CalendarData", new TreeSet<String>()); |
| metaInfo.put("FormatData", new TreeSet<String>()); |
| |
| for (Bundle bundle : bundles) { |
| // Get the target map, which contains all the data that should be |
| // visible for the bundle's locale |
| |
| Map<String, Object> targetMap = bundle.getTargetMap(); |
| |
| EnumSet<Bundle.Type> bundleTypes = bundle.getBundleTypes(); |
| |
| // Fill in any missing resources in the base bundle from en and en-US data. |
| // This is because CLDR root.xml is supposed to be language neutral and doesn't |
| // provide some resource data. Currently, the runtime assumes that there are all |
| // resources though the parent resource bundle chain. |
| if (bundle.isRoot()) { |
| Map<String, Object> enData = new HashMap<>(); |
| // Create a superset of en-US and en bundles data in order to |
| // fill in any missing resources in the base bundle. |
| enData.putAll(Bundle.getBundle("en").getTargetMap()); |
| enData.putAll(Bundle.getBundle("en_US").getTargetMap()); |
| for (String key : enData.keySet()) { |
| if (!targetMap.containsKey(key)) { |
| targetMap.put(key, enData.get(key)); |
| } |
| } |
| // Add DateTimePatternChars because CLDR no longer supports localized patterns. |
| targetMap.put("DateTimePatternChars", "GyMdkHmsSEDFwWahKzZ"); |
| } |
| |
| // Now the map contains just the entries that need to be in the resources bundles. |
| // Go ahead and generate them. |
| if (bundleTypes.contains(Bundle.Type.LOCALENAMES)) { |
| Map<String, Object> localeNamesMap = extractLocaleNames(targetMap, bundle.getID()); |
| if (!localeNamesMap.isEmpty() || bundle.isRoot()) { |
| metaInfo.get("LocaleNames").add(toLanguageTag(bundle.getID())); |
| bundleGenerator.generateBundle("util", "LocaleNames", bundle.getID(), true, localeNamesMap, BundleType.OPEN); |
| } |
| } |
| if (bundleTypes.contains(Bundle.Type.CURRENCYNAMES)) { |
| Map<String, Object> currencyNamesMap = extractCurrencyNames(targetMap, bundle.getID(), bundle.getCurrencies()); |
| if (!currencyNamesMap.isEmpty() || bundle.isRoot()) { |
| metaInfo.get("CurrencyNames").add(toLanguageTag(bundle.getID())); |
| bundleGenerator.generateBundle("util", "CurrencyNames", bundle.getID(), true, currencyNamesMap, BundleType.OPEN); |
| } |
| } |
| if (bundleTypes.contains(Bundle.Type.TIMEZONENAMES)) { |
| Map<String, Object> zoneNamesMap = extractZoneNames(targetMap, bundle.getID()); |
| if (!zoneNamesMap.isEmpty() || bundle.isRoot()) { |
| metaInfo.get("TimeZoneNames").add(toLanguageTag(bundle.getID())); |
| bundleGenerator.generateBundle("util", "TimeZoneNames", bundle.getID(), true, zoneNamesMap, BundleType.TIMEZONE); |
| } |
| } |
| if (bundleTypes.contains(Bundle.Type.CALENDARDATA)) { |
| Map<String, Object> calendarDataMap = extractCalendarData(targetMap, bundle.getID()); |
| if (!calendarDataMap.isEmpty() || bundle.isRoot()) { |
| metaInfo.get("CalendarData").add(toLanguageTag(bundle.getID())); |
| bundleGenerator.generateBundle("util", "CalendarData", bundle.getID(), true, calendarDataMap, BundleType.PLAIN); |
| } |
| } |
| if (bundleTypes.contains(Bundle.Type.FORMATDATA)) { |
| Map<String, Object> formatDataMap = extractFormatData(targetMap, bundle.getID()); |
| // LocaleData.getAvailableLocales depends on having FormatData bundles around |
| if (!formatDataMap.isEmpty() || bundle.isRoot()) { |
| metaInfo.get("FormatData").add(toLanguageTag(bundle.getID())); |
| bundleGenerator.generateBundle("text", "FormatData", bundle.getID(), true, formatDataMap, BundleType.PLAIN); |
| } |
| } |
| |
| // For testing |
| SortedSet<String> allLocales = new TreeSet<>(); |
| allLocales.addAll(metaInfo.get("CurrencyNames")); |
| allLocales.addAll(metaInfo.get("LocaleNames")); |
| allLocales.addAll(metaInfo.get("CalendarData")); |
| allLocales.addAll(metaInfo.get("FormatData")); |
| metaInfo.put("All", allLocales); |
| } |
| |
| bundleGenerator.generateMetaInfo(metaInfo); |
| } |
| |
| /* |
| * Returns the language portion of the given id. |
| * If id is "root", "" is returned. |
| */ |
| static String getLanguageCode(String id) { |
| int index = id.indexOf('_'); |
| String lang = null; |
| if (index != -1) { |
| lang = id.substring(0, index); |
| } else { |
| lang = "root".equals(id) ? "" : id; |
| } |
| return lang; |
| } |
| |
| /** |
| * Examine if the id includes the country (territory) code. If it does, it returns |
| * the country code. |
| * Otherwise, it returns null. eg. when the id is "zh_Hans_SG", it return "SG". |
| */ |
| private static String getCountryCode(String id) { |
| //Truncate a variant code with '@' if there is any |
| //(eg. de_DE@collation=phonebook,currency=DOM) |
| if (id.indexOf('@') != -1) { |
| id = id.substring(0, id.indexOf('@')); |
| } |
| String[] tokens = id.split("_"); |
| for (int index = 1; index < tokens.length; ++index) { |
| if (tokens[index].length() == 2 |
| && Character.isLetter(tokens[index].charAt(0)) |
| && Character.isLetter(tokens[index].charAt(1))) { |
| return tokens[index]; |
| } |
| } |
| return null; |
| } |
| |
| private static class KeyComparator implements Comparator<String> { |
| static KeyComparator INSTANCE = new KeyComparator(); |
| |
| private KeyComparator() { |
| } |
| |
| @Override |
| public int compare(String o1, String o2) { |
| int len1 = o1.length(); |
| int len2 = o2.length(); |
| if (!isDigit(o1.charAt(0)) && !isDigit(o2.charAt(0))) { |
| // Shorter string comes first unless either starts with a digit. |
| if (len1 < len2) { |
| return -1; |
| } |
| if (len1 > len2) { |
| return 1; |
| } |
| } |
| return o1.compareTo(o2); |
| } |
| |
| private boolean isDigit(char c) { |
| return c >= '0' && c <= '9'; |
| } |
| } |
| |
| private static Map<String, Object> extractLocaleNames(Map<String, Object> map, String id) { |
| Map<String, Object> localeNames = new TreeMap<>(KeyComparator.INSTANCE); |
| for (String key : map.keySet()) { |
| if (key.startsWith(LOCALE_NAME_PREFIX)) { |
| localeNames.put(key.substring(LOCALE_NAME_PREFIX.length()), map.get(key)); |
| } |
| } |
| return localeNames; |
| } |
| |
| @SuppressWarnings("AssignmentToForLoopParameter") |
| private static Map<String, Object> extractCurrencyNames(Map<String, Object> map, String id, String names) |
| throws Exception { |
| Map<String, Object> currencyNames = new TreeMap<>(KeyComparator.INSTANCE); |
| for (String key : map.keySet()) { |
| if (key.startsWith(CURRENCY_NAME_PREFIX)) { |
| currencyNames.put(key.substring(CURRENCY_NAME_PREFIX.length()), map.get(key)); |
| } else if (key.startsWith(CURRENCY_SYMBOL_PREFIX)) { |
| currencyNames.put(key.substring(CURRENCY_SYMBOL_PREFIX.length()), map.get(key)); |
| } |
| } |
| return currencyNames; |
| } |
| |
| private static Map<String, Object> extractZoneNames(Map<String, Object> map, String id) { |
| Map<String, Object> names = new HashMap<>(); |
| for (String tzid : handlerMetaZones.keySet()) { |
| String tzKey = TIMEZONE_ID_PREFIX + tzid; |
| Object data = map.get(tzKey); |
| if (data instanceof String[]) { |
| names.put(tzid, data); |
| } else { |
| String meta = handlerMetaZones.get(tzid); |
| if (meta != null) { |
| String metaKey = METAZONE_ID_PREFIX + meta; |
| data = map.get(metaKey); |
| if (data instanceof String[]) { |
| // Keep the metazone prefix here. |
| names.put(metaKey, data); |
| names.put(tzid, meta); |
| } |
| } |
| } |
| } |
| return names; |
| } |
| |
| private static Map<String, Object> extractCalendarData(Map<String, Object> map, String id) { |
| Map<String, Object> calendarData = new LinkedHashMap<>(); |
| copyIfPresent(map, "firstDayOfWeek", calendarData); |
| copyIfPresent(map, "minimalDaysInFirstWeek", calendarData); |
| return calendarData; |
| } |
| |
| static final String[] FORMAT_DATA_ELEMENTS = { |
| "MonthNames", |
| "standalone.MonthNames", |
| "MonthAbbreviations", |
| "standalone.MonthAbbreviations", |
| "MonthNarrows", |
| "standalone.MonthNarrows", |
| "DayNames", |
| "standalone.DayNames", |
| "DayAbbreviations", |
| "standalone.DayAbbreviations", |
| "DayNarrows", |
| "standalone.DayNarrows", |
| "QuarterNames", |
| "standalone.QuarterNames", |
| "QuarterAbbreviations", |
| "standalone.QuarterAbbreviations", |
| "QuarterNarrows", |
| "standalone.QuarterNarrows", |
| "AmPmMarkers", |
| "narrow.AmPmMarkers", |
| "long.Eras", |
| "Eras", |
| "narrow.Eras", |
| "field.era", |
| "field.year", |
| "field.month", |
| "field.week", |
| "field.weekday", |
| "field.dayperiod", |
| "field.hour", |
| "field.minute", |
| "field.second", |
| "field.zone", |
| "TimePatterns", |
| "DatePatterns", |
| "DateTimePatterns", |
| "DateTimePatternChars" |
| }; |
| |
| private static Map<String, Object> extractFormatData(Map<String, Object> map, String id) { |
| Map<String, Object> formatData = new LinkedHashMap<>(); |
| for (CalendarType calendarType : CalendarType.values()) { |
| String prefix = calendarType.keyElementName(); |
| for (String element : FORMAT_DATA_ELEMENTS) { |
| String key = prefix + element; |
| copyIfPresent(map, "java.time." + key, formatData); |
| copyIfPresent(map, key, formatData); |
| } |
| } |
| // Workaround for islamic-umalqura name support (JDK-8015986) |
| switch (id) { |
| case "ar": |
| map.put(CLDRConverter.CALENDAR_NAME_PREFIX |
| + CalendarType.ISLAMIC_UMALQURA.lname(), |
| // derived from CLDR 24 draft |
| "\u0627\u0644\u062a\u0642\u0648\u064a\u0645 " |
| +"\u0627\u0644\u0625\u0633\u0644\u0627\u0645\u064a " |
| +"[\u0623\u0645 \u0627\u0644\u0642\u0631\u0649]"); |
| break; |
| case "en": |
| map.put(CLDRConverter.CALENDAR_NAME_PREFIX |
| + CalendarType.ISLAMIC_UMALQURA.lname(), |
| // derived from CLDR 24 draft |
| "Islamic Calendar [Umm al-Qura]"); |
| break; |
| } |
| // Copy available calendar names |
| for (String key : map.keySet()) { |
| if (key.startsWith(CLDRConverter.CALENDAR_NAME_PREFIX)) { |
| String type = key.substring(CLDRConverter.CALENDAR_NAME_PREFIX.length()); |
| for (CalendarType calendarType : CalendarType.values()) { |
| if (type.equals(calendarType.lname())) { |
| Object value = map.get(key); |
| formatData.put(key, value); |
| String ukey = CLDRConverter.CALENDAR_NAME_PREFIX + calendarType.uname(); |
| if (!key.equals(ukey)) { |
| formatData.put(ukey, value); |
| } |
| } |
| } |
| } |
| } |
| |
| copyIfPresent(map, "DefaultNumberingSystem", formatData); |
| |
| @SuppressWarnings("unchecked") |
| List<String> numberingScripts = (List<String>) map.remove("numberingScripts"); |
| if (numberingScripts != null) { |
| for (String script : numberingScripts) { |
| copyIfPresent(map, script + "." + "NumberElements", formatData); |
| } |
| } else { |
| copyIfPresent(map, "NumberElements", formatData); |
| } |
| copyIfPresent(map, "NumberPatterns", formatData); |
| return formatData; |
| } |
| |
| private static void copyIfPresent(Map<String, Object> src, String key, Map<String, Object> dest) { |
| Object value = src.get(key); |
| if (value != null) { |
| dest.put(key, value); |
| } |
| } |
| |
| // --- code below here is adapted from java.util.Properties --- |
| private static final String specialSaveCharsJava = "\""; |
| private static final String specialSaveCharsProperties = "=: \t\r\n\f#!"; |
| |
| /* |
| * Converts unicodes to encoded \uxxxx |
| * and writes out any of the characters in specialSaveChars |
| * with a preceding slash |
| */ |
| static String saveConvert(String theString, boolean useJava) { |
| if (theString == null) { |
| return ""; |
| } |
| |
| String specialSaveChars; |
| if (useJava) { |
| specialSaveChars = specialSaveCharsJava; |
| } else { |
| specialSaveChars = specialSaveCharsProperties; |
| } |
| boolean escapeSpace = false; |
| |
| int len = theString.length(); |
| StringBuilder outBuffer = new StringBuilder(len * 2); |
| Formatter formatter = new Formatter(outBuffer, Locale.ROOT); |
| |
| for (int x = 0; x < len; x++) { |
| char aChar = theString.charAt(x); |
| switch (aChar) { |
| case ' ': |
| if (x == 0 || escapeSpace) { |
| outBuffer.append('\\'); |
| } |
| outBuffer.append(' '); |
| break; |
| case '\\': |
| outBuffer.append('\\'); |
| outBuffer.append('\\'); |
| break; |
| case '\t': |
| outBuffer.append('\\'); |
| outBuffer.append('t'); |
| break; |
| case '\n': |
| outBuffer.append('\\'); |
| outBuffer.append('n'); |
| break; |
| case '\r': |
| outBuffer.append('\\'); |
| outBuffer.append('r'); |
| break; |
| case '\f': |
| outBuffer.append('\\'); |
| outBuffer.append('f'); |
| break; |
| default: |
| if (aChar < 0x0020 || (!USE_UTF8 && aChar > 0x007e)) { |
| formatter.format("\\u%04x", (int)aChar); |
| } else { |
| if (specialSaveChars.indexOf(aChar) != -1) { |
| outBuffer.append('\\'); |
| } |
| outBuffer.append(aChar); |
| } |
| } |
| } |
| return outBuffer.toString(); |
| } |
| |
| private static String toLanguageTag(String locName) { |
| if (locName.indexOf('_') == -1) { |
| return locName; |
| } |
| String tag = locName.replaceAll("_", "-"); |
| Locale loc = Locale.forLanguageTag(tag); |
| return loc.toLanguageTag(); |
| } |
| |
| private static String toLocaleName(String tag) { |
| if (tag.indexOf('-') == -1) { |
| return tag; |
| } |
| return tag.replaceAll("-", "_"); |
| } |
| } |
