internal: use Parent from compact and remove internal’s
This has the side-effect that the implementations using
compact tags will now have to chose whether to use
the regional or language variant of the tag. For instance,
the number package may display Swiss German number
formatting, even though the language selected is German.
Note that the tables for plural rules have slightly changed.
The new changes pick up data for some deprecated tags as
well. The entries for the deprecated tags could be removed
as compact indices, but as long as they are there, the
changes introduced here are correct. In practice the
language Matcher will match deprecated tags to their
modern equivalent, so these changes will have no effect
in practice.
Change-Id: I32f9149b0748a3ce51cab332b43a74092deffd8f
Reviewed-on: https://go-review.googlesource.com/98438
Run-TryBot: Marcel van Lohuizen <mpvl@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ross Light <light@google.com>
diff --git a/currency/format.go b/currency/format.go
index 97ce2d9..1115263 100644
--- a/currency/format.go
+++ b/currency/format.go
@@ -9,9 +9,8 @@
"io"
"sort"
- "golang.org/x/text/internal"
"golang.org/x/text/internal/format"
- "golang.org/x/text/language"
+ "golang.org/x/text/internal/language/compact"
)
// Amount is an amount-currency unit pair.
@@ -59,9 +58,9 @@
// Format implements fmt.Formatter. It accepts format.State for
// language-specific rendering.
func (v formattedValue) Format(s fmt.State, verb rune) {
- var lang int
+ var lang compact.ID
if state, ok := s.(format.State); ok {
- lang, _ = language.CompactIndex(state.Language())
+ lang, _ = compact.RegionalID(compact.Tag(state.Language()))
}
// Get the options. Use DefaultFormat if not present.
@@ -138,7 +137,7 @@
currency Unit
kind Kind
- symbol func(compactIndex int, c Unit) string
+ symbol func(compactIndex compact.ID, c Unit) string
}
func (o *options) format(amount interface{}) formattedValue {
@@ -177,9 +176,9 @@
func formSymbol(x interface{}) formattedValue { return optSymbol.format(x) }
func formNarrow(x interface{}) formattedValue { return optNarrow.format(x) }
-func lookupISO(x int, c Unit) string { return c.String() }
-func lookupSymbol(x int, c Unit) string { return normalSymbol.lookup(x, c) }
-func lookupNarrow(x int, c Unit) string { return narrowSymbol.lookup(x, c) }
+func lookupISO(x compact.ID, c Unit) string { return c.String() }
+func lookupSymbol(x compact.ID, c Unit) string { return normalSymbol.lookup(x, c) }
+func lookupNarrow(x compact.ID, c Unit) string { return narrowSymbol.lookup(x, c) }
type symbolIndex struct {
index []uint16 // position corresponds with compact index of language.
@@ -191,7 +190,7 @@
narrowSymbol = symbolIndex{narrowLangIndex, narrowSymIndex}
)
-func (x *symbolIndex) lookup(lang int, c Unit) string {
+func (x *symbolIndex) lookup(lang compact.ID, c Unit) string {
for {
index := x.data[x.index[lang]:x.index[lang+1]]
i := sort.Search(len(index), func(i int) bool {
@@ -209,7 +208,7 @@
if lang == 0 {
break
}
- lang = int(internal.Parent[lang])
+ lang = lang.Parent()
}
return c.String()
}
diff --git a/currency/gen.go b/currency/gen.go
index 0952d41..da7712f 100644
--- a/currency/gen.go
+++ b/currency/gen.go
@@ -18,7 +18,8 @@
"strings"
"time"
- "golang.org/x/text/internal"
+ "golang.org/x/text/internal/language/compact"
+
"golang.org/x/text/internal/gen"
"golang.org/x/text/internal/tag"
"golang.org/x/text/language"
@@ -265,7 +266,7 @@
numTypes
)
// language -> currency -> type -> symbol
- var symbols [language.NumCompactTags][][numTypes]*string
+ var symbols [compact.NumCompactTags][][numTypes]*string
// Collect symbol information per language.
for _, lang := range data.Locales() {
@@ -274,7 +275,7 @@
continue
}
- langIndex, ok := language.CompactIndex(language.MustParse(lang))
+ langIndex, ok := compact.LanguageID(compact.Tag(language.MustParse(lang)))
if !ok {
log.Fatalf("No compact index for language %s", lang)
}
@@ -318,8 +319,8 @@
if sym == nil {
continue
}
- for p := uint16(langIndex); p != 0; {
- p = internal.Parent[p]
+ for p := compact.ID(langIndex); p != 0; {
+ p = p.Parent()
x := symbols[p]
if x == nil {
continue
diff --git a/date/gen_test.go b/date/gen_test.go
index 798cb4f..b6b9159 100644
--- a/date/gen_test.go
+++ b/date/gen_test.go
@@ -11,6 +11,7 @@
"golang.org/x/text/internal/cldrtree"
"golang.org/x/text/internal/gen"
+ "golang.org/x/text/internal/language/compact"
"golang.org/x/text/internal/testtext"
"golang.org/x/text/language"
"golang.org/x/text/unicode/cldr"
@@ -36,7 +37,7 @@
if ldml.Dates == nil {
continue
}
- tag, _ := language.CompactIndex(language.MustParse(lang))
+ tag, _ := compact.RegionalID(compact.Tag(language.MustParse(lang)))
test := func(want cldrtree.Element, path ...string) {
if count > 30 {
diff --git a/feature/plural/gen.go b/feature/plural/gen.go
index a0de986..104986a 100644
--- a/feature/plural/gen.go
+++ b/feature/plural/gen.go
@@ -63,9 +63,9 @@
"strconv"
"strings"
- "golang.org/x/text/internal"
"golang.org/x/text/internal/gen"
- "golang.org/x/text/language"
+ "golang.org/x/text/internal/language"
+ "golang.org/x/text/internal/language/compact"
"golang.org/x/text/unicode/cldr"
)
@@ -198,7 +198,7 @@
rules := []pluralCheck{}
index := []byte{0}
- langMap := map[int]byte{0: 0} // From compact language index to index
+ langMap := map[compact.ID]byte{0: 0}
for _, pRules := range plurals.PluralRules {
// Parse the rules.
@@ -251,7 +251,7 @@
if strings.TrimSpace(loc) == "" {
continue
}
- lang, ok := language.CompactIndex(language.MustParse(loc))
+ lang, ok := compact.FromTag(language.MustParse(loc))
if !ok {
log.Printf("No compact index for locale %q", loc)
}
@@ -261,16 +261,28 @@
}
w.WriteVar(plurals.Type+"Rules", rules)
w.WriteVar(plurals.Type+"Index", index)
- // Expand the values.
- langToIndex := make([]byte, language.NumCompactTags)
+ // Expand the values: first by using the parent relationship.
+ langToIndex := make([]byte, compact.NumCompactTags)
for i := range langToIndex {
- for p := i; ; p = int(internal.Parent[p]) {
+ for p := compact.ID(i); ; p = p.Parent() {
if x, ok := langMap[p]; ok {
langToIndex[i] = x
break
}
}
}
+ // Now expand by including entries with identical languages for which
+ // one isn't set.
+ for i, v := range langToIndex {
+ if v == 0 {
+ id, _ := compact.FromTag(language.Tag{
+ LangID: compact.ID(i).Tag().LangID,
+ })
+ if p := langToIndex[id]; p != 0 {
+ langToIndex[i] = p
+ }
+ }
+ }
w.WriteVar(plurals.Type+"LangToIndex", langToIndex)
// Need to convert array to slice because of golang.org/issue/7651.
// This will allow tables to be dropped when unused. This is especially
diff --git a/feature/plural/plural.go b/feature/plural/plural.go
index 61faf18..517a628 100644
--- a/feature/plural/plural.go
+++ b/feature/plural/plural.go
@@ -13,6 +13,7 @@
package plural
import (
+ "golang.org/x/text/internal/language/compact"
"golang.org/x/text/internal/number"
"golang.org/x/text/language"
)
@@ -113,7 +114,7 @@
// 100000 []byte{1} 6 0
// 100000.00 []byte{1} 6 3
func (p *Rules) MatchDigits(t language.Tag, digits []byte, exp, scale int) Form {
- index, _ := language.CompactIndex(t)
+ index := tagToID(t)
// Differentiate up to including mod 1000000 for the integer part.
n := getIntApprox(digits, 0, exp, 6, 1000000)
@@ -130,8 +131,7 @@
}
func validForms(p *Rules, t language.Tag) (forms []Form) {
- index, _ := language.CompactIndex(t)
- offset := p.langToIndex[index]
+ offset := p.langToIndex[tagToID(t)]
rules := p.rules[p.index[offset]:p.index[offset+1]]
forms = append(forms, Other)
@@ -146,8 +146,7 @@
}
func (p *Rules) matchComponents(t language.Tag, n, f, scale int) Form {
- index, _ := language.CompactIndex(t)
- return matchPlural(p, index, n, f, scale)
+ return matchPlural(p, tagToID(t), n, f, scale)
}
// MatchPlural returns the plural form for the given language and plural
@@ -165,11 +164,10 @@
// If any of the operand values is too large to fit in an int, it is okay to
// pass the value modulo 10,000,000.
func (p *Rules) MatchPlural(lang language.Tag, i, v, w, f, t int) Form {
- index, _ := language.CompactIndex(lang)
- return matchPlural(p, index, i, f, v)
+ return matchPlural(p, tagToID(lang), i, f, v)
}
-func matchPlural(p *Rules, index int, n, f, v int) Form {
+func matchPlural(p *Rules, index compact.ID, n, f, v int) Form {
nMask := p.inclusionMasks[n%maxMod]
// Compute the fMask inline in the rules below, as it is relatively rare.
// fMask := p.inclusionMasks[f%maxMod]
@@ -256,3 +254,8 @@
}
return Other
}
+
+func tagToID(t language.Tag) compact.ID {
+ id, _ := compact.RegionalID(compact.Tag(t))
+ return id
+}
diff --git a/feature/plural/plural_test.go b/feature/plural/plural_test.go
index b3cf4c4..feee4f0 100644
--- a/feature/plural/plural_test.go
+++ b/feature/plural/plural_test.go
@@ -189,8 +189,8 @@
func BenchmarkPluralSimpleCases(b *testing.B) {
p := Cardinal
- en, _ := language.CompactIndex(language.English)
- zh, _ := language.CompactIndex(language.Chinese)
+ en := tagToID(language.English)
+ zh := tagToID(language.Chinese)
for i := 0; i < b.N; i++ {
matchPlural(p, en, 0, 0, 0) // 0
matchPlural(p, en, 1, 0, 0) // 1
@@ -203,8 +203,8 @@
func BenchmarkPluralComplexCases(b *testing.B) {
p := Cardinal
- ar, _ := language.CompactIndex(language.Arabic)
- lv, _ := language.CompactIndex(language.Latvian)
+ ar := tagToID(language.Arabic)
+ lv := tagToID(language.Latvian)
for i := 0; i < b.N; i++ {
matchPlural(p, lv, 0, 19, 2) // 0.19
matchPlural(p, lv, 11, 0, 3) // 11.000
diff --git a/feature/plural/tables.go b/feature/plural/tables.go
index 188820b..59ae9f2 100644
--- a/feature/plural/tables.go
+++ b/feature/plural/tables.go
@@ -85,8 +85,8 @@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x12, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
- 0x00, 0x10, 0x10, 0x00, 0x00, 0x05, 0x05, 0x00,
+ 0x12, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x00, 0x00, 0x05, 0x05, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// Entry 40 - 7F
0x12, 0x12, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -149,7 +149,7 @@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x0d, 0x0d, 0x02, 0x02, 0x02,
+ 0x00, 0x00, 0x02, 0x0d, 0x0d, 0x02, 0x02, 0x02,
0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// Entry 200 - 23F
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -177,7 +177,7 @@
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x07, 0x07, 0x02, 0x00, 0x00, 0x00, 0x00,
// Entry 2C0 - 2FF
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x00,
@@ -409,12 +409,12 @@
0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
- 0x01, 0x01, 0x08, 0x08, 0x04, 0x04, 0x08, 0x00,
- 0x00, 0x08, 0x08, 0x00, 0x00, 0x1a, 0x1a, 0x08,
+ 0x01, 0x01, 0x08, 0x08, 0x04, 0x04, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x00, 0x00, 0x1a, 0x1a, 0x08,
0x08, 0x08, 0x08, 0x08, 0x08, 0x06, 0x00, 0x00,
// Entry 40 - 7F
0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x1e, 0x1e,
- 0x08, 0x08, 0x13, 0x00, 0x00, 0x13, 0x13, 0x04,
+ 0x08, 0x08, 0x13, 0x13, 0x13, 0x13, 0x13, 0x04,
0x04, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x08,
0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
0x18, 0x18, 0x00, 0x00, 0x22, 0x22, 0x09, 0x09,
@@ -459,8 +459,8 @@
0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// Entry 180 - 1BF
0x00, 0x04, 0x0a, 0x0a, 0x04, 0x04, 0x04, 0x04,
- 0x04, 0x10, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08,
- 0x00, 0x08, 0x08, 0x00, 0x00, 0x08, 0x08, 0x02,
+ 0x04, 0x10, 0x17, 0x00, 0x00, 0x00, 0x08, 0x08,
+ 0x04, 0x08, 0x08, 0x00, 0x00, 0x08, 0x08, 0x02,
0x02, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01,
@@ -473,7 +473,7 @@
0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x0d, 0x08,
0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06,
0x00, 0x00, 0x08, 0x08, 0x0b, 0x0b, 0x08, 0x08,
- 0x08, 0x08, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00,
+ 0x08, 0x08, 0x12, 0x01, 0x01, 0x00, 0x00, 0x00,
0x00, 0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00,
// Entry 200 - 23F
0x00, 0x08, 0x10, 0x10, 0x08, 0x08, 0x08, 0x08,
@@ -481,8 +481,8 @@
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00,
0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x08,
0x06, 0x00, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08,
- 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x06, 0x00,
- 0x00, 0x06, 0x06, 0x08, 0x19, 0x19, 0x0d, 0x0d,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x08, 0x19, 0x19, 0x0d, 0x0d,
0x08, 0x08, 0x03, 0x04, 0x03, 0x04, 0x04, 0x04,
// Entry 240 - 27F
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00,
@@ -491,7 +491,7 @@
0x1d, 0x1d, 0x1d, 0x00, 0x00, 0x08, 0x08, 0x00,
0x00, 0x08, 0x08, 0x00, 0x00, 0x08, 0x08, 0x08,
0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x11, 0x11,
+ 0x00, 0x00, 0x13, 0x11, 0x11, 0x11, 0x11, 0x11,
0x05, 0x05, 0x18, 0x18, 0x15, 0x15, 0x10, 0x10,
// Entry 280 - 2BF
0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x08, 0x08,
@@ -501,11 +501,11 @@
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x08,
0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
0x08, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06,
- 0x08, 0x08, 0x08, 0x00, 0x08, 0x00, 0x00, 0x08,
+ 0x08, 0x08, 0x08, 0x0c, 0x08, 0x00, 0x00, 0x08,
// Entry 2C0 - 2FF
0x08, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x07,
0x07, 0x08, 0x08, 0x1d, 0x1d, 0x04, 0x04, 0x04,
- 0x08, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x00,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00,
0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08,
0x08, 0x08, 0x08, 0x06, 0x08, 0x08, 0x00, 0x00,
0x08, 0x08, 0x08, 0x00, 0x00, 0x04, 0x04, 0x00,
@@ -549,4 +549,4 @@
// Slots used for cardinal: A6 of 0xFF rules; 24 of 0xFF indexes; 37 of 64 sets
-// Total table size 3860 bytes (3KiB); checksum: B96047F
+// Total table size 3860 bytes (3KiB); checksum: 4E56F7B1
diff --git a/gen.go b/gen.go
index 1060b2b..3131edd 100644
--- a/gen.go
+++ b/gen.go
@@ -109,8 +109,8 @@
var (
cldr = generate("./unicode/cldr", unicode)
- langint = generate("./internal/language", cldr)
- language = generate("./language", cldr, langint)
+ compact = generate("./internal/language/compact", cldr)
+ language = generate("./language", cldr, compact)
internal = generate("./internal", unicode, language)
norm = generate("./unicode/norm", unicode)
rangetable = generate("./unicode/rangetable", unicode)
diff --git a/internal/cldrtree/cldrtree_test.go b/internal/cldrtree/cldrtree_test.go
index d93c763..15960c8 100644
--- a/internal/cldrtree/cldrtree_test.go
+++ b/internal/cldrtree/cldrtree_test.go
@@ -18,6 +18,7 @@
"testing"
"golang.org/x/text/internal/gen"
+ "golang.org/x/text/internal/language/compact"
"golang.org/x/text/language"
"golang.org/x/text/unicode/cldr"
)
@@ -277,7 +278,7 @@
for _, tc := range testCases {
t.Run(tc.desc, func(t *testing.T) {
- tag, _ := language.CompactIndex(language.MustParse(tc.locale))
+ tag, _ := compact.RegionalID(compact.Tag(language.MustParse(tc.locale)))
s := tc.tree.lookup(tag, tc.isFeature, tc.path...)
if s != tc.result {
t.Errorf("got %q; want %q", s, tc.result)
diff --git a/internal/cldrtree/tree.go b/internal/cldrtree/tree.go
index 6d4084b..9321947 100644
--- a/internal/cldrtree/tree.go
+++ b/internal/cldrtree/tree.go
@@ -5,7 +5,7 @@
package cldrtree
import (
- "golang.org/x/text/internal"
+ "golang.org/x/text/internal/language/compact"
"golang.org/x/text/language"
)
@@ -30,17 +30,17 @@
// Each subsequent element in path indicates which subtree to select data from.
// The last element of the path must select a leaf node. All other elements
// of the path select a subindex.
-func (t *Tree) Lookup(tag int, path ...uint16) string {
+func (t *Tree) Lookup(tag compact.ID, path ...uint16) string {
return t.lookup(tag, false, path...)
}
// LookupFeature is like Lookup, but will first check whether a value of "other"
// as a fallback before traversing the inheritance chain.
-func (t *Tree) LookupFeature(tag int, path ...uint16) string {
+func (t *Tree) LookupFeature(tag compact.ID, path ...uint16) string {
return t.lookup(tag, true, path...)
}
-func (t *Tree) lookup(tag int, isFeature bool, path ...uint16) string {
+func (t *Tree) lookup(tag compact.ID, isFeature bool, path ...uint16) string {
origLang := tag
outer:
for {
@@ -86,7 +86,7 @@
if tag == 0 {
break
}
- tag = int(internal.Parent[tag])
+ tag = tag.Parent()
}
return ""
}
@@ -105,9 +105,9 @@
}
// Set locales for which we don't have data to the parent's data.
for i, v := range t.Locales {
- p := uint16(i)
+ p := compact.ID(i)
for v == 0 && p != 0 {
- p = internal.Parent[p]
+ p = p.Parent()
v = t.Locales[p]
}
t.Locales[i] = v
diff --git a/internal/export/idna/tables10.0.0.go b/internal/export/idna/tables10.0.0.go
index 8e46655..d8f5926 100644
--- a/internal/export/idna/tables10.0.0.go
+++ b/internal/export/idna/tables10.0.0.go
@@ -7,7 +7,7 @@
// UnicodeVersion is the Unicode version from which the tables in this package are derived.
const UnicodeVersion = "10.0.0"
-var mappings string = "" + // Size: 8176 bytes
+var mappings string = "" + // Size: 8175 bytes
"\x00\x01 \x03 ̈\x01a\x03 ̄\x012\x013\x03 ́\x03 ̧\x011\x01o\x051⁄4\x051⁄2" +
"\x053⁄4\x03i̇\x03l·\x03ʼn\x01s\x03dž\x03ⱥ\x03ⱦ\x01h\x01j\x01r\x01w\x01y" +
"\x03 ̆\x03 ̇\x03 ̊\x03 ̨\x03 ̃\x03 ̋\x01l\x01x\x04̈́\x03 ι\x01;\x05 ̈́" +
@@ -4556,4 +4556,4 @@
{value: 0x0040, lo: 0xb0, hi: 0xbf},
}
-// Total table size 42115 bytes (41KiB); checksum: F4A1FA4E
+// Total table size 42114 bytes (41KiB); checksum: 355A58A4
diff --git a/internal/gen.go b/internal/gen.go
deleted file mode 100644
index 1d678af..0000000
--- a/internal/gen.go
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2015 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
-
-package main
-
-import (
- "log"
-
- "golang.org/x/text/internal/gen"
- "golang.org/x/text/language"
- "golang.org/x/text/unicode/cldr"
-)
-
-func main() {
- r := gen.OpenCLDRCoreZip()
- defer r.Close()
-
- d := &cldr.Decoder{}
- data, err := d.DecodeZip(r)
- if err != nil {
- log.Fatalf("DecodeZip: %v", err)
- }
-
- w := gen.NewCodeWriter()
- defer w.WriteGoFile("tables.go", "internal")
-
- // Create parents table.
- parents := make([]uint16, language.NumCompactTags)
- for _, loc := range data.Locales() {
- tag := language.MustParse(loc)
- index, ok := language.CompactIndex(tag)
- if !ok {
- continue
- }
- parentIndex := 0 // und
- for p := tag.Parent(); p != language.Und; p = p.Parent() {
- if x, ok := language.CompactIndex(p); ok {
- parentIndex = x
- break
- }
- }
- parents[index] = uint16(parentIndex)
- }
-
- w.WriteComment(`
- Parent maps a compact index of a tag to the compact index of the parent of
- this tag.`)
- w.WriteVar("Parent", parents)
-}
diff --git a/internal/gen_test.go b/internal/gen_test.go
deleted file mode 100644
index a2e1981..0000000
--- a/internal/gen_test.go
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright 2015 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 internal
-
-import (
- "testing"
-
- "golang.org/x/text/language"
-)
-
-func TestParents(t *testing.T) {
- testCases := []struct {
- tag, parent string
- }{
- {"af", "und"},
- {"en", "und"},
- {"en-001", "en"},
- {"en-AU", "en-001"},
- {"en-US", "en"},
- {"en-US-u-va-posix", "en-US"},
- {"ca-ES-valencia", "ca-ES"},
- }
- for _, tc := range testCases {
- tag, ok := language.CompactIndex(language.MustParse(tc.tag))
- if !ok {
- t.Fatalf("Could not get index of flag %s", tc.tag)
- }
- want, ok := language.CompactIndex(language.MustParse(tc.parent))
- if !ok {
- t.Fatalf("Could not get index of parent %s of tag %s", tc.parent, tc.tag)
- }
- if got := int(Parent[tag]); got != want {
- t.Errorf("Parent[%s] = %d; want %d (%s)", tc.tag, got, want, tc.parent)
- }
- }
-}
diff --git a/internal/internal.go b/internal/internal.go
index eac8328..3cddbbd 100644
--- a/internal/internal.go
+++ b/internal/internal.go
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-//go:generate go run gen.go
-
// Package internal contains non-exported functionality that are used by
// packages in the text repository.
package internal // import "golang.org/x/text/internal"
diff --git a/internal/language/compact/gen_index.go b/internal/language/compact/gen_index.go
index 475ca39..136cefa 100644
--- a/internal/language/compact/gen_index.go
+++ b/internal/language/compact/gen_index.go
@@ -52,6 +52,11 @@
m[tag] = true
// }
}
+
+ // TODO: plural rules are also defined for the deprecated tags:
+ // iw mo sh tl
+ // Consider removing these as compact tags.
+
// Include locales for plural rules, which uses a different structure.
for _, plurals := range b.supp.Plurals {
for _, rules := range plurals.PluralRules {
diff --git a/internal/number/common.go b/internal/number/common.go
index 052876e..a6e9c8e 100644
--- a/internal/number/common.go
+++ b/internal/number/common.go
@@ -2,7 +2,11 @@
package number
-import "unicode/utf8"
+import (
+ "unicode/utf8"
+
+ "golang.org/x/text/internal/language/compact"
+)
// A system identifies a CLDR numbering system.
type system byte
@@ -45,7 +49,7 @@
type symOffset uint16
type altSymData struct {
- compactTag uint16
+ compactTag compact.ID
symIndex symOffset
system system
}
diff --git a/internal/number/format.go b/internal/number/format.go
index ce1a762..cd94c5d 100644
--- a/internal/number/format.go
+++ b/internal/number/format.go
@@ -39,8 +39,7 @@
func (f *Formatter) init(t language.Tag, index []uint8) {
f.Info = InfoFromTag(t)
- ci, _ := language.CompactIndex(t)
- f.Pattern = formats[index[ci]]
+ f.Pattern = formats[index[tagToID(t)]]
}
// InitPattern initializes a Formatter for the given Pattern.
diff --git a/internal/number/gen.go b/internal/number/gen.go
index 48f180f..c836221 100644
--- a/internal/number/gen.go
+++ b/internal/number/gen.go
@@ -14,11 +14,11 @@
"strings"
"unicode/utf8"
- "golang.org/x/text/internal"
"golang.org/x/text/internal/gen"
+ "golang.org/x/text/internal/language"
+ "golang.org/x/text/internal/language/compact"
"golang.org/x/text/internal/number"
"golang.org/x/text/internal/stringset"
- "golang.org/x/text/language"
"golang.org/x/text/unicode/cldr"
)
@@ -151,19 +151,19 @@
type symbols [NumSymbolTypes]string
type key struct {
- tag int // from language.CompactIndex
+ tag compact.ID
system system
}
symbolMap := map[key]*symbols{}
- defaults := map[int]system{}
+ defaults := map[compact.ID]system{}
for _, lang := range data.Locales() {
ldml := data.RawLDML(lang)
if ldml.Numbers == nil {
continue
}
- langIndex, ok := language.CompactIndex(language.MustParse(lang))
+ langIndex, ok := compact.FromTag(language.MustParse(lang))
if !ok {
log.Fatalf("No compact index for language %s", lang)
}
@@ -213,7 +213,7 @@
for t := SymDecimal; t < NumSymbolTypes; t++ {
p := k.tag
for syms[t] == "" {
- p = int(internal.Parent[p])
+ p = p.Parent()
if pSyms, ok := symbolMap[key{p, k.system}]; ok && (*pSyms)[t] != "" {
syms[t] = (*pSyms)[t]
break
@@ -234,7 +234,7 @@
for ns := system(0); ns < nNumberSystems; ns++ {
for _, l := range data.Locales() {
- langIndex, _ := language.CompactIndex(language.MustParse(l))
+ langIndex, _ := compact.FromTag(language.MustParse(l))
s := symbolMap[key{langIndex, ns}]
if s == nil {
continue
@@ -255,7 +255,7 @@
// resolveSymbolIndex gets the index from the closest matching locale,
// including the locale itself.
- resolveSymbolIndex := func(langIndex int, ns system) symOffset {
+ resolveSymbolIndex := func(langIndex compact.ID, ns system) symOffset {
for {
if sym := symbolMap[key{langIndex, ns}]; sym != nil {
return symOffset(m[*sym])
@@ -263,22 +263,22 @@
if langIndex == 0 {
return 0 // und, latn
}
- langIndex = int(internal.Parent[langIndex])
+ langIndex = langIndex.Parent()
}
}
// Create an index with the symbols for each locale for the latn numbering
// system. If this is not the default, or the only one, for a locale, we
// will overwrite the value later.
- var langToDefaults [language.NumCompactTags]symOffset
+ var langToDefaults [compact.NumCompactTags]symOffset
for _, l := range data.Locales() {
- langIndex, _ := language.CompactIndex(language.MustParse(l))
+ langIndex, _ := compact.FromTag(language.MustParse(l))
langToDefaults[langIndex] = resolveSymbolIndex(langIndex, 0)
}
// Delete redundant entries.
for _, l := range data.Locales() {
- langIndex, _ := language.CompactIndex(language.MustParse(l))
+ langIndex, _ := compact.FromTag(language.MustParse(l))
def := defaults[langIndex]
syms := symbolMap[key{langIndex, def}]
if syms == nil {
@@ -298,7 +298,7 @@
// be referenced if a user specified an alternative numbering system.
var langToAlt []altSymData
for _, l := range data.Locales() {
- langIndex, _ := language.CompactIndex(language.MustParse(l))
+ langIndex, _ := compact.FromTag(language.MustParse(l))
start := len(langToAlt)
if start >= hasNonLatnMask {
log.Fatalf("Number of alternative assignments >= %x", hasNonLatnMask)
@@ -306,7 +306,7 @@
// Create the entry for the default value.
def := defaults[langIndex]
langToAlt = append(langToAlt, altSymData{
- compactTag: uint16(langIndex),
+ compactTag: langIndex,
system: def,
symIndex: resolveSymbolIndex(langIndex, def),
})
@@ -317,7 +317,7 @@
}
if sym := symbolMap[key{langIndex, ns}]; sym != nil {
langToAlt = append(langToAlt, altSymData{
- compactTag: uint16(langIndex),
+ compactTag: langIndex,
system: ns,
symIndex: resolveSymbolIndex(langIndex, ns),
})
@@ -361,16 +361,16 @@
// TODO: It would be possible to eliminate two of these slices by having
// another indirection and store a reference to the combination of patterns.
- decimal := make([]byte, language.NumCompactTags)
- scientific := make([]byte, language.NumCompactTags)
- percent := make([]byte, language.NumCompactTags)
+ decimal := make([]byte, compact.NumCompactTags)
+ scientific := make([]byte, compact.NumCompactTags)
+ percent := make([]byte, compact.NumCompactTags)
for _, lang := range data.Locales() {
ldml := data.RawLDML(lang)
if ldml.Numbers == nil {
continue
}
- langIndex, ok := language.CompactIndex(language.MustParse(lang))
+ langIndex, ok := compact.FromTag(language.MustParse(lang))
if !ok {
log.Fatalf("No compact index for language %s", lang)
}
@@ -440,8 +440,8 @@
// indicates an unspecified value.
for _, data := range [][]byte{decimal, scientific, percent} {
for i := range data {
- p := uint16(i)
- for ; data[p] == 0; p = internal.Parent[p] {
+ p := compact.ID(i)
+ for ; data[p] == 0; p = p.Parent() {
}
data[i] = data[p]
}
diff --git a/internal/number/gen_common.go b/internal/number/gen_common.go
index f88b838..b1b41a7 100644
--- a/internal/number/gen_common.go
+++ b/internal/number/gen_common.go
@@ -6,7 +6,11 @@
package main
-import "unicode/utf8"
+import (
+ "unicode/utf8"
+
+ "golang.org/x/text/internal/language/compact"
+)
// A system identifies a CLDR numbering system.
type system byte
@@ -49,7 +53,7 @@
type symOffset uint16
type altSymData struct {
- compactTag uint16
+ compactTag compact.ID
symIndex symOffset
system system
}
diff --git a/internal/number/number.go b/internal/number/number.go
index 70c0836..fffc176 100644
--- a/internal/number/number.go
+++ b/internal/number/number.go
@@ -10,7 +10,7 @@
import (
"unicode/utf8"
- "golang.org/x/text/internal"
+ "golang.org/x/text/internal/language/compact"
"golang.org/x/text/language"
)
@@ -23,7 +23,7 @@
// InfoFromLangID returns a Info for the given compact language identifier and
// numbering system identifier. If system is the empty string, the default
// numbering system will be taken for that language.
-func InfoFromLangID(compactIndex int, numberSystem string) Info {
+func InfoFromLangID(compactIndex compact.ID, numberSystem string) Info {
p := langToDefaults[compactIndex]
// Lookup the entry for the language.
pSymIndex := symOffset(0) // Default: Latin, default symbols
@@ -51,11 +51,11 @@
break
}
// Move to the parent and retry.
- langIndex = int(internal.Parent[langIndex])
+ langIndex = langIndex.Parent()
} else {
// The index points to a list of symbol data indexes.
for _, e := range langToAlt[p&^hasNonLatnMask:] {
- if int(e.compactTag) != langIndex {
+ if e.compactTag != langIndex {
if langIndex == 0 {
// The CLDR root defines full symbol information for
// all numbering systems (even though mostly by
@@ -73,7 +73,7 @@
continue outerLoop
}
// Fall back to parent.
- langIndex = int(internal.Parent[langIndex])
+ langIndex = langIndex.Parent()
} else if e.system == ns {
pSymIndex = e.symIndex
break outerLoop
@@ -100,8 +100,7 @@
// InfoFromTag returns a Info for the given language tag.
func InfoFromTag(t language.Tag) Info {
- index, _ := language.CompactIndex(t)
- return InfoFromLangID(index, t.TypeForKey("nu"))
+ return InfoFromLangID(tagToID(t), t.TypeForKey("nu"))
}
// IsDecimal reports if the numbering system can convert decimal to native
@@ -144,6 +143,10 @@
}
func formatForLang(t language.Tag, index []byte) *Pattern {
- x, _ := language.CompactIndex(t)
- return &formats[index[x]]
+ return &formats[index[tagToID(t)]]
+}
+
+func tagToID(t language.Tag) compact.ID {
+ id, _ := compact.RegionalID(compact.Tag(t))
+ return id
}
diff --git a/internal/number/tables_test.go b/internal/number/tables_test.go
index 054e23d..f1e542a 100644
--- a/internal/number/tables_test.go
+++ b/internal/number/tables_test.go
@@ -11,8 +11,9 @@
"testing"
"golang.org/x/text/internal/gen"
+ "golang.org/x/text/internal/language"
+ "golang.org/x/text/internal/language/compact"
"golang.org/x/text/internal/testtext"
- "golang.org/x/text/language"
"golang.org/x/text/unicode/cldr"
)
@@ -74,7 +75,7 @@
if ldml.Numbers == nil {
continue
}
- langIndex, ok := language.CompactIndex(language.MustParse(lang))
+ langIndex, ok := compact.FromTag(language.MustParse(lang))
if !ok {
t.Fatalf("No compact index for language %s", lang)
}
diff --git a/internal/tables.go b/internal/tables.go
deleted file mode 100644
index 12d9c95..0000000
--- a/internal/tables.go
+++ /dev/null
@@ -1,120 +0,0 @@
-// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
-
-package internal
-
-// Parent maps a compact index of a tag to the compact index of the parent of
-// this tag.
-var Parent = []uint16{ // 775 elements
- // Entry 0 - 3F
- 0x0000, 0x0000, 0x0001, 0x0001, 0x0000, 0x0004, 0x0000, 0x0006,
- 0x0000, 0x0008, 0x0000, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a,
- 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a,
- 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a,
- 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x0000,
- 0x0000, 0x0028, 0x0000, 0x002a, 0x0000, 0x002c, 0x0000, 0x0000,
- 0x002f, 0x002e, 0x002e, 0x0000, 0x0033, 0x0000, 0x0035, 0x0000,
- 0x0037, 0x0000, 0x0039, 0x0000, 0x003b, 0x0000, 0x0000, 0x003e,
- // Entry 40 - 7F
- 0x0000, 0x0040, 0x0040, 0x0000, 0x0043, 0x0043, 0x0000, 0x0046,
- 0x0000, 0x0048, 0x0000, 0x0000, 0x004b, 0x004a, 0x004a, 0x0000,
- 0x004f, 0x004f, 0x004f, 0x004f, 0x0000, 0x0054, 0x0054, 0x0000,
- 0x0057, 0x0000, 0x0059, 0x0000, 0x005b, 0x0000, 0x005d, 0x005d,
- 0x0000, 0x0060, 0x0000, 0x0062, 0x0000, 0x0064, 0x0000, 0x0066,
- 0x0066, 0x0000, 0x0069, 0x0000, 0x006b, 0x006b, 0x006b, 0x006b,
- 0x006b, 0x006b, 0x006b, 0x0000, 0x0073, 0x0000, 0x0075, 0x0000,
- 0x0077, 0x0000, 0x0000, 0x007a, 0x0000, 0x007c, 0x0000, 0x007e,
- // Entry 80 - BF
- 0x0000, 0x0080, 0x0080, 0x0000, 0x0083, 0x0083, 0x0000, 0x0086,
- 0x0087, 0x0087, 0x0087, 0x0086, 0x0088, 0x0087, 0x0087, 0x0087,
- 0x0086, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0088,
- 0x0087, 0x0087, 0x0087, 0x0087, 0x0088, 0x0087, 0x0088, 0x0087,
- 0x0087, 0x0088, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087,
- 0x0087, 0x0087, 0x0087, 0x0086, 0x0087, 0x0087, 0x0087, 0x0087,
- 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087,
- 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0086, 0x0087, 0x0086,
- // Entry C0 - FF
- 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087,
- 0x0088, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087,
- 0x0086, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0088, 0x0087,
- 0x0087, 0x0088, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087,
- 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0086, 0x0086, 0x0087,
- 0x0087, 0x0086, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0000,
- 0x00ef, 0x0000, 0x00f1, 0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x00f2,
- 0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x00f1, 0x00f2, 0x00f1, 0x00f1,
- // Entry 100 - 13F
- 0x00f2, 0x00f2, 0x00f1, 0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x00f1,
- 0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x0000, 0x010e,
- 0x0000, 0x0110, 0x0000, 0x0112, 0x0000, 0x0114, 0x0114, 0x0000,
- 0x0117, 0x0117, 0x0117, 0x0117, 0x0000, 0x011c, 0x0000, 0x011e,
- 0x0000, 0x0120, 0x0120, 0x0000, 0x0123, 0x0123, 0x0123, 0x0123,
- 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123,
- 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123,
- 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123,
- // Entry 140 - 17F
- 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123,
- 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123,
- 0x0123, 0x0123, 0x0000, 0x0152, 0x0000, 0x0154, 0x0000, 0x0156,
- 0x0000, 0x0158, 0x0000, 0x015a, 0x0000, 0x015c, 0x015c, 0x015c,
- 0x0000, 0x0160, 0x0000, 0x0000, 0x0163, 0x0000, 0x0165, 0x0000,
- 0x0167, 0x0167, 0x0167, 0x0000, 0x016b, 0x0000, 0x016d, 0x0000,
- 0x016f, 0x0000, 0x0171, 0x0171, 0x0000, 0x0174, 0x0000, 0x0176,
- 0x0000, 0x0178, 0x0000, 0x017a, 0x0000, 0x017c, 0x0000, 0x017e,
- // Entry 180 - 1BF
- 0x0000, 0x0000, 0x0000, 0x0182, 0x0000, 0x0184, 0x0184, 0x0184,
- 0x0184, 0x0000, 0x0000, 0x0000, 0x018b, 0x0000, 0x0000, 0x018e,
- 0x0000, 0x0000, 0x0191, 0x0000, 0x0000, 0x0000, 0x0195, 0x0000,
- 0x0197, 0x0000, 0x0000, 0x019a, 0x0000, 0x0000, 0x019d, 0x0000,
- 0x019f, 0x0000, 0x01a1, 0x0000, 0x01a3, 0x0000, 0x01a5, 0x0000,
- 0x01a7, 0x0000, 0x01a9, 0x0000, 0x01ab, 0x0000, 0x01ad, 0x0000,
- 0x01af, 0x0000, 0x01b1, 0x01b1, 0x0000, 0x01b4, 0x0000, 0x01b6,
- 0x0000, 0x01b8, 0x0000, 0x01ba, 0x0000, 0x01bc, 0x0000, 0x0000,
- // Entry 1C0 - 1FF
- 0x01bf, 0x0000, 0x01c1, 0x0000, 0x01c3, 0x0000, 0x01c5, 0x0000,
- 0x01c7, 0x0000, 0x01c9, 0x0000, 0x01cb, 0x01cb, 0x01cb, 0x01cb,
- 0x0000, 0x01d0, 0x0000, 0x01d2, 0x01d2, 0x0000, 0x01d5, 0x0000,
- 0x01d7, 0x0000, 0x01d9, 0x0000, 0x01db, 0x0000, 0x01dd, 0x0000,
- 0x01df, 0x01df, 0x0000, 0x01e2, 0x0000, 0x01e4, 0x0000, 0x01e6,
- 0x0000, 0x01e8, 0x0000, 0x01ea, 0x0000, 0x01ec, 0x0000, 0x01ee,
- 0x0000, 0x01f0, 0x0000, 0x0000, 0x01f3, 0x0000, 0x01f5, 0x01f5,
- 0x01f5, 0x0000, 0x01f9, 0x0000, 0x01fb, 0x0000, 0x01fd, 0x0000,
- // Entry 200 - 23F
- 0x01ff, 0x0000, 0x0000, 0x0202, 0x0000, 0x0204, 0x0204, 0x0000,
- 0x0207, 0x0000, 0x0209, 0x0209, 0x0000, 0x020c, 0x020c, 0x0000,
- 0x020f, 0x020f, 0x020f, 0x020f, 0x020f, 0x020f, 0x020f, 0x0000,
- 0x0217, 0x0000, 0x0219, 0x0000, 0x021b, 0x0000, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0221, 0x0000, 0x0000, 0x0224, 0x0000, 0x0226,
- 0x0226, 0x0000, 0x0229, 0x0000, 0x022b, 0x022b, 0x0000, 0x0000,
- 0x022f, 0x022e, 0x022e, 0x0000, 0x0000, 0x0234, 0x0000, 0x0236,
- 0x0000, 0x0238, 0x0000, 0x0244, 0x023a, 0x0244, 0x0244, 0x0244,
- // Entry 240 - 27F
- 0x0244, 0x0244, 0x0244, 0x0244, 0x023a, 0x0244, 0x0244, 0x0000,
- 0x0247, 0x0247, 0x0247, 0x0000, 0x024b, 0x0000, 0x024d, 0x0000,
- 0x024f, 0x024f, 0x0000, 0x0252, 0x0000, 0x0254, 0x0254, 0x0254,
- 0x0254, 0x0254, 0x0254, 0x0000, 0x025b, 0x0000, 0x025d, 0x0000,
- 0x025f, 0x0000, 0x0261, 0x0000, 0x0263, 0x0000, 0x0265, 0x0000,
- 0x0000, 0x0268, 0x0268, 0x0268, 0x0000, 0x026c, 0x0000, 0x026e,
- 0x0000, 0x0270, 0x0000, 0x0000, 0x0000, 0x0274, 0x0273, 0x0273,
- 0x0000, 0x0278, 0x0000, 0x027a, 0x0000, 0x027c, 0x0000, 0x0000,
- // Entry 280 - 2BF
- 0x0000, 0x0000, 0x0281, 0x0000, 0x0000, 0x0284, 0x0000, 0x0286,
- 0x0286, 0x0286, 0x0286, 0x0000, 0x028b, 0x028b, 0x028b, 0x0000,
- 0x028f, 0x028f, 0x028f, 0x028f, 0x028f, 0x0000, 0x0295, 0x0295,
- 0x0295, 0x0295, 0x0000, 0x0000, 0x0000, 0x0000, 0x029d, 0x029d,
- 0x029d, 0x0000, 0x02a1, 0x02a1, 0x02a1, 0x02a1, 0x0000, 0x0000,
- 0x02a7, 0x02a7, 0x02a7, 0x02a7, 0x0000, 0x02ac, 0x0000, 0x02ae,
- 0x02ae, 0x0000, 0x02b1, 0x0000, 0x02b3, 0x0000, 0x02b5, 0x02b5,
- 0x0000, 0x0000, 0x02b9, 0x0000, 0x0000, 0x0000, 0x02bd, 0x0000,
- // Entry 2C0 - 2FF
- 0x02bf, 0x02bf, 0x0000, 0x0000, 0x02c3, 0x0000, 0x02c5, 0x0000,
- 0x02c7, 0x0000, 0x02c9, 0x0000, 0x02cb, 0x0000, 0x02cd, 0x02cd,
- 0x0000, 0x0000, 0x02d1, 0x0000, 0x02d3, 0x02d0, 0x02d0, 0x0000,
- 0x0000, 0x02d8, 0x02d7, 0x02d7, 0x0000, 0x0000, 0x02dd, 0x0000,
- 0x02df, 0x0000, 0x02e1, 0x0000, 0x0000, 0x02e4, 0x0000, 0x02e6,
- 0x0000, 0x0000, 0x02e9, 0x0000, 0x02eb, 0x0000, 0x02ed, 0x0000,
- 0x02ef, 0x02ef, 0x0000, 0x0000, 0x02f3, 0x02f2, 0x02f2, 0x0000,
- 0x02f7, 0x0000, 0x02f9, 0x02f9, 0x02f9, 0x02f9, 0x02f9, 0x0000,
- // Entry 300 - 33F
- 0x02ff, 0x0300, 0x02ff, 0x0000, 0x0303, 0x0051, 0x00e6,
-} // Size: 1574 bytes
-
-// Total table size 1574 bytes (1KiB); checksum: 895AAF0B
