diff options
Diffstat (limited to 'vendor/golang.org/x/text/message')
| -rw-r--r-- | vendor/golang.org/x/text/message/catalog.go | 36 | ||||
| -rw-r--r-- | vendor/golang.org/x/text/message/catalog/catalog.go | 365 | ||||
| -rw-r--r-- | vendor/golang.org/x/text/message/catalog/dict.go | 129 | ||||
| -rw-r--r-- | vendor/golang.org/x/text/message/catalog/go19.go | 15 | ||||
| -rw-r--r-- | vendor/golang.org/x/text/message/catalog/gopre19.go | 23 | ||||
| -rw-r--r-- | vendor/golang.org/x/text/message/doc.go | 99 | ||||
| -rw-r--r-- | vendor/golang.org/x/text/message/format.go | 510 | ||||
| -rw-r--r-- | vendor/golang.org/x/text/message/message.go | 192 | ||||
| -rw-r--r-- | vendor/golang.org/x/text/message/pipeline/extract.go | 821 | ||||
| -rw-r--r-- | vendor/golang.org/x/text/message/pipeline/generate.go | 329 | ||||
| -rw-r--r-- | vendor/golang.org/x/text/message/pipeline/message.go | 241 | ||||
| -rw-r--r-- | vendor/golang.org/x/text/message/pipeline/pipeline.go | 422 | ||||
| -rw-r--r-- | vendor/golang.org/x/text/message/pipeline/rewrite.go | 268 | ||||
| -rw-r--r-- | vendor/golang.org/x/text/message/print.go | 984 |
14 files changed, 0 insertions, 4434 deletions
diff --git a/vendor/golang.org/x/text/message/catalog.go b/vendor/golang.org/x/text/message/catalog.go deleted file mode 100644 index 068271d..0000000 --- a/vendor/golang.org/x/text/message/catalog.go +++ /dev/null @@ -1,36 +0,0 @@ -// 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. - -package message - -// TODO: some types in this file will need to be made public at some time. -// Documentation and method names will reflect this by using the exported name. - -import ( - "golang.org/x/text/language" - "golang.org/x/text/message/catalog" -) - -// MatchLanguage reports the matched tag obtained from language.MatchStrings for -// the Matcher of the DefaultCatalog. -func MatchLanguage(preferred ...string) language.Tag { - c := DefaultCatalog - tag, _ := language.MatchStrings(c.Matcher(), preferred...) - return tag -} - -// DefaultCatalog is used by SetString. -var DefaultCatalog catalog.Catalog = defaultCatalog - -var defaultCatalog = catalog.NewBuilder() - -// SetString calls SetString on the initial default Catalog. -func SetString(tag language.Tag, key string, msg string) error { - return defaultCatalog.SetString(tag, key, msg) -} - -// Set calls Set on the initial default Catalog. -func Set(tag language.Tag, key string, msg ...catalog.Message) error { - return defaultCatalog.Set(tag, key, msg...) -} diff --git a/vendor/golang.org/x/text/message/catalog/catalog.go b/vendor/golang.org/x/text/message/catalog/catalog.go deleted file mode 100644 index 96955d0..0000000 --- a/vendor/golang.org/x/text/message/catalog/catalog.go +++ /dev/null @@ -1,365 +0,0 @@ -// 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 catalog defines collections of translated format strings. -// -// This package mostly defines types for populating catalogs with messages. The -// catmsg package contains further definitions for creating custom message and -// dictionary types as well as packages that use Catalogs. -// -// Package catalog defines various interfaces: Dictionary, Loader, and Message. -// A Dictionary maintains a set of translations of format strings for a single -// language. The Loader interface defines a source of dictionaries. A -// translation of a format string is represented by a Message. -// -// # Catalogs -// -// A Catalog defines a programmatic interface for setting message translations. -// It maintains a set of per-language dictionaries with translations for a set -// of keys. For message translation to function properly, a translation should -// be defined for each key for each supported language. A dictionary may be -// underspecified, though, if there is a parent language that already defines -// the key. For example, a Dictionary for "en-GB" could leave out entries that -// are identical to those in a dictionary for "en". -// -// # Messages -// -// A Message is a format string which varies on the value of substitution -// variables. For instance, to indicate the number of results one could want "no -// results" if there are none, "1 result" if there is 1, and "%d results" for -// any other number. Catalog is agnostic to the kind of format strings that are -// used: for instance, messages can follow either the printf-style substitution -// from package fmt or use templates. -// -// A Message does not substitute arguments in the format string. This job is -// reserved for packages that render strings, such as message, that use Catalogs -// to selected string. This separation of concerns allows Catalog to be used to -// store any kind of formatting strings. -// -// # Selecting messages based on linguistic features of substitution arguments -// -// Messages may vary based on any linguistic features of the argument values. -// The most common one is plural form, but others exist. -// -// Selection messages are provided in packages that provide support for a -// specific linguistic feature. The following snippet uses plural.Selectf: -// -// catalog.Set(language.English, "You are %d minute(s) late.", -// plural.Selectf(1, "", -// plural.One, "You are 1 minute late.", -// plural.Other, "You are %d minutes late.")) -// -// In this example, a message is stored in the Catalog where one of two messages -// is selected based on the first argument, a number. The first message is -// selected if the argument is singular (identified by the selector "one") and -// the second message is selected in all other cases. The selectors are defined -// by the plural rules defined in CLDR. The selector "other" is special and will -// always match. Each language always defines one of the linguistic categories -// to be "other." For English, singular is "one" and plural is "other". -// -// Selects can be nested. This allows selecting sentences based on features of -// multiple arguments or multiple linguistic properties of a single argument. -// -// # String interpolation -// -// There is often a lot of commonality between the possible variants of a -// message. For instance, in the example above the word "minute" varies based on -// the plural catogory of the argument, but the rest of the sentence is -// identical. Using interpolation the above message can be rewritten as: -// -// catalog.Set(language.English, "You are %d minute(s) late.", -// catalog.Var("minutes", -// plural.Selectf(1, "", plural.One, "minute", plural.Other, "minutes")), -// catalog.String("You are %[1]d ${minutes} late.")) -// -// Var is defined to return the variable name if the message does not yield a -// match. This allows us to further simplify this snippet to -// -// catalog.Set(language.English, "You are %d minute(s) late.", -// catalog.Var("minutes", plural.Selectf(1, "", plural.One, "minute")), -// catalog.String("You are %d ${minutes} late.")) -// -// Overall this is still only a minor improvement, but things can get a lot more -// unwieldy if more than one linguistic feature is used to determine a message -// variant. Consider the following example: -// -// // argument 1: list of hosts, argument 2: list of guests -// catalog.Set(language.English, "%[1]v invite(s) %[2]v to their party.", -// catalog.Var("their", -// plural.Selectf(1, "" -// plural.One, gender.Select(1, "female", "her", "other", "his"))), -// catalog.Var("invites", plural.Selectf(1, "", plural.One, "invite")) -// catalog.String("%[1]v ${invites} %[2]v to ${their} party.")), -// -// Without variable substitution, this would have to be written as -// -// // argument 1: list of hosts, argument 2: list of guests -// catalog.Set(language.English, "%[1]v invite(s) %[2]v to their party.", -// plural.Selectf(1, "", -// plural.One, gender.Select(1, -// "female", "%[1]v invites %[2]v to her party." -// "other", "%[1]v invites %[2]v to his party."), -// plural.Other, "%[1]v invites %[2]v to their party.")) -// -// Not necessarily shorter, but using variables there is less duplication and -// the messages are more maintenance friendly. Moreover, languages may have up -// to six plural forms. This makes the use of variables more welcome. -// -// Different messages using the same inflections can reuse variables by moving -// them to macros. Using macros we can rewrite the message as: -// -// // argument 1: list of hosts, argument 2: list of guests -// catalog.SetString(language.English, "%[1]v invite(s) %[2]v to their party.", -// "%[1]v ${invites(1)} %[2]v to ${their(1)} party.") -// -// Where the following macros were defined separately. -// -// catalog.SetMacro(language.English, "invites", plural.Selectf(1, "", -// plural.One, "invite")) -// catalog.SetMacro(language.English, "their", plural.Selectf(1, "", -// plural.One, gender.Select(1, "female", "her", "other", "his"))), -// -// Placeholders use parentheses and the arguments to invoke a macro. -// -// # Looking up messages -// -// Message lookup using Catalogs is typically only done by specialized packages -// and is not something the user should be concerned with. For instance, to -// express the tardiness of a user using the related message we defined earlier, -// the user may use the package message like so: -// -// p := message.NewPrinter(language.English) -// p.Printf("You are %d minute(s) late.", 5) -// -// Which would print: -// -// You are 5 minutes late. -// -// This package is UNDER CONSTRUCTION and its API may change. -package catalog // import "golang.org/x/text/message/catalog" - -// TODO: -// Some way to freeze a catalog. -// - Locking on each lockup turns out to be about 50% of the total running time -// for some of the benchmarks in the message package. -// Consider these: -// - Sequence type to support sequences in user-defined messages. -// - Garbage collection: Remove dictionaries that can no longer be reached -// as other dictionaries have been added that cover all possible keys. - -import ( - "errors" - "fmt" - - "golang.org/x/text/internal" - - "golang.org/x/text/internal/catmsg" - "golang.org/x/text/language" -) - -// A Catalog allows lookup of translated messages. -type Catalog interface { - // Languages returns all languages for which the Catalog contains variants. - Languages() []language.Tag - - // Matcher returns a Matcher for languages from this Catalog. - Matcher() language.Matcher - - // A Context is used for evaluating Messages. - Context(tag language.Tag, r catmsg.Renderer) *Context - - // This method also makes Catalog a private interface. - lookup(tag language.Tag, key string) (data string, ok bool) -} - -// NewFromMap creates a Catalog from the given map. If a Dictionary is -// underspecified the entry is retrieved from a parent language. -func NewFromMap(dictionaries map[string]Dictionary, opts ...Option) (Catalog, error) { - options := options{} - for _, o := range opts { - o(&options) - } - c := &catalog{ - dicts: map[language.Tag]Dictionary{}, - } - _, hasFallback := dictionaries[options.fallback.String()] - if hasFallback { - // TODO: Should it be okay to not have a fallback language? - // Catalog generators could enforce there is always a fallback. - c.langs = append(c.langs, options.fallback) - } - for lang, dict := range dictionaries { - tag, err := language.Parse(lang) - if err != nil { - return nil, fmt.Errorf("catalog: invalid language tag %q", lang) - } - if _, ok := c.dicts[tag]; ok { - return nil, fmt.Errorf("catalog: duplicate entry for tag %q after normalization", tag) - } - c.dicts[tag] = dict - if !hasFallback || tag != options.fallback { - c.langs = append(c.langs, tag) - } - } - if hasFallback { - internal.SortTags(c.langs[1:]) - } else { - internal.SortTags(c.langs) - } - c.matcher = language.NewMatcher(c.langs) - return c, nil -} - -// A Dictionary is a source of translations for a single language. -type Dictionary interface { - // Lookup returns a message compiled with catmsg.Compile for the given key. - // It returns false for ok if such a message could not be found. - Lookup(key string) (data string, ok bool) -} - -type catalog struct { - langs []language.Tag - dicts map[language.Tag]Dictionary - macros store - matcher language.Matcher -} - -func (c *catalog) Languages() []language.Tag { return c.langs } -func (c *catalog) Matcher() language.Matcher { return c.matcher } - -func (c *catalog) lookup(tag language.Tag, key string) (data string, ok bool) { - for ; ; tag = tag.Parent() { - if dict, ok := c.dicts[tag]; ok { - if data, ok := dict.Lookup(key); ok { - return data, true - } - } - if tag == language.Und { - break - } - } - return "", false -} - -// Context returns a Context for formatting messages. -// Only one Message may be formatted per context at any given time. -func (c *catalog) Context(tag language.Tag, r catmsg.Renderer) *Context { - return &Context{ - cat: c, - tag: tag, - dec: catmsg.NewDecoder(tag, r, &dict{&c.macros, tag}), - } -} - -// A Builder allows building a Catalog programmatically. -type Builder struct { - options - matcher language.Matcher - - index store - macros store -} - -type options struct { - fallback language.Tag -} - -// An Option configures Catalog behavior. -type Option func(*options) - -// Fallback specifies the default fallback language. The default is Und. -func Fallback(tag language.Tag) Option { - return func(o *options) { o.fallback = tag } -} - -// TODO: -// // Catalogs specifies one or more sources for a Catalog. -// // Lookups are in order. -// // This can be changed inserting a Catalog used for setting, which implements -// // Loader, used for setting in the chain. -// func Catalogs(d ...Loader) Option { -// return nil -// } -// -// func Delims(start, end string) Option {} -// -// func Dict(tag language.Tag, d ...Dictionary) Option - -// NewBuilder returns an empty mutable Catalog. -func NewBuilder(opts ...Option) *Builder { - c := &Builder{} - for _, o := range opts { - o(&c.options) - } - return c -} - -// SetString is shorthand for Set(tag, key, String(msg)). -func (c *Builder) SetString(tag language.Tag, key string, msg string) error { - return c.set(tag, key, &c.index, String(msg)) -} - -// Set sets the translation for the given language and key. -// -// When evaluation this message, the first Message in the sequence to msgs to -// evaluate to a string will be the message returned. -func (c *Builder) Set(tag language.Tag, key string, msg ...Message) error { - return c.set(tag, key, &c.index, msg...) -} - -// SetMacro defines a Message that may be substituted in another message. -// The arguments to a macro Message are passed as arguments in the -// placeholder the form "${foo(arg1, arg2)}". -func (c *Builder) SetMacro(tag language.Tag, name string, msg ...Message) error { - return c.set(tag, name, &c.macros, msg...) -} - -// ErrNotFound indicates there was no message for the given key. -var ErrNotFound = errors.New("catalog: message not found") - -// String specifies a plain message string. It can be used as fallback if no -// other strings match or as a simple standalone message. -// -// It is an error to pass more than one String in a message sequence. -func String(name string) Message { - return catmsg.String(name) -} - -// Var sets a variable that may be substituted in formatting patterns using -// named substitution of the form "${name}". The name argument is used as a -// fallback if the statements do not produce a match. The statement sequence may -// not contain any Var calls. -// -// The name passed to a Var must be unique within message sequence. -func Var(name string, msg ...Message) Message { - return &catmsg.Var{Name: name, Message: firstInSequence(msg)} -} - -// Context returns a Context for formatting messages. -// Only one Message may be formatted per context at any given time. -func (b *Builder) Context(tag language.Tag, r catmsg.Renderer) *Context { - return &Context{ - cat: b, - tag: tag, - dec: catmsg.NewDecoder(tag, r, &dict{&b.macros, tag}), - } -} - -// A Context is used for evaluating Messages. -// Only one Message may be formatted per context at any given time. -type Context struct { - cat Catalog - tag language.Tag // TODO: use compact index. - dec *catmsg.Decoder -} - -// Execute looks up and executes the message with the given key. -// It returns ErrNotFound if no message could be found in the index. -func (c *Context) Execute(key string) error { - data, ok := c.cat.lookup(c.tag, key) - if !ok { - return ErrNotFound - } - return c.dec.Execute(data) -} diff --git a/vendor/golang.org/x/text/message/catalog/dict.go b/vendor/golang.org/x/text/message/catalog/dict.go deleted file mode 100644 index a0eb818..0000000 --- a/vendor/golang.org/x/text/message/catalog/dict.go +++ /dev/null @@ -1,129 +0,0 @@ -// 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 catalog - -import ( - "sync" - - "golang.org/x/text/internal" - "golang.org/x/text/internal/catmsg" - "golang.org/x/text/language" -) - -// TODO: -// Dictionary returns a Dictionary that returns the first Message, using the -// given language tag, that matches: -// 1. the last one registered by one of the Set methods -// 2. returned by one of the Loaders -// 3. repeat from 1. using the parent language -// This approach allows messages to be underspecified. -// func (c *Catalog) Dictionary(tag language.Tag) (Dictionary, error) { -// // TODO: verify dictionary exists. -// return &dict{&c.index, tag}, nil -// } - -type dict struct { - s *store - tag language.Tag // TODO: make compact tag. -} - -func (d *dict) Lookup(key string) (data string, ok bool) { - return d.s.lookup(d.tag, key) -} - -func (b *Builder) lookup(tag language.Tag, key string) (data string, ok bool) { - return b.index.lookup(tag, key) -} - -func (c *Builder) set(tag language.Tag, key string, s *store, msg ...Message) error { - data, err := catmsg.Compile(tag, &dict{&c.macros, tag}, firstInSequence(msg)) - - s.mutex.Lock() - defer s.mutex.Unlock() - - m := s.index[tag] - if m == nil { - m = msgMap{} - if s.index == nil { - s.index = map[language.Tag]msgMap{} - } - c.matcher = nil - s.index[tag] = m - } - - m[key] = data - return err -} - -func (c *Builder) Matcher() language.Matcher { - c.index.mutex.RLock() - m := c.matcher - c.index.mutex.RUnlock() - if m != nil { - return m - } - - c.index.mutex.Lock() - if c.matcher == nil { - c.matcher = language.NewMatcher(c.unlockedLanguages()) - } - m = c.matcher - c.index.mutex.Unlock() - return m -} - -type store struct { - mutex sync.RWMutex - index map[language.Tag]msgMap -} - -type msgMap map[string]string - -func (s *store) lookup(tag language.Tag, key string) (data string, ok bool) { - s.mutex.RLock() - defer s.mutex.RUnlock() - - for ; ; tag = tag.Parent() { - if msgs, ok := s.index[tag]; ok { - if msg, ok := msgs[key]; ok { - return msg, true - } - } - if tag == language.Und { - break - } - } - return "", false -} - -// Languages returns all languages for which the Catalog contains variants. -func (b *Builder) Languages() []language.Tag { - s := &b.index - s.mutex.RLock() - defer s.mutex.RUnlock() - - return b.unlockedLanguages() -} - -func (b *Builder) unlockedLanguages() []language.Tag { - s := &b.index - if len(s.index) == 0 { - return nil - } - tags := make([]language.Tag, 0, len(s.index)) - _, hasFallback := s.index[b.options.fallback] - offset := 0 - if hasFallback { - tags = append(tags, b.options.fallback) - offset = 1 - } - for t := range s.index { - if t != b.options.fallback { - tags = append(tags, t) - } - } - internal.SortTags(tags[offset:]) - return tags -} diff --git a/vendor/golang.org/x/text/message/catalog/go19.go b/vendor/golang.org/x/text/message/catalog/go19.go deleted file mode 100644 index 291a4df..0000000 --- a/vendor/golang.org/x/text/message/catalog/go19.go +++ /dev/null @@ -1,15 +0,0 @@ -// 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. - -//go:build go1.9 - -package catalog - -import "golang.org/x/text/internal/catmsg" - -// A Message holds a collection of translations for the same phrase that may -// vary based on the values of substitution arguments. -type Message = catmsg.Message - -type firstInSequence = catmsg.FirstOf diff --git a/vendor/golang.org/x/text/message/catalog/gopre19.go b/vendor/golang.org/x/text/message/catalog/gopre19.go deleted file mode 100644 index da44ebb..0000000 --- a/vendor/golang.org/x/text/message/catalog/gopre19.go +++ /dev/null @@ -1,23 +0,0 @@ -// 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. - -//go:build !go1.9 - -package catalog - -import "golang.org/x/text/internal/catmsg" - -// A Message holds a collection of translations for the same phrase that may -// vary based on the values of substitution arguments. -type Message interface { - catmsg.Message -} - -func firstInSequence(m []Message) catmsg.Message { - a := []catmsg.Message{} - for _, m := range m { - a = append(a, m) - } - return catmsg.FirstOf(a) -} diff --git a/vendor/golang.org/x/text/message/doc.go b/vendor/golang.org/x/text/message/doc.go deleted file mode 100644 index 4bf7bdc..0000000 --- a/vendor/golang.org/x/text/message/doc.go +++ /dev/null @@ -1,99 +0,0 @@ -// 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 message implements formatted I/O for localized strings with functions -// analogous to the fmt's print functions. It is a drop-in replacement for fmt. -// -// # Localized Formatting -// -// A format string can be localized by replacing any of the print functions of -// fmt with an equivalent call to a Printer. -// -// p := message.NewPrinter(message.MatchLanguage("en")) -// p.Println(123456.78) // Prints 123,456.78 -// -// p.Printf("%d ducks in a row", 4331) // Prints 4,331 ducks in a row -// -// p := message.NewPrinter(message.MatchLanguage("nl")) -// p.Printf("Hoogte: %.1f meter", 1244.9) // Prints Hoogte: 1,244.9 meter -// -// p := message.NewPrinter(message.MatchLanguage("bn")) -// p.Println(123456.78) // Prints ১,২৩,৪৫৬.৭৮ -// -// Printer currently supports numbers and specialized types for which packages -// exist in x/text. Other builtin types such as time.Time and slices are -// planned. -// -// Format strings largely have the same meaning as with fmt with the following -// notable exceptions: -// - flag # always resorts to fmt for printing -// - verb 'f', 'e', 'g', 'd' use localized formatting unless the '#' flag is -// specified. -// - verb 'm' inserts a translation of a string argument. -// -// See package fmt for more options. -// -// # Translation -// -// The format strings that are passed to Printf, Sprintf, Fprintf, or Errorf -// are used as keys to look up translations for the specified languages. -// More on how these need to be specified below. -// -// One can use arbitrary keys to distinguish between otherwise ambiguous -// strings: -// -// p := message.NewPrinter(language.English) -// p.Printf("archive(noun)") // Prints "archive" -// p.Printf("archive(verb)") // Prints "archive" -// -// p := message.NewPrinter(language.German) -// p.Printf("archive(noun)") // Prints "Archiv" -// p.Printf("archive(verb)") // Prints "archivieren" -// -// To retain the fallback functionality, use Key: -// -// p.Printf(message.Key("archive(noun)", "archive")) -// p.Printf(message.Key("archive(verb)", "archive")) -// -// # Translation Pipeline -// -// Format strings that contain text need to be translated to support different -// locales. The first step is to extract strings that need to be translated. -// -// 1. Install gotext -// -// go get -u golang.org/x/text/cmd/gotext -// gotext -help -// -// 2. Mark strings in your source to be translated by using message.Printer, -// instead of the functions of the fmt package. -// -// 3. Extract the strings from your source -// -// gotext extract -// -// The output will be written to the textdata directory. -// -// 4. Send the files for translation -// -// It is planned to support multiple formats, but for now one will have to -// rewrite the JSON output to the desired format. -// -// 5. Inject translations into program -// -// 6. Repeat from 2 -// -// Right now this has to be done programmatically with calls to Set or -// SetString. These functions as well as the methods defined in -// see also package golang.org/x/text/message/catalog can be used to implement -// either dynamic or static loading of messages. -// -// # Plural and Gender Forms -// -// Translated messages can vary based on the plural and gender forms of -// substitution values. In general, it is up to the translators to provide -// alternative translations for such forms. See the packages in -// golang.org/x/text/feature and golang.org/x/text/message/catalog for more -// information. -package message diff --git a/vendor/golang.org/x/text/message/format.go b/vendor/golang.org/x/text/message/format.go deleted file mode 100644 index a47d17d..0000000 --- a/vendor/golang.org/x/text/message/format.go +++ /dev/null @@ -1,510 +0,0 @@ -// 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 message - -import ( - "bytes" - "strconv" - "unicode/utf8" - - "golang.org/x/text/internal/format" -) - -const ( - ldigits = "0123456789abcdefx" - udigits = "0123456789ABCDEFX" -) - -const ( - signed = true - unsigned = false -) - -// A formatInfo is the raw formatter used by Printf etc. -// It prints into a buffer that must be set up separately. -type formatInfo struct { - buf *bytes.Buffer - - format.Parser - - // intbuf is large enough to store %b of an int64 with a sign and - // avoids padding at the end of the struct on 32 bit architectures. - intbuf [68]byte -} - -func (f *formatInfo) init(buf *bytes.Buffer) { - f.ClearFlags() - f.buf = buf -} - -// writePadding generates n bytes of padding. -func (f *formatInfo) writePadding(n int) { - if n <= 0 { // No padding bytes needed. - return - } - f.buf.Grow(n) - // Decide which byte the padding should be filled with. - padByte := byte(' ') - if f.Zero { - padByte = byte('0') - } - // Fill padding with padByte. - for i := 0; i < n; i++ { - f.buf.WriteByte(padByte) // TODO: make more efficient. - } -} - -// pad appends b to f.buf, padded on left (!f.minus) or right (f.minus). -func (f *formatInfo) pad(b []byte) { - if !f.WidthPresent || f.Width == 0 { - f.buf.Write(b) - return - } - width := f.Width - utf8.RuneCount(b) - if !f.Minus { - // left padding - f.writePadding(width) - f.buf.Write(b) - } else { - // right padding - f.buf.Write(b) - f.writePadding(width) - } -} - -// padString appends s to f.buf, padded on left (!f.minus) or right (f.minus). -func (f *formatInfo) padString(s string) { - if !f.WidthPresent || f.Width == 0 { - f.buf.WriteString(s) - return - } - width := f.Width - utf8.RuneCountInString(s) - if !f.Minus { - // left padding - f.writePadding(width) - f.buf.WriteString(s) - } else { - // right padding - f.buf.WriteString(s) - f.writePadding(width) - } -} - -// fmt_boolean formats a boolean. -func (f *formatInfo) fmt_boolean(v bool) { - if v { - f.padString("true") - } else { - f.padString("false") - } -} - -// fmt_unicode formats a uint64 as "U+0078" or with f.sharp set as "U+0078 'x'". -func (f *formatInfo) fmt_unicode(u uint64) { - buf := f.intbuf[0:] - - // With default precision set the maximum needed buf length is 18 - // for formatting -1 with %#U ("U+FFFFFFFFFFFFFFFF") which fits - // into the already allocated intbuf with a capacity of 68 bytes. - prec := 4 - if f.PrecPresent && f.Prec > 4 { - prec = f.Prec - // Compute space needed for "U+" , number, " '", character, "'". - width := 2 + prec + 2 + utf8.UTFMax + 1 - if width > len(buf) { - buf = make([]byte, width) - } - } - - // Format into buf, ending at buf[i]. Formatting numbers is easier right-to-left. - i := len(buf) - - // For %#U we want to add a space and a quoted character at the end of the buffer. - if f.Sharp && u <= utf8.MaxRune && strconv.IsPrint(rune(u)) { - i-- - buf[i] = '\'' - i -= utf8.RuneLen(rune(u)) - utf8.EncodeRune(buf[i:], rune(u)) - i-- - buf[i] = '\'' - i-- - buf[i] = ' ' - } - // Format the Unicode code point u as a hexadecimal number. - for u >= 16 { - i-- - buf[i] = udigits[u&0xF] - prec-- - u >>= 4 - } - i-- - buf[i] = udigits[u] - prec-- - // Add zeros in front of the number until requested precision is reached. - for prec > 0 { - i-- - buf[i] = '0' - prec-- - } - // Add a leading "U+". - i-- - buf[i] = '+' - i-- - buf[i] = 'U' - - oldZero := f.Zero - f.Zero = false - f.pad(buf[i:]) - f.Zero = oldZero -} - -// fmt_integer formats signed and unsigned integers. -func (f *formatInfo) fmt_integer(u uint64, base int, isSigned bool, digits string) { - negative := isSigned && int64(u) < 0 - if negative { - u = -u - } - - buf := f.intbuf[0:] - // The already allocated f.intbuf with a capacity of 68 bytes - // is large enough for integer formatting when no precision or width is set. - if f.WidthPresent || f.PrecPresent { - // Account 3 extra bytes for possible addition of a sign and "0x". - width := 3 + f.Width + f.Prec // wid and prec are always positive. - if width > len(buf) { - // We're going to need a bigger boat. - buf = make([]byte, width) - } - } - - // Two ways to ask for extra leading zero digits: %.3d or %03d. - // If both are specified the f.zero flag is ignored and - // padding with spaces is used instead. - prec := 0 - if f.PrecPresent { - prec = f.Prec - // Precision of 0 and value of 0 means "print nothing" but padding. - if prec == 0 && u == 0 { - oldZero := f.Zero - f.Zero = false - f.writePadding(f.Width) - f.Zero = oldZero - return - } - } else if f.Zero && f.WidthPresent { - prec = f.Width - if negative || f.Plus || f.Space { - prec-- // leave room for sign - } - } - - // Because printing is easier right-to-left: format u into buf, ending at buf[i]. - // We could make things marginally faster by splitting the 32-bit case out - // into a separate block but it's not worth the duplication, so u has 64 bits. - i := len(buf) - // Use constants for the division and modulo for more efficient code. - // Switch cases ordered by popularity. - switch base { - case 10: - for u >= 10 { - i-- - next := u / 10 - buf[i] = byte('0' + u - next*10) - u = next - } - case 16: - for u >= 16 { - i-- - buf[i] = digits[u&0xF] - u >>= 4 - } - case 8: - for u >= 8 { - i-- - buf[i] = byte('0' + u&7) - u >>= 3 - } - case 2: - for u >= 2 { - i-- - buf[i] = byte('0' + u&1) - u >>= 1 - } - default: - panic("fmt: unknown base; can't happen") - } - i-- - buf[i] = digits[u] - for i > 0 && prec > len(buf)-i { - i-- - buf[i] = '0' - } - - // Various prefixes: 0x, -, etc. - if f.Sharp { - switch base { - case 8: - if buf[i] != '0' { - i-- - buf[i] = '0' - } - case 16: - // Add a leading 0x or 0X. - i-- - buf[i] = digits[16] - i-- - buf[i] = '0' - } - } - - if negative { - i-- - buf[i] = '-' - } else if f.Plus { - i-- - buf[i] = '+' - } else if f.Space { - i-- - buf[i] = ' ' - } - - // Left padding with zeros has already been handled like precision earlier - // or the f.zero flag is ignored due to an explicitly set precision. - oldZero := f.Zero - f.Zero = false - f.pad(buf[i:]) - f.Zero = oldZero -} - -// truncate truncates the string to the specified precision, if present. -func (f *formatInfo) truncate(s string) string { - if f.PrecPresent { - n := f.Prec - for i := range s { - n-- - if n < 0 { - return s[:i] - } - } - } - return s -} - -// fmt_s formats a string. -func (f *formatInfo) fmt_s(s string) { - s = f.truncate(s) - f.padString(s) -} - -// fmt_sbx formats a string or byte slice as a hexadecimal encoding of its bytes. -func (f *formatInfo) fmt_sbx(s string, b []byte, digits string) { - length := len(b) - if b == nil { - // No byte slice present. Assume string s should be encoded. - length = len(s) - } - // Set length to not process more bytes than the precision demands. - if f.PrecPresent && f.Prec < length { - length = f.Prec - } - // Compute width of the encoding taking into account the f.sharp and f.space flag. - width := 2 * length - if width > 0 { - if f.Space { - // Each element encoded by two hexadecimals will get a leading 0x or 0X. - if f.Sharp { - width *= 2 - } - // Elements will be separated by a space. - width += length - 1 - } else if f.Sharp { - // Only a leading 0x or 0X will be added for the whole string. - width += 2 - } - } else { // The byte slice or string that should be encoded is empty. - if f.WidthPresent { - f.writePadding(f.Width) - } - return - } - // Handle padding to the left. - if f.WidthPresent && f.Width > width && !f.Minus { - f.writePadding(f.Width - width) - } - // Write the encoding directly into the output buffer. - buf := f.buf - if f.Sharp { - // Add leading 0x or 0X. - buf.WriteByte('0') - buf.WriteByte(digits[16]) - } - var c byte - for i := 0; i < length; i++ { - if f.Space && i > 0 { - // Separate elements with a space. - buf.WriteByte(' ') - if f.Sharp { - // Add leading 0x or 0X for each element. - buf.WriteByte('0') - buf.WriteByte(digits[16]) - } - } - if b != nil { - c = b[i] // Take a byte from the input byte slice. - } else { - c = s[i] // Take a byte from the input string. - } - // Encode each byte as two hexadecimal digits. - buf.WriteByte(digits[c>>4]) - buf.WriteByte(digits[c&0xF]) - } - // Handle padding to the right. - if f.WidthPresent && f.Width > width && f.Minus { - f.writePadding(f.Width - width) - } -} - -// fmt_sx formats a string as a hexadecimal encoding of its bytes. -func (f *formatInfo) fmt_sx(s, digits string) { - f.fmt_sbx(s, nil, digits) -} - -// fmt_bx formats a byte slice as a hexadecimal encoding of its bytes. -func (f *formatInfo) fmt_bx(b []byte, digits string) { - f.fmt_sbx("", b, digits) -} - -// fmt_q formats a string as a double-quoted, escaped Go string constant. -// If f.sharp is set a raw (backquoted) string may be returned instead -// if the string does not contain any control characters other than tab. -func (f *formatInfo) fmt_q(s string) { - s = f.truncate(s) - if f.Sharp && strconv.CanBackquote(s) { - f.padString("`" + s + "`") - return - } - buf := f.intbuf[:0] - if f.Plus { - f.pad(strconv.AppendQuoteToASCII(buf, s)) - } else { - f.pad(strconv.AppendQuote(buf, s)) - } -} - -// fmt_c formats an integer as a Unicode character. -// If the character is not valid Unicode, it will print '\ufffd'. -func (f *formatInfo) fmt_c(c uint64) { - r := rune(c) - if c > utf8.MaxRune { - r = utf8.RuneError - } - buf := f.intbuf[:0] - w := utf8.EncodeRune(buf[:utf8.UTFMax], r) - f.pad(buf[:w]) -} - -// fmt_qc formats an integer as a single-quoted, escaped Go character constant. -// If the character is not valid Unicode, it will print '\ufffd'. -func (f *formatInfo) fmt_qc(c uint64) { - r := rune(c) - if c > utf8.MaxRune { - r = utf8.RuneError - } - buf := f.intbuf[:0] - if f.Plus { - f.pad(strconv.AppendQuoteRuneToASCII(buf, r)) - } else { - f.pad(strconv.AppendQuoteRune(buf, r)) - } -} - -// fmt_float formats a float64. It assumes that verb is a valid format specifier -// for strconv.AppendFloat and therefore fits into a byte. -func (f *formatInfo) fmt_float(v float64, size int, verb rune, prec int) { - // Explicit precision in format specifier overrules default precision. - if f.PrecPresent { - prec = f.Prec - } - // Format number, reserving space for leading + sign if needed. - num := strconv.AppendFloat(f.intbuf[:1], v, byte(verb), prec, size) - if num[1] == '-' || num[1] == '+' { - num = num[1:] - } else { - num[0] = '+' - } - // f.space means to add a leading space instead of a "+" sign unless - // the sign is explicitly asked for by f.plus. - if f.Space && num[0] == '+' && !f.Plus { - num[0] = ' ' - } - // Special handling for infinities and NaN, - // which don't look like a number so shouldn't be padded with zeros. - if num[1] == 'I' || num[1] == 'N' { - oldZero := f.Zero - f.Zero = false - // Remove sign before NaN if not asked for. - if num[1] == 'N' && !f.Space && !f.Plus { - num = num[1:] - } - f.pad(num) - f.Zero = oldZero - return - } - // The sharp flag forces printing a decimal point for non-binary formats - // and retains trailing zeros, which we may need to restore. - if f.Sharp && verb != 'b' { - digits := 0 - switch verb { - case 'v', 'g', 'G': - digits = prec - // If no precision is set explicitly use a precision of 6. - if digits == -1 { - digits = 6 - } - } - - // Buffer pre-allocated with enough room for - // exponent notations of the form "e+123". - var tailBuf [5]byte - tail := tailBuf[:0] - - hasDecimalPoint := false - // Starting from i = 1 to skip sign at num[0]. - for i := 1; i < len(num); i++ { - switch num[i] { - case '.': - hasDecimalPoint = true - case 'e', 'E': - tail = append(tail, num[i:]...) - num = num[:i] - default: - digits-- - } - } - if !hasDecimalPoint { - num = append(num, '.') - } - for digits > 0 { - num = append(num, '0') - digits-- - } - num = append(num, tail...) - } - // We want a sign if asked for and if the sign is not positive. - if f.Plus || num[0] != '+' { - // If we're zero padding to the left we want the sign before the leading zeros. - // Achieve this by writing the sign out and then padding the unsigned number. - if f.Zero && f.WidthPresent && f.Width > len(num) { - f.buf.WriteByte(num[0]) - f.writePadding(f.Width - len(num)) - f.buf.Write(num[1:]) - return - } - f.pad(num) - return - } - // No sign to show and the number is positive; just print the unsigned number. - f.pad(num[1:]) -} diff --git a/vendor/golang.org/x/text/message/message.go b/vendor/golang.org/x/text/message/message.go deleted file mode 100644 index 91a9726..0000000 --- a/vendor/golang.org/x/text/message/message.go +++ /dev/null @@ -1,192 +0,0 @@ -// 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. - -package message // import "golang.org/x/text/message" - -import ( - "io" - "os" - - // Include features to facilitate generated catalogs. - _ "golang.org/x/text/feature/plural" - - "golang.org/x/text/internal/number" - "golang.org/x/text/language" - "golang.org/x/text/message/catalog" -) - -// A Printer implements language-specific formatted I/O analogous to the fmt -// package. -type Printer struct { - // the language - tag language.Tag - - toDecimal number.Formatter - toScientific number.Formatter - - cat catalog.Catalog -} - -type options struct { - cat catalog.Catalog - // TODO: - // - allow %s to print integers in written form (tables are likely too large - // to enable this by default). - // - list behavior - // -} - -// An Option defines an option of a Printer. -type Option func(o *options) - -// Catalog defines the catalog to be used. -func Catalog(c catalog.Catalog) Option { - return func(o *options) { o.cat = c } -} - -// NewPrinter returns a Printer that formats messages tailored to language t. -func NewPrinter(t language.Tag, opts ...Option) *Printer { - options := &options{ - cat: DefaultCatalog, - } - for _, o := range opts { - o(options) - } - p := &Printer{ - tag: t, - cat: options.cat, - } - p.toDecimal.InitDecimal(t) - p.toScientific.InitScientific(t) - return p -} - -// Sprint is like fmt.Sprint, but using language-specific formatting. -func (p *Printer) Sprint(a ...interface{}) string { - pp := newPrinter(p) - pp.doPrint(a) - s := pp.String() - pp.free() - return s -} - -// Fprint is like fmt.Fprint, but using language-specific formatting. -func (p *Printer) Fprint(w io.Writer, a ...interface{}) (n int, err error) { - pp := newPrinter(p) - pp.doPrint(a) - n64, err := io.Copy(w, &pp.Buffer) - pp.free() - return int(n64), err -} - -// Print is like fmt.Print, but using language-specific formatting. -func (p *Printer) Print(a ...interface{}) (n int, err error) { - return p.Fprint(os.Stdout, a...) -} - -// Sprintln is like fmt.Sprintln, but using language-specific formatting. -func (p *Printer) Sprintln(a ...interface{}) string { - pp := newPrinter(p) - pp.doPrintln(a) - s := pp.String() - pp.free() - return s -} - -// Fprintln is like fmt.Fprintln, but using language-specific formatting. -func (p *Printer) Fprintln(w io.Writer, a ...interface{}) (n int, err error) { - pp := newPrinter(p) - pp.doPrintln(a) - n64, err := io.Copy(w, &pp.Buffer) - pp.free() - return int(n64), err -} - -// Println is like fmt.Println, but using language-specific formatting. -func (p *Printer) Println(a ...interface{}) (n int, err error) { - return p.Fprintln(os.Stdout, a...) -} - -// Sprintf is like fmt.Sprintf, but using language-specific formatting. -func (p *Printer) Sprintf(key Reference, a ...interface{}) string { - pp := newPrinter(p) - lookupAndFormat(pp, key, a) - s := pp.String() - pp.free() - return s -} - -// Fprintf is like fmt.Fprintf, but using language-specific formatting. -func (p *Printer) Fprintf(w io.Writer, key Reference, a ...interface{}) (n int, err error) { - pp := newPrinter(p) - lookupAndFormat(pp, key, a) - n, err = w.Write(pp.Bytes()) - pp.free() - return n, err - -} - -// Printf is like fmt.Printf, but using language-specific formatting. -func (p *Printer) Printf(key Reference, a ...interface{}) (n int, err error) { - pp := newPrinter(p) - lookupAndFormat(pp, key, a) - n, err = os.Stdout.Write(pp.Bytes()) - pp.free() - return n, err -} - -func lookupAndFormat(p *printer, r Reference, a []interface{}) { - p.fmt.Reset(a) - switch v := r.(type) { - case string: - if p.catContext.Execute(v) == catalog.ErrNotFound { - p.Render(v) - return - } - case key: - if p.catContext.Execute(v.id) == catalog.ErrNotFound && - p.catContext.Execute(v.fallback) == catalog.ErrNotFound { - p.Render(v.fallback) - return - } - default: - panic("key argument is not a Reference") - } -} - -type rawPrinter struct { - p *printer -} - -func (p rawPrinter) Render(msg string) { p.p.WriteString(msg) } -func (p rawPrinter) Arg(i int) interface{} { return nil } - -// Arg implements catmsg.Renderer. -func (p *printer) Arg(i int) interface{} { // TODO, also return "ok" bool - i-- - if uint(i) < uint(len(p.fmt.Args)) { - return p.fmt.Args[i] - } - return nil -} - -// Render implements catmsg.Renderer. -func (p *printer) Render(msg string) { - p.doPrintf(msg) -} - -// A Reference is a string or a message reference. -type Reference interface { - // TODO: also allow []string -} - -// Key creates a message Reference for a message where the given id is used for -// message lookup and the fallback is returned when no matches are found. -func Key(id string, fallback string) Reference { - return key{id, fallback} -} - -type key struct { - id, fallback string -} diff --git a/vendor/golang.org/x/text/message/pipeline/extract.go b/vendor/golang.org/x/text/message/pipeline/extract.go deleted file mode 100644 index a15a7f9..0000000 --- a/vendor/golang.org/x/text/message/pipeline/extract.go +++ /dev/null @@ -1,821 +0,0 @@ -// Copyright 2016 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 pipeline - -import ( - "bytes" - "errors" - "fmt" - "go/ast" - "go/constant" - "go/format" - "go/token" - "go/types" - "path/filepath" - "sort" - "strings" - "unicode" - "unicode/utf8" - - fmtparser "golang.org/x/text/internal/format" - "golang.org/x/tools/go/callgraph" - "golang.org/x/tools/go/callgraph/cha" - "golang.org/x/tools/go/loader" - "golang.org/x/tools/go/ssa" - "golang.org/x/tools/go/ssa/ssautil" -) - -const debug = false - -// TODO: -// - merge information into existing files -// - handle different file formats (PO, XLIFF) -// - handle features (gender, plural) -// - message rewriting - -// - `msg:"etc"` tags - -// Extract extracts all strings form the package defined in Config. -func Extract(c *Config) (*State, error) { - x, err := newExtracter(c) - if err != nil { - return nil, wrap(err, "") - } - - if err := x.seedEndpoints(); err != nil { - return nil, err - } - x.extractMessages() - - return &State{ - Config: *c, - program: x.iprog, - Extracted: Messages{ - Language: c.SourceLanguage, - Messages: x.messages, - }, - }, nil -} - -type extracter struct { - conf loader.Config - iprog *loader.Program - prog *ssa.Program - callGraph *callgraph.Graph - - // Calls and other expressions to collect. - globals map[token.Pos]*constData - funcs map[token.Pos]*callData - messages []Message -} - -func newExtracter(c *Config) (x *extracter, err error) { - x = &extracter{ - conf: loader.Config{}, - globals: map[token.Pos]*constData{}, - funcs: map[token.Pos]*callData{}, - } - - x.iprog, err = loadPackages(&x.conf, c.Packages) - if err != nil { - return nil, wrap(err, "") - } - - x.prog = ssautil.CreateProgram(x.iprog, ssa.GlobalDebug|ssa.BareInits) - x.prog.Build() - - x.callGraph = cha.CallGraph(x.prog) - - return x, nil -} - -func (x *extracter) globalData(pos token.Pos) *constData { - cd := x.globals[pos] - if cd == nil { - cd = &constData{} - x.globals[pos] = cd - } - return cd -} - -func (x *extracter) seedEndpoints() error { - pkgInfo := x.iprog.Package("golang.org/x/text/message") - if pkgInfo == nil { - return errors.New("pipeline: golang.org/x/text/message is not imported") - } - pkg := x.prog.Package(pkgInfo.Pkg) - typ := types.NewPointer(pkg.Type("Printer").Type()) - - x.processGlobalVars() - - x.handleFunc(x.prog.LookupMethod(typ, pkg.Pkg, "Printf"), &callData{ - formatPos: 1, - argPos: 2, - isMethod: true, - }) - x.handleFunc(x.prog.LookupMethod(typ, pkg.Pkg, "Sprintf"), &callData{ - formatPos: 1, - argPos: 2, - isMethod: true, - }) - x.handleFunc(x.prog.LookupMethod(typ, pkg.Pkg, "Fprintf"), &callData{ - formatPos: 2, - argPos: 3, - isMethod: true, - }) - return nil -} - -// processGlobalVars finds string constants that are assigned to global -// variables. -func (x *extracter) processGlobalVars() { - for _, p := range x.prog.AllPackages() { - m, ok := p.Members["init"] - if !ok { - continue - } - for _, b := range m.(*ssa.Function).Blocks { - for _, i := range b.Instrs { - s, ok := i.(*ssa.Store) - if !ok { - continue - } - a, ok := s.Addr.(*ssa.Global) - if !ok { - continue - } - t := a.Type() - for { - p, ok := t.(*types.Pointer) - if !ok { - break - } - t = p.Elem() - } - if b, ok := t.(*types.Basic); !ok || b.Kind() != types.String { - continue - } - x.visitInit(a, s.Val) - } - } - } -} - -type constData struct { - call *callData // to provide a signature for the constants - values []constVal - others []token.Pos // Assigned to other global data. -} - -func (d *constData) visit(x *extracter, f func(c constant.Value)) { - for _, v := range d.values { - f(v.value) - } - for _, p := range d.others { - if od, ok := x.globals[p]; ok { - od.visit(x, f) - } - } -} - -type constVal struct { - value constant.Value - pos token.Pos -} - -type callData struct { - call ssa.CallInstruction - expr *ast.CallExpr - formats []constant.Value - - callee *callData - isMethod bool - formatPos int - argPos int // varargs at this position in the call - argTypes []int // arguments extractable from this position -} - -func (c *callData) callFormatPos() int { - c = c.callee - if c.isMethod { - return c.formatPos - 1 - } - return c.formatPos -} - -func (c *callData) callArgsStart() int { - c = c.callee - if c.isMethod { - return c.argPos - 1 - } - return c.argPos -} - -func (c *callData) Pos() token.Pos { return c.call.Pos() } -func (c *callData) Pkg() *types.Package { return c.call.Parent().Pkg.Pkg } - -func (x *extracter) handleFunc(f *ssa.Function, fd *callData) { - for _, e := range x.callGraph.Nodes[f].In { - if e.Pos() == 0 { - continue - } - - call := e.Site - caller := x.funcs[call.Pos()] - if caller != nil { - // TODO: theoretically a format string could be passed to multiple - // arguments of a function. Support this eventually. - continue - } - x.debug(call, "CALL", f.String()) - - caller = &callData{ - call: call, - callee: fd, - formatPos: -1, - argPos: -1, - } - // Offset by one if we are invoking an interface method. - offset := 0 - if call.Common().IsInvoke() { - offset = -1 - } - x.funcs[call.Pos()] = caller - if fd.argPos >= 0 { - x.visitArgs(caller, call.Common().Args[fd.argPos+offset]) - } - x.visitFormats(caller, call.Common().Args[fd.formatPos+offset]) - } -} - -type posser interface { - Pos() token.Pos - Parent() *ssa.Function -} - -func (x *extracter) debug(v posser, header string, args ...interface{}) { - if debug { - pos := "" - if p := v.Parent(); p != nil { - pos = posString(&x.conf, p.Package().Pkg, v.Pos()) - } - if header != "CALL" && header != "INSERT" { - header = " " + header - } - fmt.Printf("%-32s%-10s%-15T ", pos+fmt.Sprintf("@%d", v.Pos()), header, v) - for _, a := range args { - fmt.Printf(" %v", a) - } - fmt.Println() - } -} - -// visitInit evaluates and collects values assigned to global variables in an -// init function. -func (x *extracter) visitInit(global *ssa.Global, v ssa.Value) { - if v == nil { - return - } - x.debug(v, "GLOBAL", v) - - switch v := v.(type) { - case *ssa.Phi: - for _, e := range v.Edges { - x.visitInit(global, e) - } - - case *ssa.Const: - // Only record strings with letters. - if str := constant.StringVal(v.Value); isMsg(str) { - cd := x.globalData(global.Pos()) - cd.values = append(cd.values, constVal{v.Value, v.Pos()}) - } - // TODO: handle %m-directive. - - case *ssa.Global: - cd := x.globalData(global.Pos()) - cd.others = append(cd.others, v.Pos()) - - case *ssa.FieldAddr, *ssa.Field: - // TODO: mark field index v.Field of v.X.Type() for extraction. extract - // an example args as to give parameters for the translator. - - case *ssa.Slice: - if v.Low == nil && v.High == nil && v.Max == nil { - x.visitInit(global, v.X) - } - - case *ssa.Alloc: - if ref := v.Referrers(); ref == nil { - for _, r := range *ref { - values := []ssa.Value{} - for _, o := range r.Operands(nil) { - if o == nil || *o == v { - continue - } - values = append(values, *o) - } - // TODO: return something different if we care about multiple - // values as well. - if len(values) == 1 { - x.visitInit(global, values[0]) - } - } - } - - case ssa.Instruction: - rands := v.Operands(nil) - if len(rands) == 1 && rands[0] != nil { - x.visitInit(global, *rands[0]) - } - } - return -} - -// visitFormats finds the original source of the value. The returned index is -// position of the argument if originated from a function argument or -1 -// otherwise. -func (x *extracter) visitFormats(call *callData, v ssa.Value) { - if v == nil { - return - } - x.debug(v, "VALUE", v) - - switch v := v.(type) { - case *ssa.Phi: - for _, e := range v.Edges { - x.visitFormats(call, e) - } - - case *ssa.Const: - // Only record strings with letters. - if isMsg(constant.StringVal(v.Value)) { - x.debug(call.call, "FORMAT", v.Value.ExactString()) - call.formats = append(call.formats, v.Value) - } - // TODO: handle %m-directive. - - case *ssa.Global: - x.globalData(v.Pos()).call = call - - case *ssa.FieldAddr, *ssa.Field: - // TODO: mark field index v.Field of v.X.Type() for extraction. extract - // an example args as to give parameters for the translator. - - case *ssa.Slice: - if v.Low == nil && v.High == nil && v.Max == nil { - x.visitFormats(call, v.X) - } - - case *ssa.Parameter: - // TODO: handle the function for the index parameter. - f := v.Parent() - for i, p := range f.Params { - if p == v { - if call.formatPos < 0 { - call.formatPos = i - // TODO: is there a better way to detect this is calling - // a method rather than a function? - call.isMethod = len(f.Params) > f.Signature.Params().Len() - x.handleFunc(v.Parent(), call) - } else if debug && i != call.formatPos { - // TODO: support this. - fmt.Printf("WARNING:%s: format string passed to arg %d and %d\n", - posString(&x.conf, call.Pkg(), call.Pos()), - call.formatPos, i) - } - } - } - - case *ssa.Alloc: - if ref := v.Referrers(); ref == nil { - for _, r := range *ref { - values := []ssa.Value{} - for _, o := range r.Operands(nil) { - if o == nil || *o == v { - continue - } - values = append(values, *o) - } - // TODO: return something different if we care about multiple - // values as well. - if len(values) == 1 { - x.visitFormats(call, values[0]) - } - } - } - - // TODO: - // case *ssa.Index: - // // Get all values in the array if applicable - // case *ssa.IndexAddr: - // // Get all values in the slice or *array if applicable. - // case *ssa.Lookup: - // // Get all values in the map if applicable. - - case *ssa.FreeVar: - // TODO: find the link between free variables and parameters: - // - // func freeVar(p *message.Printer, str string) { - // fn := func(p *message.Printer) { - // p.Printf(str) - // } - // fn(p) - // } - - case *ssa.Call: - - case ssa.Instruction: - rands := v.Operands(nil) - if len(rands) == 1 && rands[0] != nil { - x.visitFormats(call, *rands[0]) - } - } -} - -// Note: a function may have an argument marked as both format and passthrough. - -// visitArgs collects information on arguments. For wrapped functions it will -// just determine the position of the variable args slice. -func (x *extracter) visitArgs(fd *callData, v ssa.Value) { - if v == nil { - return - } - x.debug(v, "ARGV", v) - switch v := v.(type) { - - case *ssa.Slice: - if v.Low == nil && v.High == nil && v.Max == nil { - x.visitArgs(fd, v.X) - } - - case *ssa.Parameter: - // TODO: handle the function for the index parameter. - f := v.Parent() - for i, p := range f.Params { - if p == v { - fd.argPos = i - } - } - - case *ssa.Alloc: - if ref := v.Referrers(); ref == nil { - for _, r := range *ref { - values := []ssa.Value{} - for _, o := range r.Operands(nil) { - if o == nil || *o == v { - continue - } - values = append(values, *o) - } - // TODO: return something different if we care about - // multiple values as well. - if len(values) == 1 { - x.visitArgs(fd, values[0]) - } - } - } - - case ssa.Instruction: - rands := v.Operands(nil) - if len(rands) == 1 && rands[0] != nil { - x.visitArgs(fd, *rands[0]) - } - } -} - -// print returns Go syntax for the specified node. -func (x *extracter) print(n ast.Node) string { - var buf bytes.Buffer - format.Node(&buf, x.conf.Fset, n) - return buf.String() -} - -type packageExtracter struct { - f *ast.File - x *extracter - info *loader.PackageInfo - cmap ast.CommentMap -} - -func (px packageExtracter) getComment(n ast.Node) string { - cs := px.cmap.Filter(n).Comments() - if len(cs) > 0 { - return strings.TrimSpace(cs[0].Text()) - } - return "" -} - -func (x *extracter) extractMessages() { - prog := x.iprog - keys := make([]*types.Package, 0, len(x.iprog.AllPackages)) - for k := range x.iprog.AllPackages { - keys = append(keys, k) - } - sort.Slice(keys, func(i, j int) bool { return keys[i].Path() < keys[j].Path() }) - files := []packageExtracter{} - for _, k := range keys { - info := x.iprog.AllPackages[k] - for _, f := range info.Files { - // Associate comments with nodes. - px := packageExtracter{ - f, x, info, - ast.NewCommentMap(prog.Fset, f, f.Comments), - } - files = append(files, px) - } - } - for _, px := range files { - ast.Inspect(px.f, func(n ast.Node) bool { - switch v := n.(type) { - case *ast.CallExpr: - if d := x.funcs[v.Lparen]; d != nil { - d.expr = v - } - } - return true - }) - } - for _, px := range files { - ast.Inspect(px.f, func(n ast.Node) bool { - switch v := n.(type) { - case *ast.CallExpr: - return px.handleCall(v) - case *ast.ValueSpec: - return px.handleGlobal(v) - } - return true - }) - } -} - -func (px packageExtracter) handleGlobal(spec *ast.ValueSpec) bool { - comment := px.getComment(spec) - - for _, ident := range spec.Names { - data, ok := px.x.globals[ident.Pos()] - if !ok { - continue - } - name := ident.Name - var arguments []argument - if data.call != nil { - arguments = px.getArguments(data.call) - } else if !strings.HasPrefix(name, "msg") && !strings.HasPrefix(name, "Msg") { - continue - } - data.visit(px.x, func(c constant.Value) { - px.addMessage(spec.Pos(), []string{name}, c, comment, arguments) - }) - } - - return true -} - -func (px packageExtracter) handleCall(call *ast.CallExpr) bool { - x := px.x - data := x.funcs[call.Lparen] - if data == nil || len(data.formats) == 0 { - return true - } - if data.expr != call { - panic("invariant `data.call != call` failed") - } - x.debug(data.call, "INSERT", data.formats) - - argn := data.callFormatPos() - if argn >= len(call.Args) { - return true - } - format := call.Args[argn] - - arguments := px.getArguments(data) - - comment := "" - key := []string{} - if ident, ok := format.(*ast.Ident); ok { - key = append(key, ident.Name) - if v, ok := ident.Obj.Decl.(*ast.ValueSpec); ok && v.Comment != nil { - // TODO: get comment above ValueSpec as well - comment = v.Comment.Text() - } - } - if c := px.getComment(call.Args[0]); c != "" { - comment = c - } - - formats := data.formats - for _, c := range formats { - px.addMessage(call.Lparen, key, c, comment, arguments) - } - return true -} - -func (px packageExtracter) getArguments(data *callData) []argument { - arguments := []argument{} - x := px.x - info := px.info - if data.callArgsStart() >= 0 { - args := data.expr.Args[data.callArgsStart():] - for i, arg := range args { - expr := x.print(arg) - val := "" - if v := info.Types[arg].Value; v != nil { - val = v.ExactString() - switch arg.(type) { - case *ast.BinaryExpr, *ast.UnaryExpr: - expr = val - } - } - arguments = append(arguments, argument{ - ArgNum: i + 1, - Type: info.Types[arg].Type.String(), - UnderlyingType: info.Types[arg].Type.Underlying().String(), - Expr: expr, - Value: val, - Comment: px.getComment(arg), - Position: posString(&x.conf, info.Pkg, arg.Pos()), - // TODO report whether it implements - // interfaces plural.Interface, - // gender.Interface. - }) - } - } - return arguments -} - -func (px packageExtracter) addMessage( - pos token.Pos, - key []string, - c constant.Value, - comment string, - arguments []argument) { - x := px.x - fmtMsg := constant.StringVal(c) - - ph := placeholders{index: map[string]string{}} - - trimmed, _, _ := trimWS(fmtMsg) - - p := fmtparser.Parser{} - simArgs := make([]interface{}, len(arguments)) - for i, v := range arguments { - simArgs[i] = v - } - msg := "" - p.Reset(simArgs) - for p.SetFormat(trimmed); p.Scan(); { - name := "" - var arg *argument - switch p.Status { - case fmtparser.StatusText: - msg += p.Text() - continue - case fmtparser.StatusSubstitution, - fmtparser.StatusBadWidthSubstitution, - fmtparser.StatusBadPrecSubstitution: - arguments[p.ArgNum-1].used = true - arg = &arguments[p.ArgNum-1] - name = getID(arg) - case fmtparser.StatusBadArgNum, fmtparser.StatusMissingArg: - arg = &argument{ - ArgNum: p.ArgNum, - Position: posString(&x.conf, px.info.Pkg, pos), - } - name, arg.UnderlyingType = verbToPlaceholder(p.Text(), p.ArgNum) - } - sub := p.Text() - if !p.HasIndex { - r, sz := utf8.DecodeLastRuneInString(sub) - sub = fmt.Sprintf("%s[%d]%c", sub[:len(sub)-sz], p.ArgNum, r) - } - msg += fmt.Sprintf("{%s}", ph.addArg(arg, name, sub)) - } - key = append(key, msg) - - // Add additional Placeholders that can be used in translations - // that are not present in the string. - for _, arg := range arguments { - if arg.used { - continue - } - ph.addArg(&arg, getID(&arg), fmt.Sprintf("%%[%d]v", arg.ArgNum)) - } - - x.messages = append(x.messages, Message{ - ID: key, - Key: fmtMsg, - Message: Text{Msg: msg}, - // TODO(fix): this doesn't get the before comment. - Comment: comment, - Placeholders: ph.slice, - Position: posString(&x.conf, px.info.Pkg, pos), - }) -} - -func posString(conf *loader.Config, pkg *types.Package, pos token.Pos) string { - p := conf.Fset.Position(pos) - file := fmt.Sprintf("%s:%d:%d", filepath.Base(p.Filename), p.Line, p.Column) - return filepath.Join(pkg.Path(), file) -} - -func getID(arg *argument) string { - s := getLastComponent(arg.Expr) - s = strip(s) - s = strings.Replace(s, " ", "", -1) - // For small variable names, use user-defined types for more info. - if len(s) <= 2 && arg.UnderlyingType != arg.Type { - s = getLastComponent(arg.Type) - } - return strings.Title(s) -} - -// strip is a dirty hack to convert function calls to placeholder IDs. -func strip(s string) string { - s = strings.Map(func(r rune) rune { - if unicode.IsSpace(r) || r == '-' { - return '_' - } - if !unicode.In(r, unicode.Letter, unicode.Mark, unicode.Number) { - return -1 - } - return r - }, s) - // Strip "Get" from getter functions. - if strings.HasPrefix(s, "Get") || strings.HasPrefix(s, "get") { - if len(s) > len("get") { - r, _ := utf8.DecodeRuneInString(s) - if !unicode.In(r, unicode.Ll, unicode.M) { // not lower or mark - s = s[len("get"):] - } - } - } - return s -} - -// verbToPlaceholder gives a name for a placeholder based on the substitution -// verb. This is only to be used if there is otherwise no other type information -// available. -func verbToPlaceholder(sub string, pos int) (name, underlying string) { - r, _ := utf8.DecodeLastRuneInString(sub) - name = fmt.Sprintf("Arg_%d", pos) - switch r { - case 's', 'q': - underlying = "string" - case 'd': - name = "Integer" - underlying = "int" - case 'e', 'f', 'g': - name = "Number" - underlying = "float64" - case 'm': - name = "Message" - underlying = "string" - default: - underlying = "interface{}" - } - return name, underlying -} - -type placeholders struct { - index map[string]string - slice []Placeholder -} - -func (p *placeholders) addArg(arg *argument, name, sub string) (id string) { - id = name - alt, ok := p.index[id] - for i := 1; ok && alt != sub; i++ { - id = fmt.Sprintf("%s_%d", name, i) - alt, ok = p.index[id] - } - p.index[id] = sub - p.slice = append(p.slice, Placeholder{ - ID: id, - String: sub, - Type: arg.Type, - UnderlyingType: arg.UnderlyingType, - ArgNum: arg.ArgNum, - Expr: arg.Expr, - Comment: arg.Comment, - }) - return id -} - -func getLastComponent(s string) string { - return s[1+strings.LastIndexByte(s, '.'):] -} - -// isMsg returns whether s should be translated. -func isMsg(s string) bool { - // TODO: parse as format string and omit strings that contain letters - // coming from format verbs. - for _, r := range s { - if unicode.In(r, unicode.L) { - return true - } - } - return false -} diff --git a/vendor/golang.org/x/text/message/pipeline/generate.go b/vendor/golang.org/x/text/message/pipeline/generate.go deleted file mode 100644 index f747c37..0000000 --- a/vendor/golang.org/x/text/message/pipeline/generate.go +++ /dev/null @@ -1,329 +0,0 @@ -// 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 pipeline - -import ( - "fmt" - "go/build" - "io" - "os" - "path/filepath" - "regexp" - "sort" - "strings" - "text/template" - - "golang.org/x/text/collate" - "golang.org/x/text/feature/plural" - "golang.org/x/text/internal" - "golang.org/x/text/internal/catmsg" - "golang.org/x/text/internal/gen" - "golang.org/x/text/language" - "golang.org/x/tools/go/loader" -) - -var transRe = regexp.MustCompile(`messages\.(.*)\.json`) - -// Generate writes a Go file that defines a Catalog with translated messages. -// Translations are retrieved from s.Messages, not s.Translations, so it -// is assumed Merge has been called. -func (s *State) Generate() error { - path := s.Config.GenPackage - if path == "" { - path = "." - } - isDir := path[0] == '.' - prog, err := loadPackages(&loader.Config{}, []string{path}) - if err != nil { - return wrap(err, "could not load package") - } - pkgs := prog.InitialPackages() - if len(pkgs) != 1 { - return errorf("more than one package selected: %v", pkgs) - } - pkg := pkgs[0].Pkg.Name() - - cw, err := s.generate() - if err != nil { - return err - } - if !isDir { - gopath := filepath.SplitList(build.Default.GOPATH)[0] - path = filepath.Join(gopath, "src", filepath.FromSlash(pkgs[0].Pkg.Path())) - } - if len(s.Config.GenFile) == 0 { - cw.WriteGo(os.Stdout, pkg, "") - return nil - } - if filepath.IsAbs(s.Config.GenFile) { - path = s.Config.GenFile - } else { - path = filepath.Join(path, s.Config.GenFile) - } - cw.WriteGoFile(path, pkg) // TODO: WriteGoFile should return error. - return err -} - -// WriteGen writes a Go file with the given package name to w that defines a -// Catalog with translated messages. Translations are retrieved from s.Messages, -// not s.Translations, so it is assumed Merge has been called. -func (s *State) WriteGen(w io.Writer, pkg string) error { - cw, err := s.generate() - if err != nil { - return err - } - _, err = cw.WriteGo(w, pkg, "") - return err -} - -// Generate is deprecated; use (*State).Generate(). -func Generate(w io.Writer, pkg string, extracted *Messages, trans ...Messages) (n int, err error) { - s := State{ - Extracted: *extracted, - Translations: trans, - } - cw, err := s.generate() - if err != nil { - return 0, err - } - return cw.WriteGo(w, pkg, "") -} - -func (s *State) generate() (*gen.CodeWriter, error) { - // Build up index of translations and original messages. - translations := map[language.Tag]map[string]Message{} - languages := []language.Tag{} - usedKeys := map[string]int{} - - for _, loc := range s.Messages { - tag := loc.Language - if _, ok := translations[tag]; !ok { - translations[tag] = map[string]Message{} - languages = append(languages, tag) - } - for _, m := range loc.Messages { - if !m.Translation.IsEmpty() { - for _, id := range m.ID { - if _, ok := translations[tag][id]; ok { - warnf("Duplicate translation in locale %q for message %q", tag, id) - } - translations[tag][id] = m - } - } - } - } - - // Verify completeness and register keys. - internal.SortTags(languages) - - langVars := []string{} - for _, tag := range languages { - langVars = append(langVars, strings.Replace(tag.String(), "-", "_", -1)) - dict := translations[tag] - for _, msg := range s.Extracted.Messages { - for _, id := range msg.ID { - if trans, ok := dict[id]; ok && !trans.Translation.IsEmpty() { - if _, ok := usedKeys[msg.Key]; !ok { - usedKeys[msg.Key] = len(usedKeys) - } - break - } - // TODO: log missing entry. - warnf("%s: Missing entry for %q.", tag, id) - } - } - } - - cw := gen.NewCodeWriter() - - x := &struct { - Fallback language.Tag - Languages []string - }{ - Fallback: s.Extracted.Language, - Languages: langVars, - } - - if err := lookup.Execute(cw, x); err != nil { - return nil, wrap(err, "error") - } - - keyToIndex := []string{} - for k := range usedKeys { - keyToIndex = append(keyToIndex, k) - } - sort.Strings(keyToIndex) - fmt.Fprint(cw, "var messageKeyToIndex = map[string]int{\n") - for _, k := range keyToIndex { - fmt.Fprintf(cw, "%q: %d,\n", k, usedKeys[k]) - } - fmt.Fprint(cw, "}\n\n") - - for i, tag := range languages { - dict := translations[tag] - a := make([]string, len(usedKeys)) - for _, msg := range s.Extracted.Messages { - for _, id := range msg.ID { - if trans, ok := dict[id]; ok && !trans.Translation.IsEmpty() { - m, err := assemble(&msg, &trans.Translation) - if err != nil { - return nil, wrap(err, "error") - } - _, leadWS, trailWS := trimWS(msg.Key) - if leadWS != "" || trailWS != "" { - m = catmsg.Affix{ - Message: m, - Prefix: leadWS, - Suffix: trailWS, - } - } - // TODO: support macros. - data, err := catmsg.Compile(tag, nil, m) - if err != nil { - return nil, wrap(err, "error") - } - key := usedKeys[msg.Key] - if d := a[key]; d != "" && d != data { - warnf("Duplicate non-consistent translation for key %q, picking the one for message %q", msg.Key, id) - } - a[key] = string(data) - break - } - } - } - index := []uint32{0} - p := 0 - for _, s := range a { - p += len(s) - index = append(index, uint32(p)) - } - - cw.WriteVar(langVars[i]+"Index", index) - cw.WriteConst(langVars[i]+"Data", strings.Join(a, "")) - } - return cw, nil -} - -func assemble(m *Message, t *Text) (msg catmsg.Message, err error) { - keys := []string{} - for k := range t.Var { - keys = append(keys, k) - } - sort.Strings(keys) - var a []catmsg.Message - for _, k := range keys { - t := t.Var[k] - m, err := assemble(m, &t) - if err != nil { - return nil, err - } - a = append(a, &catmsg.Var{Name: k, Message: m}) - } - if t.Select != nil { - s, err := assembleSelect(m, t.Select) - if err != nil { - return nil, err - } - a = append(a, s) - } - if t.Msg != "" { - sub, err := m.Substitute(t.Msg) - if err != nil { - return nil, err - } - a = append(a, catmsg.String(sub)) - } - switch len(a) { - case 0: - return nil, errorf("generate: empty message") - case 1: - return a[0], nil - default: - return catmsg.FirstOf(a), nil - - } -} - -func assembleSelect(m *Message, s *Select) (msg catmsg.Message, err error) { - cases := []string{} - for c := range s.Cases { - cases = append(cases, c) - } - sortCases(cases) - - caseMsg := []interface{}{} - for _, c := range cases { - cm := s.Cases[c] - m, err := assemble(m, &cm) - if err != nil { - return nil, err - } - caseMsg = append(caseMsg, c, m) - } - - ph := m.Placeholder(s.Arg) - - switch s.Feature { - case "plural": - // TODO: only printf-style selects are supported as of yet. - return plural.Selectf(ph.ArgNum, ph.String, caseMsg...), nil - } - return nil, errorf("unknown feature type %q", s.Feature) -} - -func sortCases(cases []string) { - // TODO: implement full interface. - sort.Slice(cases, func(i, j int) bool { - switch { - case cases[i] != "other" && cases[j] == "other": - return true - case cases[i] == "other" && cases[j] != "other": - return false - } - // the following code relies on '<' < '=' < any letter. - return cmpNumeric(cases[i], cases[j]) == -1 - }) -} - -var cmpNumeric = collate.New(language.Und, collate.Numeric).CompareString - -var lookup = template.Must(template.New("gen").Parse(` -import ( - "golang.org/x/text/language" - "golang.org/x/text/message" - "golang.org/x/text/message/catalog" -) - -type dictionary struct { - index []uint32 - data string -} - -func (d *dictionary) Lookup(key string) (data string, ok bool) { - p, ok := messageKeyToIndex[key] - if !ok { - return "", false - } - start, end := d.index[p], d.index[p+1] - if start == end { - return "", false - } - return d.data[start:end], true -} - -func init() { - dict := map[string]catalog.Dictionary{ - {{range .Languages}}"{{.}}": &dictionary{index: {{.}}Index, data: {{.}}Data }, - {{end}} - } - fallback := language.MustParse("{{.Fallback}}") - cat, err := catalog.NewFromMap(dict, catalog.Fallback(fallback)) - if err != nil { - panic(err) - } - message.DefaultCatalog = cat -} - -`)) diff --git a/vendor/golang.org/x/text/message/pipeline/message.go b/vendor/golang.org/x/text/message/pipeline/message.go deleted file mode 100644 index c83a8fd..0000000 --- a/vendor/golang.org/x/text/message/pipeline/message.go +++ /dev/null @@ -1,241 +0,0 @@ -// 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 pipeline - -import ( - "encoding/json" - "errors" - "strings" - - "golang.org/x/text/language" -) - -// TODO: these definitions should be moved to a package so that the can be used -// by other tools. - -// The file contains the structures used to define translations of a certain -// messages. -// -// A translation may have multiple translations strings, or messages, depending -// on the feature values of the various arguments. For instance, consider -// a hypothetical translation from English to English, where the source defines -// the format string "%d file(s) remaining". -// See the examples directory for examples of extracted messages. - -// Messages is used to store translations for a single language. -type Messages struct { - Language language.Tag `json:"language"` - Messages []Message `json:"messages"` - Macros map[string]Text `json:"macros,omitempty"` -} - -// A Message describes a message to be translated. -type Message struct { - // ID contains a list of identifiers for the message. - ID IDList `json:"id"` - // Key is the string that is used to look up the message at runtime. - Key string `json:"key,omitempty"` - Meaning string `json:"meaning,omitempty"` - Message Text `json:"message"` - Translation Text `json:"translation"` - - Comment string `json:"comment,omitempty"` - TranslatorComment string `json:"translatorComment,omitempty"` - - Placeholders []Placeholder `json:"placeholders,omitempty"` - - // Fuzzy indicates that the provide translation needs review by a - // translator, for instance because it was derived from automated - // translation. - Fuzzy bool `json:"fuzzy,omitempty"` - - // TODO: default placeholder syntax is {foo}. Allow alternative escaping - // like `foo`. - - // Extraction information. - Position string `json:"position,omitempty"` // filePosition:line -} - -// Placeholder reports the placeholder for the given ID if it is defined or nil -// otherwise. -func (m *Message) Placeholder(id string) *Placeholder { - for _, p := range m.Placeholders { - if p.ID == id { - return &p - } - } - return nil -} - -// Substitute replaces placeholders in msg with their original value. -func (m *Message) Substitute(msg string) (sub string, err error) { - last := 0 - for i := 0; i < len(msg); { - pLeft := strings.IndexByte(msg[i:], '{') - if pLeft == -1 { - break - } - pLeft += i - pRight := strings.IndexByte(msg[pLeft:], '}') - if pRight == -1 { - return "", errorf("unmatched '}'") - } - pRight += pLeft - id := strings.TrimSpace(msg[pLeft+1 : pRight]) - i = pRight + 1 - if id != "" && id[0] == '$' { - continue - } - sub += msg[last:pLeft] - last = i - ph := m.Placeholder(id) - if ph == nil { - return "", errorf("unknown placeholder %q in message %q", id, msg) - } - sub += ph.String - } - sub += msg[last:] - return sub, err -} - -var errIncompatibleMessage = errors.New("messages incompatible") - -func checkEquivalence(a, b *Message) error { - for _, v := range a.ID { - for _, w := range b.ID { - if v == w { - return nil - } - } - } - // TODO: canonicalize placeholders and check for type equivalence. - return errIncompatibleMessage -} - -// A Placeholder is a part of the message that should not be changed by a -// translator. It can be used to hide or prettify format strings (e.g. %d or -// {{.Count}}), hide HTML, or mark common names that should not be translated. -type Placeholder struct { - // ID is the placeholder identifier without the curly braces. - ID string `json:"id"` - - // String is the string with which to replace the placeholder. This may be a - // formatting string (for instance "%d" or "{{.Count}}") or a literal string - // (<div>). - String string `json:"string"` - - Type string `json:"type"` - UnderlyingType string `json:"underlyingType"` - // ArgNum and Expr are set if the placeholder is a substitution of an - // argument. - ArgNum int `json:"argNum,omitempty"` - Expr string `json:"expr,omitempty"` - - Comment string `json:"comment,omitempty"` - Example string `json:"example,omitempty"` - - // Features contains the features that are available for the implementation - // of this argument. - Features []Feature `json:"features,omitempty"` -} - -// An argument contains information about the arguments passed to a message. -type argument struct { - // ArgNum corresponds to the number that should be used for explicit argument indexes (e.g. - // "%[1]d"). - ArgNum int `json:"argNum,omitempty"` - - used bool // Used by Placeholder - Type string `json:"type"` - UnderlyingType string `json:"underlyingType"` - Expr string `json:"expr"` - Value string `json:"value,omitempty"` - Comment string `json:"comment,omitempty"` - Position string `json:"position,omitempty"` -} - -// Feature holds information about a feature that can be implemented by -// an Argument. -type Feature struct { - Type string `json:"type"` // Right now this is only gender and plural. - - // TODO: possible values and examples for the language under consideration. - -} - -// Text defines a message to be displayed. -type Text struct { - // Msg and Select contains the message to be displayed. Msg may be used as - // a fallback value if none of the select cases match. - Msg string `json:"msg,omitempty"` - Select *Select `json:"select,omitempty"` - - // Var defines a map of variables that may be substituted in the selected - // message. - Var map[string]Text `json:"var,omitempty"` - - // Example contains an example message formatted with default values. - Example string `json:"example,omitempty"` -} - -// IsEmpty reports whether this Text can generate anything. -func (t *Text) IsEmpty() bool { - return t.Msg == "" && t.Select == nil && t.Var == nil -} - -// rawText erases the UnmarshalJSON method. -type rawText Text - -// UnmarshalJSON implements json.Unmarshaler. -func (t *Text) UnmarshalJSON(b []byte) error { - if b[0] == '"' { - return json.Unmarshal(b, &t.Msg) - } - return json.Unmarshal(b, (*rawText)(t)) -} - -// MarshalJSON implements json.Marshaler. -func (t *Text) MarshalJSON() ([]byte, error) { - if t.Select == nil && t.Var == nil && t.Example == "" { - return json.Marshal(t.Msg) - } - return json.Marshal((*rawText)(t)) -} - -// IDList is a set identifiers that each may refer to possibly different -// versions of the same message. When looking up a messages, the first -// identifier in the list takes precedence. -type IDList []string - -// UnmarshalJSON implements json.Unmarshaler. -func (id *IDList) UnmarshalJSON(b []byte) error { - if b[0] == '"' { - *id = []string{""} - return json.Unmarshal(b, &((*id)[0])) - } - return json.Unmarshal(b, (*[]string)(id)) -} - -// MarshalJSON implements json.Marshaler. -func (id *IDList) MarshalJSON() ([]byte, error) { - if len(*id) == 1 { - return json.Marshal((*id)[0]) - } - return json.Marshal((*[]string)(id)) -} - -// Select selects a Text based on the feature value associated with a feature of -// a certain argument. -type Select struct { - Feature string `json:"feature"` // Name of Feature type (e.g plural) - Arg string `json:"arg"` // The placeholder ID - Cases map[string]Text `json:"cases"` -} - -// TODO: order matters, but can we derive the ordering from the case keys? -// type Case struct { -// Key string `json:"key"` -// Value Text `json:"value"` -// } diff --git a/vendor/golang.org/x/text/message/pipeline/pipeline.go b/vendor/golang.org/x/text/message/pipeline/pipeline.go deleted file mode 100644 index 34f15f8..0000000 --- a/vendor/golang.org/x/text/message/pipeline/pipeline.go +++ /dev/null @@ -1,422 +0,0 @@ -// 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 pipeline provides tools for creating translation pipelines. -// -// NOTE: UNDER DEVELOPMENT. API MAY CHANGE. -package pipeline - -import ( - "bytes" - "encoding/json" - "fmt" - "go/build" - "go/parser" - "io/ioutil" - "log" - "os" - "path/filepath" - "regexp" - "strings" - "text/template" - "unicode" - - "golang.org/x/text/internal" - "golang.org/x/text/language" - "golang.org/x/text/runes" - "golang.org/x/tools/go/loader" -) - -const ( - extractFile = "extracted.gotext.json" - outFile = "out.gotext.json" - gotextSuffix = "gotext.json" -) - -// Config contains configuration for the translation pipeline. -type Config struct { - // Supported indicates the languages for which data should be generated. - // The default is to support all locales for which there are matching - // translation files. - Supported []language.Tag - - // --- Extraction - - SourceLanguage language.Tag - - Packages []string - - // --- File structure - - // Dir is the root dir for all operations. - Dir string - - // TranslationsPattern is a regular expression to match incoming translation - // files. These files may appear in any directory rooted at Dir. - // language for the translation files is determined as follows: - // 1. From the Language field in the file. - // 2. If not present, from a valid language tag in the filename, separated - // by dots (e.g. "en-US.json" or "incoming.pt_PT.xmb"). - // 3. If not present, from a the closest subdirectory in which the file - // is contained that parses as a valid language tag. - TranslationsPattern string - - // OutPattern defines the location for translation files for a certain - // language. The default is "{{.Dir}}/{{.Language}}/out.{{.Ext}}" - OutPattern string - - // Format defines the file format for generated translation files. - // The default is XMB. Alternatives are GetText, XLIFF, L20n, GoText. - Format string - - Ext string - - // TODO: - // Actions are additional actions to be performed after the initial extract - // and merge. - // Actions []struct { - // Name string - // Options map[string]string - // } - - // --- Generation - - // GenFile may be in a different package. It is not defined, it will - // be written to stdout. - GenFile string - - // GenPackage is the package or relative path into which to generate the - // file. If not specified it is relative to the current directory. - GenPackage string - - // DeclareVar defines a variable to which to assign the generated Catalog. - DeclareVar string - - // SetDefault determines whether to assign the generated Catalog to - // message.DefaultCatalog. The default for this is true if DeclareVar is - // not defined, false otherwise. - SetDefault bool - - // TODO: - // - Printf-style configuration - // - Template-style configuration - // - Extraction options - // - Rewrite options - // - Generation options -} - -// Operations: -// - extract: get the strings -// - disambiguate: find messages with the same key, but possible different meaning. -// - create out: create a list of messages that need translations -// - load trans: load the list of current translations -// - merge: assign list of translations as done -// - (action)expand: analyze features and create example sentences for each version. -// - (action)googletrans: pre-populate messages with automatic translations. -// - (action)export: send out messages somewhere non-standard -// - (action)import: load messages from somewhere non-standard -// - vet program: don't pass "foo" + var + "bar" strings. Not using funcs for translated strings. -// - vet trans: coverage: all translations/ all features. -// - generate: generate Go code - -// State holds all accumulated information on translations during processing. -type State struct { - Config Config - - Package string - program *loader.Program - - Extracted Messages `json:"messages"` - - // Messages includes all messages for which there need to be translations. - // Duplicates may be eliminated. Generation will be done from these messages - // (usually after merging). - Messages []Messages - - // Translations are incoming translations for the application messages. - Translations []Messages -} - -func (s *State) dir() string { - if d := s.Config.Dir; d != "" { - return d - } - return "./locales" -} - -func outPattern(s *State) (string, error) { - c := s.Config - pat := c.OutPattern - if pat == "" { - pat = "{{.Dir}}/{{.Language}}/out.{{.Ext}}" - } - - ext := c.Ext - if ext == "" { - ext = c.Format - } - if ext == "" { - ext = gotextSuffix - } - t, err := template.New("").Parse(pat) - if err != nil { - return "", wrap(err, "error parsing template") - } - buf := bytes.Buffer{} - err = t.Execute(&buf, map[string]string{ - "Dir": s.dir(), - "Language": "%s", - "Ext": ext, - }) - return filepath.FromSlash(buf.String()), wrap(err, "incorrect OutPattern") -} - -var transRE = regexp.MustCompile(`.*\.` + gotextSuffix) - -// Import loads existing translation files. -func (s *State) Import() error { - outPattern, err := outPattern(s) - if err != nil { - return err - } - re := transRE - if pat := s.Config.TranslationsPattern; pat != "" { - if re, err = regexp.Compile(pat); err != nil { - return wrapf(err, "error parsing regexp %q", s.Config.TranslationsPattern) - } - } - x := importer{s, outPattern, re} - return x.walkImport(s.dir(), s.Config.SourceLanguage) -} - -type importer struct { - state *State - outPattern string - transFile *regexp.Regexp -} - -func (i *importer) walkImport(path string, tag language.Tag) error { - files, err := ioutil.ReadDir(path) - if err != nil { - return nil - } - for _, f := range files { - name := f.Name() - tag := tag - if f.IsDir() { - if t, err := language.Parse(name); err == nil { - tag = t - } - // We ignore errors - if err := i.walkImport(filepath.Join(path, name), tag); err != nil { - return err - } - continue - } - for _, l := range strings.Split(name, ".") { - if t, err := language.Parse(l); err == nil { - tag = t - } - } - file := filepath.Join(path, name) - // TODO: Should we skip files that match output files? - if fmt.Sprintf(i.outPattern, tag) == file { - continue - } - // TODO: handle different file formats. - if !i.transFile.MatchString(name) { - continue - } - b, err := ioutil.ReadFile(file) - if err != nil { - return wrap(err, "read file failed") - } - var translations Messages - if err := json.Unmarshal(b, &translations); err != nil { - return wrap(err, "parsing translation file failed") - } - i.state.Translations = append(i.state.Translations, translations) - } - return nil -} - -// Merge merges the extracted messages with the existing translations. -func (s *State) Merge() error { - if s.Messages != nil { - panic("already merged") - } - // Create an index for each unique message. - // Duplicates are okay as long as the substitution arguments are okay as - // well. - // Top-level messages are okay to appear in multiple substitution points. - - // Collect key equivalence. - msgs := []*Message{} - keyToIDs := map[string]*Message{} - for _, m := range s.Extracted.Messages { - m := m - if prev, ok := keyToIDs[m.Key]; ok { - if err := checkEquivalence(&m, prev); err != nil { - warnf("Key %q matches conflicting messages: %v and %v", m.Key, prev.ID, m.ID) - // TODO: track enough information so that the rewriter can - // suggest/disambiguate messages. - } - // TODO: add position to message. - continue - } - i := len(msgs) - msgs = append(msgs, &m) - keyToIDs[m.Key] = msgs[i] - } - - // Messages with different keys may still refer to the same translated - // message (e.g. different whitespace). Filter these. - idMap := map[string]bool{} - filtered := []*Message{} - for _, m := range msgs { - found := false - for _, id := range m.ID { - found = found || idMap[id] - } - if !found { - filtered = append(filtered, m) - } - for _, id := range m.ID { - idMap[id] = true - } - } - - // Build index of translations. - translations := map[language.Tag]map[string]Message{} - languages := append([]language.Tag{}, s.Config.Supported...) - - for _, t := range s.Translations { - tag := t.Language - if _, ok := translations[tag]; !ok { - translations[tag] = map[string]Message{} - languages = append(languages, tag) - } - for _, m := range t.Messages { - if !m.Translation.IsEmpty() { - for _, id := range m.ID { - if _, ok := translations[tag][id]; ok { - warnf("Duplicate translation in locale %q for message %q", tag, id) - } - translations[tag][id] = m - } - } - } - } - languages = internal.UniqueTags(languages) - - for _, tag := range languages { - ms := Messages{Language: tag} - for _, orig := range filtered { - m := *orig - m.Key = "" - m.Position = "" - - for _, id := range m.ID { - if t, ok := translations[tag][id]; ok { - m.Translation = t.Translation - if t.TranslatorComment != "" { - m.TranslatorComment = t.TranslatorComment - m.Fuzzy = t.Fuzzy - } - break - } - } - if tag == s.Config.SourceLanguage && m.Translation.IsEmpty() { - m.Translation = m.Message - if m.TranslatorComment == "" { - m.TranslatorComment = "Copied from source." - m.Fuzzy = true - } - } - // TODO: if translation is empty: pre-expand based on available - // linguistic features. This may also be done as a plugin. - ms.Messages = append(ms.Messages, m) - } - s.Messages = append(s.Messages, ms) - } - return nil -} - -// Export writes out the messages to translation out files. -func (s *State) Export() error { - path, err := outPattern(s) - if err != nil { - return wrap(err, "export failed") - } - for _, out := range s.Messages { - // TODO: inject translations from existing files to avoid retranslation. - data, err := json.MarshalIndent(out, "", " ") - if err != nil { - return wrap(err, "JSON marshal failed") - } - file := fmt.Sprintf(path, out.Language) - if err := os.MkdirAll(filepath.Dir(file), 0755); err != nil { - return wrap(err, "dir create failed") - } - if err := ioutil.WriteFile(file, data, 0644); err != nil { - return wrap(err, "write failed") - } - } - return nil -} - -var ( - ws = runes.In(unicode.White_Space).Contains - notWS = runes.NotIn(unicode.White_Space).Contains -) - -func trimWS(s string) (trimmed, leadWS, trailWS string) { - trimmed = strings.TrimRightFunc(s, ws) - trailWS = s[len(trimmed):] - if i := strings.IndexFunc(trimmed, notWS); i > 0 { - leadWS = trimmed[:i] - trimmed = trimmed[i:] - } - return trimmed, leadWS, trailWS -} - -// NOTE: The command line tool already prefixes with "gotext:". -var ( - wrap = func(err error, msg string) error { - if err == nil { - return nil - } - return fmt.Errorf("%s: %v", msg, err) - } - wrapf = func(err error, msg string, args ...interface{}) error { - if err == nil { - return nil - } - return wrap(err, fmt.Sprintf(msg, args...)) - } - errorf = fmt.Errorf -) - -func warnf(format string, args ...interface{}) { - // TODO: don't log. - log.Printf(format, args...) -} - -func loadPackages(conf *loader.Config, args []string) (*loader.Program, error) { - if len(args) == 0 { - args = []string{"."} - } - - conf.Build = &build.Default - conf.ParserMode = parser.ParseComments - - // Use the initial packages from the command line. - args, err := conf.FromArgs(args, false) - if err != nil { - return nil, wrap(err, "loading packages failed") - } - - // Load, parse and type-check the whole program. - return conf.Load() -} diff --git a/vendor/golang.org/x/text/message/pipeline/rewrite.go b/vendor/golang.org/x/text/message/pipeline/rewrite.go deleted file mode 100644 index cf1511f..0000000 --- a/vendor/golang.org/x/text/message/pipeline/rewrite.go +++ /dev/null @@ -1,268 +0,0 @@ -// 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 pipeline - -import ( - "bytes" - "fmt" - "go/ast" - "go/constant" - "go/format" - "go/token" - "io" - "os" - "strings" - - "golang.org/x/tools/go/loader" -) - -const printerType = "golang.org/x/text/message.Printer" - -// Rewrite rewrites the Go files in a single package to use the localization -// machinery and rewrites strings to adopt best practices when possible. -// If w is not nil the generated files are written to it, each files with a -// "--- <filename>" header. Otherwise the files are overwritten. -func Rewrite(w io.Writer, args ...string) error { - conf := &loader.Config{ - AllowErrors: true, // Allow unused instances of message.Printer. - } - prog, err := loadPackages(conf, args) - if err != nil { - return wrap(err, "") - } - - for _, info := range prog.InitialPackages() { - for _, f := range info.Files { - // Associate comments with nodes. - - // Pick up initialized Printers at the package level. - r := rewriter{info: info, conf: conf} - for _, n := range info.InitOrder { - if t := r.info.Types[n.Rhs].Type.String(); strings.HasSuffix(t, printerType) { - r.printerVar = n.Lhs[0].Name() - } - } - - ast.Walk(&r, f) - - w := w - if w == nil { - var err error - if w, err = os.Create(conf.Fset.File(f.Pos()).Name()); err != nil { - return wrap(err, "open failed") - } - } else { - fmt.Fprintln(w, "---", conf.Fset.File(f.Pos()).Name()) - } - - if err := format.Node(w, conf.Fset, f); err != nil { - return wrap(err, "go format failed") - } - } - } - - return nil -} - -type rewriter struct { - info *loader.PackageInfo - conf *loader.Config - printerVar string -} - -// print returns Go syntax for the specified node. -func (r *rewriter) print(n ast.Node) string { - var buf bytes.Buffer - format.Node(&buf, r.conf.Fset, n) - return buf.String() -} - -func (r *rewriter) Visit(n ast.Node) ast.Visitor { - // Save the state by scope. - if _, ok := n.(*ast.BlockStmt); ok { - r := *r - return &r - } - // Find Printers created by assignment. - stmt, ok := n.(*ast.AssignStmt) - if ok { - for _, v := range stmt.Lhs { - if r.printerVar == r.print(v) { - r.printerVar = "" - } - } - for i, v := range stmt.Rhs { - if t := r.info.Types[v].Type.String(); strings.HasSuffix(t, printerType) { - r.printerVar = r.print(stmt.Lhs[i]) - return r - } - } - } - // Find Printers created by variable declaration. - spec, ok := n.(*ast.ValueSpec) - if ok { - for _, v := range spec.Names { - if r.printerVar == r.print(v) { - r.printerVar = "" - } - } - for i, v := range spec.Values { - if t := r.info.Types[v].Type.String(); strings.HasSuffix(t, printerType) { - r.printerVar = r.print(spec.Names[i]) - return r - } - } - } - if r.printerVar == "" { - return r - } - call, ok := n.(*ast.CallExpr) - if !ok { - return r - } - - // TODO: Handle literal values? - sel, ok := call.Fun.(*ast.SelectorExpr) - if !ok { - return r - } - meth := r.info.Selections[sel] - - source := r.print(sel.X) - fun := r.print(sel.Sel) - if meth != nil { - source = meth.Recv().String() - fun = meth.Obj().Name() - } - - // TODO: remove cheap hack and check if the type either - // implements some interface or is specifically of type - // "golang.org/x/text/message".Printer. - m, ok := rewriteFuncs[source] - if !ok { - return r - } - - rewriteType, ok := m[fun] - if !ok { - return r - } - ident := ast.NewIdent(r.printerVar) - ident.NamePos = sel.X.Pos() - sel.X = ident - if rewriteType.method != "" { - sel.Sel.Name = rewriteType.method - } - - // Analyze arguments. - argn := rewriteType.arg - if rewriteType.format || argn >= len(call.Args) { - return r - } - hasConst := false - for _, a := range call.Args[argn:] { - if v := r.info.Types[a].Value; v != nil && v.Kind() == constant.String { - hasConst = true - break - } - } - if !hasConst { - return r - } - sel.Sel.Name = rewriteType.methodf - - // We are done if there is only a single string that does not need to be - // escaped. - if len(call.Args) == 1 { - s, ok := constStr(r.info, call.Args[0]) - if ok && !strings.Contains(s, "%") && !rewriteType.newLine { - return r - } - } - - // Rewrite arguments as format string. - expr := &ast.BasicLit{ - ValuePos: call.Lparen, - Kind: token.STRING, - } - newArgs := append(call.Args[:argn:argn], expr) - newStr := []string{} - for i, a := range call.Args[argn:] { - if s, ok := constStr(r.info, a); ok { - newStr = append(newStr, strings.Replace(s, "%", "%%", -1)) - } else { - newStr = append(newStr, "%v") - newArgs = append(newArgs, call.Args[argn+i]) - } - } - s := strings.Join(newStr, rewriteType.sep) - if rewriteType.newLine { - s += "\n" - } - expr.Value = fmt.Sprintf("%q", s) - - call.Args = newArgs - - // TODO: consider creating an expression instead of a constant string and - // then wrapping it in an escape function or so: - // call.Args[argn+i] = &ast.CallExpr{ - // Fun: &ast.SelectorExpr{ - // X: ast.NewIdent("message"), - // Sel: ast.NewIdent("Lookup"), - // }, - // Args: []ast.Expr{a}, - // } - // } - - return r -} - -type rewriteType struct { - // method is the name of the equivalent method on a printer, or "" if it is - // the same. - method string - - // methodf is the method to use if the arguments can be rewritten as a - // arguments to a printf-style call. - methodf string - - // format is true if the method takes a formatting string followed by - // substitution arguments. - format bool - - // arg indicates the position of the argument to extract. If all is - // positive, all arguments from this argument onwards needs to be extracted. - arg int - - sep string - newLine bool -} - -// rewriteFuncs list functions that can be directly mapped to the printer -// functions of the message package. -var rewriteFuncs = map[string]map[string]rewriteType{ - // TODO: Printer -> *golang.org/x/text/message.Printer - "fmt": { - "Print": rewriteType{methodf: "Printf"}, - "Sprint": rewriteType{methodf: "Sprintf"}, - "Fprint": rewriteType{methodf: "Fprintf"}, - - "Println": rewriteType{methodf: "Printf", sep: " ", newLine: true}, - "Sprintln": rewriteType{methodf: "Sprintf", sep: " ", newLine: true}, - "Fprintln": rewriteType{methodf: "Fprintf", sep: " ", newLine: true}, - - "Printf": rewriteType{method: "Printf", format: true}, - "Sprintf": rewriteType{method: "Sprintf", format: true}, - "Fprintf": rewriteType{method: "Fprintf", format: true}, - }, -} - -func constStr(info *loader.PackageInfo, e ast.Expr) (s string, ok bool) { - v := info.Types[e].Value - if v == nil || v.Kind() != constant.String { - return "", false - } - return constant.StringVal(v), true -} diff --git a/vendor/golang.org/x/text/message/print.go b/vendor/golang.org/x/text/message/print.go deleted file mode 100644 index da304cc..0000000 --- a/vendor/golang.org/x/text/message/print.go +++ /dev/null @@ -1,984 +0,0 @@ -// 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 message - -import ( - "bytes" - "fmt" // TODO: consider copying interfaces from package fmt to avoid dependency. - "math" - "reflect" - "sync" - "unicode/utf8" - - "golang.org/x/text/internal/format" - "golang.org/x/text/internal/number" - "golang.org/x/text/language" - "golang.org/x/text/message/catalog" -) - -// Strings for use with buffer.WriteString. -// This is less overhead than using buffer.Write with byte arrays. -const ( - commaSpaceString = ", " - nilAngleString = "<nil>" - nilParenString = "(nil)" - nilString = "nil" - mapString = "map[" - percentBangString = "%!" - missingString = "(MISSING)" - badIndexString = "(BADINDEX)" - panicString = "(PANIC=" - extraString = "%!(EXTRA " - badWidthString = "%!(BADWIDTH)" - badPrecString = "%!(BADPREC)" - noVerbString = "%!(NOVERB)" - - invReflectString = "<invalid reflect.Value>" -) - -var printerPool = sync.Pool{ - New: func() interface{} { return new(printer) }, -} - -// newPrinter allocates a new printer struct or grabs a cached one. -func newPrinter(pp *Printer) *printer { - p := printerPool.Get().(*printer) - p.Printer = *pp - // TODO: cache most of the following call. - p.catContext = pp.cat.Context(pp.tag, p) - - p.panicking = false - p.erroring = false - p.fmt.init(&p.Buffer) - return p -} - -// free saves used printer structs in printerFree; avoids an allocation per invocation. -func (p *printer) free() { - p.Buffer.Reset() - p.arg = nil - p.value = reflect.Value{} - printerPool.Put(p) -} - -// printer is used to store a printer's state. -// It implements "golang.org/x/text/internal/format".State. -type printer struct { - Printer - - // the context for looking up message translations - catContext *catalog.Context - - // buffer for accumulating output. - bytes.Buffer - - // arg holds the current item, as an interface{}. - arg interface{} - // value is used instead of arg for reflect values. - value reflect.Value - - // fmt is used to format basic items such as integers or strings. - fmt formatInfo - - // panicking is set by catchPanic to avoid infinite panic, recover, panic, ... recursion. - panicking bool - // erroring is set when printing an error string to guard against calling handleMethods. - erroring bool -} - -// Language implements "golang.org/x/text/internal/format".State. -func (p *printer) Language() language.Tag { return p.tag } - -func (p *printer) Width() (wid int, ok bool) { return p.fmt.Width, p.fmt.WidthPresent } - -func (p *printer) Precision() (prec int, ok bool) { return p.fmt.Prec, p.fmt.PrecPresent } - -func (p *printer) Flag(b int) bool { - switch b { - case '-': - return p.fmt.Minus - case '+': - return p.fmt.Plus || p.fmt.PlusV - case '#': - return p.fmt.Sharp || p.fmt.SharpV - case ' ': - return p.fmt.Space - case '0': - return p.fmt.Zero - } - return false -} - -// getField gets the i'th field of the struct value. -// If the field is itself is an interface, return a value for -// the thing inside the interface, not the interface itself. -func getField(v reflect.Value, i int) reflect.Value { - val := v.Field(i) - if val.Kind() == reflect.Interface && !val.IsNil() { - val = val.Elem() - } - return val -} - -func (p *printer) unknownType(v reflect.Value) { - if !v.IsValid() { - p.WriteString(nilAngleString) - return - } - p.WriteByte('?') - p.WriteString(v.Type().String()) - p.WriteByte('?') -} - -func (p *printer) badVerb(verb rune) { - p.erroring = true - p.WriteString(percentBangString) - p.WriteRune(verb) - p.WriteByte('(') - switch { - case p.arg != nil: - p.WriteString(reflect.TypeOf(p.arg).String()) - p.WriteByte('=') - p.printArg(p.arg, 'v') - case p.value.IsValid(): - p.WriteString(p.value.Type().String()) - p.WriteByte('=') - p.printValue(p.value, 'v', 0) - default: - p.WriteString(nilAngleString) - } - p.WriteByte(')') - p.erroring = false -} - -func (p *printer) fmtBool(v bool, verb rune) { - switch verb { - case 't', 'v': - p.fmt.fmt_boolean(v) - default: - p.badVerb(verb) - } -} - -// fmt0x64 formats a uint64 in hexadecimal and prefixes it with 0x or -// not, as requested, by temporarily setting the sharp flag. -func (p *printer) fmt0x64(v uint64, leading0x bool) { - sharp := p.fmt.Sharp - p.fmt.Sharp = leading0x - p.fmt.fmt_integer(v, 16, unsigned, ldigits) - p.fmt.Sharp = sharp -} - -// fmtInteger formats a signed or unsigned integer. -func (p *printer) fmtInteger(v uint64, isSigned bool, verb rune) { - switch verb { - case 'v': - if p.fmt.SharpV && !isSigned { - p.fmt0x64(v, true) - return - } - fallthrough - case 'd': - if p.fmt.Sharp || p.fmt.SharpV { - p.fmt.fmt_integer(v, 10, isSigned, ldigits) - } else { - p.fmtDecimalInt(v, isSigned) - } - case 'b': - p.fmt.fmt_integer(v, 2, isSigned, ldigits) - case 'o': - p.fmt.fmt_integer(v, 8, isSigned, ldigits) - case 'x': - p.fmt.fmt_integer(v, 16, isSigned, ldigits) - case 'X': - p.fmt.fmt_integer(v, 16, isSigned, udigits) - case 'c': - p.fmt.fmt_c(v) - case 'q': - if v <= utf8.MaxRune { - p.fmt.fmt_qc(v) - } else { - p.badVerb(verb) - } - case 'U': - p.fmt.fmt_unicode(v) - default: - p.badVerb(verb) - } -} - -// fmtFloat formats a float. The default precision for each verb -// is specified as last argument in the call to fmt_float. -func (p *printer) fmtFloat(v float64, size int, verb rune) { - switch verb { - case 'b': - p.fmt.fmt_float(v, size, verb, -1) - case 'v': - verb = 'g' - fallthrough - case 'g', 'G': - if p.fmt.Sharp || p.fmt.SharpV { - p.fmt.fmt_float(v, size, verb, -1) - } else { - p.fmtVariableFloat(v, size) - } - case 'e', 'E': - if p.fmt.Sharp || p.fmt.SharpV { - p.fmt.fmt_float(v, size, verb, 6) - } else { - p.fmtScientific(v, size, 6) - } - case 'f', 'F': - if p.fmt.Sharp || p.fmt.SharpV { - p.fmt.fmt_float(v, size, verb, 6) - } else { - p.fmtDecimalFloat(v, size, 6) - } - default: - p.badVerb(verb) - } -} - -func (p *printer) setFlags(f *number.Formatter) { - f.Flags &^= number.ElideSign - if p.fmt.Plus || p.fmt.Space { - f.Flags |= number.AlwaysSign - if !p.fmt.Plus { - f.Flags |= number.ElideSign - } - } else { - f.Flags &^= number.AlwaysSign - } -} - -func (p *printer) updatePadding(f *number.Formatter) { - f.Flags &^= number.PadMask - if p.fmt.Minus { - f.Flags |= number.PadAfterSuffix - } else { - f.Flags |= number.PadBeforePrefix - } - f.PadRune = ' ' - f.FormatWidth = uint16(p.fmt.Width) -} - -func (p *printer) initDecimal(minFrac, maxFrac int) { - f := &p.toDecimal - f.MinIntegerDigits = 1 - f.MaxIntegerDigits = 0 - f.MinFractionDigits = uint8(minFrac) - f.MaxFractionDigits = int16(maxFrac) - p.setFlags(f) - f.PadRune = 0 - if p.fmt.WidthPresent { - if p.fmt.Zero { - wid := p.fmt.Width - // Use significant integers for this. - // TODO: this is not the same as width, but so be it. - if f.MinFractionDigits > 0 { - wid -= 1 + int(f.MinFractionDigits) - } - if p.fmt.Plus || p.fmt.Space { - wid-- - } - if wid > 0 && wid > int(f.MinIntegerDigits) { - f.MinIntegerDigits = uint8(wid) - } - } - p.updatePadding(f) - } -} - -func (p *printer) initScientific(minFrac, maxFrac int) { - f := &p.toScientific - if maxFrac < 0 { - f.SetPrecision(maxFrac) - } else { - f.SetPrecision(maxFrac + 1) - f.MinFractionDigits = uint8(minFrac) - f.MaxFractionDigits = int16(maxFrac) - } - f.MinExponentDigits = 2 - p.setFlags(f) - f.PadRune = 0 - if p.fmt.WidthPresent { - f.Flags &^= number.PadMask - if p.fmt.Zero { - f.PadRune = f.Digit(0) - f.Flags |= number.PadAfterPrefix - } else { - f.PadRune = ' ' - f.Flags |= number.PadBeforePrefix - } - p.updatePadding(f) - } -} - -func (p *printer) fmtDecimalInt(v uint64, isSigned bool) { - var d number.Decimal - - f := &p.toDecimal - if p.fmt.PrecPresent { - p.setFlags(f) - f.MinIntegerDigits = uint8(p.fmt.Prec) - f.MaxIntegerDigits = 0 - f.MinFractionDigits = 0 - f.MaxFractionDigits = 0 - if p.fmt.WidthPresent { - p.updatePadding(f) - } - } else { - p.initDecimal(0, 0) - } - d.ConvertInt(p.toDecimal.RoundingContext, isSigned, v) - - out := p.toDecimal.Format([]byte(nil), &d) - p.Buffer.Write(out) -} - -func (p *printer) fmtDecimalFloat(v float64, size, prec int) { - var d number.Decimal - if p.fmt.PrecPresent { - prec = p.fmt.Prec - } - p.initDecimal(prec, prec) - d.ConvertFloat(p.toDecimal.RoundingContext, v, size) - - out := p.toDecimal.Format([]byte(nil), &d) - p.Buffer.Write(out) -} - -func (p *printer) fmtVariableFloat(v float64, size int) { - prec := -1 - if p.fmt.PrecPresent { - prec = p.fmt.Prec - } - var d number.Decimal - p.initScientific(0, prec) - d.ConvertFloat(p.toScientific.RoundingContext, v, size) - - // Copy logic of 'g' formatting from strconv. It is simplified a bit as - // we don't have to mind having prec > len(d.Digits). - shortest := prec < 0 - ePrec := prec - if shortest { - prec = len(d.Digits) - ePrec = 6 - } else if prec == 0 { - prec = 1 - ePrec = 1 - } - exp := int(d.Exp) - 1 - if exp < -4 || exp >= ePrec { - p.initScientific(0, prec) - - out := p.toScientific.Format([]byte(nil), &d) - p.Buffer.Write(out) - } else { - if prec > int(d.Exp) { - prec = len(d.Digits) - } - if prec -= int(d.Exp); prec < 0 { - prec = 0 - } - p.initDecimal(0, prec) - - out := p.toDecimal.Format([]byte(nil), &d) - p.Buffer.Write(out) - } -} - -func (p *printer) fmtScientific(v float64, size, prec int) { - var d number.Decimal - if p.fmt.PrecPresent { - prec = p.fmt.Prec - } - p.initScientific(prec, prec) - rc := p.toScientific.RoundingContext - d.ConvertFloat(rc, v, size) - - out := p.toScientific.Format([]byte(nil), &d) - p.Buffer.Write(out) - -} - -// fmtComplex formats a complex number v with -// r = real(v) and j = imag(v) as (r+ji) using -// fmtFloat for r and j formatting. -func (p *printer) fmtComplex(v complex128, size int, verb rune) { - // Make sure any unsupported verbs are found before the - // calls to fmtFloat to not generate an incorrect error string. - switch verb { - case 'v', 'b', 'g', 'G', 'f', 'F', 'e', 'E': - p.WriteByte('(') - p.fmtFloat(real(v), size/2, verb) - // Imaginary part always has a sign. - if math.IsNaN(imag(v)) { - // By CLDR's rules, NaNs do not use patterns or signs. As this code - // relies on AlwaysSign working for imaginary parts, we need to - // manually handle NaNs. - f := &p.toScientific - p.setFlags(f) - p.updatePadding(f) - p.setFlags(f) - nan := f.Symbol(number.SymNan) - extra := 0 - if w, ok := p.Width(); ok { - extra = w - utf8.RuneCountInString(nan) - 1 - } - if f.Flags&number.PadAfterNumber == 0 { - for ; extra > 0; extra-- { - p.WriteRune(f.PadRune) - } - } - p.WriteString(f.Symbol(number.SymPlusSign)) - p.WriteString(nan) - for ; extra > 0; extra-- { - p.WriteRune(f.PadRune) - } - p.WriteString("i)") - return - } - oldPlus := p.fmt.Plus - p.fmt.Plus = true - p.fmtFloat(imag(v), size/2, verb) - p.WriteString("i)") // TODO: use symbol? - p.fmt.Plus = oldPlus - default: - p.badVerb(verb) - } -} - -func (p *printer) fmtString(v string, verb rune) { - switch verb { - case 'v': - if p.fmt.SharpV { - p.fmt.fmt_q(v) - } else { - p.fmt.fmt_s(v) - } - case 's': - p.fmt.fmt_s(v) - case 'x': - p.fmt.fmt_sx(v, ldigits) - case 'X': - p.fmt.fmt_sx(v, udigits) - case 'q': - p.fmt.fmt_q(v) - case 'm': - ctx := p.cat.Context(p.tag, rawPrinter{p}) - if ctx.Execute(v) == catalog.ErrNotFound { - p.WriteString(v) - } - default: - p.badVerb(verb) - } -} - -func (p *printer) fmtBytes(v []byte, verb rune, typeString string) { - switch verb { - case 'v', 'd': - if p.fmt.SharpV { - p.WriteString(typeString) - if v == nil { - p.WriteString(nilParenString) - return - } - p.WriteByte('{') - for i, c := range v { - if i > 0 { - p.WriteString(commaSpaceString) - } - p.fmt0x64(uint64(c), true) - } - p.WriteByte('}') - } else { - p.WriteByte('[') - for i, c := range v { - if i > 0 { - p.WriteByte(' ') - } - p.fmt.fmt_integer(uint64(c), 10, unsigned, ldigits) - } - p.WriteByte(']') - } - case 's': - p.fmt.fmt_s(string(v)) - case 'x': - p.fmt.fmt_bx(v, ldigits) - case 'X': - p.fmt.fmt_bx(v, udigits) - case 'q': - p.fmt.fmt_q(string(v)) - default: - p.printValue(reflect.ValueOf(v), verb, 0) - } -} - -func (p *printer) fmtPointer(value reflect.Value, verb rune) { - var u uintptr - switch value.Kind() { - case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer: - u = value.Pointer() - default: - p.badVerb(verb) - return - } - - switch verb { - case 'v': - if p.fmt.SharpV { - p.WriteByte('(') - p.WriteString(value.Type().String()) - p.WriteString(")(") - if u == 0 { - p.WriteString(nilString) - } else { - p.fmt0x64(uint64(u), true) - } - p.WriteByte(')') - } else { - if u == 0 { - p.fmt.padString(nilAngleString) - } else { - p.fmt0x64(uint64(u), !p.fmt.Sharp) - } - } - case 'p': - p.fmt0x64(uint64(u), !p.fmt.Sharp) - case 'b', 'o', 'd', 'x', 'X': - if verb == 'd' { - p.fmt.Sharp = true // Print as standard go. TODO: does this make sense? - } - p.fmtInteger(uint64(u), unsigned, verb) - default: - p.badVerb(verb) - } -} - -func (p *printer) catchPanic(arg interface{}, verb rune) { - if err := recover(); err != nil { - // If it's a nil pointer, just say "<nil>". The likeliest causes are a - // Stringer that fails to guard against nil or a nil pointer for a - // value receiver, and in either case, "<nil>" is a nice result. - if v := reflect.ValueOf(arg); v.Kind() == reflect.Ptr && v.IsNil() { - p.WriteString(nilAngleString) - return - } - // Otherwise print a concise panic message. Most of the time the panic - // value will print itself nicely. - if p.panicking { - // Nested panics; the recursion in printArg cannot succeed. - panic(err) - } - - oldFlags := p.fmt.Parser - // For this output we want default behavior. - p.fmt.ClearFlags() - - p.WriteString(percentBangString) - p.WriteRune(verb) - p.WriteString(panicString) - p.panicking = true - p.printArg(err, 'v') - p.panicking = false - p.WriteByte(')') - - p.fmt.Parser = oldFlags - } -} - -func (p *printer) handleMethods(verb rune) (handled bool) { - if p.erroring { - return - } - // Is it a Formatter? - if formatter, ok := p.arg.(format.Formatter); ok { - handled = true - defer p.catchPanic(p.arg, verb) - formatter.Format(p, verb) - return - } - if formatter, ok := p.arg.(fmt.Formatter); ok { - handled = true - defer p.catchPanic(p.arg, verb) - formatter.Format(p, verb) - return - } - - // If we're doing Go syntax and the argument knows how to supply it, take care of it now. - if p.fmt.SharpV { - if stringer, ok := p.arg.(fmt.GoStringer); ok { - handled = true - defer p.catchPanic(p.arg, verb) - // Print the result of GoString unadorned. - p.fmt.fmt_s(stringer.GoString()) - return - } - } else { - // If a string is acceptable according to the format, see if - // the value satisfies one of the string-valued interfaces. - // Println etc. set verb to %v, which is "stringable". - switch verb { - case 'v', 's', 'x', 'X', 'q': - // Is it an error or Stringer? - // The duplication in the bodies is necessary: - // setting handled and deferring catchPanic - // must happen before calling the method. - switch v := p.arg.(type) { - case error: - handled = true - defer p.catchPanic(p.arg, verb) - p.fmtString(v.Error(), verb) - return - - case fmt.Stringer: - handled = true - defer p.catchPanic(p.arg, verb) - p.fmtString(v.String(), verb) - return - } - } - } - return false -} - -func (p *printer) printArg(arg interface{}, verb rune) { - p.arg = arg - p.value = reflect.Value{} - - if arg == nil { - switch verb { - case 'T', 'v': - p.fmt.padString(nilAngleString) - default: - p.badVerb(verb) - } - return - } - - // Special processing considerations. - // %T (the value's type) and %p (its address) are special; we always do them first. - switch verb { - case 'T': - p.fmt.fmt_s(reflect.TypeOf(arg).String()) - return - case 'p': - p.fmtPointer(reflect.ValueOf(arg), 'p') - return - } - - // Some types can be done without reflection. - switch f := arg.(type) { - case bool: - p.fmtBool(f, verb) - case float32: - p.fmtFloat(float64(f), 32, verb) - case float64: - p.fmtFloat(f, 64, verb) - case complex64: - p.fmtComplex(complex128(f), 64, verb) - case complex128: - p.fmtComplex(f, 128, verb) - case int: - p.fmtInteger(uint64(f), signed, verb) - case int8: - p.fmtInteger(uint64(f), signed, verb) - case int16: - p.fmtInteger(uint64(f), signed, verb) - case int32: - p.fmtInteger(uint64(f), signed, verb) - case int64: - p.fmtInteger(uint64(f), signed, verb) - case uint: - p.fmtInteger(uint64(f), unsigned, verb) - case uint8: - p.fmtInteger(uint64(f), unsigned, verb) - case uint16: - p.fmtInteger(uint64(f), unsigned, verb) - case uint32: - p.fmtInteger(uint64(f), unsigned, verb) - case uint64: - p.fmtInteger(f, unsigned, verb) - case uintptr: - p.fmtInteger(uint64(f), unsigned, verb) - case string: - p.fmtString(f, verb) - case []byte: - p.fmtBytes(f, verb, "[]byte") - case reflect.Value: - // Handle extractable values with special methods - // since printValue does not handle them at depth 0. - if f.IsValid() && f.CanInterface() { - p.arg = f.Interface() - if p.handleMethods(verb) { - return - } - } - p.printValue(f, verb, 0) - default: - // If the type is not simple, it might have methods. - if !p.handleMethods(verb) { - // Need to use reflection, since the type had no - // interface methods that could be used for formatting. - p.printValue(reflect.ValueOf(f), verb, 0) - } - } -} - -// printValue is similar to printArg but starts with a reflect value, not an interface{} value. -// It does not handle 'p' and 'T' verbs because these should have been already handled by printArg. -func (p *printer) printValue(value reflect.Value, verb rune, depth int) { - // Handle values with special methods if not already handled by printArg (depth == 0). - if depth > 0 && value.IsValid() && value.CanInterface() { - p.arg = value.Interface() - if p.handleMethods(verb) { - return - } - } - p.arg = nil - p.value = value - - switch f := value; value.Kind() { - case reflect.Invalid: - if depth == 0 { - p.WriteString(invReflectString) - } else { - switch verb { - case 'v': - p.WriteString(nilAngleString) - default: - p.badVerb(verb) - } - } - case reflect.Bool: - p.fmtBool(f.Bool(), verb) - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - p.fmtInteger(uint64(f.Int()), signed, verb) - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: - p.fmtInteger(f.Uint(), unsigned, verb) - case reflect.Float32: - p.fmtFloat(f.Float(), 32, verb) - case reflect.Float64: - p.fmtFloat(f.Float(), 64, verb) - case reflect.Complex64: - p.fmtComplex(f.Complex(), 64, verb) - case reflect.Complex128: - p.fmtComplex(f.Complex(), 128, verb) - case reflect.String: - p.fmtString(f.String(), verb) - case reflect.Map: - if p.fmt.SharpV { - p.WriteString(f.Type().String()) - if f.IsNil() { - p.WriteString(nilParenString) - return - } - p.WriteByte('{') - } else { - p.WriteString(mapString) - } - keys := f.MapKeys() - for i, key := range keys { - if i > 0 { - if p.fmt.SharpV { - p.WriteString(commaSpaceString) - } else { - p.WriteByte(' ') - } - } - p.printValue(key, verb, depth+1) - p.WriteByte(':') - p.printValue(f.MapIndex(key), verb, depth+1) - } - if p.fmt.SharpV { - p.WriteByte('}') - } else { - p.WriteByte(']') - } - case reflect.Struct: - if p.fmt.SharpV { - p.WriteString(f.Type().String()) - } - p.WriteByte('{') - for i := 0; i < f.NumField(); i++ { - if i > 0 { - if p.fmt.SharpV { - p.WriteString(commaSpaceString) - } else { - p.WriteByte(' ') - } - } - if p.fmt.PlusV || p.fmt.SharpV { - if name := f.Type().Field(i).Name; name != "" { - p.WriteString(name) - p.WriteByte(':') - } - } - p.printValue(getField(f, i), verb, depth+1) - } - p.WriteByte('}') - case reflect.Interface: - value := f.Elem() - if !value.IsValid() { - if p.fmt.SharpV { - p.WriteString(f.Type().String()) - p.WriteString(nilParenString) - } else { - p.WriteString(nilAngleString) - } - } else { - p.printValue(value, verb, depth+1) - } - case reflect.Array, reflect.Slice: - switch verb { - case 's', 'q', 'x', 'X': - // Handle byte and uint8 slices and arrays special for the above verbs. - t := f.Type() - if t.Elem().Kind() == reflect.Uint8 { - var bytes []byte - if f.Kind() == reflect.Slice { - bytes = f.Bytes() - } else if f.CanAddr() { - bytes = f.Slice(0, f.Len()).Bytes() - } else { - // We have an array, but we cannot Slice() a non-addressable array, - // so we build a slice by hand. This is a rare case but it would be nice - // if reflection could help a little more. - bytes = make([]byte, f.Len()) - for i := range bytes { - bytes[i] = byte(f.Index(i).Uint()) - } - } - p.fmtBytes(bytes, verb, t.String()) - return - } - } - if p.fmt.SharpV { - p.WriteString(f.Type().String()) - if f.Kind() == reflect.Slice && f.IsNil() { - p.WriteString(nilParenString) - return - } - p.WriteByte('{') - for i := 0; i < f.Len(); i++ { - if i > 0 { - p.WriteString(commaSpaceString) - } - p.printValue(f.Index(i), verb, depth+1) - } - p.WriteByte('}') - } else { - p.WriteByte('[') - for i := 0; i < f.Len(); i++ { - if i > 0 { - p.WriteByte(' ') - } - p.printValue(f.Index(i), verb, depth+1) - } - p.WriteByte(']') - } - case reflect.Ptr: - // pointer to array or slice or struct? ok at top level - // but not embedded (avoid loops) - if depth == 0 && f.Pointer() != 0 { - switch a := f.Elem(); a.Kind() { - case reflect.Array, reflect.Slice, reflect.Struct, reflect.Map: - p.WriteByte('&') - p.printValue(a, verb, depth+1) - return - } - } - fallthrough - case reflect.Chan, reflect.Func, reflect.UnsafePointer: - p.fmtPointer(f, verb) - default: - p.unknownType(f) - } -} - -func (p *printer) badArgNum(verb rune) { - p.WriteString(percentBangString) - p.WriteRune(verb) - p.WriteString(badIndexString) -} - -func (p *printer) missingArg(verb rune) { - p.WriteString(percentBangString) - p.WriteRune(verb) - p.WriteString(missingString) -} - -func (p *printer) doPrintf(fmt string) { - for p.fmt.Parser.SetFormat(fmt); p.fmt.Scan(); { - switch p.fmt.Status { - case format.StatusText: - p.WriteString(p.fmt.Text()) - case format.StatusSubstitution: - p.printArg(p.Arg(p.fmt.ArgNum), p.fmt.Verb) - case format.StatusBadWidthSubstitution: - p.WriteString(badWidthString) - p.printArg(p.Arg(p.fmt.ArgNum), p.fmt.Verb) - case format.StatusBadPrecSubstitution: - p.WriteString(badPrecString) - p.printArg(p.Arg(p.fmt.ArgNum), p.fmt.Verb) - case format.StatusNoVerb: - p.WriteString(noVerbString) - case format.StatusBadArgNum: - p.badArgNum(p.fmt.Verb) - case format.StatusMissingArg: - p.missingArg(p.fmt.Verb) - default: - panic("unreachable") - } - } - - // Check for extra arguments, but only if there was at least one ordered - // argument. Note that this behavior is necessarily different from fmt: - // different variants of messages may opt to drop some or all of the - // arguments. - if !p.fmt.Reordered && p.fmt.ArgNum < len(p.fmt.Args) && p.fmt.ArgNum != 0 { - p.fmt.ClearFlags() - p.WriteString(extraString) - for i, arg := range p.fmt.Args[p.fmt.ArgNum:] { - if i > 0 { - p.WriteString(commaSpaceString) - } - if arg == nil { - p.WriteString(nilAngleString) - } else { - p.WriteString(reflect.TypeOf(arg).String()) - p.WriteString("=") - p.printArg(arg, 'v') - } - } - p.WriteByte(')') - } -} - -func (p *printer) doPrint(a []interface{}) { - prevString := false - for argNum, arg := range a { - isString := arg != nil && reflect.TypeOf(arg).Kind() == reflect.String - // Add a space between two non-string arguments. - if argNum > 0 && !isString && !prevString { - p.WriteByte(' ') - } - p.printArg(arg, 'v') - prevString = isString - } -} - -// doPrintln is like doPrint but always adds a space between arguments -// and a newline after the last argument. -func (p *printer) doPrintln(a []interface{}) { - for argNum, arg := range a { - if argNum > 0 { - p.WriteByte(' ') - } - p.printArg(arg, 'v') - } - p.WriteByte('\n') -} |