+++ /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
