| // Copyright 2014 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. | |
| //go:generate go run maketables.go -output tables.go | |
| // Package display provides display names for languages, scripts and regions in | |
| // a requested language. | |
| // | |
| // The data is based on CLDR's localeDisplayNames. It includes the names of the | |
| // draft level "contributed" or "approved". The resulting tables are quite | |
| // large. The display package is designed so that users can reduce the linked-in | |
| // table sizes by cherry picking the languages one wishes to support. There is a | |
| // Dictionary defined for a selected set of common languages for this purpose. | |
| package display // import "golang.org/x/text/language/display" | |
| import ( | |
| "fmt" | |
| "strings" | |
| "golang.org/x/text/internal/format" | |
| "golang.org/x/text/language" | |
| ) | |
| /* | |
| TODO: | |
| All fairly low priority at the moment: | |
| - Include alternative and variants as an option (using func options). | |
| - Option for returning the empty string for undefined values. | |
| - Support variants, currencies, time zones, option names and other data | |
| provided in CLDR. | |
| - Do various optimizations: | |
| - Reduce size of offset tables. | |
| - Consider compressing infrequently used languages and decompress on demand. | |
| */ | |
| // A Formatter formats a tag in the current language. It is used in conjunction | |
| // with the message package. | |
| type Formatter struct { | |
| lookup func(tag int, x interface{}) string | |
| x interface{} | |
| } | |
| // Format implements "golang.org/x/text/internal/format".Formatter. | |
| func (f Formatter) Format(state format.State, verb rune) { | |
| // TODO: there are a lot of inefficiencies in this code. Fix it when we | |
| // language.Tag has embedded compact tags. | |
| t := state.Language() | |
| _, index, _ := matcher.Match(t) | |
| str := f.lookup(index, f.x) | |
| if str == "" { | |
| // TODO: use language-specific punctuation. | |
| // TODO: use codePattern instead of language? | |
| if unknown := f.lookup(index, language.Und); unknown != "" { | |
| fmt.Fprintf(state, "%v (%v)", unknown, f.x) | |
| } else { | |
| fmt.Fprintf(state, "[language: %v]", f.x) | |
| } | |
| } else { | |
| state.Write([]byte(str)) | |
| } | |
| } | |
| // Language returns a Formatter that renders the name for lang in the | |
| // the current language. x may be a language.Base or a language.Tag. | |
| // It renders lang in the default language if no translation for the current | |
| // language is supported. | |
| func Language(lang interface{}) Formatter { | |
| return Formatter{langFunc, lang} | |
| } | |
| // Region returns a Formatter that renders the name for region in the current | |
| // language. region may be a language.Region or a language.Tag. | |
| // It renders region in the default language if no translation for the current | |
| // language is supported. | |
| func Region(region interface{}) Formatter { | |
| return Formatter{regionFunc, region} | |
| } | |
| // Script returns a Formatter that renders the name for script in the current | |
| // language. script may be a language.Script or a language.Tag. | |
| // It renders script in the default language if no translation for the current | |
| // language is supported. | |
| func Script(script interface{}) Formatter { | |
| return Formatter{scriptFunc, script} | |
| } | |
| // Script returns a Formatter that renders the name for tag in the current | |
| // language. tag may be a language.Tag. | |
| // It renders tag in the default language if no translation for the current | |
| // language is supported. | |
| func Tag(tag interface{}) Formatter { | |
| return Formatter{tagFunc, tag} | |
| } | |
| // A Namer is used to get the name for a given value, such as a Tag, Language, | |
| // Script or Region. | |
| type Namer interface { | |
| // Name returns a display string for the given value. A Namer returns an | |
| // empty string for values it does not support. A Namer may support naming | |
| // an unspecified value. For example, when getting the name for a region for | |
| // a tag that does not have a defined Region, it may return the name for an | |
| // unknown region. It is up to the user to filter calls to Name for values | |
| // for which one does not want to have a name string. | |
| Name(x interface{}) string | |
| } | |
| var ( | |
| // Supported lists the languages for which names are defined. | |
| Supported language.Coverage | |
| // The set of all possible values for which names are defined. Note that not | |
| // all Namer implementations will cover all the values of a given type. | |
| // A Namer will return the empty string for unsupported values. | |
| Values language.Coverage | |
| matcher language.Matcher | |
| ) | |
| func init() { | |
| tags := make([]language.Tag, numSupported) | |
| s := supported | |
| for i := range tags { | |
| p := strings.IndexByte(s, '|') | |
| tags[i] = language.Raw.Make(s[:p]) | |
| s = s[p+1:] | |
| } | |
| matcher = language.NewMatcher(tags) | |
| Supported = language.NewCoverage(tags) | |
| Values = language.NewCoverage(langTagSet.Tags, supportedScripts, supportedRegions) | |
| } | |
| // Languages returns a Namer for naming languages. It returns nil if there is no | |
| // data for the given tag. The type passed to Name must be either language.Base | |
| // or language.Tag. Note that the result may differ between passing a tag or its | |
| // base language. For example, for English, passing "nl-BE" would return Flemish | |
| // whereas passing "nl" returns "Dutch". | |
| func Languages(t language.Tag) Namer { | |
| if _, index, conf := matcher.Match(t); conf != language.No { | |
| return languageNamer(index) | |
| } | |
| return nil | |
| } | |
| type languageNamer int | |
| func langFunc(i int, x interface{}) string { | |
| return nameLanguage(languageNamer(i), x) | |
| } | |
| func (n languageNamer) name(i int) string { | |
| return lookup(langHeaders[:], int(n), i) | |
| } | |
| // Name implements the Namer interface for language names. | |
| func (n languageNamer) Name(x interface{}) string { | |
| return nameLanguage(n, x) | |
| } | |
| // nonEmptyIndex walks up the parent chain until a non-empty header is found. | |
| // It returns -1 if no index could be found. | |
| func nonEmptyIndex(h []header, index int) int { | |
| for ; index != -1 && h[index].data == ""; index = int(parents[index]) { | |
| } | |
| return index | |
| } | |
| // Scripts returns a Namer for naming scripts. It returns nil if there is no | |
| // data for the given tag. The type passed to Name must be either a | |
| // language.Script or a language.Tag. It will not attempt to infer a script for | |
| // tags with an unspecified script. | |
| func Scripts(t language.Tag) Namer { | |
| if _, index, conf := matcher.Match(t); conf != language.No { | |
| if index = nonEmptyIndex(scriptHeaders[:], index); index != -1 { | |
| return scriptNamer(index) | |
| } | |
| } | |
| return nil | |
| } | |
| type scriptNamer int | |
| func scriptFunc(i int, x interface{}) string { | |
| return nameScript(scriptNamer(i), x) | |
| } | |
| func (n scriptNamer) name(i int) string { | |
| return lookup(scriptHeaders[:], int(n), i) | |
| } | |
| // Name implements the Namer interface for script names. | |
| func (n scriptNamer) Name(x interface{}) string { | |
| return nameScript(n, x) | |
| } | |
| // Regions returns a Namer for naming regions. It returns nil if there is no | |
| // data for the given tag. The type passed to Name must be either a | |
| // language.Region or a language.Tag. It will not attempt to infer a region for | |
| // tags with an unspecified region. | |
| func Regions(t language.Tag) Namer { | |
| if _, index, conf := matcher.Match(t); conf != language.No { | |
| if index = nonEmptyIndex(regionHeaders[:], index); index != -1 { | |
| return regionNamer(index) | |
| } | |
| } | |
| return nil | |
| } | |
| type regionNamer int | |
| func regionFunc(i int, x interface{}) string { | |
| return nameRegion(regionNamer(i), x) | |
| } | |
| func (n regionNamer) name(i int) string { | |
| return lookup(regionHeaders[:], int(n), i) | |
| } | |
| // Name implements the Namer interface for region names. | |
| func (n regionNamer) Name(x interface{}) string { | |
| return nameRegion(n, x) | |
| } | |
| // Tags returns a Namer for giving a full description of a tag. The names of | |
| // scripts and regions that are not already implied by the language name will | |
| // in appended within parentheses. It returns nil if there is not data for the | |
| // given tag. The type passed to Name must be a tag. | |
| func Tags(t language.Tag) Namer { | |
| if _, index, conf := matcher.Match(t); conf != language.No { | |
| return tagNamer(index) | |
| } | |
| return nil | |
| } | |
| type tagNamer int | |
| func tagFunc(i int, x interface{}) string { | |
| return nameTag(languageNamer(i), scriptNamer(i), regionNamer(i), x) | |
| } | |
| // Name implements the Namer interface for tag names. | |
| func (n tagNamer) Name(x interface{}) string { | |
| return nameTag(languageNamer(n), scriptNamer(n), regionNamer(n), x) | |
| } | |
| // lookup finds the name for an entry in a global table, traversing the | |
| // inheritance hierarchy if needed. | |
| func lookup(table []header, dict, want int) string { | |
| for dict != -1 { | |
| if s := table[dict].name(want); s != "" { | |
| return s | |
| } | |
| dict = int(parents[dict]) | |
| } | |
| return "" | |
| } | |
| // A Dictionary holds a collection of Namers for a single language. One can | |
| // reduce the amount of data linked in to a binary by only referencing | |
| // Dictionaries for the languages one needs to support instead of using the | |
| // generic Namer factories. | |
| type Dictionary struct { | |
| parent *Dictionary | |
| lang header | |
| script header | |
| region header | |
| } | |
| // Tags returns a Namer for giving a full description of a tag. The names of | |
| // scripts and regions that are not already implied by the language name will | |
| // in appended within parentheses. It returns nil if there is not data for the | |
| // given tag. The type passed to Name must be a tag. | |
| func (d *Dictionary) Tags() Namer { | |
| return dictTags{d} | |
| } | |
| type dictTags struct { | |
| d *Dictionary | |
| } | |
| // Name implements the Namer interface for tag names. | |
| func (n dictTags) Name(x interface{}) string { | |
| return nameTag(dictLanguages{n.d}, dictScripts{n.d}, dictRegions{n.d}, x) | |
| } | |
| // Languages returns a Namer for naming languages. It returns nil if there is no | |
| // data for the given tag. The type passed to Name must be either language.Base | |
| // or language.Tag. Note that the result may differ between passing a tag or its | |
| // base language. For example, for English, passing "nl-BE" would return Flemish | |
| // whereas passing "nl" returns "Dutch". | |
| func (d *Dictionary) Languages() Namer { | |
| return dictLanguages{d} | |
| } | |
| type dictLanguages struct { | |
| d *Dictionary | |
| } | |
| func (n dictLanguages) name(i int) string { | |
| for d := n.d; d != nil; d = d.parent { | |
| if s := d.lang.name(i); s != "" { | |
| return s | |
| } | |
| } | |
| return "" | |
| } | |
| // Name implements the Namer interface for language names. | |
| func (n dictLanguages) Name(x interface{}) string { | |
| return nameLanguage(n, x) | |
| } | |
| // Scripts returns a Namer for naming scripts. It returns nil if there is no | |
| // data for the given tag. The type passed to Name must be either a | |
| // language.Script or a language.Tag. It will not attempt to infer a script for | |
| // tags with an unspecified script. | |
| func (d *Dictionary) Scripts() Namer { | |
| return dictScripts{d} | |
| } | |
| type dictScripts struct { | |
| d *Dictionary | |
| } | |
| func (n dictScripts) name(i int) string { | |
| for d := n.d; d != nil; d = d.parent { | |
| if s := d.script.name(i); s != "" { | |
| return s | |
| } | |
| } | |
| return "" | |
| } | |
| // Name implements the Namer interface for script names. | |
| func (n dictScripts) Name(x interface{}) string { | |
| return nameScript(n, x) | |
| } | |
| // Regions returns a Namer for naming regions. It returns nil if there is no | |
| // data for the given tag. The type passed to Name must be either a | |
| // language.Region or a language.Tag. It will not attempt to infer a region for | |
| // tags with an unspecified region. | |
| func (d *Dictionary) Regions() Namer { | |
| return dictRegions{d} | |
| } | |
| type dictRegions struct { | |
| d *Dictionary | |
| } | |
| func (n dictRegions) name(i int) string { | |
| for d := n.d; d != nil; d = d.parent { | |
| if s := d.region.name(i); s != "" { | |
| return s | |
| } | |
| } | |
| return "" | |
| } | |
| // Name implements the Namer interface for region names. | |
| func (n dictRegions) Name(x interface{}) string { | |
| return nameRegion(n, x) | |
| } | |
| // A SelfNamer implements a Namer that returns the name of language in this same | |
| // language. It provides a very compact mechanism to provide a comprehensive | |
| // list of languages to users in their native language. | |
| type SelfNamer struct { | |
| // Supported defines the values supported by this Namer. | |
| Supported language.Coverage | |
| } | |
| var ( | |
| // Self is a shared instance of a SelfNamer. | |
| Self *SelfNamer = &self | |
| self = SelfNamer{language.NewCoverage(selfTagSet.Tags)} | |
| ) | |
| // Name returns the name of a given language tag in the language identified by | |
| // this tag. It supports both the language.Base and language.Tag types. | |
| func (n SelfNamer) Name(x interface{}) string { | |
| t, _ := language.All.Compose(x) | |
| base, scr, reg := t.Raw() | |
| baseScript := language.Script{} | |
| if (scr == language.Script{} && reg != language.Region{}) { | |
| // For looking up in the self dictionary, we need to select the | |
| // maximized script. This is even the case if the script isn't | |
| // specified. | |
| s1, _ := t.Script() | |
| if baseScript = getScript(base); baseScript != s1 { | |
| scr = s1 | |
| } | |
| } | |
| i, scr, reg := selfTagSet.index(base, scr, reg) | |
| if i == -1 { | |
| return "" | |
| } | |
| // Only return the display name if the script matches the expected script. | |
| if (scr != language.Script{}) { | |
| if (baseScript == language.Script{}) { | |
| baseScript = getScript(base) | |
| } | |
| if baseScript != scr { | |
| return "" | |
| } | |
| } | |
| return selfHeaders[0].name(i) | |
| } | |
| // getScript returns the maximized script for a base language. | |
| func getScript(b language.Base) language.Script { | |
| tag, _ := language.Raw.Compose(b) | |
| scr, _ := tag.Script() | |
| return scr | |
| } |