restic/vendor/golang.org/x/text/internal/cldrtree/generate.go

209 lines
4.6 KiB
Go
Raw Normal View History

// Copyright 2017 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 cldrtree
import (
"bytes"
"fmt"
"io"
"reflect"
"strconv"
"strings"
"golang.org/x/text/internal/gen"
)
func generate(b *Builder, t *Tree, w *gen.CodeWriter) error {
fmt.Fprintln(w, `import "golang.org/x/text/internal/cldrtree"`)
fmt.Fprintln(w)
fmt.Fprintf(w, "var tree = &cldrtree.Tree{locales, indices, buckets}\n\n")
w.WriteComment("Path values:\n" + b.stats())
fmt.Fprintln(w)
// Generate enum types.
for _, e := range b.enums {
// Build enum types.
w.WriteComment("%s specifies a property of a CLDR field.", e.name)
fmt.Fprintf(w, "type %s uint16\n", e.name)
}
d, err := getEnumData(b)
if err != nil {
return err
}
fmt.Fprintln(w, "const (")
for i, k := range d.keys {
fmt.Fprintf(w, "%s %s = %d // %s\n", toCamel(k), d.enums[i], d.m[k], k)
}
fmt.Fprintln(w, ")")
w.WriteVar("locales", t.Locales)
w.WriteVar("indices", t.Indices)
// Generate string buckets.
fmt.Fprintln(w, "var buckets = []string{")
for i := range t.Buckets {
fmt.Fprintf(w, "bucket%d,\n", i)
}
fmt.Fprint(w, "}\n\n")
w.Size += int(reflect.TypeOf("").Size()) * len(t.Buckets)
// Generate string buckets.
for i, bucket := range t.Buckets {
w.WriteVar(fmt.Sprint("bucket", i), bucket)
}
return nil
}
func generateTestData(b *Builder, w *gen.CodeWriter) error {
d, err := getEnumData(b)
if err != nil {
return err
}
fmt.Fprintln(w)
fmt.Fprintln(w, "var enumMap = map[string]uint16{")
fmt.Fprintln(w, `"": 0,`)
for _, k := range d.keys {
fmt.Fprintf(w, "%q: %d,\n", k, d.m[k])
}
fmt.Fprintln(w, "}")
return nil
}
func toCamel(s string) string {
p := strings.Split(s, "-")
for i, s := range p[1:] {
p[i+1] = strings.Title(s)
}
return strings.Replace(strings.Join(p, ""), "/", "", -1)
}
func (b *Builder) stats() string {
w := &bytes.Buffer{}
b.rootMeta.validate()
for _, es := range b.enums {
fmt.Fprintf(w, "<%s>\n", es.name)
printEnumValues(w, es, 1, nil)
}
fmt.Fprintln(w)
printEnums(w, b.rootMeta.typeInfo, 0)
fmt.Fprintln(w)
fmt.Fprintln(w, "Nr elem: ", len(b.strToBucket))
fmt.Fprintln(w, "uniqued size: ", b.size)
fmt.Fprintln(w, "total string size: ", b.sizeAll)
fmt.Fprintln(w, "bucket waste: ", b.bucketWaste)
return w.String()
}
func printEnums(w io.Writer, s *typeInfo, indent int) {
idStr := strings.Repeat(" ", indent) + "- "
e := s.enum
if e == nil {
if len(s.entries) > 0 {
panic(fmt.Errorf("has entries but no enum values: %#v", s.entries))
}
return
}
if e.name != "" {
fmt.Fprintf(w, "%s<%s>\n", idStr, e.name)
} else {
printEnumValues(w, e, indent, s)
}
if s.sharedKeys() {
for _, v := range s.entries {
printEnums(w, v, indent+1)
break
}
}
}
func printEnumValues(w io.Writer, e *enum, indent int, info *typeInfo) {
idStr := strings.Repeat(" ", indent) + "- "
for i := 0; i < len(e.keys); i++ {
fmt.Fprint(w, idStr)
k := e.keys[i]
if u, err := strconv.ParseUint(k, 10, 16); err == nil {
fmt.Fprintf(w, "%s", k)
// Skip contiguous integers
var v, last uint64
for i++; i < len(e.keys); i++ {
k = e.keys[i]
if v, err = strconv.ParseUint(k, 10, 16); err != nil {
break
}
last = v
}
if u < last {
fmt.Fprintf(w, `..%d`, last)
}
fmt.Fprintln(w)
if err != nil {
fmt.Fprintf(w, "%s%s\n", idStr, k)
}
} else if k == "" {
fmt.Fprintln(w, `""`)
} else {
fmt.Fprintf(w, "%s\n", k)
}
if info != nil && !info.sharedKeys() {
if e := info.entries[enumIndex(i)]; e != nil {
printEnums(w, e, indent+1)
}
}
}
}
func getEnumData(b *Builder) (*enumData, error) {
d := &enumData{m: map[string]int{}}
if errStr := d.insert(b.rootMeta.typeInfo); errStr != "" {
// TODO: consider returning the error.
return nil, fmt.Errorf("cldrtree: %s", errStr)
}
return d, nil
}
type enumData struct {
m map[string]int
keys []string
enums []string
}
func (d *enumData) insert(t *typeInfo) (errStr string) {
e := t.enum
if e == nil {
return ""
}
for i, k := range e.keys {
if _, err := strconv.ParseUint(k, 10, 16); err == nil {
// We don't include any enum that has integer values.
break
}
if v, ok := d.m[k]; ok {
if v != i {
return fmt.Sprintf("%q has value %d and %d", k, i, v)
}
} else {
d.m[k] = i
if k != "" {
d.keys = append(d.keys, k)
d.enums = append(d.enums, e.name)
}
}
}
for i := range t.enum.keys {
if e := t.entries[enumIndex(i)]; e != nil {
if errStr := d.insert(e); errStr != "" {
return fmt.Sprintf("%q>%v", t.enum.keys[i], errStr)
}
}
}
return ""
}