| // Copyright 2013 The Go Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style | |
| // license that can be found in the LICENSE file. | |
| package language | |
| import ( | |
| "bytes" | |
| "fmt" | |
| "sort" | |
| "strconv" | |
| "golang.org/x/text/internal/tag" | |
| ) | |
| // findIndex tries to find the given tag in idx and returns a standardized error | |
| // if it could not be found. | |
| func findIndex(idx tag.Index, key []byte, form string) (index int, err error) { | |
| if !tag.FixCase(form, key) { | |
| return 0, ErrSyntax | |
| } | |
| i := idx.Index(key) | |
| if i == -1 { | |
| return 0, NewValueError(key) | |
| } | |
| return i, nil | |
| } | |
| func searchUint(imap []uint16, key uint16) int { | |
| return sort.Search(len(imap), func(i int) bool { | |
| return imap[i] >= key | |
| }) | |
| } | |
| type Language uint16 | |
| // getLangID returns the langID of s if s is a canonical subtag | |
| // or langUnknown if s is not a canonical subtag. | |
| func getLangID(s []byte) (Language, error) { | |
| if len(s) == 2 { | |
| return getLangISO2(s) | |
| } | |
| return getLangISO3(s) | |
| } | |
| // TODO language normalization as well as the AliasMaps could be moved to the | |
| // higher level package, but it is a bit tricky to separate the generation. | |
| func (id Language) Canonicalize() (Language, AliasType) { | |
| return normLang(id) | |
| } | |
| // mapLang returns the mapped langID of id according to mapping m. | |
| func normLang(id Language) (Language, AliasType) { | |
| k := sort.Search(len(AliasMap), func(i int) bool { | |
| return AliasMap[i].From >= uint16(id) | |
| }) | |
| if k < len(AliasMap) && AliasMap[k].From == uint16(id) { | |
| return Language(AliasMap[k].To), AliasTypes[k] | |
| } | |
| return id, AliasTypeUnknown | |
| } | |
| // getLangISO2 returns the langID for the given 2-letter ISO language code | |
| // or unknownLang if this does not exist. | |
| func getLangISO2(s []byte) (Language, error) { | |
| if !tag.FixCase("zz", s) { | |
| return 0, ErrSyntax | |
| } | |
| if i := lang.Index(s); i != -1 && lang.Elem(i)[3] != 0 { | |
| return Language(i), nil | |
| } | |
| return 0, NewValueError(s) | |
| } | |
| const base = 'z' - 'a' + 1 | |
| func strToInt(s []byte) uint { | |
| v := uint(0) | |
| for i := 0; i < len(s); i++ { | |
| v *= base | |
| v += uint(s[i] - 'a') | |
| } | |
| return v | |
| } | |
| // converts the given integer to the original ASCII string passed to strToInt. | |
| // len(s) must match the number of characters obtained. | |
| func intToStr(v uint, s []byte) { | |
| for i := len(s) - 1; i >= 0; i-- { | |
| s[i] = byte(v%base) + 'a' | |
| v /= base | |
| } | |
| } | |
| // getLangISO3 returns the langID for the given 3-letter ISO language code | |
| // or unknownLang if this does not exist. | |
| func getLangISO3(s []byte) (Language, error) { | |
| if tag.FixCase("und", s) { | |
| // first try to match canonical 3-letter entries | |
| for i := lang.Index(s[:2]); i != -1; i = lang.Next(s[:2], i) { | |
| if e := lang.Elem(i); e[3] == 0 && e[2] == s[2] { | |
| // We treat "und" as special and always translate it to "unspecified". | |
| // Note that ZZ and Zzzz are private use and are not treated as | |
| // unspecified by default. | |
| id := Language(i) | |
| if id == nonCanonicalUnd { | |
| return 0, nil | |
| } | |
| return id, nil | |
| } | |
| } | |
| if i := altLangISO3.Index(s); i != -1 { | |
| return Language(altLangIndex[altLangISO3.Elem(i)[3]]), nil | |
| } | |
| n := strToInt(s) | |
| if langNoIndex[n/8]&(1<<(n%8)) != 0 { | |
| return Language(n) + langNoIndexOffset, nil | |
| } | |
| // Check for non-canonical uses of ISO3. | |
| for i := lang.Index(s[:1]); i != -1; i = lang.Next(s[:1], i) { | |
| if e := lang.Elem(i); e[2] == s[1] && e[3] == s[2] { | |
| return Language(i), nil | |
| } | |
| } | |
| return 0, NewValueError(s) | |
| } | |
| return 0, ErrSyntax | |
| } | |
| // StringToBuf writes the string to b and returns the number of bytes | |
| // written. cap(b) must be >= 3. | |
| func (id Language) StringToBuf(b []byte) int { | |
| if id >= langNoIndexOffset { | |
| intToStr(uint(id)-langNoIndexOffset, b[:3]) | |
| return 3 | |
| } else if id == 0 { | |
| return copy(b, "und") | |
| } | |
| l := lang[id<<2:] | |
| if l[3] == 0 { | |
| return copy(b, l[:3]) | |
| } | |
| return copy(b, l[:2]) | |
| } | |
| // String returns the BCP 47 representation of the langID. | |
| // Use b as variable name, instead of id, to ensure the variable | |
| // used is consistent with that of Base in which this type is embedded. | |
| func (b Language) String() string { | |
| if b == 0 { | |
| return "und" | |
| } else if b >= langNoIndexOffset { | |
| b -= langNoIndexOffset | |
| buf := [3]byte{} | |
| intToStr(uint(b), buf[:]) | |
| return string(buf[:]) | |
| } | |
| l := lang.Elem(int(b)) | |
| if l[3] == 0 { | |
| return l[:3] | |
| } | |
| return l[:2] | |
| } | |
| // ISO3 returns the ISO 639-3 language code. | |
| func (b Language) ISO3() string { | |
| if b == 0 || b >= langNoIndexOffset { | |
| return b.String() | |
| } | |
| l := lang.Elem(int(b)) | |
| if l[3] == 0 { | |
| return l[:3] | |
| } else if l[2] == 0 { | |
| return altLangISO3.Elem(int(l[3]))[:3] | |
| } | |
| // This allocation will only happen for 3-letter ISO codes | |
| // that are non-canonical BCP 47 language identifiers. | |
| return l[0:1] + l[2:4] | |
| } | |
| // IsPrivateUse reports whether this language code is reserved for private use. | |
| func (b Language) IsPrivateUse() bool { | |
| return langPrivateStart <= b && b <= langPrivateEnd | |
| } | |
| // SuppressScript returns the script marked as SuppressScript in the IANA | |
| // language tag repository, or 0 if there is no such script. | |
| func (b Language) SuppressScript() Script { | |
| if b < langNoIndexOffset { | |
| return Script(suppressScript[b]) | |
| } | |
| return 0 | |
| } | |
| type Region uint16 | |
| // getRegionID returns the region id for s if s is a valid 2-letter region code | |
| // or unknownRegion. | |
| func getRegionID(s []byte) (Region, error) { | |
| if len(s) == 3 { | |
| if isAlpha(s[0]) { | |
| return getRegionISO3(s) | |
| } | |
| if i, err := strconv.ParseUint(string(s), 10, 10); err == nil { | |
| return getRegionM49(int(i)) | |
| } | |
| } | |
| return getRegionISO2(s) | |
| } | |
| // getRegionISO2 returns the regionID for the given 2-letter ISO country code | |
| // or unknownRegion if this does not exist. | |
| func getRegionISO2(s []byte) (Region, error) { | |
| i, err := findIndex(regionISO, s, "ZZ") | |
| if err != nil { | |
| return 0, err | |
| } | |
| return Region(i) + isoRegionOffset, nil | |
| } | |
| // getRegionISO3 returns the regionID for the given 3-letter ISO country code | |
| // or unknownRegion if this does not exist. | |
| func getRegionISO3(s []byte) (Region, error) { | |
| if tag.FixCase("ZZZ", s) { | |
| for i := regionISO.Index(s[:1]); i != -1; i = regionISO.Next(s[:1], i) { | |
| if e := regionISO.Elem(i); e[2] == s[1] && e[3] == s[2] { | |
| return Region(i) + isoRegionOffset, nil | |
| } | |
| } | |
| for i := 0; i < len(altRegionISO3); i += 3 { | |
| if tag.Compare(altRegionISO3[i:i+3], s) == 0 { | |
| return Region(altRegionIDs[i/3]), nil | |
| } | |
| } | |
| return 0, NewValueError(s) | |
| } | |
| return 0, ErrSyntax | |
| } | |
| func getRegionM49(n int) (Region, error) { | |
| if 0 < n && n <= 999 { | |
| const ( | |
| searchBits = 7 | |
| regionBits = 9 | |
| regionMask = 1<<regionBits - 1 | |
| ) | |
| idx := n >> searchBits | |
| buf := fromM49[m49Index[idx]:m49Index[idx+1]] | |
| val := uint16(n) << regionBits // we rely on bits shifting out | |
| i := sort.Search(len(buf), func(i int) bool { | |
| return buf[i] >= val | |
| }) | |
| if r := fromM49[int(m49Index[idx])+i]; r&^regionMask == val { | |
| return Region(r & regionMask), nil | |
| } | |
| } | |
| var e ValueError | |
| fmt.Fprint(bytes.NewBuffer([]byte(e.v[:])), n) | |
| return 0, e | |
| } | |
| // normRegion returns a region if r is deprecated or 0 otherwise. | |
| // TODO: consider supporting BYS (-> BLR), CSK (-> 200 or CZ), PHI (-> PHL) and AFI (-> DJ). | |
| // TODO: consider mapping split up regions to new most populous one (like CLDR). | |
| func normRegion(r Region) Region { | |
| m := regionOldMap | |
| k := sort.Search(len(m), func(i int) bool { | |
| return m[i].From >= uint16(r) | |
| }) | |
| if k < len(m) && m[k].From == uint16(r) { | |
| return Region(m[k].To) | |
| } | |
| return 0 | |
| } | |
| const ( | |
| iso3166UserAssigned = 1 << iota | |
| ccTLD | |
| bcp47Region | |
| ) | |
| func (r Region) typ() byte { | |
| return regionTypes[r] | |
| } | |
| // String returns the BCP 47 representation for the region. | |
| // It returns "ZZ" for an unspecified region. | |
| func (r Region) String() string { | |
| if r < isoRegionOffset { | |
| if r == 0 { | |
| return "ZZ" | |
| } | |
| return fmt.Sprintf("%03d", r.M49()) | |
| } | |
| r -= isoRegionOffset | |
| return regionISO.Elem(int(r))[:2] | |
| } | |
| // ISO3 returns the 3-letter ISO code of r. | |
| // Note that not all regions have a 3-letter ISO code. | |
| // In such cases this method returns "ZZZ". | |
| func (r Region) ISO3() string { | |
| if r < isoRegionOffset { | |
| return "ZZZ" | |
| } | |
| r -= isoRegionOffset | |
| reg := regionISO.Elem(int(r)) | |
| switch reg[2] { | |
| case 0: | |
| return altRegionISO3[reg[3]:][:3] | |
| case ' ': | |
| return "ZZZ" | |
| } | |
| return reg[0:1] + reg[2:4] | |
| } | |
| // M49 returns the UN M.49 encoding of r, or 0 if this encoding | |
| // is not defined for r. | |
| func (r Region) M49() int { | |
| return int(m49[r]) | |
| } | |
| // IsPrivateUse reports whether r has the ISO 3166 User-assigned status. This | |
| // may include private-use tags that are assigned by CLDR and used in this | |
| // implementation. So IsPrivateUse and IsCountry can be simultaneously true. | |
| func (r Region) IsPrivateUse() bool { | |
| return r.typ()&iso3166UserAssigned != 0 | |
| } | |
| type Script uint8 | |
| // getScriptID returns the script id for string s. It assumes that s | |
| // is of the format [A-Z][a-z]{3}. | |
| func getScriptID(idx tag.Index, s []byte) (Script, error) { | |
| i, err := findIndex(idx, s, "Zzzz") | |
| return Script(i), err | |
| } | |
| // String returns the script code in title case. | |
| // It returns "Zzzz" for an unspecified script. | |
| func (s Script) String() string { | |
| if s == 0 { | |
| return "Zzzz" | |
| } | |
| return script.Elem(int(s)) | |
| } | |
| // IsPrivateUse reports whether this script code is reserved for private use. | |
| func (s Script) IsPrivateUse() bool { | |
| return _Qaaa <= s && s <= _Qabx | |
| } | |
| const ( | |
| maxAltTaglen = len("en-US-POSIX") | |
| maxLen = maxAltTaglen | |
| ) | |
| var ( | |
| // grandfatheredMap holds a mapping from legacy and grandfathered tags to | |
| // their base language or index to more elaborate tag. | |
| grandfatheredMap = map[[maxLen]byte]int16{ | |
| [maxLen]byte{'a', 'r', 't', '-', 'l', 'o', 'j', 'b', 'a', 'n'}: _jbo, // art-lojban | |
| [maxLen]byte{'i', '-', 'a', 'm', 'i'}: _ami, // i-ami | |
| [maxLen]byte{'i', '-', 'b', 'n', 'n'}: _bnn, // i-bnn | |
| [maxLen]byte{'i', '-', 'h', 'a', 'k'}: _hak, // i-hak | |
| [maxLen]byte{'i', '-', 'k', 'l', 'i', 'n', 'g', 'o', 'n'}: _tlh, // i-klingon | |
| [maxLen]byte{'i', '-', 'l', 'u', 'x'}: _lb, // i-lux | |
| [maxLen]byte{'i', '-', 'n', 'a', 'v', 'a', 'j', 'o'}: _nv, // i-navajo | |
| [maxLen]byte{'i', '-', 'p', 'w', 'n'}: _pwn, // i-pwn | |
| [maxLen]byte{'i', '-', 't', 'a', 'o'}: _tao, // i-tao | |
| [maxLen]byte{'i', '-', 't', 'a', 'y'}: _tay, // i-tay | |
| [maxLen]byte{'i', '-', 't', 's', 'u'}: _tsu, // i-tsu | |
| [maxLen]byte{'n', 'o', '-', 'b', 'o', 'k'}: _nb, // no-bok | |
| [maxLen]byte{'n', 'o', '-', 'n', 'y', 'n'}: _nn, // no-nyn | |
| [maxLen]byte{'s', 'g', 'n', '-', 'b', 'e', '-', 'f', 'r'}: _sfb, // sgn-BE-FR | |
| [maxLen]byte{'s', 'g', 'n', '-', 'b', 'e', '-', 'n', 'l'}: _vgt, // sgn-BE-NL | |
| [maxLen]byte{'s', 'g', 'n', '-', 'c', 'h', '-', 'd', 'e'}: _sgg, // sgn-CH-DE | |
| [maxLen]byte{'z', 'h', '-', 'g', 'u', 'o', 'y', 'u'}: _cmn, // zh-guoyu | |
| [maxLen]byte{'z', 'h', '-', 'h', 'a', 'k', 'k', 'a'}: _hak, // zh-hakka | |
| [maxLen]byte{'z', 'h', '-', 'm', 'i', 'n', '-', 'n', 'a', 'n'}: _nan, // zh-min-nan | |
| [maxLen]byte{'z', 'h', '-', 'x', 'i', 'a', 'n', 'g'}: _hsn, // zh-xiang | |
| // Grandfathered tags with no modern replacement will be converted as | |
| // follows: | |
| [maxLen]byte{'c', 'e', 'l', '-', 'g', 'a', 'u', 'l', 'i', 's', 'h'}: -1, // cel-gaulish | |
| [maxLen]byte{'e', 'n', '-', 'g', 'b', '-', 'o', 'e', 'd'}: -2, // en-GB-oed | |
| [maxLen]byte{'i', '-', 'd', 'e', 'f', 'a', 'u', 'l', 't'}: -3, // i-default | |
| [maxLen]byte{'i', '-', 'e', 'n', 'o', 'c', 'h', 'i', 'a', 'n'}: -4, // i-enochian | |
| [maxLen]byte{'i', '-', 'm', 'i', 'n', 'g', 'o'}: -5, // i-mingo | |
| [maxLen]byte{'z', 'h', '-', 'm', 'i', 'n'}: -6, // zh-min | |
| // CLDR-specific tag. | |
| [maxLen]byte{'r', 'o', 'o', 't'}: 0, // root | |
| [maxLen]byte{'e', 'n', '-', 'u', 's', '-', 'p', 'o', 's', 'i', 'x'}: -7, // en_US_POSIX" | |
| } | |
| altTagIndex = [...]uint8{0, 17, 31, 45, 61, 74, 86, 102} | |
| altTags = "xtg-x-cel-gaulishen-GB-oxendicten-x-i-defaultund-x-i-enochiansee-x-i-mingonan-x-zh-minen-US-u-va-posix" | |
| ) | |
| func grandfathered(s [maxAltTaglen]byte) (t Tag, ok bool) { | |
| if v, ok := grandfatheredMap[s]; ok { | |
| if v < 0 { | |
| return Make(altTags[altTagIndex[-v-1]:altTagIndex[-v]]), true | |
| } | |
| t.LangID = Language(v) | |
| return t, true | |
| } | |
| return t, false | |
| } |