1 files changed, 197 insertions, 0 deletions

diff --git a/vendor/honnef.co/go/tools/printf/printf.go b/vendor/honnef.co/go/tools/printf/printf.go
new file mode 100644
index 0000000..754db9b
--- /dev/null
+++ b/vendor/honnef.co/go/tools/printf/printf.go
@@ -0,0 +1,197 @@
+// Package printf implements a parser for fmt.Printf-style format
+// strings.
+//
+// It parses verbs according to the following syntax:
+//     Numeric -> '0'-'9'
+//     Letter -> 'a'-'z' | 'A'-'Z'
+//     Index -> '[' Numeric+ ']'
+//     Star -> '*'
+//     Star -> Index '*'
+//
+//     Precision -> Numeric+ | Star
+//     Width -> Numeric+ | Star
+//
+//     WidthAndPrecision -> Width '.' Precision
+//     WidthAndPrecision -> Width '.'
+//     WidthAndPrecision -> Width
+//     WidthAndPrecision -> '.' Precision
+//     WidthAndPrecision -> '.'
+//
+//     Flag -> '+' | '-' | '#' | ' ' | '0'
+//     Verb -> Letter | '%'
+//
+//     Input -> '%' [ Flag+ ] [ WidthAndPrecision ] [ Index ] Verb
+package printf
+
+import (
+        "errors"
+        "regexp"
+        "strconv"
+        "strings"
+)
+
+// ErrInvalid is returned for invalid format strings or verbs.
+var ErrInvalid = errors.New("invalid format string")
+
+type Verb struct {
+        Letter rune
+        Flags  string
+
+        Width     Argument
+        Precision Argument
+        // Which value in the argument list the verb uses.
+        // -1 denotes the next argument,
+        // values > 0 denote explicit arguments.
+        // The value 0 denotes that no argument is consumed. This is the case for %%.
+        Value int
+
+        Raw string
+}
+
+// Argument is an implicit or explicit width or precision.
+type Argument interface {
+        isArgument()
+}
+
+// The Default value, when no width or precision is provided.
+type Default struct{}
+
+// Zero is the implicit zero value.
+// This value may only appear for precisions in format strings like %6.f
+type Zero struct{}
+
+// Star is a * value, which may either refer to the next argument (Index == -1) or an explicit argument.
+type Star struct{ Index int }
+
+// A Literal value, such as 6 in %6d.
+type Literal int
+
+func (Default) isArgument() {}
+func (Zero) isArgument()    {}
+func (Star) isArgument()    {}
+func (Literal) isArgument() {}
+
+// Parse parses f and returns a list of actions.
+// An action may either be a literal string, or a Verb.
+func Parse(f string) ([]interface{}, error) {
+        var out []interface{}
+        for len(f) > 0 {
+                if f[0] == '%' {
+                        v, n, err := ParseVerb(f)
+                        if err != nil {
+                                return nil, err
+                        }
+                        f = f[n:]
+                        out = append(out, v)
+                } else {
+                        n := strings.IndexByte(f, '%')
+                        if n > -1 {
+                                out = append(out, f[:n])
+                                f = f[n:]
+                        } else {
+                                out = append(out, f)
+                                f = ""
+                        }
+                }
+        }
+
+        return out, nil
+}
+
+func atoi(s string) int {
+        n, _ := strconv.Atoi(s)
+        return n
+}
+
+// ParseVerb parses the verb at the beginning of f.
+// It returns the verb, how much of the input was consumed, and an error, if any.
+func ParseVerb(f string) (Verb, int, error) {
+        if len(f) < 2 {
+                return Verb{}, 0, ErrInvalid
+        }
+        const (
+                flags = 1
+
+                width      = 2
+                widthStar  = 3
+                widthIndex = 5
+
+                dot       = 6
+                prec      = 7
+                precStar  = 8
+                precIndex = 10
+
+                verbIndex = 11
+                verb      = 12
+        )
+
+        m := re.FindStringSubmatch(f)
+        if m == nil {
+                return Verb{}, 0, ErrInvalid
+        }
+
+        v := Verb{
+                Letter: []rune(m[verb])[0],
+                Flags:  m[flags],
+                Raw:    m[0],
+        }
+
+        if m[width] != "" {
+                // Literal width
+                v.Width = Literal(atoi(m[width]))
+        } else if m[widthStar] != "" {
+                // Star width
+                if m[widthIndex] != "" {
+                        v.Width = Star{atoi(m[widthIndex])}
+                } else {
+                        v.Width = Star{-1}
+                }
+        } else {
+                // Default width
+                v.Width = Default{}
+        }
+
+        if m[dot] == "" {
+                // default precision
+                v.Precision = Default{}
+        } else {
+                if m[prec] != "" {
+                        // Literal precision
+                        v.Precision = Literal(atoi(m[prec]))
+                } else if m[precStar] != "" {
+                        // Star precision
+                        if m[precIndex] != "" {
+                                v.Precision = Star{atoi(m[precIndex])}
+                        } else {
+                                v.Precision = Star{-1}
+                        }
+                } else {
+                        // Zero precision
+                        v.Precision = Zero{}
+                }
+        }
+
+        if m[verb] == "%" {
+                v.Value = 0
+        } else if m[verbIndex] != "" {
+                v.Value = atoi(m[verbIndex])
+        } else {
+                v.Value = -1
+        }
+
+        return v, len(m[0]), nil
+}
+
+const (
+        flags             = `([+#0 -]*)`
+        verb              = `([a-zA-Z%])`
+        index             = `(?:\[([0-9]+)\])`
+        star              = `((` + index + `)?\*)`
+        width1            = `([0-9]+)`
+        width2            = star
+        width             = `(?:` + width1 + `|` + width2 + `)`
+        precision         = width
+        widthAndPrecision = `(?:(?:` + width + `)?(?:(\.)(?:` + precision + `)?)?)`
+)
+
+var re = regexp.MustCompile(`^%` + flags + widthAndPrecision + `?` + index + `?` + verb)