Update vendor

vendor/golang.org/x/text/language/display/dict.go

@@ -0,0 +1,92 @@
+// 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.
+
+package display
+
+// This file contains sets of data for specific languages. Users can use these
+// to create smaller collections of supported languages and reduce total table
+// size.
+
+// The variable names defined here correspond to those in package language.
+
+var (
+	Afrikaans            *Dictionary = &af        // af
+	Amharic              *Dictionary = &am        // am
+	Arabic               *Dictionary = &ar        // ar
+	ModernStandardArabic *Dictionary = Arabic     // ar-001
+	Azerbaijani          *Dictionary = &az        // az
+	Bulgarian            *Dictionary = &bg        // bg
+	Bengali              *Dictionary = &bn        // bn
+	Catalan              *Dictionary = &ca        // ca
+	Czech                *Dictionary = &cs        // cs
+	Danish               *Dictionary = &da        // da
+	German               *Dictionary = &de        // de
+	Greek                *Dictionary = &el        // el
+	English              *Dictionary = &en        // en
+	AmericanEnglish      *Dictionary = English    // en-US
+	BritishEnglish       *Dictionary = English    // en-GB
+	Spanish              *Dictionary = &es        // es
+	EuropeanSpanish      *Dictionary = Spanish    // es-ES
+	LatinAmericanSpanish *Dictionary = Spanish    // es-419
+	Estonian             *Dictionary = &et        // et
+	Persian              *Dictionary = &fa        // fa
+	Finnish              *Dictionary = &fi        // fi
+	Filipino             *Dictionary = &fil       // fil
+	French               *Dictionary = &fr        // fr
+	Gujarati             *Dictionary = &gu        // gu
+	Hebrew               *Dictionary = &he        // he
+	Hindi                *Dictionary = &hi        // hi
+	Croatian             *Dictionary = &hr        // hr
+	Hungarian            *Dictionary = &hu        // hu
+	Armenian             *Dictionary = &hy        // hy
+	Indonesian           *Dictionary = &id        // id
+	Icelandic            *Dictionary = &is        // is
+	Italian              *Dictionary = &it        // it
+	Japanese             *Dictionary = &ja        // ja
+	Georgian             *Dictionary = &ka        // ka
+	Kazakh               *Dictionary = &kk        // kk
+	Khmer                *Dictionary = &km        // km
+	Kannada              *Dictionary = &kn        // kn
+	Korean               *Dictionary = &ko        // ko
+	Kirghiz              *Dictionary = &ky        // ky
+	Lao                  *Dictionary = &lo        // lo
+	Lithuanian           *Dictionary = &lt        // lt
+	Latvian              *Dictionary = &lv        // lv
+	Macedonian           *Dictionary = &mk        // mk
+	Malayalam            *Dictionary = &ml        // ml
+	Mongolian            *Dictionary = &mn        // mn
+	Marathi              *Dictionary = &mr        // mr
+	Malay                *Dictionary = &ms        // ms
+	Burmese              *Dictionary = &my        // my
+	Nepali               *Dictionary = &ne        // ne
+	Dutch                *Dictionary = &nl        // nl
+	Norwegian            *Dictionary = &no        // no
+	Punjabi              *Dictionary = &pa        // pa
+	Polish               *Dictionary = &pl        // pl
+	Portuguese           *Dictionary = &pt        // pt
+	BrazilianPortuguese  *Dictionary = Portuguese // pt-BR
+	EuropeanPortuguese   *Dictionary = &ptPT      // pt-PT
+	Romanian             *Dictionary = &ro        // ro
+	Russian              *Dictionary = &ru        // ru
+	Sinhala              *Dictionary = &si        // si
+	Slovak               *Dictionary = &sk        // sk
+	Slovenian            *Dictionary = &sl        // sl
+	Albanian             *Dictionary = &sq        // sq
+	Serbian              *Dictionary = &sr        // sr
+	SerbianLatin         *Dictionary = &srLatn    // sr
+	Swedish              *Dictionary = &sv        // sv
+	Swahili              *Dictionary = &sw        // sw
+	Tamil                *Dictionary = &ta        // ta
+	Telugu               *Dictionary = &te        // te
+	Thai                 *Dictionary = &th        // th
+	Turkish              *Dictionary = &tr        // tr
+	Ukrainian            *Dictionary = &uk        // uk
+	Urdu                 *Dictionary = &ur        // ur
+	Uzbek                *Dictionary = &uz        // uz
+	Vietnamese           *Dictionary = &vi        // vi
+	Chinese              *Dictionary = &zh        // zh
+	SimplifiedChinese    *Dictionary = Chinese    // zh-Hans
+	TraditionalChinese   *Dictionary = &zhHant    // zh-Hant
+	Zulu                 *Dictionary = &zu        // zu
+)

