1 /*
2 * Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 /*
27 *******************************************************************************
28 * Copyright (C) 2010, International Business Machines Corporation and *
29 * others. All Rights Reserved. *
30 *******************************************************************************
31 */
32 package sun.util.locale;
33
34 import java.util.ArrayList;
35 import java.util.Collections;
36 import java.util.HashMap;
37 import java.util.List;
38 import java.util.Map;
39 import java.util.Set;
40
41 public class LanguageTag {
42 //
43 // static fields
44 //
45 public static final String SEP = "-";
46 public static final String PRIVATEUSE = "x";
47 public static final String UNDETERMINED = "und";
48 public static final String PRIVUSE_VARIANT_PREFIX = "lvariant";
49
50 //
51 // Language subtag fields
52 //
53 private String language = ""; // language subtag
54 private String script = ""; // script subtag
55 private String region = ""; // region subtag
56 private String privateuse = ""; // privateuse
57
58 private List<String> extlangs = Collections.emptyList(); // extlang subtags
59 private List<String> variants = Collections.emptyList(); // variant subtags
60 private List<String> extensions = Collections.emptyList(); // extensions
61
62 // Map contains grandfathered tags and its preferred mappings from
63 // http://www.ietf.org/rfc/rfc5646.txt
64 // Keys are lower-case strings.
65 private static final Map<String, String[]> GRANDFATHERED = new HashMap<>();
66
67 static {
68 // grandfathered = irregular ; non-redundant tags registered
69 // / regular ; during the RFC 3066 era
70 //
71 // irregular = "en-GB-oed" ; irregular tags do not match
72 // / "i-ami" ; the 'langtag' production and
73 // / "i-bnn" ; would not otherwise be
74 // / "i-default" ; considered 'well-formed'
75 // / "i-enochian" ; These tags are all valid,
76 // / "i-hak" ; but most are deprecated
77 // / "i-klingon" ; in favor of more modern
78 // / "i-lux" ; subtags or subtag
79 // / "i-mingo" ; combination
80 // / "i-navajo"
81 // / "i-pwn"
82 // / "i-tao"
83 // / "i-tay"
84 // / "i-tsu"
85 // / "sgn-BE-FR"
86 // / "sgn-BE-NL"
87 // / "sgn-CH-DE"
88 //
89 // regular = "art-lojban" ; these tags match the 'langtag'
90 // / "cel-gaulish" ; production, but their subtags
91 // / "no-bok" ; are not extended language
92 // / "no-nyn" ; or variant subtags: their meaning
93 // / "zh-guoyu" ; is defined by their registration
94 // / "zh-hakka" ; and all of these are deprecated
95 // / "zh-min" ; in favor of a more modern
96 // / "zh-min-nan" ; subtag or sequence of subtags
97 // / "zh-xiang"
98
99 final String[][] entries = {
100 //{"tag", "preferred"},
101 {"art-lojban", "jbo"},
102 {"cel-gaulish", "xtg-x-cel-gaulish"}, // fallback
103 {"en-GB-oed", "en-GB-x-oed"}, // fallback
104 {"i-ami", "ami"},
105 {"i-bnn", "bnn"},
106 {"i-default", "en-x-i-default"}, // fallback
107 {"i-enochian", "und-x-i-enochian"}, // fallback
108 {"i-hak", "hak"},
109 {"i-klingon", "tlh"},
110 {"i-lux", "lb"},
111 {"i-mingo", "see-x-i-mingo"}, // fallback
112 {"i-navajo", "nv"},
113 {"i-pwn", "pwn"},
114 {"i-tao", "tao"},
115 {"i-tay", "tay"},
116 {"i-tsu", "tsu"},
117 {"no-bok", "nb"},
118 {"no-nyn", "nn"},
119 {"sgn-BE-FR", "sfb"},
120 {"sgn-BE-NL", "vgt"},
121 {"sgn-CH-DE", "sgg"},
122 {"zh-guoyu", "cmn"},
123 {"zh-hakka", "hak"},
124 {"zh-min", "nan-x-zh-min"}, // fallback
125 {"zh-min-nan", "nan"},
126 {"zh-xiang", "hsn"},
127 };
128 for (String[] e : entries) {
129 GRANDFATHERED.put(LocaleUtils.toLowerString(e[0]), e);
130 }
131 }
132
133 private LanguageTag() {
134 }
135
136 /*
137 * BNF in RFC5464
138 *
139 * Language-Tag = langtag ; normal language tags
140 * / privateuse ; private use tag
141 * / grandfathered ; grandfathered tags
142 *
143 *
144 * langtag = language
145 * ["-" script]
146 * ["-" region]
147 * *("-" variant)
148 * *("-" extension)
149 * ["-" privateuse]
150 *
151 * language = 2*3ALPHA ; shortest ISO 639 code
152 * ["-" extlang] ; sometimes followed by
153 * ; extended language subtags
154 * / 4ALPHA ; or reserved for future use
155 * / 5*8ALPHA ; or registered language subtag
156 *
157 * extlang = 3ALPHA ; selected ISO 639 codes
158 * *2("-" 3ALPHA) ; permanently reserved
159 *
160 * script = 4ALPHA ; ISO 15924 code
161 *
162 * region = 2ALPHA ; ISO 3166-1 code
163 * / 3DIGIT ; UN M.49 code
164 *
165 * variant = 5*8alphanum ; registered variants
166 * / (DIGIT 3alphanum)
167 *
168 * extension = singleton 1*("-" (2*8alphanum))
169 *
170 * ; Single alphanumerics
171 * ; "x" reserved for private use
172 * singleton = DIGIT ; 0 - 9
173 * / %x41-57 ; A - W
174 * / %x59-5A ; Y - Z
175 * / %x61-77 ; a - w
176 * / %x79-7A ; y - z
177 *
178 * privateuse = "x" 1*("-" (1*8alphanum))
179 *
180 */
181 public static LanguageTag parse(String languageTag, ParseStatus sts) {
182 if (sts == null) {
183 sts = new ParseStatus();
184 } else {
185 sts.reset();
186 }
187
188 StringTokenIterator itr;
189
190 // Check if the tag is grandfathered
191 String[] gfmap = GRANDFATHERED.get(LocaleUtils.toLowerString(languageTag));
192 if (gfmap != null) {
193 // use preferred mapping
194 itr = new StringTokenIterator(gfmap[1], SEP);
195 } else {
196 itr = new StringTokenIterator(languageTag, SEP);
197 }
198
199 LanguageTag tag = new LanguageTag();
200
201 // langtag must start with either language or privateuse
202 if (tag.parseLanguage(itr, sts)) {
203 tag.parseExtlangs(itr, sts);
204 tag.parseScript(itr, sts);
205 tag.parseRegion(itr, sts);
206 tag.parseVariants(itr, sts);
207 tag.parseExtensions(itr, sts);
208 }
209 tag.parsePrivateuse(itr, sts);
210
211 if (!itr.isDone() && !sts.isError()) {
212 String s = itr.current();
213 sts.errorIndex = itr.currentStart();
214 if (s.length() == 0) {
215 sts.errorMsg = "Empty subtag";
216 } else {
217 sts.errorMsg = "Invalid subtag: " + s;
218 }
219 }
220
221 return tag;
222 }
223
224 //
225 // Language subtag parsers
226 //
227
228 private boolean parseLanguage(StringTokenIterator itr, ParseStatus sts) {
229 if (itr.isDone() || sts.isError()) {
230 return false;
231 }
232
233 boolean found = false;
234
235 String s = itr.current();
236 if (isLanguage(s)) {
237 found = true;
238 language = s;
239 sts.parseLength = itr.currentEnd();
240 itr.next();
241 }
242
243 return found;
244 }
245
246 private boolean parseExtlangs(StringTokenIterator itr, ParseStatus sts) {
247 if (itr.isDone() || sts.isError()) {
248 return false;
249 }
250
251 boolean found = false;
252
253 while (!itr.isDone()) {
254 String s = itr.current();
255 if (!isExtlang(s)) {
256 break;
257 }
258 found = true;
259 if (extlangs.isEmpty()) {
260 extlangs = new ArrayList<>(3);
261 }
262 extlangs.add(s);
263 sts.parseLength = itr.currentEnd();
264 itr.next();
265
266 if (extlangs.size() == 3) {
267 // Maximum 3 extlangs
268 break;
269 }
270 }
271
272 return found;
273 }
274
275 private boolean parseScript(StringTokenIterator itr, ParseStatus sts) {
276 if (itr.isDone() || sts.isError()) {
277 return false;
278 }
279
280 boolean found = false;
281
282 String s = itr.current();
283 if (isScript(s)) {
284 found = true;
285 script = s;
286 sts.parseLength = itr.currentEnd();
287 itr.next();
288 }
289
290 return found;
291 }
292
293 private boolean parseRegion(StringTokenIterator itr, ParseStatus sts) {
294 if (itr.isDone() || sts.isError()) {
295 return false;
296 }
297
298 boolean found = false;
299
300 String s = itr.current();
301 if (isRegion(s)) {
302 found = true;
303 region = s;
304 sts.parseLength = itr.currentEnd();
305 itr.next();
306 }
307
308 return found;
309 }
310
311 private boolean parseVariants(StringTokenIterator itr, ParseStatus sts) {
312 if (itr.isDone() || sts.isError()) {
313 return false;
314 }
315
316 boolean found = false;
317
318 while (!itr.isDone()) {
319 String s = itr.current();
320 if (!isVariant(s)) {
321 break;
322 }
323 found = true;
324 if (variants.isEmpty()) {
325 variants = new ArrayList<>(3);
326 }
327 variants.add(s);
328 sts.parseLength = itr.currentEnd();
329 itr.next();
330 }
331
332 return found;
333 }
334
335 private boolean parseExtensions(StringTokenIterator itr, ParseStatus sts) {
336 if (itr.isDone() || sts.isError()) {
337 return false;
338 }
339
340 boolean found = false;
341
342 while (!itr.isDone()) {
343 String s = itr.current();
344 if (isExtensionSingleton(s)) {
345 int start = itr.currentStart();
346 String singleton = s;
347 StringBuilder sb = new StringBuilder(singleton);
348
349 itr.next();
350 while (!itr.isDone()) {
351 s = itr.current();
352 if (isExtensionSubtag(s)) {
353 sb.append(SEP).append(s);
354 sts.parseLength = itr.currentEnd();
355 } else {
356 break;
357 }
358 itr.next();
359 }
360
361 if (sts.parseLength <= start) {
362 sts.errorIndex = start;
363 sts.errorMsg = "Incomplete extension '" + singleton + "'";
364 break;
365 }
366
367 if (extensions.isEmpty()) {
368 extensions = new ArrayList<>(4);
369 }
370 extensions.add(sb.toString());
371 found = true;
372 } else {
373 break;
374 }
375 }
376 return found;
377 }
378
379 private boolean parsePrivateuse(StringTokenIterator itr, ParseStatus sts) {
380 if (itr.isDone() || sts.isError()) {
381 return false;
382 }
383
384 boolean found = false;
385
386 String s = itr.current();
387 if (isPrivateusePrefix(s)) {
388 int start = itr.currentStart();
389 StringBuilder sb = new StringBuilder(s);
390
391 itr.next();
392 while (!itr.isDone()) {
393 s = itr.current();
394 if (!isPrivateuseSubtag(s)) {
395 break;
396 }
397 sb.append(SEP).append(s);
398 sts.parseLength = itr.currentEnd();
399
400 itr.next();
401 }
402
403 if (sts.parseLength <= start) {
404 // need at least 1 private subtag
405 sts.errorIndex = start;
406 sts.errorMsg = "Incomplete privateuse";
407 } else {
408 privateuse = sb.toString();
409 found = true;
410 }
411 }
412
413 return found;
414 }
415
416 public static LanguageTag parseLocale(BaseLocale baseLocale, LocaleExtensions localeExtensions) {
417 LanguageTag tag = new LanguageTag();
418
419 String language = baseLocale.getLanguage();
420 String script = baseLocale.getScript();
421 String region = baseLocale.getRegion();
422 String variant = baseLocale.getVariant();
423
424 boolean hasSubtag = false;
425
426 String privuseVar = null; // store ill-formed variant subtags
427
428 if (isLanguage(language)) {
429 // Convert a deprecated language code to its new code
430 if (language.equals("iw")) {
431 language = "he";
432 } else if (language.equals("ji")) {
433 language = "yi";
434 } else if (language.equals("in")) {
435 language = "id";
436 }
437 tag.language = language;
438 }
439
440 if (isScript(script)) {
441 tag.script = canonicalizeScript(script);
442 hasSubtag = true;
443 }
444
445 if (isRegion(region)) {
446 tag.region = canonicalizeRegion(region);
447 hasSubtag = true;
448 }
449
450 // Special handling for no_NO_NY - use nn_NO for language tag
451 if (tag.language.equals("no") && tag.region.equals("NO") && variant.equals("NY")) {
452 tag.language = "nn";
453 variant = "";
454 }
455
456 if (variant.length() > 0) {
457 List<String> variants = null;
458 StringTokenIterator varitr = new StringTokenIterator(variant, BaseLocale.SEP);
459 while (!varitr.isDone()) {
460 String var = varitr.current();
461 if (!isVariant(var)) {
462 break;
463 }
464 if (variants == null) {
465 variants = new ArrayList<>();
466 }
467 variants.add(var); // Do not canonicalize!
468 varitr.next();
469 }
470 if (variants != null) {
471 tag.variants = variants;
472 hasSubtag = true;
473 }
474 if (!varitr.isDone()) {
475 // ill-formed variant subtags
476 StringBuilder buf = new StringBuilder();
477 while (!varitr.isDone()) {
478 String prvv = varitr.current();
479 if (!isPrivateuseSubtag(prvv)) {
480 // cannot use private use subtag - truncated
481 break;
482 }
483 if (buf.length() > 0) {
484 buf.append(SEP);
485 }
486 buf.append(prvv);
487 varitr.next();
488 }
489 if (buf.length() > 0) {
490 privuseVar = buf.toString();
491 }
492 }
493 }
494
495 List<String> extensions = null;
496 String privateuse = null;
497
498 if (localeExtensions != null) {
499 Set<Character> locextKeys = localeExtensions.getKeys();
500 for (Character locextKey : locextKeys) {
501 Extension ext = localeExtensions.getExtension(locextKey);
502 if (isPrivateusePrefixChar(locextKey)) {
503 privateuse = ext.getValue();
504 } else {
505 if (extensions == null) {
506 extensions = new ArrayList<>();
507 }
508 extensions.add(locextKey.toString() + SEP + ext.getValue());
509 }
510 }
511 }
512
513 if (extensions != null) {
514 tag.extensions = extensions;
515 hasSubtag = true;
516 }
517
518 // append ill-formed variant subtags to private use
519 if (privuseVar != null) {
520 if (privateuse == null) {
521 privateuse = PRIVUSE_VARIANT_PREFIX + SEP + privuseVar;
522 } else {
523 privateuse = privateuse + SEP + PRIVUSE_VARIANT_PREFIX
524 + SEP + privuseVar.replace(BaseLocale.SEP, SEP);
525 }
526 }
527
528 if (privateuse != null) {
529 tag.privateuse = privateuse;
530 }
531
532 if (tag.language.length() == 0 && (hasSubtag || privateuse == null)) {
533 // use lang "und" when 1) no language is available AND
534 // 2) any of other subtags other than private use are available or
535 // no private use tag is available
536 tag.language = UNDETERMINED;
537 }
538
539 return tag;
540 }
541
542 //
543 // Getter methods for language subtag fields
544 //
545
546 public String getLanguage() {
547 return language;
548 }
549
550 public List<String> getExtlangs() {
551 if (extlangs.isEmpty()) {
552 return Collections.emptyList();
553 }
554 return Collections.unmodifiableList(extlangs);
555 }
556
557 public String getScript() {
558 return script;
559 }
560
561 public String getRegion() {
562 return region;
563 }
564
565 public List<String> getVariants() {
566 if (variants.isEmpty()) {
567 return Collections.emptyList();
568 }
569 return Collections.unmodifiableList(variants);
570 }
571
572 public List<String> getExtensions() {
573 if (extensions.isEmpty()) {
574 return Collections.emptyList();
575 }
576 return Collections.unmodifiableList(extensions);
577 }
578
579 public String getPrivateuse() {
580 return privateuse;
581 }
582
583 //
584 // Language subtag syntax checking methods
585 //
586
587 public static boolean isLanguage(String s) {
588 // language = 2*3ALPHA ; shortest ISO 639 code
589 // ["-" extlang] ; sometimes followed by
590 // ; extended language subtags
591 // / 4ALPHA ; or reserved for future use
592 // / 5*8ALPHA ; or registered language subtag
593 int len = s.length();
594 return (len >= 2) && (len <= 8) && LocaleUtils.isAlphaString(s);
595 }
596
597 public static boolean isExtlang(String s) {
598 // extlang = 3ALPHA ; selected ISO 639 codes
599 // *2("-" 3ALPHA) ; permanently reserved
600 return (s.length() == 3) && LocaleUtils.isAlphaString(s);
601 }
602
603 public static boolean isScript(String s) {
604 // script = 4ALPHA ; ISO 15924 code
605 return (s.length() == 4) && LocaleUtils.isAlphaString(s);
606 }
607
608 public static boolean isRegion(String s) {
609 // region = 2ALPHA ; ISO 3166-1 code
610 // / 3DIGIT ; UN M.49 code
611 return ((s.length() == 2) && LocaleUtils.isAlphaString(s))
612 || ((s.length() == 3) && LocaleUtils.isNumericString(s));
613 }
614
615 public static boolean isVariant(String s) {
616 // variant = 5*8alphanum ; registered variants
617 // / (DIGIT 3alphanum)
618 int len = s.length();
619 if (len >= 5 && len <= 8) {
620 return LocaleUtils.isAlphaNumericString(s);
621 }
622 if (len == 4) {
623 return LocaleUtils.isNumeric(s.charAt(0))
624 && LocaleUtils.isAlphaNumeric(s.charAt(1))
625 && LocaleUtils.isAlphaNumeric(s.charAt(2))
626 && LocaleUtils.isAlphaNumeric(s.charAt(3));
627 }
628 return false;
629 }
630
631 public static boolean isExtensionSingleton(String s) {
632 // singleton = DIGIT ; 0 - 9
633 // / %x41-57 ; A - W
634 // / %x59-5A ; Y - Z
635 // / %x61-77 ; a - w
636 // / %x79-7A ; y - z
637
638 return (s.length() == 1)
639 && LocaleUtils.isAlphaString(s)
640 && !LocaleUtils.caseIgnoreMatch(PRIVATEUSE, s);
641 }
642
643 public static boolean isExtensionSingletonChar(char c) {
644 return isExtensionSingleton(String.valueOf(c));
645 }
646
647 public static boolean isExtensionSubtag(String s) {
648 // extension = singleton 1*("-" (2*8alphanum))
649 int len = s.length();
650 return (len >= 2) && (len <= 8) && LocaleUtils.isAlphaNumericString(s);
651 }
652
653 public static boolean isPrivateusePrefix(String s) {
654 // privateuse = "x" 1*("-" (1*8alphanum))
655 return (s.length() == 1)
656 && LocaleUtils.caseIgnoreMatch(PRIVATEUSE, s);
657 }
658
659 public static boolean isPrivateusePrefixChar(char c) {
660 return (LocaleUtils.caseIgnoreMatch(PRIVATEUSE, String.valueOf(c)));
661 }
662
663 public static boolean isPrivateuseSubtag(String s) {
664 // privateuse = "x" 1*("-" (1*8alphanum))
665 int len = s.length();
666 return (len >= 1) && (len <= 8) && LocaleUtils.isAlphaNumericString(s);
667 }
668
669 //
670 // Language subtag canonicalization methods
671 //
672
673 public static String canonicalizeLanguage(String s) {
674 return LocaleUtils.toLowerString(s);
675 }
676
677 public static String canonicalizeExtlang(String s) {
678 return LocaleUtils.toLowerString(s);
679 }
680
681 public static String canonicalizeScript(String s) {
682 return LocaleUtils.toTitleString(s);
683 }
684
685 public static String canonicalizeRegion(String s) {
686 return LocaleUtils.toUpperString(s);
687 }
688
689 public static String canonicalizeVariant(String s) {
690 return LocaleUtils.toLowerString(s);
691 }
692
693 public static String canonicalizeExtension(String s) {
694 return LocaleUtils.toLowerString(s);
695 }
696
697 public static String canonicalizeExtensionSingleton(String s) {
698 return LocaleUtils.toLowerString(s);
699 }
700
701 public static String canonicalizeExtensionSubtag(String s) {
702 return LocaleUtils.toLowerString(s);
703 }
704
705 public static String canonicalizePrivateuse(String s) {
706 return LocaleUtils.toLowerString(s);
707 }
708
709 public static String canonicalizePrivateuseSubtag(String s) {
710 return LocaleUtils.toLowerString(s);
711 }
712
713 @Override
714 public String toString() {
715 StringBuilder sb = new StringBuilder();
716
717 if (language.length() > 0) {
718 sb.append(language);
719
720 for (String extlang : extlangs) {
721 sb.append(SEP).append(extlang);
722 }
723
724 if (script.length() > 0) {
725 sb.append(SEP).append(script);
726 }
727
728 if (region.length() > 0) {
729 sb.append(SEP).append(region);
730 }
731
732 for (String variant : variants) {
733 sb.append(SEP).append(variant);
734 }
735
736 for (String extension : extensions) {
737 sb.append(SEP).append(extension);
738 }
739 }
740 if (privateuse.length() > 0) {
741 if (sb.length() > 0) {
742 sb.append(SEP);
743 }
744 sb.append(privateuse);
745 }
746
747 return sb.toString();
748 }
749 }