summaryrefslogtreecommitdiffstats
path: root/vendor/golang.org/x/text/language/match.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/golang.org/x/text/language/match.go')
-rw-r--r--vendor/golang.org/x/text/language/match.go722
1 files changed, 308 insertions, 414 deletions
diff --git a/vendor/golang.org/x/text/language/match.go b/vendor/golang.org/x/text/language/match.go
index 8ad95053..8cf116a6 100644
--- a/vendor/golang.org/x/text/language/match.go
+++ b/vendor/golang.org/x/text/language/match.go
@@ -4,7 +4,45 @@
package language
-import "errors"
+import (
+ "errors"
+ "strings"
+
+ "golang.org/x/text/internal/language"
+)
+
+// A MatchOption configures a Matcher.
+type MatchOption func(*matcher)
+
+// PreferSameScript will, in the absence of a match, result in the first
+// preferred tag with the same script as a supported tag to match this supported
+// tag. The default is currently true, but this may change in the future.
+func PreferSameScript(preferSame bool) MatchOption {
+ return func(m *matcher) { m.preferSameScript = preferSame }
+}
+
+// TODO(v1.0.0): consider making Matcher a concrete type, instead of interface.
+// There doesn't seem to be too much need for multiple types.
+// Making it a concrete type allows MatchStrings to be a method, which will
+// improve its discoverability.
+
+// MatchStrings parses and matches the given strings until one of them matches
+// the language in the Matcher. A string may be an Accept-Language header as
+// handled by ParseAcceptLanguage. The default language is returned if no
+// other language matched.
+func MatchStrings(m Matcher, lang ...string) (tag Tag, index int) {
+ for _, accept := range lang {
+ desired, _, err := ParseAcceptLanguage(accept)
+ if err != nil {
+ continue
+ }
+ if tag, index, conf := m.Match(desired...); conf != No {
+ return tag, index
+ }
+ }
+ tag, index, _ = m.Match()
+ return
+}
// Matcher is the interface that wraps the Match method.
//
@@ -36,242 +74,70 @@ func Comprehends(speaker, alternative Tag) Confidence {
// matched tag in t, but is augmented with the Unicode extension ('u')of the
// corresponding preferred tag. This allows user locale options to be passed
// transparently.
-func NewMatcher(t []Tag) Matcher {
- return newMatcher(t)
+func NewMatcher(t []Tag, options ...MatchOption) Matcher {
+ return newMatcher(t, options)
}
func (m *matcher) Match(want ...Tag) (t Tag, index int, c Confidence) {
+ var tt language.Tag
match, w, c := m.getBest(want...)
- if match == nil {
- t = m.default_.tag
+ if match != nil {
+ tt, index = match.tag, match.index
} else {
- t, index = match.tag, match.index
- }
- // Copy options from the user-provided tag into the result tag. This is hard
- // to do after the fact, so we do it here.
- // TODO: consider also adding in variants that are compatible with the
- // matched language.
- // TODO: Add back region if it is non-ambiguous? Or create another tag to
- // preserve the region?
- if u, ok := w.Extension('u'); ok {
- t, _ = Raw.Compose(t, u)
- }
- return t, index, c
-}
-
-type scriptRegionFlags uint8
-
-const (
- isList = 1 << iota
- scriptInFrom
- regionInFrom
-)
-
-func (t *Tag) setUndefinedLang(id langID) {
- if t.lang == 0 {
- t.lang = id
- }
-}
-
-func (t *Tag) setUndefinedScript(id scriptID) {
- if t.script == 0 {
- t.script = id
- }
-}
-
-func (t *Tag) setUndefinedRegion(id regionID) {
- if t.region == 0 || t.region.contains(id) {
- t.region = id
- }
-}
-
-// ErrMissingLikelyTagsData indicates no information was available
-// to compute likely values of missing tags.
-var ErrMissingLikelyTagsData = errors.New("missing likely tags data")
-
-// addLikelySubtags sets subtags to their most likely value, given the locale.
-// In most cases this means setting fields for unknown values, but in some
-// cases it may alter a value. It returns a ErrMissingLikelyTagsData error
-// if the given locale cannot be expanded.
-func (t Tag) addLikelySubtags() (Tag, error) {
- id, err := addTags(t)
- if err != nil {
- return t, err
- } else if id.equalTags(t) {
- return t, nil
- }
- id.remakeString()
- return id, nil
-}
-
-// specializeRegion attempts to specialize a group region.
-func specializeRegion(t *Tag) bool {
- if i := regionInclusion[t.region]; i < nRegionGroups {
- x := likelyRegionGroup[i]
- if langID(x.lang) == t.lang && scriptID(x.script) == t.script {
- t.region = regionID(x.region)
- }
- return true
- }
- return false
-}
-
-func addTags(t Tag) (Tag, error) {
- // We leave private use identifiers alone.
- if t.private() {
- return t, nil
- }
- if t.script != 0 && t.region != 0 {
- if t.lang != 0 {
- // already fully specified
- specializeRegion(&t)
- return t, nil
- }
- // Search matches for und-script-region. Note that for these cases
- // region will never be a group so there is no need to check for this.
- list := likelyRegion[t.region : t.region+1]
- if x := list[0]; x.flags&isList != 0 {
- list = likelyRegionList[x.lang : x.lang+uint16(x.script)]
- }
- for _, x := range list {
- // Deviating from the spec. See match_test.go for details.
- if scriptID(x.script) == t.script {
- t.setUndefinedLang(langID(x.lang))
- return t, nil
- }
- }
- }
- if t.lang != 0 {
- // Search matches for lang-script and lang-region, where lang != und.
- if t.lang < langNoIndexOffset {
- x := likelyLang[t.lang]
- if x.flags&isList != 0 {
- list := likelyLangList[x.region : x.region+uint16(x.script)]
- if t.script != 0 {
- for _, x := range list {
- if scriptID(x.script) == t.script && x.flags&scriptInFrom != 0 {
- t.setUndefinedRegion(regionID(x.region))
- return t, nil
- }
- }
- } else if t.region != 0 {
- count := 0
- goodScript := true
- tt := t
- for _, x := range list {
- // We visit all entries for which the script was not
- // defined, including the ones where the region was not
- // defined. This allows for proper disambiguation within
- // regions.
- if x.flags&scriptInFrom == 0 && t.region.contains(regionID(x.region)) {
- tt.region = regionID(x.region)
- tt.setUndefinedScript(scriptID(x.script))
- goodScript = goodScript && tt.script == scriptID(x.script)
- count++
- }
- }
- if count == 1 {
- return tt, nil
- }
- // Even if we fail to find a unique Region, we might have
- // an unambiguous script.
- if goodScript {
- t.script = tt.script
- }
+ // TODO: this should be an option
+ tt = m.default_.tag
+ if m.preferSameScript {
+ outer:
+ for _, w := range want {
+ script, _ := w.Script()
+ if script.scriptID == 0 {
+ // Don't do anything if there is no script, such as with
+ // private subtags.
+ continue
}
- }
- }
- } else {
- // Search matches for und-script.
- if t.script != 0 {
- x := likelyScript[t.script]
- if x.region != 0 {
- t.setUndefinedRegion(regionID(x.region))
- t.setUndefinedLang(langID(x.lang))
- return t, nil
- }
- }
- // Search matches for und-region. If und-script-region exists, it would
- // have been found earlier.
- if t.region != 0 {
- if i := regionInclusion[t.region]; i < nRegionGroups {
- x := likelyRegionGroup[i]
- if x.region != 0 {
- t.setUndefinedLang(langID(x.lang))
- t.setUndefinedScript(scriptID(x.script))
- t.region = regionID(x.region)
- }
- } else {
- x := likelyRegion[t.region]
- if x.flags&isList != 0 {
- x = likelyRegionList[x.lang]
- }
- if x.script != 0 && x.flags != scriptInFrom {
- t.setUndefinedLang(langID(x.lang))
- t.setUndefinedScript(scriptID(x.script))
- return t, nil
+ for i, h := range m.supported {
+ if script.scriptID == h.maxScript {
+ tt, index = h.tag, i
+ break outer
+ }
}
}
}
+ // TODO: select first language tag based on script.
}
-
- // Search matches for lang.
- if t.lang < langNoIndexOffset {
- x := likelyLang[t.lang]
- if x.flags&isList != 0 {
- x = likelyLangList[x.region]
+ if w.RegionID != tt.RegionID && w.RegionID != 0 {
+ if w.RegionID != 0 && tt.RegionID != 0 && tt.RegionID.Contains(w.RegionID) {
+ tt.RegionID = w.RegionID
+ tt.RemakeString()
+ } else if r := w.RegionID.String(); len(r) == 2 {
+ // TODO: also filter macro and deprecated.
+ tt, _ = tt.SetTypeForKey("rg", strings.ToLower(r)+"zzzz")
}
- if x.region != 0 {
- t.setUndefinedScript(scriptID(x.script))
- t.setUndefinedRegion(regionID(x.region))
- }
- specializeRegion(&t)
- if t.lang == 0 {
- t.lang = _en // default language
+ }
+ // Copy options from the user-provided tag into the result tag. This is hard
+ // to do after the fact, so we do it here.
+ // TODO: add in alternative variants to -u-va-.
+ // TODO: add preferred region to -u-rg-.
+ if e := w.Extensions(); len(e) > 0 {
+ b := language.Builder{}
+ b.SetTag(tt)
+ for _, e := range e {
+ b.AddExt(e)
}
- return t, nil
+ tt = b.Make()
}
- return t, ErrMissingLikelyTagsData
+ return makeTag(tt), index, c
}
-func (t *Tag) setTagsFrom(id Tag) {
- t.lang = id.lang
- t.script = id.script
- t.region = id.region
-}
+// ErrMissingLikelyTagsData indicates no information was available
+// to compute likely values of missing tags.
+var ErrMissingLikelyTagsData = errors.New("missing likely tags data")
-// minimize removes the region or script subtags from t such that
-// t.addLikelySubtags() == t.minimize().addLikelySubtags().
-func (t Tag) minimize() (Tag, error) {
- t, err := minimizeTags(t)
- if err != nil {
- return t, err
- }
- t.remakeString()
- return t, nil
-}
-
-// minimizeTags mimics the behavior of the ICU 51 C implementation.
-func minimizeTags(t Tag) (Tag, error) {
- if t.equalTags(und) {
- return t, nil
- }
- max, err := addTags(t)
- if err != nil {
- return t, err
- }
- for _, id := range [...]Tag{
- {lang: t.lang},
- {lang: t.lang, region: t.region},
- {lang: t.lang, script: t.script},
- } {
- if x, err := addTags(id); err == nil && max.equalTags(x) {
- t.setTagsFrom(id)
- break
- }
- }
- return t, nil
-}
+// func (t *Tag) setTagsFrom(id Tag) {
+// t.LangID = id.LangID
+// t.ScriptID = id.ScriptID
+// t.RegionID = id.RegionID
+// }
// Tag Matching
// CLDR defines an algorithm for finding the best match between two sets of language
@@ -300,8 +166,9 @@ func minimizeTags(t Tag) (Tag, error) {
// 1) compute the match between the two tags.
// 2) if the match is better than the previous best match, replace it
// with the new match. (see next section)
-// b) if the current best match is above a certain threshold, return this
-// match without proceeding to the next tag in "desired". [See Note 1]
+// b) if the current best match is Exact and pin is true the result will be
+// frozen to the language found thusfar, although better matches may
+// still be found for the same language.
// 3) If the best match so far is below a certain threshold, return "default".
//
// Ranking:
@@ -350,9 +217,6 @@ func minimizeTags(t Tag) (Tag, error) {
// found wins.
//
// Notes:
-// [1] Note that even if we may not have a perfect match, if a match is above a
-// certain threshold, it is considered a better match than any other match
-// to a tag later in the list of preferred language tags.
// [2] In practice, as matching of Exact is done in a separate phase from
// matching the other levels, we reuse the Exact level to mean MaxExact in
// the second phase. As a consequence, we only need the levels defined by
@@ -388,22 +252,24 @@ func minimizeTags(t Tag) (Tag, error) {
// matcher keeps a set of supported language tags, indexed by language.
type matcher struct {
- default_ *haveTag
- index map[langID]*matchHeader
- passSettings bool
+ default_ *haveTag
+ supported []*haveTag
+ index map[language.Language]*matchHeader
+ passSettings bool
+ preferSameScript bool
}
// matchHeader has the lists of tags for exact matches and matches based on
// maximized and canonicalized tags for a given language.
type matchHeader struct {
- exact []*haveTag
- max []*haveTag
+ haveTags []*haveTag
+ original bool
}
// haveTag holds a supported Tag and its maximized script and region. The maximized
// or canonicalized language is not stored as it is not needed during matching.
type haveTag struct {
- tag Tag
+ tag language.Tag
// index of this tag in the original list of supported tags.
index int
@@ -413,35 +279,37 @@ type haveTag struct {
conf Confidence
// Maximized region and script.
- maxRegion regionID
- maxScript scriptID
+ maxRegion language.Region
+ maxScript language.Script
// altScript may be checked as an alternative match to maxScript. If altScript
// matches, the confidence level for this match is Low. Theoretically there
// could be multiple alternative scripts. This does not occur in practice.
- altScript scriptID
+ altScript language.Script
// nextMax is the index of the next haveTag with the same maximized tags.
nextMax uint16
}
-func makeHaveTag(tag Tag, index int) (haveTag, langID) {
+func makeHaveTag(tag language.Tag, index int) (haveTag, language.Language) {
max := tag
- if tag.lang != 0 {
- max, _ = max.canonicalize(All)
- max, _ = addTags(max)
- max.remakeString()
+ if tag.LangID != 0 || tag.RegionID != 0 || tag.ScriptID != 0 {
+ max, _ = canonicalize(All, max)
+ max, _ = max.Maximize()
+ max.RemakeString()
}
- return haveTag{tag, index, Exact, max.region, max.script, altScript(max.lang, max.script), 0}, max.lang
+ return haveTag{tag, index, Exact, max.RegionID, max.ScriptID, altScript(max.LangID, max.ScriptID), 0}, max.LangID
}
// altScript returns an alternative script that may match the given script with
// a low confidence. At the moment, the langMatch data allows for at most one
// script to map to another and we rely on this to keep the code simple.
-func altScript(l langID, s scriptID) scriptID {
+func altScript(l language.Language, s language.Script) language.Script {
for _, alt := range matchScript {
- if (alt.lang == 0 || langID(alt.lang) == l) && scriptID(alt.have) == s {
- return scriptID(alt.want)
+ // TODO: also match cases where language is not the same.
+ if (language.Language(alt.wantLang) == l || language.Language(alt.haveLang) == l) &&
+ language.Script(alt.haveScript) == s {
+ return language.Script(alt.wantScript)
}
}
return 0
@@ -450,34 +318,32 @@ func altScript(l langID, s scriptID) scriptID {
// addIfNew adds a haveTag to the list of tags only if it is a unique tag.
// Tags that have the same maximized values are linked by index.
func (h *matchHeader) addIfNew(n haveTag, exact bool) {
+ h.original = h.original || exact
// Don't add new exact matches.
- for _, v := range h.exact {
- if v.tag.equalsRest(n.tag) {
+ for _, v := range h.haveTags {
+ if equalsRest(v.tag, n.tag) {
return
}
}
- if exact {
- h.exact = append(h.exact, &n)
- }
// Allow duplicate maximized tags, but create a linked list to allow quickly
// comparing the equivalents and bail out.
- for i, v := range h.max {
+ for i, v := range h.haveTags {
if v.maxScript == n.maxScript &&
v.maxRegion == n.maxRegion &&
- v.tag.variantOrPrivateTagStr() == n.tag.variantOrPrivateTagStr() {
- for h.max[i].nextMax != 0 {
- i = int(h.max[i].nextMax)
+ v.tag.VariantOrPrivateUseTags() == n.tag.VariantOrPrivateUseTags() {
+ for h.haveTags[i].nextMax != 0 {
+ i = int(h.haveTags[i].nextMax)
}
- h.max[i].nextMax = uint16(len(h.max))
+ h.haveTags[i].nextMax = uint16(len(h.haveTags))
break
}
}
- h.max = append(h.max, &n)
+ h.haveTags = append(h.haveTags, &n)
}
// header returns the matchHeader for the given language. It creates one if
// it doesn't already exist.
-func (m *matcher) header(l langID) *matchHeader {
+func (m *matcher) header(l language.Language) *matchHeader {
if h := m.index[l]; h != nil {
return h
}
@@ -486,12 +352,26 @@ func (m *matcher) header(l langID) *matchHeader {
return h
}
+func toConf(d uint8) Confidence {
+ if d <= 10 {
+ return High
+ }
+ if d < 30 {
+ return Low
+ }
+ return No
+}
+
// newMatcher builds an index for the given supported tags and returns it as
// a matcher. It also expands the index by considering various equivalence classes
// for a given tag.
-func newMatcher(supported []Tag) *matcher {
+func newMatcher(supported []Tag, options []MatchOption) *matcher {
m := &matcher{
- index: make(map[langID]*matchHeader),
+ index: make(map[language.Language]*matchHeader),
+ preferSameScript: true,
+ }
+ for _, o := range options {
+ o(m)
}
if len(supported) == 0 {
m.default_ = &haveTag{}
@@ -500,36 +380,41 @@ func newMatcher(supported []Tag) *matcher {
// Add supported languages to the index. Add exact matches first to give
// them precedence.
for i, tag := range supported {
- pair, _ := makeHaveTag(tag, i)
- m.header(tag.lang).addIfNew(pair, true)
- }
- m.default_ = m.header(supported[0].lang).exact[0]
+ tt := tag.tag()
+ pair, _ := makeHaveTag(tt, i)
+ m.header(tt.LangID).addIfNew(pair, true)
+ m.supported = append(m.supported, &pair)
+ }
+ m.default_ = m.header(supported[0].lang()).haveTags[0]
+ // Keep these in two different loops to support the case that two equivalent
+ // languages are distinguished, such as iw and he.
for i, tag := range supported {
- pair, max := makeHaveTag(tag, i)
- if max != tag.lang {
- m.header(max).addIfNew(pair, false)
+ tt := tag.tag()
+ pair, max := makeHaveTag(tt, i)
+ if max != tt.LangID {
+ m.header(max).addIfNew(pair, true)
}
}
// update is used to add indexes in the map for equivalent languages.
- // If force is true, the update will also apply to derived entries. To
- // avoid applying a "transitive closure", use false.
- update := func(want, have uint16, conf Confidence, force bool) {
- if hh := m.index[langID(have)]; hh != nil {
- if !force && len(hh.exact) == 0 {
+ // update will only add entries to original indexes, thus not computing any
+ // transitive relations.
+ update := func(want, have uint16, conf Confidence) {
+ if hh := m.index[language.Language(have)]; hh != nil {
+ if !hh.original {
return
}
- hw := m.header(langID(want))
- for _, ht := range hh.max {
+ hw := m.header(language.Language(want))
+ for _, ht := range hh.haveTags {
v := *ht
if conf < v.conf {
v.conf = conf
}
v.nextMax = 0 // this value needs to be recomputed
if v.altScript != 0 {
- v.altScript = altScript(langID(want), v.maxScript)
+ v.altScript = altScript(language.Language(want), v.maxScript)
}
- hw.addIfNew(v, conf == Exact && len(hh.exact) > 0)
+ hw.addIfNew(v, conf == Exact && hh.original)
}
}
}
@@ -537,9 +422,9 @@ func newMatcher(supported []Tag) *matcher {
// Add entries for languages with mutual intelligibility as defined by CLDR's
// languageMatch data.
for _, ml := range matchLang {
- update(ml.want, ml.have, Confidence(ml.conf), false)
+ update(ml.want, ml.have, toConf(ml.distance))
if !ml.oneway {
- update(ml.have, ml.want, Confidence(ml.conf), false)
+ update(ml.have, ml.want, toConf(ml.distance))
}
}
@@ -548,126 +433,157 @@ func newMatcher(supported []Tag) *matcher {
// First we match deprecated equivalents. If they are perfect equivalents
// (their canonicalization simply substitutes a different language code, but
// nothing else), the match confidence is Exact, otherwise it is High.
- for i, lm := range langAliasMap {
- if lm.from == _sh {
- continue
- }
-
+ for i, lm := range language.AliasMap {
// If deprecated codes match and there is no fiddling with the script or
// or region, we consider it an exact match.
conf := Exact
- if langAliasTypes[i] != langMacro {
- if !isExactEquivalent(langID(lm.from)) {
+ if language.AliasTypes[i] != language.Macro {
+ if !isExactEquivalent(language.Language(lm.From)) {
conf = High
}
- update(lm.to, lm.from, conf, true)
+ update(lm.To, lm.From, conf)
}
- update(lm.from, lm.to, conf, true)
+ update(lm.From, lm.To, conf)
}
return m
}
// getBest gets the best matching tag in m for any of the given tags, taking into
// account the order of preference of the given tags.
-func (m *matcher) getBest(want ...Tag) (got *haveTag, orig Tag, c Confidence) {
+func (m *matcher) getBest(want ...Tag) (got *haveTag, orig language.Tag, c Confidence) {
best := bestMatch{}
- for _, w := range want {
- var max Tag
+ for i, ww := range want {
+ w := ww.tag()
+ var max language.Tag
// Check for exact match first.
- h := m.index[w.lang]
- if w.lang != 0 {
- // Base language is defined.
+ h := m.index[w.LangID]
+ if w.LangID != 0 {
if h == nil {
continue
}
- for i := range h.exact {
- have := h.exact[i]
- if have.tag.equalsRest(w) {
- return have, w, Exact
- }
+ // Base language is defined.
+ max, _ = canonicalize(Legacy|Deprecated|Macro, w)
+ // A region that is added through canonicalization is stronger than
+ // a maximized region: set it in the original (e.g. mo -> ro-MD).
+ if w.RegionID != max.RegionID {
+ w.RegionID = max.RegionID
}
- max, _ = w.canonicalize(Legacy | Deprecated)
- max, _ = addTags(max)
+ // TODO: should we do the same for scripts?
+ // See test case: en, sr, nl ; sh ; sr
+ max, _ = max.Maximize()
} else {
// Base language is not defined.
if h != nil {
- for i := range h.exact {
- have := h.exact[i]
- if have.tag.equalsRest(w) {
+ for i := range h.haveTags {
+ have := h.haveTags[i]
+ if equalsRest(have.tag, w) {
return have, w, Exact
}
}
}
- if w.script == 0 && w.region == 0 {
+ if w.ScriptID == 0 && w.RegionID == 0 {
// We skip all tags matching und for approximate matching, including
// private tags.
continue
}
- max, _ = addTags(w)
- if h = m.index[max.lang]; h == nil {
+ max, _ = w.Maximize()
+ if h = m.index[max.LangID]; h == nil {
continue
}
}
+ pin := true
+ for _, t := range want[i+1:] {
+ if w.LangID == t.lang() {
+ pin = false
+ break
+ }
+ }
// Check for match based on maximized tag.
- for i := range h.max {
- have := h.max[i]
- best.update(have, w, max.script, max.region)
+ for i := range h.haveTags {
+ have := h.haveTags[i]
+ best.update(have, w, max.ScriptID, max.RegionID, pin)
if best.conf == Exact {
for have.nextMax != 0 {
- have = h.max[have.nextMax]
- best.update(have, w, max.script, max.region)
+ have = h.haveTags[have.nextMax]
+ best.update(have, w, max.ScriptID, max.RegionID, pin)
}
- return best.have, best.want, High
+ return best.have, best.want, best.conf
}
}
}
if best.conf <= No {
if len(want) != 0 {
- return nil, want[0], No
+ return nil, want[0].tag(), No
}
- return nil, Tag{}, No
+ return nil, language.Tag{}, No
}
return best.have, best.want, best.conf
}
// bestMatch accumulates the best match so far.
type bestMatch struct {
- have *haveTag
- want Tag
- conf Confidence
+ have *haveTag
+ want language.Tag
+ conf Confidence
+ pinnedRegion language.Region
+ pinLanguage bool
+ sameRegionGroup bool
// Cached results from applying tie-breaking rules.
- origLang bool
- origReg bool
- regDist uint8
- origScript bool
- parentDist uint8 // 255 if have is not an ancestor of want tag.
+ origLang bool
+ origReg bool
+ paradigmReg bool
+ regGroupDist uint8
+ origScript bool
}
// update updates the existing best match if the new pair is considered to be a
-// better match.
-// To determine if the given pair is a better match, it first computes the rough
-// confidence level. If this surpasses the current match, it will replace it and
-// update the tie-breaker rule cache. If there is a tie, it proceeds with applying
-// a series of tie-breaker rules. If there is no conclusive winner after applying
-// the tie-breaker rules, it leaves the current match as the preferred match.
-func (m *bestMatch) update(have *haveTag, tag Tag, maxScript scriptID, maxRegion regionID) {
+// better match. To determine if the given pair is a better match, it first
+// computes the rough confidence level. If this surpasses the current match, it
+// will replace it and update the tie-breaker rule cache. If there is a tie, it
+// proceeds with applying a series of tie-breaker rules. If there is no
+// conclusive winner after applying the tie-breaker rules, it leaves the current
+// match as the preferred match.
+//
+// If pin is true and have and tag are a strong match, it will henceforth only
+// consider matches for this language. This corresponds to the nothing that most
+// users have a strong preference for the first defined language. A user can
+// still prefer a second language over a dialect of the preferred language by
+// explicitly specifying dialects, e.g. "en, nl, en-GB". In this case pin should
+// be false.
+func (m *bestMatch) update(have *haveTag, tag language.Tag, maxScript language.Script, maxRegion language.Region, pin bool) {
// Bail if the maximum attainable confidence is below that of the current best match.
c := have.conf
if c < m.conf {
return
}
- if have.maxScript != maxScript {
+ // Don't change the language once we already have found an exact match.
+ if m.pinLanguage && tag.LangID != m.want.LangID {
+ return
+ }
+ // Pin the region group if we are comparing tags for the same language.
+ if tag.LangID == m.want.LangID && m.sameRegionGroup {
+ _, sameGroup := regionGroupDist(m.pinnedRegion, have.maxRegion, have.maxScript, m.want.LangID)
+ if !sameGroup {
+ return
+ }
+ }
+ if c == Exact && have.maxScript == maxScript {
+ // If there is another language and then another entry of this language,
+ // don't pin anything, otherwise pin the language.
+ m.pinLanguage = pin
+ }
+ if equalsRest(have.tag, tag) {
+ } else if have.maxScript != maxScript {
// There is usually very little comprehension between different scripts.
- // In a few cases there may still be Low comprehension. This possibility is
- // pre-computed and stored in have.altScript.
+ // In a few cases there may still be Low comprehension. This possibility
+ // is pre-computed and stored in have.altScript.
if Low < m.conf || have.altScript != maxScript {
return
}
c = Low
} else if have.maxRegion != maxRegion {
- // There is usually a small difference between languages across regions.
- // We use the region distance (below) to disambiguate between equal matches.
if High < c {
+ // There is usually a small difference between languages across regions.
c = High
}
}
@@ -686,7 +602,7 @@ func (m *bestMatch) update(have *haveTag, tag Tag, maxScript scriptID, maxRegion
// Tie-breaker rules:
// We prefer if the pre-maximized language was specified and identical.
- origLang := have.tag.lang == tag.lang && tag.lang != 0
+ origLang := have.tag.LangID == tag.LangID && tag.LangID != 0
if !beaten && m.origLang != origLang {
if m.origLang {
return
@@ -695,7 +611,7 @@ func (m *bestMatch) update(have *haveTag, tag Tag, maxScript scriptID, maxRegion
}
// We prefer if the pre-maximized region was specified and identical.
- origReg := have.tag.region == tag.region && tag.region != 0
+ origReg := have.tag.RegionID == tag.RegionID && tag.RegionID != 0
if !beaten && m.origReg != origReg {
if m.origReg {
return
@@ -703,28 +619,26 @@ func (m *bestMatch) update(have *haveTag, tag Tag, maxScript scriptID, maxRegion
beaten = true
}
- // Next we prefer smaller distances between regions, as defined by regionDist.
- regDist := regionDist(have.maxRegion, maxRegion, tag.lang)
- if !beaten && m.regDist != regDist {
- if regDist > m.regDist {
+ regGroupDist, sameGroup := regionGroupDist(have.maxRegion, maxRegion, maxScript, tag.LangID)
+ if !beaten && m.regGroupDist != regGroupDist {
+ if regGroupDist > m.regGroupDist {
return
}
beaten = true
}
- // Next we prefer if the pre-maximized script was specified and identical.
- origScript := have.tag.script == tag.script && tag.script != 0
- if !beaten && m.origScript != origScript {
- if m.origScript {
+ paradigmReg := isParadigmLocale(tag.LangID, have.maxRegion)
+ if !beaten && m.paradigmReg != paradigmReg {
+ if !paradigmReg {
return
}
beaten = true
}
- // Finally we prefer tags which have a closer parent relationship.
- parentDist := parentDistance(have.tag.region, tag)
- if !beaten && m.parentDist != parentDist {
- if parentDist > m.parentDist {
+ // Next we prefer if the pre-maximized script was specified and identical.
+ origScript := have.tag.ScriptID == tag.ScriptID && tag.ScriptID != 0
+ if !beaten && m.origScript != origScript {
+ if m.origScript {
return
}
beaten = true
@@ -735,90 +649,59 @@ func (m *bestMatch) update(have *haveTag, tag Tag, maxScript scriptID, maxRegion
m.have = have
m.want = tag
m.conf = c
+ m.pinnedRegion = maxRegion
+ m.sameRegionGroup = sameGroup
m.origLang = origLang
m.origReg = origReg
+ m.paradigmReg = paradigmReg
m.origScript = origScript
- m.regDist = regDist
- m.parentDist = parentDist
+ m.regGroupDist = regGroupDist
}
}
-// parentDistance returns the number of times Parent must be called before the
-// regions match. It is assumed that it has already been checked that lang and
-// script are identical. If haveRegion does not occur in the ancestor chain of
-// tag, it returns 255.
-func parentDistance(haveRegion regionID, tag Tag) uint8 {
- p := tag.Parent()
- d := uint8(1)
- for haveRegion != p.region {
- if p.region == 0 {
- return 255
+func isParadigmLocale(lang language.Language, r language.Region) bool {
+ for _, e := range paradigmLocales {
+ if language.Language(e[0]) == lang && (r == language.Region(e[1]) || r == language.Region(e[2])) {
+ return true
}
- p = p.Parent()
- d++
- }
- return d
-}
-
-// regionDist wraps regionDistance with some exceptions to the algorithmic distance.
-func regionDist(a, b regionID, lang langID) uint8 {
- if lang == _en {
- // Two variants of non-US English are close to each other, regardless of distance.
- if a != _US && b != _US {
- return 2
- }
- }
- return uint8(regionDistance(a, b))
-}
-
-// regionDistance computes the distance between two regions based on the
-// distance in the graph of region containments as defined in CLDR. It iterates
-// over increasingly inclusive sets of groups, represented as bit vectors, until
-// the source bit vector has bits in common with the destination vector.
-func regionDistance(a, b regionID) int {
- if a == b {
- return 0
- }
- p, q := regionInclusion[a], regionInclusion[b]
- if p < nRegionGroups {
- p, q = q, p
- }
- set := regionInclusionBits
- if q < nRegionGroups && set[p]&(1<<q) != 0 {
- return 1
- }
- d := 2
- for goal := set[q]; set[p]&goal == 0; p = regionInclusionNext[p] {
- d++
}
- return d
+ return false
}
-func (t Tag) variants() string {
- if t.pVariant == 0 {
- return ""
- }
- return t.str[t.pVariant:t.pExt]
-}
+// regionGroupDist computes the distance between two regions based on their
+// CLDR grouping.
+func regionGroupDist(a, b language.Region, script language.Script, lang language.Language) (dist uint8, same bool) {
+ const defaultDistance = 4
-// variantOrPrivateTagStr returns variants or private use tags.
-func (t Tag) variantOrPrivateTagStr() string {
- if t.pExt > 0 {
- return t.str[t.pVariant:t.pExt]
+ aGroup := uint(regionToGroups[a]) << 1
+ bGroup := uint(regionToGroups[b]) << 1
+ for _, ri := range matchRegion {
+ if language.Language(ri.lang) == lang && (ri.script == 0 || language.Script(ri.script) == script) {
+ group := uint(1 << (ri.group &^ 0x80))
+ if 0x80&ri.group == 0 {
+ if aGroup&bGroup&group != 0 { // Both regions are in the group.
+ return ri.distance, ri.distance == defaultDistance
+ }
+ } else {
+ if (aGroup|bGroup)&group == 0 { // Both regions are not in the group.
+ return ri.distance, ri.distance == defaultDistance
+ }
+ }
+ }
}
- return t.str[t.pVariant:]
+ return defaultDistance, true
}
// equalsRest compares everything except the language.
-func (a Tag) equalsRest(b Tag) bool {
+func equalsRest(a, b language.Tag) bool {
// TODO: don't include extensions in this comparison. To do this efficiently,
// though, we should handle private tags separately.
- return a.script == b.script && a.region == b.region && a.variantOrPrivateTagStr() == b.variantOrPrivateTagStr()
+ return a.ScriptID == b.ScriptID && a.RegionID == b.RegionID && a.VariantOrPrivateUseTags() == b.VariantOrPrivateUseTags()
}
// isExactEquivalent returns true if canonicalizing the language will not alter
// the script or region of a tag.
-func isExactEquivalent(l langID) bool {
+func isExactEquivalent(l language.Language) bool {
for _, o := range notEquivalent {
if o == l {
return false
@@ -827,15 +710,26 @@ func isExactEquivalent(l langID) bool {
return true
}
-var notEquivalent []langID
+var notEquivalent []language.Language
func init() {
// Create a list of all languages for which canonicalization may alter the
// script or region.
- for _, lm := range langAliasMap {
- tag := Tag{lang: langID(lm.from)}
- if tag, _ = tag.canonicalize(All); tag.script != 0 || tag.region != 0 {
- notEquivalent = append(notEquivalent, langID(lm.from))
+ for _, lm := range language.AliasMap {
+ tag := language.Tag{LangID: language.Language(lm.From)}
+ if tag, _ = canonicalize(All, tag); tag.ScriptID != 0 || tag.RegionID != 0 {
+ notEquivalent = append(notEquivalent, language.Language(lm.From))
+ }
+ }
+ // Maximize undefined regions of paradigm locales.
+ for i, v := range paradigmLocales {
+ t := language.Tag{LangID: language.Language(v[0])}
+ max, _ := t.Maximize()
+ if v[1] == 0 {
+ paradigmLocales[i][1] = uint16(max.RegionID)
+ }
+ if v[2] == 0 {
+ paradigmLocales[i][2] = uint16(max.RegionID)
}
}
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-05 15:37:40 +0000