vendor/golang.org/x/text/language/display/display.go

@@ -0,0 +1,343 @@
+// 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 (
+	"strings"
+
+	"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 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 (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 (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 (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
+
+// 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
+}

vendor/golang.org/x/text/language/display/lookup.go

@@ -0,0 +1,251 @@
+// 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.
+
+package display
+
+// This file contains common lookup code that is shared between the various
+// implementations of Namer and Dictionaries.
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	"golang.org/x/text/language"
+)
+
+type namer interface {
+	// name gets the string for the given index. It should walk the
+	// inheritance chain if a value is not present in the base index.
+	name(idx int) string
+}
+
+func nameLanguage(n namer, x interface{}) string {
+	t, _ := language.All.Compose(x)
+	for {
+		i, _, _ := langTagSet.index(t.Raw())
+		if s := n.name(i); s != "" {
+			return s
+		}
+		if t = t.Parent(); t == language.Und {
+			return ""
+		}
+	}
+}
+
+func nameScript(n namer, x interface{}) string {
+	t, _ := language.DeprecatedScript.Compose(x)
+	_, s, _ := t.Raw()
+	return n.name(scriptIndex.index(s.String()))
+}
+
+func nameRegion(n namer, x interface{}) string {
+	t, _ := language.DeprecatedRegion.Compose(x)
+	_, _, r := t.Raw()
+	return n.name(regionIndex.index(r.String()))
+}
+
+func nameTag(langN, scrN, regN namer, x interface{}) string {
+	t, ok := x.(language.Tag)
+	if !ok {
+		return ""
+	}
+	const form = language.All &^ language.SuppressScript
+	if c, err := form.Canonicalize(t); err == nil {
+		t = c
+	}
+	_, sRaw, rRaw := t.Raw()
+	i, scr, reg := langTagSet.index(t.Raw())
+	for i != -1 {
+		if str := langN.name(i); str != "" {
+			if hasS, hasR := (scr != language.Script{}), (reg != language.Region{}); hasS || hasR {
+				ss, sr := "", ""
+				if hasS {
+					ss = scrN.name(scriptIndex.index(scr.String()))
+				}
+				if hasR {
+					sr = regN.name(regionIndex.index(reg.String()))
+				}
+				// TODO: use patterns in CLDR or at least confirm they are the
+				// same for all languages.
+				if ss != "" && sr != "" {
+					return fmt.Sprintf("%s (%s, %s)", str, ss, sr)
+				}
+				if ss != "" || sr != "" {
+					return fmt.Sprintf("%s (%s%s)", str, ss, sr)
+				}
+			}
+			return str
+		}
+		scr, reg = sRaw, rRaw
+		if t = t.Parent(); t == language.Und {
+			return ""
+		}
+		i, _, _ = langTagSet.index(t.Raw())
+	}
+	return ""
+}
+
+// header contains the data and indexes for a single namer.
+// data contains a series of strings concatenated into one. index contains the
+// offsets for a string in data. For example, consider a header that defines
+// strings for the languages de, el, en, fi, and nl:
+//
+// 		header{
+// 			data: "GermanGreekEnglishDutch",
+//  		index: []uint16{ 0, 6, 11, 18, 18, 23 },
+// 		}
+//
+// For a language with index i, the string is defined by
+// data[index[i]:index[i+1]]. So the number of elements in index is always one
+// greater than the number of languages for which header defines a value.
+// A string for a language may be empty, which means the name is undefined. In
+// the above example, the name for fi (Finnish) is undefined.
+type header struct {
+	data  string
+	index []uint16
+}
+
+// name looks up the name for a tag in the dictionary, given its index.
+func (h *header) name(i int) string {
+	if 0 <= i && i < len(h.index)-1 {
+		return h.data[h.index[i]:h.index[i+1]]
+	}
+	return ""
+}
+
+// tagSet is used to find the index of a language in a set of tags.
+type tagSet struct {
+	single tagIndex
+	long   []string
+}
+
+var (
+	langTagSet = tagSet{
+		single: langIndex,
+		long:   langTagsLong,
+	}
+
+	// selfTagSet is used for indexing the language strings in their own
+	// language.
+	selfTagSet = tagSet{
+		single: selfIndex,
+		long:   selfTagsLong,
+	}
+
+	zzzz = language.MustParseScript("Zzzz")
+	zz   = language.MustParseRegion("ZZ")
+)
+
+// index returns the index of the tag for the given base, script and region or
+// its parent if the tag is not available. If the match is for a parent entry,
+// the excess script and region are returned.
+func (ts *tagSet) index(base language.Base, scr language.Script, reg language.Region) (int, language.Script, language.Region) {
+	lang := base.String()
+	index := -1
+	if (scr != language.Script{} || reg != language.Region{}) {
+		if scr == zzzz {
+			scr = language.Script{}
+		}
+		if reg == zz {
+			reg = language.Region{}
+		}
+
+		i := sort.SearchStrings(ts.long, lang)
+		// All entries have either a script or a region and not both.
+		scrStr, regStr := scr.String(), reg.String()
+		for ; i < len(ts.long) && strings.HasPrefix(ts.long[i], lang); i++ {
+			if s := ts.long[i][len(lang)+1:]; s == scrStr {
+				scr = language.Script{}
+				index = i + ts.single.len()
+				break
+			} else if s == regStr {
+				reg = language.Region{}
+				index = i + ts.single.len()
+				break
+			}
+		}
+	}
+	if index == -1 {
+		index = ts.single.index(lang)
+	}
+	return index, scr, reg
+}
+
+func (ts *tagSet) Tags() []language.Tag {
+	tags := make([]language.Tag, 0, ts.single.len()+len(ts.long))
+	ts.single.keys(func(s string) {
+		tags = append(tags, language.Raw.MustParse(s))
+	})
+	for _, s := range ts.long {
+		tags = append(tags, language.Raw.MustParse(s))
+	}
+	return tags
+}
+
+func supportedScripts() []language.Script {
+	scr := make([]language.Script, 0, scriptIndex.len())
+	scriptIndex.keys(func(s string) {
+		scr = append(scr, language.MustParseScript(s))
+	})
+	return scr
+}
+
+func supportedRegions() []language.Region {
+	reg := make([]language.Region, 0, regionIndex.len())
+	regionIndex.keys(func(s string) {
+		reg = append(reg, language.MustParseRegion(s))
+	})
+	return reg
+}
+
+// tagIndex holds a concatenated lists of subtags of length 2 to 4, one string
+// for each length, which can be used in combination with binary search to get
+// the index associated with a tag.
+// For example, a tagIndex{
+//   "arenesfrruzh",  // 6 2-byte tags.
+//   "barwae",        // 2 3-byte tags.
+//   "",
+// }
+// would mean that the 2-byte tag "fr" had an index of 3, and the 3-byte tag
+// "wae" had an index of 7.
+type tagIndex [3]string
+
+func (t *tagIndex) index(s string) int {
+	sz := len(s)
+	if sz < 2 || 4 < sz {
+		return -1
+	}
+	a := t[sz-2]
+	index := sort.Search(len(a)/sz, func(i int) bool {
+		p := i * sz
+		return a[p:p+sz] >= s
+	})
+	p := index * sz
+	if end := p + sz; end > len(a) || a[p:end] != s {
+		return -1
+	}
+	// Add the number of tags for smaller sizes.
+	for i := 0; i < sz-2; i++ {
+		index += len(t[i]) / (i + 2)
+	}
+	return index
+}
+
+// len returns the number of tags that are contained in the tagIndex.
+func (t *tagIndex) len() (n int) {
+	for i, s := range t {
+		n += len(s) / (i + 2)
+	}
+	return n
+}
+
+// keys calls f for each tag.
+func (t *tagIndex) keys(f func(key string)) {
+	for i, s := range *t {
+		for ; s != ""; s = s[i+2:] {
+			f(s[:i+2])
+		}
+	}
+}

