lookup.go

Documentation: cmd/vendor/golang.org/x/text/internal/language

     1  // Copyright 2013 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package language
     6  
     7  import (
     8  	"bytes"
     9  	"fmt"
    10  	"sort"
    11  	"strconv"
    12  
    13  	"golang.org/x/text/internal/tag"
    14  )
    15  
    16  // findIndex tries to find the given tag in idx and returns a standardized error
    17  // if it could not be found.
    18  func findIndex(idx tag.Index, key []byte, form string) (index int, err error) {
    19  	if !tag.FixCase(form, key) {
    20  		return 0, ErrSyntax
    21  	}
    22  	i := idx.Index(key)
    23  	if i == -1 {
    24  		return 0, NewValueError(key)
    25  	}
    26  	return i, nil
    27  }
    28  
    29  func searchUint(imap []uint16, key uint16) int {
    30  	return sort.Search(len(imap), func(i int) bool {
    31  		return imap[i] >= key
    32  	})
    33  }
    34  
    35  type Language uint16
    36  
    37  // getLangID returns the langID of s if s is a canonical subtag
    38  // or langUnknown if s is not a canonical subtag.
    39  func getLangID(s []byte) (Language, error) {
    40  	if len(s) == 2 {
    41  		return getLangISO2(s)
    42  	}
    43  	return getLangISO3(s)
    44  }
    45  
    46  // TODO language normalization as well as the AliasMaps could be moved to the
    47  // higher level package, but it is a bit tricky to separate the generation.
    48  
    49  func (id Language) Canonicalize() (Language, AliasType) {
    50  	return normLang(id)
    51  }
    52  
    53  // normLang returns the mapped langID of id according to mapping m.
    54  func normLang(id Language) (Language, AliasType) {
    55  	k := sort.Search(len(AliasMap), func(i int) bool {
    56  		return AliasMap[i].From >= uint16(id)
    57  	})
    58  	if k < len(AliasMap) && AliasMap[k].From == uint16(id) {
    59  		return Language(AliasMap[k].To), AliasTypes[k]
    60  	}
    61  	return id, AliasTypeUnknown
    62  }
    63  
    64  // getLangISO2 returns the langID for the given 2-letter ISO language code
    65  // or unknownLang if this does not exist.
    66  func getLangISO2(s []byte) (Language, error) {
    67  	if !tag.FixCase("zz", s) {
    68  		return 0, ErrSyntax
    69  	}
    70  	if i := lang.Index(s); i != -1 && lang.Elem(i)[3] != 0 {
    71  		return Language(i), nil
    72  	}
    73  	return 0, NewValueError(s)
    74  }
    75  
    76  const base = 'z' - 'a' + 1
    77  
    78  func strToInt(s []byte) uint {
    79  	v := uint(0)
    80  	for i := 0; i < len(s); i++ {
    81  		v *= base
    82  		v += uint(s[i] - 'a')
    83  	}
    84  	return v
    85  }
    86  
    87  // converts the given integer to the original ASCII string passed to strToInt.
    88  // len(s) must match the number of characters obtained.
    89  func intToStr(v uint, s []byte) {
    90  	for i := len(s) - 1; i >= 0; i-- {
    91  		s[i] = byte(v%base) + 'a'
    92  		v /= base
    93  	}
    94  }
    95  
    96  // getLangISO3 returns the langID for the given 3-letter ISO language code
    97  // or unknownLang if this does not exist.
    98  func getLangISO3(s []byte) (Language, error) {
    99  	if tag.FixCase("und", s) {
   100  		// first try to match canonical 3-letter entries
   101  		for i := lang.Index(s[:2]); i != -1; i = lang.Next(s[:2], i) {
   102  			if e := lang.Elem(i); e[3] == 0 && e[2] == s[2] {
   103  				// We treat "und" as special and always translate it to "unspecified".
   104  				// Note that ZZ and Zzzz are private use and are not treated as
   105  				// unspecified by default.
   106  				id := Language(i)
   107  				if id == nonCanonicalUnd {
   108  					return 0, nil
   109  				}
   110  				return id, nil
   111  			}
   112  		}
   113  		if i := altLangISO3.Index(s); i != -1 {
   114  			return Language(altLangIndex[altLangISO3.Elem(i)[3]]), nil
   115  		}
   116  		n := strToInt(s)
   117  		if langNoIndex[n/8]&(1<<(n%8)) != 0 {
   118  			return Language(n) + langNoIndexOffset, nil
   119  		}
   120  		// Check for non-canonical uses of ISO3.
   121  		for i := lang.Index(s[:1]); i != -1; i = lang.Next(s[:1], i) {
   122  			if e := lang.Elem(i); e[2] == s[1] && e[3] == s[2] {
   123  				return Language(i), nil
   124  			}
   125  		}
   126  		return 0, NewValueError(s)
   127  	}
   128  	return 0, ErrSyntax
   129  }
   130  
   131  // StringToBuf writes the string to b and returns the number of bytes
   132  // written.  cap(b) must be >= 3.
   133  func (id Language) StringToBuf(b []byte) int {
   134  	if id >= langNoIndexOffset {
   135  		intToStr(uint(id)-langNoIndexOffset, b[:3])
   136  		return 3
   137  	} else if id == 0 {
   138  		return copy(b, "und")
   139  	}
   140  	l := lang[id<<2:]
   141  	if l[3] == 0 {
   142  		return copy(b, l[:3])
   143  	}
   144  	return copy(b, l[:2])
   145  }
   146  
   147  // String returns the BCP 47 representation of the langID.
   148  // Use b as variable name, instead of id, to ensure the variable
   149  // used is consistent with that of Base in which this type is embedded.
   150  func (b Language) String() string {
   151  	if b == 0 {
   152  		return "und"
   153  	} else if b >= langNoIndexOffset {
   154  		b -= langNoIndexOffset
   155  		buf := [3]byte{}
   156  		intToStr(uint(b), buf[:])
   157  		return string(buf[:])
   158  	}
   159  	l := lang.Elem(int(b))
   160  	if l[3] == 0 {
   161  		return l[:3]
   162  	}
   163  	return l[:2]
   164  }
   165  
   166  // ISO3 returns the ISO 639-3 language code.
   167  func (b Language) ISO3() string {
   168  	if b == 0 || b >= langNoIndexOffset {
   169  		return b.String()
   170  	}
   171  	l := lang.Elem(int(b))
   172  	if l[3] == 0 {
   173  		return l[:3]
   174  	} else if l[2] == 0 {
   175  		return altLangISO3.Elem(int(l[3]))[:3]
   176  	}
   177  	// This allocation will only happen for 3-letter ISO codes
   178  	// that are non-canonical BCP 47 language identifiers.
   179  	return l[0:1] + l[2:4]
   180  }
   181  
   182  // IsPrivateUse reports whether this language code is reserved for private use.
   183  func (b Language) IsPrivateUse() bool {
   184  	return langPrivateStart <= b && b <= langPrivateEnd
   185  }
   186  
   187  // SuppressScript returns the script marked as SuppressScript in the IANA
   188  // language tag repository, or 0 if there is no such script.
   189  func (b Language) SuppressScript() Script {
   190  	if b < langNoIndexOffset {
   191  		return Script(suppressScript[b])
   192  	}
   193  	return 0
   194  }
   195  
   196  type Region uint16
   197  
   198  // getRegionID returns the region id for s if s is a valid 2-letter region code
   199  // or unknownRegion.
   200  func getRegionID(s []byte) (Region, error) {
   201  	if len(s) == 3 {
   202  		if isAlpha(s[0]) {
   203  			return getRegionISO3(s)
   204  		}
   205  		if i, err := strconv.ParseUint(string(s), 10, 10); err == nil {
   206  			return getRegionM49(int(i))
   207  		}
   208  	}
   209  	return getRegionISO2(s)
   210  }
   211  
   212  // getRegionISO2 returns the regionID for the given 2-letter ISO country code
   213  // or unknownRegion if this does not exist.
   214  func getRegionISO2(s []byte) (Region, error) {
   215  	i, err := findIndex(regionISO, s, "ZZ")
   216  	if err != nil {
   217  		return 0, err
   218  	}
   219  	return Region(i) + isoRegionOffset, nil
   220  }
   221  
   222  // getRegionISO3 returns the regionID for the given 3-letter ISO country code
   223  // or unknownRegion if this does not exist.
   224  func getRegionISO3(s []byte) (Region, error) {
   225  	if tag.FixCase("ZZZ", s) {
   226  		for i := regionISO.Index(s[:1]); i != -1; i = regionISO.Next(s[:1], i) {
   227  			if e := regionISO.Elem(i); e[2] == s[1] && e[3] == s[2] {
   228  				return Region(i) + isoRegionOffset, nil
   229  			}
   230  		}
   231  		for i := 0; i < len(altRegionISO3); i += 3 {
   232  			if tag.Compare(altRegionISO3[i:i+3], s) == 0 {
   233  				return Region(altRegionIDs[i/3]), nil
   234  			}
   235  		}
   236  		return 0, NewValueError(s)
   237  	}
   238  	return 0, ErrSyntax
   239  }
   240  
   241  func getRegionM49(n int) (Region, error) {
   242  	if 0 < n && n <= 999 {
   243  		const (
   244  			searchBits = 7
   245  			regionBits = 9
   246  			regionMask = 1<<regionBits - 1
   247  		)
   248  		idx := n >> searchBits
   249  		buf := fromM49[m49Index[idx]:m49Index[idx+1]]
   250  		val := uint16(n) << regionBits // we rely on bits shifting out
   251  		i := sort.Search(len(buf), func(i int) bool {
   252  			return buf[i] >= val
   253  		})
   254  		if r := fromM49[int(m49Index[idx])+i]; r&^regionMask == val {
   255  			return Region(r & regionMask), nil
   256  		}
   257  	}
   258  	var e ValueError
   259  	fmt.Fprint(bytes.NewBuffer([]byte(e.v[:])), n)
   260  	return 0, e
   261  }
   262  
   263  // normRegion returns a region if r is deprecated or 0 otherwise.
   264  // TODO: consider supporting BYS (-> BLR), CSK (-> 200 or CZ), PHI (-> PHL) and AFI (-> DJ).
   265  // TODO: consider mapping split up regions to new most populous one (like CLDR).
   266  func normRegion(r Region) Region {
   267  	m := regionOldMap
   268  	k := sort.Search(len(m), func(i int) bool {
   269  		return m[i].From >= uint16(r)
   270  	})
   271  	if k < len(m) && m[k].From == uint16(r) {
   272  		return Region(m[k].To)
   273  	}
   274  	return 0
   275  }
   276  
   277  const (
   278  	iso3166UserAssigned = 1 << iota
   279  	ccTLD
   280  	bcp47Region
   281  )
   282  
   283  func (r Region) typ() byte {
   284  	return regionTypes[r]
   285  }
   286  
   287  // String returns the BCP 47 representation for the region.
   288  // It returns "ZZ" for an unspecified region.
   289  func (r Region) String() string {
   290  	if r < isoRegionOffset {
   291  		if r == 0 {
   292  			return "ZZ"
   293  		}
   294  		return fmt.Sprintf("%03d", r.M49())
   295  	}
   296  	r -= isoRegionOffset
   297  	return regionISO.Elem(int(r))[:2]
   298  }
   299  
   300  // ISO3 returns the 3-letter ISO code of r.
   301  // Note that not all regions have a 3-letter ISO code.
   302  // In such cases this method returns "ZZZ".
   303  func (r Region) ISO3() string {
   304  	if r < isoRegionOffset {
   305  		return "ZZZ"
   306  	}
   307  	r -= isoRegionOffset
   308  	reg := regionISO.Elem(int(r))
   309  	switch reg[2] {
   310  	case 0:
   311  		return altRegionISO3[reg[3]:][:3]
   312  	case ' ':
   313  		return "ZZZ"
   314  	}
   315  	return reg[0:1] + reg[2:4]
   316  }
   317  
   318  // M49 returns the UN M.49 encoding of r, or 0 if this encoding
   319  // is not defined for r.
   320  func (r Region) M49() int {
   321  	return int(m49[r])
   322  }
   323  
   324  // IsPrivateUse reports whether r has the ISO 3166 User-assigned status. This
   325  // may include private-use tags that are assigned by CLDR and used in this
   326  // implementation. So IsPrivateUse and IsCountry can be simultaneously true.
   327  func (r Region) IsPrivateUse() bool {
   328  	return r.typ()&iso3166UserAssigned != 0
   329  }
   330  
   331  type Script uint16
   332  
   333  // getScriptID returns the script id for string s. It assumes that s
   334  // is of the format [A-Z][a-z]{3}.
   335  func getScriptID(idx tag.Index, s []byte) (Script, error) {
   336  	i, err := findIndex(idx, s, "Zzzz")
   337  	return Script(i), err
   338  }
   339  
   340  // String returns the script code in title case.
   341  // It returns "Zzzz" for an unspecified script.
   342  func (s Script) String() string {
   343  	if s == 0 {
   344  		return "Zzzz"
   345  	}
   346  	return script.Elem(int(s))
   347  }
   348  
   349  // IsPrivateUse reports whether this script code is reserved for private use.
   350  func (s Script) IsPrivateUse() bool {
   351  	return _Qaaa <= s && s <= _Qabx
   352  }
   353  
   354  const (
   355  	maxAltTaglen = len("en-US-POSIX")
   356  	maxLen       = maxAltTaglen
   357  )
   358  
   359  var (
   360  	// grandfatheredMap holds a mapping from legacy and grandfathered tags to
   361  	// their base language or index to more elaborate tag.
   362  	grandfatheredMap = map[[maxLen]byte]int16{
   363  		[maxLen]byte{'a', 'r', 't', '-', 'l', 'o', 'j', 'b', 'a', 'n'}: _jbo, // art-lojban
   364  		[maxLen]byte{'i', '-', 'a', 'm', 'i'}:                          _ami, // i-ami
   365  		[maxLen]byte{'i', '-', 'b', 'n', 'n'}:                          _bnn, // i-bnn
   366  		[maxLen]byte{'i', '-', 'h', 'a', 'k'}:                          _hak, // i-hak
   367  		[maxLen]byte{'i', '-', 'k', 'l', 'i', 'n', 'g', 'o', 'n'}:      _tlh, // i-klingon
   368  		[maxLen]byte{'i', '-', 'l', 'u', 'x'}:                          _lb,  // i-lux
   369  		[maxLen]byte{'i', '-', 'n', 'a', 'v', 'a', 'j', 'o'}:           _nv,  // i-navajo
   370  		[maxLen]byte{'i', '-', 'p', 'w', 'n'}:                          _pwn, // i-pwn
   371  		[maxLen]byte{'i', '-', 't', 'a', 'o'}:                          _tao, // i-tao
   372  		[maxLen]byte{'i', '-', 't', 'a', 'y'}:                          _tay, // i-tay
   373  		[maxLen]byte{'i', '-', 't', 's', 'u'}:                          _tsu, // i-tsu
   374  		[maxLen]byte{'n', 'o', '-', 'b', 'o', 'k'}:                     _nb,  // no-bok
   375  		[maxLen]byte{'n', 'o', '-', 'n', 'y', 'n'}:                     _nn,  // no-nyn
   376  		[maxLen]byte{'s', 'g', 'n', '-', 'b', 'e', '-', 'f', 'r'}:      _sfb, // sgn-BE-FR
   377  		[maxLen]byte{'s', 'g', 'n', '-', 'b', 'e', '-', 'n', 'l'}:      _vgt, // sgn-BE-NL
   378  		[maxLen]byte{'s', 'g', 'n', '-', 'c', 'h', '-', 'd', 'e'}:      _sgg, // sgn-CH-DE
   379  		[maxLen]byte{'z', 'h', '-', 'g', 'u', 'o', 'y', 'u'}:           _cmn, // zh-guoyu
   380  		[maxLen]byte{'z', 'h', '-', 'h', 'a', 'k', 'k', 'a'}:           _hak, // zh-hakka
   381  		[maxLen]byte{'z', 'h', '-', 'm', 'i', 'n', '-', 'n', 'a', 'n'}: _nan, // zh-min-nan
   382  		[maxLen]byte{'z', 'h', '-', 'x', 'i', 'a', 'n', 'g'}:           _hsn, // zh-xiang
   383  
   384  		// Grandfathered tags with no modern replacement will be converted as
   385  		// follows:
   386  		[maxLen]byte{'c', 'e', 'l', '-', 'g', 'a', 'u', 'l', 'i', 's', 'h'}: -1, // cel-gaulish
   387  		[maxLen]byte{'e', 'n', '-', 'g', 'b', '-', 'o', 'e', 'd'}:           -2, // en-GB-oed
   388  		[maxLen]byte{'i', '-', 'd', 'e', 'f', 'a', 'u', 'l', 't'}:           -3, // i-default
   389  		[maxLen]byte{'i', '-', 'e', 'n', 'o', 'c', 'h', 'i', 'a', 'n'}:      -4, // i-enochian
   390  		[maxLen]byte{'i', '-', 'm', 'i', 'n', 'g', 'o'}:                     -5, // i-mingo
   391  		[maxLen]byte{'z', 'h', '-', 'm', 'i', 'n'}:                          -6, // zh-min
   392  
   393  		// CLDR-specific tag.
   394  		[maxLen]byte{'r', 'o', 'o', 't'}:                                    0,  // root
   395  		[maxLen]byte{'e', 'n', '-', 'u', 's', '-', 'p', 'o', 's', 'i', 'x'}: -7, // en_US_POSIX"
   396  	}
   397  
   398  	altTagIndex = [...]uint8{0, 17, 31, 45, 61, 74, 86, 102}
   399  
   400  	altTags = "xtg-x-cel-gaulishen-GB-oxendicten-x-i-defaultund-x-i-enochiansee-x-i-mingonan-x-zh-minen-US-u-va-posix"
   401  )
   402  
   403  func grandfathered(s [maxAltTaglen]byte) (t Tag, ok bool) {
   404  	if v, ok := grandfatheredMap[s]; ok {
   405  		if v < 0 {
   406  			return Make(altTags[altTagIndex[-v-1]:altTagIndex[-v]]), true
   407  		}
   408  		t.LangID = Language(v)
   409  		return t, true
   410  	}
   411  	return t, false
   412  }
   413
View as plain text