| // Copyright 2013 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 cldr |
| |
| // This file implements the various inheritance constructs defined by LDML. |
| // See http://www.unicode.org/reports/tr35/#Inheritance_and_Validity |
| // for more details. |
| |
| import ( |
| "fmt" |
| "log" |
| "reflect" |
| "regexp" |
| "sort" |
| "strings" |
| ) |
| |
| // fieldIter iterates over fields in a struct. It includes |
| // fields of embedded structs. |
| type fieldIter struct { |
| v reflect.Value |
| index, n []int |
| } |
| |
| func iter(v reflect.Value) fieldIter { |
| if v.Kind() != reflect.Struct { |
| log.Panicf("value %v must be a struct", v) |
| } |
| i := fieldIter{ |
| v: v, |
| index: []int{0}, |
| n: []int{v.NumField()}, |
| } |
| i.descent() |
| return i |
| } |
| |
| func (i *fieldIter) descent() { |
| for f := i.field(); f.Anonymous && f.Type.NumField() > 0; f = i.field() { |
| i.index = append(i.index, 0) |
| i.n = append(i.n, f.Type.NumField()) |
| } |
| } |
| |
| func (i *fieldIter) done() bool { |
| return len(i.index) == 1 && i.index[0] >= i.n[0] |
| } |
| |
| func skip(f reflect.StructField) bool { |
| return !f.Anonymous && (f.Name[0] < 'A' || f.Name[0] > 'Z') |
| } |
| |
| func (i *fieldIter) next() { |
| for { |
| k := len(i.index) - 1 |
| i.index[k]++ |
| if i.index[k] < i.n[k] { |
| if !skip(i.field()) { |
| break |
| } |
| } else { |
| if k == 0 { |
| return |
| } |
| i.index = i.index[:k] |
| i.n = i.n[:k] |
| } |
| } |
| i.descent() |
| } |
| |
| func (i *fieldIter) value() reflect.Value { |
| return i.v.FieldByIndex(i.index) |
| } |
| |
| func (i *fieldIter) field() reflect.StructField { |
| return i.v.Type().FieldByIndex(i.index) |
| } |
| |
| type visitor func(v reflect.Value) error |
| |
| var stopDescent = fmt.Errorf("do not recurse") |
| |
| func (f visitor) visit(x interface{}) error { |
| return f.visitRec(reflect.ValueOf(x)) |
| } |
| |
| // visit recursively calls f on all nodes in v. |
| func (f visitor) visitRec(v reflect.Value) error { |
| if v.Kind() == reflect.Ptr { |
| if v.IsNil() { |
| return nil |
| } |
| return f.visitRec(v.Elem()) |
| } |
| if err := f(v); err != nil { |
| if err == stopDescent { |
| return nil |
| } |
| return err |
| } |
| switch v.Kind() { |
| case reflect.Struct: |
| for i := iter(v); !i.done(); i.next() { |
| if err := f.visitRec(i.value()); err != nil { |
| return err |
| } |
| } |
| case reflect.Slice: |
| for i := 0; i < v.Len(); i++ { |
| if err := f.visitRec(v.Index(i)); err != nil { |
| return err |
| } |
| } |
| } |
| return nil |
| } |
| |
| // getPath is used for error reporting purposes only. |
| func getPath(e Elem) string { |
| if e == nil { |
| return "<nil>" |
| } |
| if e.enclosing() == nil { |
| return e.GetCommon().name |
| } |
| if e.GetCommon().Type == "" { |
| return fmt.Sprintf("%s.%s", getPath(e.enclosing()), e.GetCommon().name) |
| } |
| return fmt.Sprintf("%s.%s[type=%s]", getPath(e.enclosing()), e.GetCommon().name, e.GetCommon().Type) |
| } |
| |
| // xmlName returns the xml name of the element or attribute |
| func xmlName(f reflect.StructField) (name string, attr bool) { |
| tags := strings.Split(f.Tag.Get("xml"), ",") |
| for _, s := range tags { |
| attr = attr || s == "attr" |
| } |
| return tags[0], attr |
| } |
| |
| func findField(v reflect.Value, key string) (reflect.Value, error) { |
| v = reflect.Indirect(v) |
| for i := iter(v); !i.done(); i.next() { |
| if n, _ := xmlName(i.field()); n == key { |
| return i.value(), nil |
| } |
| } |
| return reflect.Value{}, fmt.Errorf("cldr: no field %q in element %#v", key, v.Interface()) |
| } |
| |
| var xpathPart = regexp.MustCompile(`(\pL+)(?:\[@(\pL+)='([\w-]+)'\])?`) |
| |
| func walkXPath(e Elem, path string) (res Elem, err error) { |
| for _, c := range strings.Split(path, "/") { |
| if c == ".." { |
| if e = e.enclosing(); e == nil { |
| panic("path ..") |
| return nil, fmt.Errorf(`cldr: ".." moves past root in path %q`, path) |
| } |
| continue |
| } else if c == "" { |
| continue |
| } |
| m := xpathPart.FindStringSubmatch(c) |
| if len(m) == 0 || len(m[0]) != len(c) { |
| return nil, fmt.Errorf("cldr: syntax error in path component %q", c) |
| } |
| v, err := findField(reflect.ValueOf(e), m[1]) |
| if err != nil { |
| return nil, err |
| } |
| switch v.Kind() { |
| case reflect.Slice: |
| i := 0 |
| if m[2] != "" || v.Len() > 1 { |
| if m[2] == "" { |
| m[2] = "type" |
| if m[3] = e.GetCommon().Default(); m[3] == "" { |
| return nil, fmt.Errorf("cldr: type selector or default value needed for element %s", m[1]) |
| } |
| } |
| for ; i < v.Len(); i++ { |
| vi := v.Index(i) |
| key, err := findField(vi.Elem(), m[2]) |
| if err != nil { |
| return nil, err |
| } |
| key = reflect.Indirect(key) |
| if key.Kind() == reflect.String && key.String() == m[3] { |
| break |
| } |
| } |
| } |
| if i == v.Len() || v.Index(i).IsNil() { |
| return nil, fmt.Errorf("no %s found with %s==%s", m[1], m[2], m[3]) |
| } |
| e = v.Index(i).Interface().(Elem) |
| case reflect.Ptr: |
| if v.IsNil() { |
| return nil, fmt.Errorf("cldr: element %q not found within element %q", m[1], e.GetCommon().name) |
| } |
| var ok bool |
| if e, ok = v.Interface().(Elem); !ok { |
| return nil, fmt.Errorf("cldr: %q is not an XML element", m[1]) |
| } else if m[2] != "" || m[3] != "" { |
| return nil, fmt.Errorf("cldr: no type selector allowed for element %s", m[1]) |
| } |
| default: |
| return nil, fmt.Errorf("cldr: %q is not an XML element", m[1]) |
| } |
| } |
| return e, nil |
| } |
| |
| const absPrefix = "//ldml/" |
| |
| func (cldr *CLDR) resolveAlias(e Elem, src, path string) (res Elem, err error) { |
| if src != "locale" { |
| if !strings.HasPrefix(path, absPrefix) { |
| return nil, fmt.Errorf("cldr: expected absolute path, found %q", path) |
| } |
| path = path[len(absPrefix):] |
| if e, err = cldr.resolve(src); err != nil { |
| return nil, err |
| } |
| } |
| return walkXPath(e, path) |
| } |
| |
| func (cldr *CLDR) resolveAndMergeAlias(e Elem) error { |
| alias := e.GetCommon().Alias |
| if alias == nil { |
| return nil |
| } |
| a, err := cldr.resolveAlias(e, alias.Source, alias.Path) |
| if err != nil { |
| return fmt.Errorf("%v: error evaluating path %q: %v", getPath(e), alias.Path, err) |
| } |
| // Ensure alias node was already evaluated. TODO: avoid double evaluation. |
| err = cldr.resolveAndMergeAlias(a) |
| v := reflect.ValueOf(e).Elem() |
| for i := iter(reflect.ValueOf(a).Elem()); !i.done(); i.next() { |
| if vv := i.value(); vv.Kind() != reflect.Ptr || !vv.IsNil() { |
| if _, attr := xmlName(i.field()); !attr { |
| v.FieldByIndex(i.index).Set(vv) |
| } |
| } |
| } |
| return err |
| } |
| |
| func (cldr *CLDR) aliasResolver() visitor { |
| return func(v reflect.Value) (err error) { |
| if e, ok := v.Addr().Interface().(Elem); ok { |
| err = cldr.resolveAndMergeAlias(e) |
| if err == nil && blocking[e.GetCommon().name] { |
| return stopDescent |
| } |
| } |
| return err |
| } |
| } |
| |
| // elements within blocking elements do not inherit. |
| // Taken from CLDR's supplementalMetaData.xml. |
| var blocking = map[string]bool{ |
| "identity": true, |
| "supplementalData": true, |
| "cldrTest": true, |
| "collation": true, |
| "transform": true, |
| } |
| |
| // Distinguishing attributes affect inheritance; two elements with different |
| // distinguishing attributes are treated as different for purposes of inheritance, |
| // except when such attributes occur in the indicated elements. |
| // Taken from CLDR's supplementalMetaData.xml. |
| var distinguishing = map[string][]string{ |
| "key": nil, |
| "request_id": nil, |
| "id": nil, |
| "registry": nil, |
| "alt": nil, |
| "iso4217": nil, |
| "iso3166": nil, |
| "mzone": nil, |
| "from": nil, |
| "to": nil, |
| "type": []string{ |
| "abbreviationFallback", |
| "default", |
| "mapping", |
| "measurementSystem", |
| "preferenceOrdering", |
| }, |
| "numberSystem": nil, |
| } |
| |
| func in(set []string, s string) bool { |
| for _, v := range set { |
| if v == s { |
| return true |
| } |
| } |
| return false |
| } |
| |
| // attrKey computes a key based on the distinguishable attributes of |
| // an element and it's values. |
| func attrKey(v reflect.Value, exclude ...string) string { |
| parts := []string{} |
| ename := v.Interface().(Elem).GetCommon().name |
| v = v.Elem() |
| for i := iter(v); !i.done(); i.next() { |
| if name, attr := xmlName(i.field()); attr { |
| if except, ok := distinguishing[name]; ok && !in(exclude, name) && !in(except, ename) { |
| v := i.value() |
| if v.Kind() == reflect.Ptr { |
| v = v.Elem() |
| } |
| if v.IsValid() { |
| parts = append(parts, fmt.Sprintf("%s=%s", name, v.String())) |
| } |
| } |
| } |
| } |
| sort.Strings(parts) |
| return strings.Join(parts, ";") |
| } |
| |
| // Key returns a key for e derived from all distinguishing attributes |
| // except those specified by exclude. |
| func Key(e Elem, exclude ...string) string { |
| return attrKey(reflect.ValueOf(e), exclude...) |
| } |
| |
| // linkEnclosing sets the enclosing element as well as the name |
| // for all sub-elements of child, recursively. |
| func linkEnclosing(parent, child Elem) { |
| child.setEnclosing(parent) |
| v := reflect.ValueOf(child).Elem() |
| for i := iter(v); !i.done(); i.next() { |
| vf := i.value() |
| if vf.Kind() == reflect.Slice { |
| for j := 0; j < vf.Len(); j++ { |
| linkEnclosing(child, vf.Index(j).Interface().(Elem)) |
| } |
| } else if vf.Kind() == reflect.Ptr && !vf.IsNil() && vf.Elem().Kind() == reflect.Struct { |
| linkEnclosing(child, vf.Interface().(Elem)) |
| } |
| } |
| } |
| |
| func setNames(e Elem, name string) { |
| e.setName(name) |
| v := reflect.ValueOf(e).Elem() |
| for i := iter(v); !i.done(); i.next() { |
| vf := i.value() |
| name, _ = xmlName(i.field()) |
| if vf.Kind() == reflect.Slice { |
| for j := 0; j < vf.Len(); j++ { |
| setNames(vf.Index(j).Interface().(Elem), name) |
| } |
| } else if vf.Kind() == reflect.Ptr && !vf.IsNil() && vf.Elem().Kind() == reflect.Struct { |
| setNames(vf.Interface().(Elem), name) |
| } |
| } |
| } |
| |
| // deepCopy copies elements of v recursively. All elements of v that may |
| // be modified by inheritance are explicitly copied. |
| func deepCopy(v reflect.Value) reflect.Value { |
| switch v.Kind() { |
| case reflect.Ptr: |
| if v.IsNil() || v.Elem().Kind() != reflect.Struct { |
| return v |
| } |
| nv := reflect.New(v.Elem().Type()) |
| nv.Elem().Set(v.Elem()) |
| deepCopyRec(nv.Elem(), v.Elem()) |
| return nv |
| case reflect.Slice: |
| nv := reflect.MakeSlice(v.Type(), v.Len(), v.Len()) |
| for i := 0; i < v.Len(); i++ { |
| deepCopyRec(nv.Index(i), v.Index(i)) |
| } |
| return nv |
| } |
| panic("deepCopy: must be called with pointer or slice") |
| } |
| |
| // deepCopyRec is only called by deepCopy. |
| func deepCopyRec(nv, v reflect.Value) { |
| if v.Kind() == reflect.Struct { |
| t := v.Type() |
| for i := 0; i < v.NumField(); i++ { |
| if name, attr := xmlName(t.Field(i)); name != "" && !attr { |
| deepCopyRec(nv.Field(i), v.Field(i)) |
| } |
| } |
| } else { |
| nv.Set(deepCopy(v)) |
| } |
| } |
| |
| // newNode is used to insert a missing node during inheritance. |
| func (cldr *CLDR) newNode(v, enc reflect.Value) reflect.Value { |
| n := reflect.New(v.Type()) |
| for i := iter(v); !i.done(); i.next() { |
| if name, attr := xmlName(i.field()); name == "" || attr { |
| n.Elem().FieldByIndex(i.index).Set(i.value()) |
| } |
| } |
| n.Interface().(Elem).GetCommon().setEnclosing(enc.Addr().Interface().(Elem)) |
| return n |
| } |
| |
| // v, parent must be pointers to struct |
| func (cldr *CLDR) inheritFields(v, parent reflect.Value) (res reflect.Value, err error) { |
| t := v.Type() |
| nv := reflect.New(t) |
| nv.Elem().Set(v) |
| for i := iter(v); !i.done(); i.next() { |
| vf := i.value() |
| f := i.field() |
| name, attr := xmlName(f) |
| if name == "" || attr { |
| continue |
| } |
| pf := parent.FieldByIndex(i.index) |
| if blocking[name] { |
| if vf.IsNil() { |
| vf = pf |
| } |
| nv.Elem().FieldByIndex(i.index).Set(deepCopy(vf)) |
| continue |
| } |
| switch f.Type.Kind() { |
| case reflect.Ptr: |
| if f.Type.Elem().Kind() == reflect.Struct { |
| if !vf.IsNil() { |
| if vf, err = cldr.inheritStructPtr(vf, pf); err != nil { |
| return reflect.Value{}, err |
| } |
| vf.Interface().(Elem).setEnclosing(nv.Interface().(Elem)) |
| nv.Elem().FieldByIndex(i.index).Set(vf) |
| } else if !pf.IsNil() { |
| n := cldr.newNode(pf.Elem(), v) |
| if vf, err = cldr.inheritStructPtr(n, pf); err != nil { |
| return reflect.Value{}, err |
| } |
| vf.Interface().(Elem).setEnclosing(nv.Interface().(Elem)) |
| nv.Elem().FieldByIndex(i.index).Set(vf) |
| } |
| } |
| case reflect.Slice: |
| vf, err := cldr.inheritSlice(nv.Elem(), vf, pf) |
| if err != nil { |
| return reflect.Zero(t), err |
| } |
| nv.Elem().FieldByIndex(i.index).Set(vf) |
| } |
| } |
| return nv, nil |
| } |
| |
| func root(e Elem) *LDML { |
| for ; e.enclosing() != nil; e = e.enclosing() { |
| } |
| return e.(*LDML) |
| } |
| |
| // inheritStructPtr first merges possible aliases in with v and then inherits |
| // any underspecified elements from parent. |
| func (cldr *CLDR) inheritStructPtr(v, parent reflect.Value) (r reflect.Value, err error) { |
| if !v.IsNil() { |
| e := v.Interface().(Elem).GetCommon() |
| alias := e.Alias |
| if alias == nil && !parent.IsNil() { |
| alias = parent.Interface().(Elem).GetCommon().Alias |
| } |
| if alias != nil { |
| a, err := cldr.resolveAlias(v.Interface().(Elem), alias.Source, alias.Path) |
| if a != nil { |
| if v, err = cldr.inheritFields(v.Elem(), reflect.ValueOf(a).Elem()); err != nil { |
| return reflect.Value{}, err |
| } |
| } |
| } |
| if !parent.IsNil() { |
| return cldr.inheritFields(v.Elem(), parent.Elem()) |
| } |
| } else if parent.IsNil() { |
| panic("should not reach here") |
| } |
| return v, nil |
| } |
| |
| // Must be slice of struct pointers. |
| func (cldr *CLDR) inheritSlice(enc, v, parent reflect.Value) (res reflect.Value, err error) { |
| t := v.Type() |
| index := make(map[string]reflect.Value) |
| if !v.IsNil() { |
| for i := 0; i < v.Len(); i++ { |
| vi := v.Index(i) |
| key := attrKey(vi) |
| index[key] = vi |
| } |
| } |
| if !parent.IsNil() { |
| for i := 0; i < parent.Len(); i++ { |
| vi := parent.Index(i) |
| key := attrKey(vi) |
| if w, ok := index[key]; ok { |
| index[key], err = cldr.inheritStructPtr(w, vi) |
| } else { |
| n := cldr.newNode(vi.Elem(), enc) |
| index[key], err = cldr.inheritStructPtr(n, vi) |
| } |
| index[key].Interface().(Elem).setEnclosing(enc.Addr().Interface().(Elem)) |
| if err != nil { |
| return v, err |
| } |
| } |
| } |
| keys := make([]string, 0, len(index)) |
| for k, _ := range index { |
| keys = append(keys, k) |
| } |
| sort.Strings(keys) |
| sl := reflect.MakeSlice(t, len(index), len(index)) |
| for i, k := range keys { |
| sl.Index(i).Set(index[k]) |
| } |
| return sl, nil |
| } |
| |
| func parentLocale(loc string) string { |
| parts := strings.Split(loc, "_") |
| if len(parts) == 1 { |
| return "root" |
| } |
| parts = parts[:len(parts)-1] |
| key := strings.Join(parts, "_") |
| return key |
| } |
| |
| func (cldr *CLDR) resolve(loc string) (res *LDML, err error) { |
| if r := cldr.resolved[loc]; r != nil { |
| return r, nil |
| } |
| x := cldr.RawLDML(loc) |
| if x == nil { |
| return nil, fmt.Errorf("cldr: unknown locale %q", loc) |
| } |
| var v reflect.Value |
| if loc == "root" { |
| x = deepCopy(reflect.ValueOf(x)).Interface().(*LDML) |
| linkEnclosing(nil, x) |
| err = cldr.aliasResolver().visit(x) |
| } else { |
| key := parentLocale(loc) |
| var parent *LDML |
| for ; cldr.locale[key] == nil; key = parentLocale(key) { |
| } |
| if parent, err = cldr.resolve(key); err != nil { |
| return nil, err |
| } |
| v, err = cldr.inheritFields(reflect.ValueOf(x).Elem(), reflect.ValueOf(parent).Elem()) |
| x = v.Interface().(*LDML) |
| linkEnclosing(nil, x) |
| } |
| if err != nil { |
| return nil, err |
| } |
| cldr.resolved[loc] = x |
| return x, err |
| } |
| |
| // finalize finalizes the initialization of the raw LDML structs. It also |
| // removed unwanted fields, as specified by filter, so that they will not |
| // be unnecessarily evaluated. |
| func (cldr *CLDR) finalize(filter []string) { |
| for _, x := range cldr.locale { |
| if filter != nil { |
| v := reflect.ValueOf(x).Elem() |
| t := v.Type() |
| for i := 0; i < v.NumField(); i++ { |
| f := t.Field(i) |
| name, _ := xmlName(f) |
| if name != "" && name != "identity" && !in(filter, name) { |
| v.Field(i).Set(reflect.Zero(f.Type)) |
| } |
| } |
| } |
| linkEnclosing(nil, x) // for resolving aliases and paths |
| setNames(x, "ldml") |
| } |
| } |