vendor/golang.org/x/text/language/display/maketables.go

@@ -0,0 +1,596 @@
+// 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.
+
+// +build ignore
+
+// Generator for display name tables.
+
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"log"
+	"reflect"
+	"sort"
+	"strings"
+
+	"golang.org/x/text/internal/gen"
+	"golang.org/x/text/language"
+	"golang.org/x/text/unicode/cldr"
+)
+
+var (
+	test = flag.Bool("test", false,
+		"test existing tables; can be used to compare web data with package data.")
+	outputFile = flag.String("output", "tables.go", "output file")
+
+	stats = flag.Bool("stats", false, "prints statistics to stderr")
+
+	short = flag.Bool("short", false, `Use "short" alternatives, when available.`)
+	draft = flag.String("draft",
+		"contributed",
+		`Minimal draft requirements (approved, contributed, provisional, unconfirmed).`)
+	pkg = flag.String("package",
+		"display",
+		"the name of the package in which the generated file is to be included")
+
+	tags = newTagSet("tags",
+		[]language.Tag{},
+		"space-separated list of tags to include or empty for all")
+	dict = newTagSet("dict",
+		dictTags(),
+		"space-separated list or tags for which to include a Dictionary. "+
+			`"" means the common list from go.text/language.`)
+)
+
+func dictTags() (tag []language.Tag) {
+	// TODO: replace with language.Common.Tags() once supported.
+	const str = "af am ar ar-001 az bg bn ca cs da de el en en-US en-GB " +
+		"es es-ES es-419 et fa fi fil fr fr-CA gu he hi hr hu hy id is it ja " +
+		"ka kk km kn ko ky lo lt lv mk ml mn mr ms my ne nl no pa pl pt pt-BR " +
+		"pt-PT ro ru si sk sl sq sr sr-Latn sv sw ta te th tr uk ur uz vi " +
+		"zh zh-Hans zh-Hant zu"
+
+	for _, s := range strings.Split(str, " ") {
+		tag = append(tag, language.MustParse(s))
+	}
+	return tag
+}
+
+func main() {
+	gen.Init()
+
+	// Read the CLDR zip file.
+	r := gen.OpenCLDRCoreZip()
+	defer r.Close()
+
+	d := &cldr.Decoder{}
+	d.SetDirFilter("main", "supplemental")
+	d.SetSectionFilter("localeDisplayNames")
+	data, err := d.DecodeZip(r)
+	if err != nil {
+		log.Fatalf("DecodeZip: %v", err)
+	}
+
+	w := gen.NewCodeWriter()
+	defer w.WriteGoFile(*outputFile, "display")
+
+	gen.WriteCLDRVersion(w)
+
+	b := builder{
+		w:     w,
+		data:  data,
+		group: make(map[string]*group),
+	}
+	b.generate()
+}
+
+const tagForm = language.All
+
+// tagSet is used to parse command line flags of tags. It implements the
+// flag.Value interface.
+type tagSet map[language.Tag]bool
+
+func newTagSet(name string, tags []language.Tag, usage string) tagSet {
+	f := tagSet(make(map[language.Tag]bool))
+	for _, t := range tags {
+		f[t] = true
+	}
+	flag.Var(f, name, usage)
+	return f
+}
+
+// String implements the String method of the flag.Value interface.
+func (f tagSet) String() string {
+	tags := []string{}
+	for t := range f {
+		tags = append(tags, t.String())
+	}
+	sort.Strings(tags)
+	return strings.Join(tags, " ")
+}
+
+// Set implements Set from the flag.Value interface.
+func (f tagSet) Set(s string) error {
+	if s != "" {
+		for _, s := range strings.Split(s, " ") {
+			if s != "" {
+				tag, err := tagForm.Parse(s)
+				if err != nil {
+					return err
+				}
+				f[tag] = true
+			}
+		}
+	}
+	return nil
+}
+
+func (f tagSet) contains(t language.Tag) bool {
+	if len(f) == 0 {
+		return true
+	}
+	return f[t]
+}
+
+// builder is used to create all tables with display name information.
+type builder struct {
+	w *gen.CodeWriter
+
+	data *cldr.CLDR
+
+	fromLocs []string
+
+	// destination tags for the current locale.
+	toTags     []string
+	toTagIndex map[string]int
+
+	// list of supported tags
+	supported []language.Tag
+
+	// key-value pairs per group
+	group map[string]*group
+
+	// statistics
+	sizeIndex int // total size of all indexes of headers
+	sizeData  int // total size of all data of headers
+	totalSize int
+}
+
+type group struct {
+	// Maps from a given language to the Namer data for this language.
+	lang    map[language.Tag]keyValues
+	headers []header
+
+	toTags        []string
+	threeStart    int
+	fourPlusStart int
+}
+
+// set sets the typ to the name for locale loc.
+func (g *group) set(t language.Tag, typ, name string) {
+	kv := g.lang[t]
+	if kv == nil {
+		kv = make(keyValues)
+		g.lang[t] = kv
+	}
+	if kv[typ] == "" {
+		kv[typ] = name
+	}
+}
+
+type keyValues map[string]string
+
+type header struct {
+	tag   language.Tag
+	data  string
+	index []uint16
+}
+
+var versionInfo = `// Version is deprecated. Use CLDRVersion.
+const Version = %#v
+
+`
+
+var self = language.MustParse("mul")
+
+// generate builds and writes all tables.
+func (b *builder) generate() {
+	fmt.Fprintf(b.w, versionInfo, cldr.Version)
+
+	b.filter()
+	b.setData("lang", func(g *group, loc language.Tag, ldn *cldr.LocaleDisplayNames) {
+		if ldn.Languages != nil {
+			for _, v := range ldn.Languages.Language {
+				tag := tagForm.MustParse(v.Type)
+				if tags.contains(tag) {
+					g.set(loc, tag.String(), v.Data())
+				}
+			}
+		}
+	})
+	b.setData("script", func(g *group, loc language.Tag, ldn *cldr.LocaleDisplayNames) {
+		if ldn.Scripts != nil {
+			for _, v := range ldn.Scripts.Script {
+				code := language.MustParseScript(v.Type)
+				if code.IsPrivateUse() { // Qaaa..Qabx
+					// TODO: data currently appears to be very meager.
+					// Reconsider if we have data for English.
+					if loc == language.English {
+						log.Fatal("Consider including data for private use scripts.")
+					}
+					continue
+				}
+				g.set(loc, code.String(), v.Data())
+			}
+		}
+	})
+	b.setData("region", func(g *group, loc language.Tag, ldn *cldr.LocaleDisplayNames) {
+		if ldn.Territories != nil {
+			for _, v := range ldn.Territories.Territory {
+				g.set(loc, language.MustParseRegion(v.Type).String(), v.Data())
+			}
+		}
+	})
+
+	b.makeSupported()
+
+	b.writeParents()
+
+	b.writeGroup("lang")
+	b.writeGroup("script")
+	b.writeGroup("region")
+
+	b.w.WriteConst("numSupported", len(b.supported))
+	buf := bytes.Buffer{}
+	for _, tag := range b.supported {
+		fmt.Fprint(&buf, tag.String(), "|")
+	}
+	b.w.WriteConst("supported", buf.String())
+
+	b.writeDictionaries()
+
+	b.supported = []language.Tag{self}
+
+	// Compute the names of locales in their own language. Some of these names
+	// may be specified in their parent locales. We iterate the maximum depth
+	// of the parent three times to match successive parents of tags until a
+	// possible match is found.
+	for i := 0; i < 4; i++ {
+		b.setData("self", func(g *group, tag language.Tag, ldn *cldr.LocaleDisplayNames) {
+			parent := tag
+			if b, s, r := tag.Raw(); i > 0 && (s != language.Script{} && r == language.Region{}) {
+				parent, _ = language.Raw.Compose(b)
+			}
+			if ldn.Languages != nil {
+				for _, v := range ldn.Languages.Language {
+					key := tagForm.MustParse(v.Type)
+					saved := key
+					if key == parent {
+						g.set(self, tag.String(), v.Data())
+					}
+					for k := 0; k < i; k++ {
+						key = key.Parent()
+					}
+					if key == tag {
+						g.set(self, saved.String(), v.Data()) // set does not overwrite a value.
+					}
+				}
+			}
+		})
+	}
+
+	b.writeGroup("self")
+}
+
+func (b *builder) setData(name string, f func(*group, language.Tag, *cldr.LocaleDisplayNames)) {
+	b.sizeIndex = 0
+	b.sizeData = 0
+	b.toTags = nil
+	b.fromLocs = nil
+	b.toTagIndex = make(map[string]int)
+
+	g := b.group[name]
+	if g == nil {
+		g = &group{lang: make(map[language.Tag]keyValues)}
+		b.group[name] = g
+	}
+	for _, loc := range b.data.Locales() {
+		// We use RawLDML instead of LDML as we are managing our own inheritance
+		// in this implementation.
+		ldml := b.data.RawLDML(loc)
+
+		// We do not support the POSIX variant (it is not a supported BCP 47
+		// variant). This locale also doesn't happen to contain any data, so
+		// we'll skip it by checking for this.
+		tag, err := tagForm.Parse(loc)
+		if err != nil {
+			if ldml.LocaleDisplayNames != nil {
+				log.Fatalf("setData: %v", err)
+			}
+			continue
+		}
+		if ldml.LocaleDisplayNames != nil && tags.contains(tag) {
+			f(g, tag, ldml.LocaleDisplayNames)
+		}
+	}
+}
+
+func (b *builder) filter() {
+	filter := func(s *cldr.Slice) {
+		if *short {
+			s.SelectOnePerGroup("alt", []string{"short", ""})
+		} else {
+			s.SelectOnePerGroup("alt", []string{"stand-alone", ""})
+		}
+		d, err := cldr.ParseDraft(*draft)
+		if err != nil {
+			log.Fatalf("filter: %v", err)
+		}
+		s.SelectDraft(d)
+	}
+	for _, loc := range b.data.Locales() {
+		if ldn := b.data.RawLDML(loc).LocaleDisplayNames; ldn != nil {
+			if ldn.Languages != nil {
+				s := cldr.MakeSlice(&ldn.Languages.Language)
+				if filter(&s); len(ldn.Languages.Language) == 0 {
+					ldn.Languages = nil
+				}
+			}
+			if ldn.Scripts != nil {
+				s := cldr.MakeSlice(&ldn.Scripts.Script)
+				if filter(&s); len(ldn.Scripts.Script) == 0 {
+					ldn.Scripts = nil
+				}
+			}
+			if ldn.Territories != nil {
+				s := cldr.MakeSlice(&ldn.Territories.Territory)
+				if filter(&s); len(ldn.Territories.Territory) == 0 {
+					ldn.Territories = nil
+				}
+			}
+		}
+	}
+}
+
+// makeSupported creates a list of all supported locales.
+func (b *builder) makeSupported() {
+	// tags across groups
+	for _, g := range b.group {
+		for t, _ := range g.lang {
+			b.supported = append(b.supported, t)
+		}
+	}
+	b.supported = b.supported[:unique(tagsSorter(b.supported))]
+
+}
+
+type tagsSorter []language.Tag
+
+func (a tagsSorter) Len() int           { return len(a) }
+func (a tagsSorter) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a tagsSorter) Less(i, j int) bool { return a[i].String() < a[j].String() }
+
+func (b *builder) writeGroup(name string) {
+	g := b.group[name]
+
+	for _, kv := range g.lang {
+		for t, _ := range kv {
+			g.toTags = append(g.toTags, t)
+		}
+	}
+	g.toTags = g.toTags[:unique(tagsBySize(g.toTags))]
+
+	// Allocate header per supported value.
+	g.headers = make([]header, len(b.supported))
+	for i, sup := range b.supported {
+		kv, ok := g.lang[sup]
+		if !ok {
+			g.headers[i].tag = sup
+			continue
+		}
+		data := []byte{}
+		index := make([]uint16, len(g.toTags), len(g.toTags)+1)
+		for j, t := range g.toTags {
+			index[j] = uint16(len(data))
+			data = append(data, kv[t]...)
+		}
+		index = append(index, uint16(len(data)))
+
+		// Trim the tail of the index.
+		// TODO: indexes can be reduced in size quite a bit more.
+		n := len(index)
+		for ; n >= 2 && index[n-2] == index[n-1]; n-- {
+		}
+		index = index[:n]
+
+		// Workaround for a bug in CLDR 26.
+		// See http://unicode.org/cldr/trac/ticket/8042.
+		if cldr.Version == "26" && sup.String() == "hsb" {
+			data = bytes.Replace(data, []byte{'"'}, nil, 1)
+		}
+		g.headers[i] = header{sup, string(data), index}
+	}
+	g.writeTable(b.w, name)
+}
+
+type tagsBySize []string
+
+func (l tagsBySize) Len() int      { return len(l) }
+func (l tagsBySize) Swap(i, j int) { l[i], l[j] = l[j], l[i] }
+func (l tagsBySize) Less(i, j int) bool {
+	a, b := l[i], l[j]
+	// Sort single-tag entries based on size first. Otherwise alphabetic.
+	if len(a) != len(b) && (len(a) <= 4 || len(b) <= 4) {
+		return len(a) < len(b)
+	}
+	return a < b
+}
+
+// parentIndices returns slice a of len(tags) where tags[a[i]] is the parent
+// of tags[i].
+func parentIndices(tags []language.Tag) []int16 {
+	index := make(map[language.Tag]int16)
+	for i, t := range tags {
+		index[t] = int16(i)
+	}
+
+	// Construct default parents.
+	parents := make([]int16, len(tags))
+	for i, t := range tags {
+		parents[i] = -1
+		for t = t.Parent(); t != language.Und; t = t.Parent() {
+			if j, ok := index[t]; ok {
+				parents[i] = j
+				break
+			}
+		}
+	}
+	return parents
+}
+
+func (b *builder) writeParents() {
+	parents := parentIndices(b.supported)
+	fmt.Fprintf(b.w, "var parents = ")
+	b.w.WriteArray(parents)
+}
+
+// writeKeys writes keys to a special index used by the display package.
+// tags are assumed to be sorted by length.
+func writeKeys(w *gen.CodeWriter, name string, keys []string) {
+	w.Size += int(3 * reflect.TypeOf("").Size())
+	w.WriteComment("Number of keys: %d", len(keys))
+	fmt.Fprintf(w, "var (\n\t%sIndex = tagIndex{\n", name)
+	for i := 2; i <= 4; i++ {
+		sub := []string{}
+		for _, t := range keys {
+			if len(t) != i {
+				break
+			}
+			sub = append(sub, t)
+		}
+		s := strings.Join(sub, "")
+		w.WriteString(s)
+		fmt.Fprintf(w, ",\n")
+		keys = keys[len(sub):]
+	}
+	fmt.Fprintln(w, "\t}")
+	if len(keys) > 0 {
+		w.Size += int(reflect.TypeOf([]string{}).Size())
+		fmt.Fprintf(w, "\t%sTagsLong = ", name)
+		w.WriteSlice(keys)
+	}
+	fmt.Fprintln(w, ")\n")
+}
+
+// identifier creates an identifier from the given tag.
+func identifier(t language.Tag) string {
+	return strings.Replace(t.String(), "-", "", -1)
+}
+
+func (h *header) writeEntry(w *gen.CodeWriter, name string) {
+	if len(dict) > 0 && dict.contains(h.tag) {
+		fmt.Fprintf(w, "\t{ // %s\n", h.tag)
+		fmt.Fprintf(w, "\t\t%[1]s%[2]sStr,\n\t\t%[1]s%[2]sIdx,\n", identifier(h.tag), name)
+		fmt.Fprintln(w, "\t},")
+	} else if len(h.data) == 0 {
+		fmt.Fprintln(w, "\t\t{}, //", h.tag)
+	} else {
+		fmt.Fprintf(w, "\t{ // %s\n", h.tag)
+		w.WriteString(h.data)
+		fmt.Fprintln(w, ",")
+		w.WriteSlice(h.index)
+		fmt.Fprintln(w, ",\n\t},")
+	}
+}
+
+// write the data for the given header as single entries. The size for this data
+// was already accounted for in writeEntry.
+func (h *header) writeSingle(w *gen.CodeWriter, name string) {
+	if len(dict) > 0 && dict.contains(h.tag) {
+		tag := identifier(h.tag)
+		w.WriteConst(tag+name+"Str", h.data)
+
+		// Note that we create a slice instead of an array. If we use an array
+		// we need to refer to it as a[:] in other tables, which will cause the
+		// array to always be included by the linker. See Issue 7651.
+		w.WriteVar(tag+name+"Idx", h.index)
+	}
+}
+
+// WriteTable writes an entry for a single Namer.
+func (g *group) writeTable(w *gen.CodeWriter, name string) {
+	start := w.Size
+	writeKeys(w, name, g.toTags)
+	w.Size += len(g.headers) * int(reflect.ValueOf(g.headers[0]).Type().Size())
+
+	fmt.Fprintf(w, "var %sHeaders = [%d]header{\n", name, len(g.headers))
+
+	title := strings.Title(name)
+	for _, h := range g.headers {
+		h.writeEntry(w, title)
+	}
+	fmt.Fprintln(w, "}\n")
+
+	for _, h := range g.headers {
+		h.writeSingle(w, title)
+	}
+	n := w.Size - start
+	fmt.Fprintf(w, "// Total size for %s: %d bytes (%d KB)\n\n", name, n, n/1000)
+}
+
+func (b *builder) writeDictionaries() {
+	fmt.Fprintln(b.w, "// Dictionary entries of frequent languages")
+	fmt.Fprintln(b.w, "var (")
+	parents := parentIndices(b.supported)
+
+	for i, t := range b.supported {
+		if dict.contains(t) {
+			ident := identifier(t)
+			fmt.Fprintf(b.w, "\t%s = Dictionary{ // %s\n", ident, t)
+			if p := parents[i]; p == -1 {
+				fmt.Fprintln(b.w, "\t\tnil,")
+			} else {
+				fmt.Fprintf(b.w, "\t\t&%s,\n", identifier(b.supported[p]))
+			}
+			fmt.Fprintf(b.w, "\t\theader{%[1]sLangStr, %[1]sLangIdx},\n", ident)
+			fmt.Fprintf(b.w, "\t\theader{%[1]sScriptStr, %[1]sScriptIdx},\n", ident)
+			fmt.Fprintf(b.w, "\t\theader{%[1]sRegionStr, %[1]sRegionIdx},\n", ident)
+			fmt.Fprintln(b.w, "\t}")
+		}
+	}
+	fmt.Fprintln(b.w, ")")
+
+	var s string
+	var a []uint16
+	sz := reflect.TypeOf(s).Size()
+	sz += reflect.TypeOf(a).Size()
+	sz *= 3
+	sz += reflect.TypeOf(&a).Size()
+	n := int(sz) * len(dict)
+	fmt.Fprintf(b.w, "// Total size for %d entries: %d bytes (%d KB)\n\n", len(dict), n, n/1000)
+
+	b.w.Size += n
+}
+
+// unique sorts the given lists and removes duplicate entries by swapping them
+// past position k, where k is the number of unique values. It returns k.
+func unique(a sort.Interface) int {
+	if a.Len() == 0 {
+		return 0
+	}
+	sort.Sort(a)
+	k := 1
+	for i := 1; i < a.Len(); i++ {
+		if a.Less(k-1, i) {
+			if k != i {
+				a.Swap(k, i)
+			}
+			k++
+		}
+	}
+	return k
+}