--- /dev/null
+// 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
+
+// Generator for currency-related data.
+
+package main
+
+import (
+ "flag"
+ "fmt"
+ "log"
+ "os"
+ "sort"
+ "strconv"
+ "strings"
+ "time"
+
+ "golang.org/x/text/internal"
+ "golang.org/x/text/internal/gen"
+ "golang.org/x/text/internal/tag"
+ "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")
+
+ draft = flag.String("draft",
+ "contributed",
+ `Minimal draft requirements (approved, contributed, provisional, unconfirmed).`)
+)
+
+func main() {
+ gen.Init()
+
+ gen.Repackage("gen_common.go", "common.go", "currency")
+
+ // Read the CLDR zip file.
+ r := gen.OpenCLDRCoreZip()
+ defer r.Close()
+
+ d := &cldr.Decoder{}
+ d.SetDirFilter("supplemental", "main")
+ d.SetSectionFilter("numbers")
+ data, err := d.DecodeZip(r)
+ if err != nil {
+ log.Fatalf("DecodeZip: %v", err)
+ }
+
+ w := gen.NewCodeWriter()
+ defer w.WriteGoFile(*outputFile, "currency")
+
+ fmt.Fprintln(w, `import "golang.org/x/text/internal/tag"`)
+
+ gen.WriteCLDRVersion(w)
+ b := &builder{}
+ b.genCurrencies(w, data.Supplemental())
+ b.genSymbols(w, data)
+}
+
+var constants = []string{
+ // Undefined and testing.
+ "XXX", "XTS",
+ // G11 currencies https://en.wikipedia.org/wiki/G10_currencies.
+ "USD", "EUR", "JPY", "GBP", "CHF", "AUD", "NZD", "CAD", "SEK", "NOK", "DKK",
+ // Precious metals.
+ "XAG", "XAU", "XPT", "XPD",
+
+ // Additional common currencies as defined by CLDR.
+ "BRL", "CNY", "INR", "RUB", "HKD", "IDR", "KRW", "MXN", "PLN", "SAR",
+ "THB", "TRY", "TWD", "ZAR",
+}
+
+type builder struct {
+ currencies tag.Index
+ numCurrencies int
+}
+
+func (b *builder) genCurrencies(w *gen.CodeWriter, data *cldr.SupplementalData) {
+ // 3-letter ISO currency codes
+ // Start with dummy to let index start at 1.
+ currencies := []string{"\x00\x00\x00\x00"}
+
+ // currency codes
+ for _, reg := range data.CurrencyData.Region {
+ for _, cur := range reg.Currency {
+ currencies = append(currencies, cur.Iso4217)
+ }
+ }
+ // Not included in the list for some reasons:
+ currencies = append(currencies, "MVP")
+
+ sort.Strings(currencies)
+ // Unique the elements.
+ k := 0
+ for i := 1; i < len(currencies); i++ {
+ if currencies[k] != currencies[i] {
+ currencies[k+1] = currencies[i]
+ k++
+ }
+ }
+ currencies = currencies[:k+1]
+
+ // Close with dummy for simpler and faster searching.
+ currencies = append(currencies, "\xff\xff\xff\xff")
+
+ // Write currency values.
+ fmt.Fprintln(w, "const (")
+ for _, c := range constants {
+ index := sort.SearchStrings(currencies, c)
+ fmt.Fprintf(w, "\t%s = %d\n", strings.ToLower(c), index)
+ }
+ fmt.Fprint(w, ")")
+
+ // Compute currency-related data that we merge into the table.
+ for _, info := range data.CurrencyData.Fractions[0].Info {
+ if info.Iso4217 == "DEFAULT" {
+ continue
+ }
+ standard := getRoundingIndex(info.Digits, info.Rounding, 0)
+ cash := getRoundingIndex(info.CashDigits, info.CashRounding, standard)
+
+ index := sort.SearchStrings(currencies, info.Iso4217)
+ currencies[index] += mkCurrencyInfo(standard, cash)
+ }
+
+ // Set default values for entries that weren't touched.
+ for i, c := range currencies {
+ if len(c) == 3 {
+ currencies[i] += mkCurrencyInfo(0, 0)
+ }
+ }
+
+ b.currencies = tag.Index(strings.Join(currencies, ""))
+ w.WriteComment(`
+ currency holds an alphabetically sorted list of canonical 3-letter currency
+ identifiers. Each identifier is followed by a byte of type currencyInfo,
+ defined in gen_common.go.`)
+ w.WriteConst("currency", b.currencies)
+
+ // Hack alert: gofmt indents a trailing comment after an indented string.
+ // Ensure that the next thing written is not a comment.
+ b.numCurrencies = (len(b.currencies) / 4) - 2
+ w.WriteConst("numCurrencies", b.numCurrencies)
+
+ // Create a table that maps regions to currencies.
+ regionToCurrency := []toCurrency{}
+
+ for _, reg := range data.CurrencyData.Region {
+ if len(reg.Iso3166) != 2 {
+ log.Fatalf("Unexpected group %q in region data", reg.Iso3166)
+ }
+ if len(reg.Currency) == 0 {
+ continue
+ }
+ cur := reg.Currency[0]
+ if cur.To != "" || cur.Tender == "false" {
+ continue
+ }
+ regionToCurrency = append(regionToCurrency, toCurrency{
+ region: regionToCode(language.MustParseRegion(reg.Iso3166)),
+ code: uint16(b.currencies.Index([]byte(cur.Iso4217))),
+ })
+ }
+ sort.Sort(byRegion(regionToCurrency))
+
+ w.WriteType(toCurrency{})
+ w.WriteVar("regionToCurrency", regionToCurrency)
+
+ // Create a table that maps regions to currencies.
+ regionData := []regionInfo{}
+
+ for _, reg := range data.CurrencyData.Region {
+ if len(reg.Iso3166) != 2 {
+ log.Fatalf("Unexpected group %q in region data", reg.Iso3166)
+ }
+ for _, cur := range reg.Currency {
+ from, _ := time.Parse("2006-01-02", cur.From)
+ to, _ := time.Parse("2006-01-02", cur.To)
+ code := uint16(b.currencies.Index([]byte(cur.Iso4217)))
+ if cur.Tender == "false" {
+ code |= nonTenderBit
+ }
+ regionData = append(regionData, regionInfo{
+ region: regionToCode(language.MustParseRegion(reg.Iso3166)),
+ code: code,
+ from: toDate(from),
+ to: toDate(to),
+ })
+ }
+ }
+ sort.Stable(byRegionCode(regionData))
+
+ w.WriteType(regionInfo{})
+ w.WriteVar("regionData", regionData)
+}
+
+type regionInfo struct {
+ region uint16
+ code uint16 // 0x8000 not legal tender
+ from uint32
+ to uint32
+}
+
+type byRegionCode []regionInfo
+
+func (a byRegionCode) Len() int { return len(a) }
+func (a byRegionCode) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+func (a byRegionCode) Less(i, j int) bool { return a[i].region < a[j].region }
+
+type toCurrency struct {
+ region uint16
+ code uint16
+}
+
+type byRegion []toCurrency
+
+func (a byRegion) Len() int { return len(a) }
+func (a byRegion) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+func (a byRegion) Less(i, j int) bool { return a[i].region < a[j].region }
+
+func mkCurrencyInfo(standard, cash int) string {
+ return string([]byte{byte(cash<<cashShift | standard)})
+}
+
+func getRoundingIndex(digits, rounding string, defIndex int) int {
+ round := roundings[defIndex] // default
+
+ if digits != "" {
+ round.scale = parseUint8(digits)
+ }
+ if rounding != "" && rounding != "0" { // 0 means 1 here in CLDR
+ round.increment = parseUint8(rounding)
+ }
+
+ // Will panic if the entry doesn't exist:
+ for i, r := range roundings {
+ if r == round {
+ return i
+ }
+ }
+ log.Fatalf("Rounding entry %#v does not exist.", round)
+ panic("unreachable")
+}
+
+// genSymbols generates the symbols used for currencies. Most symbols are
+// defined in root and there is only very small variation per language.
+// The following rules apply:
+// - A symbol can be requested as normal or narrow.
+// - If a symbol is not defined for a currency, it defaults to its ISO code.
+func (b *builder) genSymbols(w *gen.CodeWriter, data *cldr.CLDR) {
+ d, err := cldr.ParseDraft(*draft)
+ if err != nil {
+ log.Fatalf("filter: %v", err)
+ }
+
+ const (
+ normal = iota
+ narrow
+ numTypes
+ )
+ // language -> currency -> type -> symbol
+ var symbols [language.NumCompactTags][][numTypes]*string
+
+ // Collect symbol information per language.
+ for _, lang := range data.Locales() {
+ ldml := data.RawLDML(lang)
+ if ldml.Numbers == nil || ldml.Numbers.Currencies == nil {
+ continue
+ }
+
+ langIndex, ok := language.CompactIndex(language.MustParse(lang))
+ if !ok {
+ log.Fatalf("No compact index for language %s", lang)
+ }
+
+ symbols[langIndex] = make([][numTypes]*string, b.numCurrencies+1)
+
+ for _, c := range ldml.Numbers.Currencies.Currency {
+ syms := cldr.MakeSlice(&c.Symbol)
+ syms.SelectDraft(d)
+
+ for _, sym := range c.Symbol {
+ v := sym.Data()
+ if v == c.Type {
+ // We define "" to mean the ISO symbol.
+ v = ""
+ }
+ cur := b.currencies.Index([]byte(c.Type))
+ // XXX gets reassigned to 0 in the package's code.
+ if c.Type == "XXX" {
+ cur = 0
+ }
+ if cur == -1 {
+ fmt.Println("Unsupported:", c.Type)
+ continue
+ }
+
+ switch sym.Alt {
+ case "":
+ symbols[langIndex][cur][normal] = &v
+ case "narrow":
+ symbols[langIndex][cur][narrow] = &v
+ }
+ }
+ }
+ }
+
+ // Remove values identical to the parent.
+ for langIndex, data := range symbols {
+ for curIndex, curs := range data {
+ for typ, sym := range curs {
+ if sym == nil {
+ continue
+ }
+ for p := uint16(langIndex); p != 0; {
+ p = internal.Parent[p]
+ x := symbols[p]
+ if x == nil {
+ continue
+ }
+ if v := x[curIndex][typ]; v != nil || p == 0 {
+ // Value is equal to the default value root value is undefined.
+ parentSym := ""
+ if v != nil {
+ parentSym = *v
+ }
+ if parentSym == *sym {
+ // Value is the same as parent.
+ data[curIndex][typ] = nil
+ }
+ break
+ }
+ }
+ }
+ }
+ }
+
+ // Create symbol index.
+ symbolData := []byte{0}
+ symbolLookup := map[string]uint16{"": 0} // 0 means default, so block that value.
+ for _, data := range symbols {
+ for _, curs := range data {
+ for _, sym := range curs {
+ if sym == nil {
+ continue
+ }
+ if _, ok := symbolLookup[*sym]; !ok {
+ symbolLookup[*sym] = uint16(len(symbolData))
+ symbolData = append(symbolData, byte(len(*sym)))
+ symbolData = append(symbolData, *sym...)
+ }
+ }
+ }
+ }
+ w.WriteComment(`
+ symbols holds symbol data of the form <n> <str>, where n is the length of
+ the symbol string str.`)
+ w.WriteConst("symbols", string(symbolData))
+
+ // Create index from language to currency lookup to symbol.
+ type curToIndex struct{ cur, idx uint16 }
+ w.WriteType(curToIndex{})
+
+ prefix := []string{"normal", "narrow"}
+ // Create data for regular and narrow symbol data.
+ for typ := normal; typ <= narrow; typ++ {
+
+ indexes := []curToIndex{} // maps currency to symbol index
+ languages := []uint16{}
+
+ for _, data := range symbols {
+ languages = append(languages, uint16(len(indexes)))
+ for curIndex, curs := range data {
+
+ if sym := curs[typ]; sym != nil {
+ indexes = append(indexes, curToIndex{uint16(curIndex), symbolLookup[*sym]})
+ }
+ }
+ }
+ languages = append(languages, uint16(len(indexes)))
+
+ w.WriteVar(prefix[typ]+"LangIndex", languages)
+ w.WriteVar(prefix[typ]+"SymIndex", indexes)
+ }
+}
+func parseUint8(str string) uint8 {
+ x, err := strconv.ParseUint(str, 10, 8)
+ if err != nil {
+ // Show line number of where this function was called.
+ log.New(os.Stderr, "", log.Lshortfile).Output(2, err.Error())
+ os.Exit(1)
+ }
+ return uint8(x)
+}
OSDN Git Service
