summaryrefslogtreecommitdiff
path: root/vendor/golang.org/x/text/date/gen.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/golang.org/x/text/date/gen.go')
-rw-r--r--vendor/golang.org/x/text/date/gen.go329
1 files changed, 329 insertions, 0 deletions
diff --git a/vendor/golang.org/x/text/date/gen.go b/vendor/golang.org/x/text/date/gen.go
new file mode 100644
index 0000000..6f4ae07
--- /dev/null
+++ b/vendor/golang.org/x/text/date/gen.go
@@ -0,0 +1,329 @@
+// 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.
+
+// +build ignore
+
+package main
+
+import (
+ "flag"
+ "log"
+ "strconv"
+ "strings"
+
+ "golang.org/x/text/internal/cldrtree"
+ "golang.org/x/text/internal/gen"
+ "golang.org/x/text/language"
+ "golang.org/x/text/unicode/cldr"
+)
+
+var (
+ draft = flag.String("draft",
+ "contributed",
+ `Minimal draft requirements (approved, contributed, provisional, unconfirmed).`)
+)
+
+// TODO:
+// - Compile format patterns.
+// - Compress the large amount of redundancy in metazones.
+// - Split trees (with shared buckets) with data that is enough for default
+// formatting of Go Time values and and tables that are needed for larger
+// variants.
+// - zone to metaZone mappings (in supplemental)
+// - Add more enum values and also some key maps for some of the elements.
+
+func main() {
+ gen.Init()
+
+ r := gen.OpenCLDRCoreZip()
+ defer r.Close()
+
+ d := &cldr.Decoder{}
+ d.SetDirFilter("supplemental", "main")
+ d.SetSectionFilter("dates")
+ data, err := d.DecodeZip(r)
+ if err != nil {
+ log.Fatalf("DecodeZip: %v", err)
+ }
+
+ dates := cldrtree.New("dates")
+ buildCLDRTree(data, dates)
+
+ w := gen.NewCodeWriter()
+ if err := dates.Gen(w); err != nil {
+ log.Fatal(err)
+ }
+ gen.WriteCLDRVersion(w)
+ w.WriteGoFile("tables.go", "date")
+
+ w = gen.NewCodeWriter()
+ if err := dates.GenTestData(w); err != nil {
+ log.Fatal(err)
+ }
+ w.WriteGoFile("data_test.go", "date")
+}
+
+func buildCLDRTree(data *cldr.CLDR, dates *cldrtree.Builder) {
+ context := cldrtree.Enum("context")
+ widthMap := func(s string) string {
+ // Align era with width values.
+ if r, ok := map[string]string{
+ "eraAbbr": "abbreviated",
+ "eraNarrow": "narrow",
+ "eraNames": "wide",
+ }[s]; ok {
+ s = r
+ }
+ // Prefix width to disambiguate with some overlapping length values.
+ return "width" + strings.Title(s)
+ }
+ width := cldrtree.EnumFunc("width", widthMap, "abbreviated", "narrow", "wide")
+ length := cldrtree.Enum("length", "short", "long")
+ month := cldrtree.Enum("month", "leap7")
+ relTime := cldrtree.EnumFunc("relTime", func(s string) string {
+ x, err := strconv.ParseInt(s, 10, 8)
+ if err != nil {
+ log.Fatal("Invalid number:", err)
+ }
+ return []string{
+ "before2",
+ "before1",
+ "current",
+ "after1",
+ "after2",
+ "after3",
+ }[x+2]
+ })
+ // Disambiguate keys like 'months' and 'sun'.
+ cycleType := cldrtree.EnumFunc("cycleType", func(s string) string {
+ return s + "CycleType"
+ })
+ field := cldrtree.EnumFunc("field", func(s string) string {
+ return s + "Field"
+ })
+ timeType := cldrtree.EnumFunc("timeType", func(s string) string {
+ if s == "" {
+ return "genericTime"
+ }
+ return s + "Time"
+ }, "generic")
+
+ zoneType := []cldrtree.Option{cldrtree.SharedType(), timeType}
+ metaZoneType := []cldrtree.Option{cldrtree.SharedType(), timeType}
+
+ for _, lang := range data.Locales() {
+ tag := language.Make(lang)
+ ldml := data.RawLDML(lang)
+ if ldml.Dates == nil {
+ continue
+ }
+ x := dates.Locale(tag)
+ if x := x.Index(ldml.Dates.Calendars); x != nil {
+ for _, cal := range ldml.Dates.Calendars.Calendar {
+ x := x.IndexFromType(cal)
+ if x := x.Index(cal.Months); x != nil {
+ for _, mc := range cal.Months.MonthContext {
+ x := x.IndexFromType(mc, context)
+ for _, mw := range mc.MonthWidth {
+ x := x.IndexFromType(mw, width)
+ for _, m := range mw.Month {
+ x.SetValue(m.Yeartype+m.Type, m, month)
+ }
+ }
+ }
+ }
+ if x := x.Index(cal.MonthPatterns); x != nil {
+ for _, mc := range cal.MonthPatterns.MonthPatternContext {
+ x := x.IndexFromType(mc, context)
+ for _, mw := range mc.MonthPatternWidth {
+ // Value is always leap, so no need to create a
+ // subindex.
+ for _, m := range mw.MonthPattern {
+ x.SetValue(mw.Type, m, width)
+ }
+ }
+ }
+ }
+ if x := x.Index(cal.CyclicNameSets); x != nil {
+ for _, cns := range cal.CyclicNameSets.CyclicNameSet {
+ x := x.IndexFromType(cns, cycleType)
+ for _, cc := range cns.CyclicNameContext {
+ x := x.IndexFromType(cc, context)
+ for _, cw := range cc.CyclicNameWidth {
+ x := x.IndexFromType(cw, width)
+ for _, c := range cw.CyclicName {
+ x.SetValue(c.Type, c)
+ }
+ }
+ }
+ }
+ }
+ if x := x.Index(cal.Days); x != nil {
+ for _, dc := range cal.Days.DayContext {
+ x := x.IndexFromType(dc, context)
+ for _, dw := range dc.DayWidth {
+ x := x.IndexFromType(dw, width)
+ for _, d := range dw.Day {
+ x.SetValue(d.Type, d)
+ }
+ }
+ }
+ }
+ if x := x.Index(cal.Quarters); x != nil {
+ for _, qc := range cal.Quarters.QuarterContext {
+ x := x.IndexFromType(qc, context)
+ for _, qw := range qc.QuarterWidth {
+ x := x.IndexFromType(qw, width)
+ for _, q := range qw.Quarter {
+ x.SetValue(q.Type, q)
+ }
+ }
+ }
+ }
+ if x := x.Index(cal.DayPeriods); x != nil {
+ for _, dc := range cal.DayPeriods.DayPeriodContext {
+ x := x.IndexFromType(dc, context)
+ for _, dw := range dc.DayPeriodWidth {
+ x := x.IndexFromType(dw, width)
+ for _, d := range dw.DayPeriod {
+ x.IndexFromType(d).SetValue(d.Alt, d)
+ }
+ }
+ }
+ }
+ if x := x.Index(cal.Eras); x != nil {
+ opts := []cldrtree.Option{width, cldrtree.SharedType()}
+ if x := x.Index(cal.Eras.EraNames, opts...); x != nil {
+ for _, e := range cal.Eras.EraNames.Era {
+ x.IndexFromAlt(e).SetValue(e.Type, e)
+ }
+ }
+ if x := x.Index(cal.Eras.EraAbbr, opts...); x != nil {
+ for _, e := range cal.Eras.EraAbbr.Era {
+ x.IndexFromAlt(e).SetValue(e.Type, e)
+ }
+ }
+ if x := x.Index(cal.Eras.EraNarrow, opts...); x != nil {
+ for _, e := range cal.Eras.EraNarrow.Era {
+ x.IndexFromAlt(e).SetValue(e.Type, e)
+ }
+ }
+ }
+ if x := x.Index(cal.DateFormats); x != nil {
+ for _, dfl := range cal.DateFormats.DateFormatLength {
+ x := x.IndexFromType(dfl, length)
+ for _, df := range dfl.DateFormat {
+ for _, p := range df.Pattern {
+ x.SetValue(p.Alt, p)
+ }
+ }
+ }
+ }
+ if x := x.Index(cal.TimeFormats); x != nil {
+ for _, tfl := range cal.TimeFormats.TimeFormatLength {
+ x := x.IndexFromType(tfl, length)
+ for _, tf := range tfl.TimeFormat {
+ for _, p := range tf.Pattern {
+ x.SetValue(p.Alt, p)
+ }
+ }
+ }
+ }
+ if x := x.Index(cal.DateTimeFormats); x != nil {
+ for _, dtfl := range cal.DateTimeFormats.DateTimeFormatLength {
+ x := x.IndexFromType(dtfl, length)
+ for _, dtf := range dtfl.DateTimeFormat {
+ for _, p := range dtf.Pattern {
+ x.SetValue(p.Alt, p)
+ }
+ }
+ }
+ // TODO:
+ // - appendItems
+ // - intervalFormats
+ }
+ }
+ }
+ // TODO: this is a lot of data and is probably relatively little used.
+ // Store this somewhere else.
+ if x := x.Index(ldml.Dates.Fields); x != nil {
+ for _, f := range ldml.Dates.Fields.Field {
+ x := x.IndexFromType(f, field)
+ for _, d := range f.DisplayName {
+ x.Index(d).SetValue(d.Alt, d)
+ }
+ for _, r := range f.Relative {
+ x.Index(r).SetValue(r.Type, r, relTime)
+ }
+ for _, rt := range f.RelativeTime {
+ x := x.Index(rt).IndexFromType(rt)
+ for _, p := range rt.RelativeTimePattern {
+ x.SetValue(p.Count, p)
+ }
+ }
+ for _, rp := range f.RelativePeriod {
+ x.Index(rp).SetValue(rp.Alt, rp)
+ }
+ }
+ }
+ if x := x.Index(ldml.Dates.TimeZoneNames); x != nil {
+ format := x.IndexWithName("zoneFormat")
+ for _, h := range ldml.Dates.TimeZoneNames.HourFormat {
+ format.SetValue(h.Element(), h)
+ }
+ for _, g := range ldml.Dates.TimeZoneNames.GmtFormat {
+ format.SetValue(g.Element(), g)
+ }
+ for _, g := range ldml.Dates.TimeZoneNames.GmtZeroFormat {
+ format.SetValue(g.Element(), g)
+ }
+ for _, r := range ldml.Dates.TimeZoneNames.RegionFormat {
+ x.Index(r).SetValue(r.Type, r, timeType)
+ }
+
+ set := func(x *cldrtree.Index, e []*cldr.Common, zone string) {
+ for _, n := range e {
+ x.Index(n, zoneType...).SetValue(zone, n)
+ }
+ }
+ zoneWidth := []cldrtree.Option{length, cldrtree.SharedType()}
+ zs := x.IndexWithName("zone")
+ for _, z := range ldml.Dates.TimeZoneNames.Zone {
+ for _, l := range z.Long {
+ x := zs.Index(l, zoneWidth...)
+ set(x, l.Generic, z.Type)
+ set(x, l.Standard, z.Type)
+ set(x, l.Daylight, z.Type)
+ }
+ for _, s := range z.Short {
+ x := zs.Index(s, zoneWidth...)
+ set(x, s.Generic, z.Type)
+ set(x, s.Standard, z.Type)
+ set(x, s.Daylight, z.Type)
+ }
+ }
+ set = func(x *cldrtree.Index, e []*cldr.Common, zone string) {
+ for _, n := range e {
+ x.Index(n, metaZoneType...).SetValue(zone, n)
+ }
+ }
+ zoneWidth = []cldrtree.Option{length, cldrtree.SharedType()}
+ zs = x.IndexWithName("metaZone")
+ for _, z := range ldml.Dates.TimeZoneNames.Metazone {
+ for _, l := range z.Long {
+ x := zs.Index(l, zoneWidth...)
+ set(x, l.Generic, z.Type)
+ set(x, l.Standard, z.Type)
+ set(x, l.Daylight, z.Type)
+ }
+ for _, s := range z.Short {
+ x := zs.Index(s, zoneWidth...)
+ set(x, s.Generic, z.Type)
+ set(x, s.Standard, z.Type)
+ set(x, s.Daylight, z.Type)
+ }
+ }
+ }
+ }
+}