@@ -44,7 +44,7 @@ github.com/hashicorp/serf 598c54895cc5a7b1a24a398d635e8c0ea0959870

 github.com/docker/libkv 1d8431073ae03cdaedb198a89722f3aab6d418ef

 github.com/vishvananda/netns 604eaf189ee867d8c147fafc28def2394e878d25

 github.com/vishvananda/netlink b2de5d10e38ecce8607e6b438b6d174f389a004e

-github.com/BurntSushi/toml f706d00e3de6abe700c994cdd545a1a4915af060

+github.com/BurntSushi/toml a368813c5e648fee92e5f6c30e3944ff9d5e8895

 github.com/samuel/go-zookeeper d0e0d8e11f318e000a8cc434616d69e329edc374

 github.com/deckarep/golang-set ef32fa3046d9f249d399f98ebaf9be944430fd1d

 github.com/coreos/etcd v3.2.1

@@ -1,14 +1,21 @@

-            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE

-                    Version 2, December 2004

+The MIT License (MIT)

- Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>

+Copyright (c) 2013 TOML authors

- Everyone is permitted to copy and distribute verbatim or modified

- copies of this license document, and changing it is allowed as long

- as the name is changed.

+Permission is hereby granted, free of charge, to any person obtaining a copy

+of this software and associated documentation files (the "Software"), to deal

+in the Software without restriction, including without limitation the rights

+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

+copies of the Software, and to permit persons to whom the Software is

+furnished to do so, subject to the following conditions:

-            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE

-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

-

-  0. You just DO WHAT THE FUCK YOU WANT TO.

+The above copyright notice and this permission notice shall be included in

+all copies or substantial portions of the Software.

+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

+THE SOFTWARE.

@@ -1,17 +1,17 @@

 ## TOML parser and encoder for Go with reflection

 TOML stands for Tom's Obvious, Minimal Language. This Go package provides a

-reflection interface similar to Go's standard library `json` and `xml` 

+reflection interface similar to Go's standard library `json` and `xml`

 packages. This package also supports the `encoding.TextUnmarshaler` and

-`encoding.TextMarshaler` interfaces so that you can define custom data 

+`encoding.TextMarshaler` interfaces so that you can define custom data

 representations. (There is an example of this below.)

-Spec: https://github.com/mojombo/toml

+Spec: https://github.com/toml-lang/toml

 Compatible with TOML version

-[v0.2.0](https://github.com/mojombo/toml/blob/master/versions/toml-v0.2.0.md)

+[v0.4.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md)

-Documentation: http://godoc.org/github.com/BurntSushi/toml

+Documentation: https://godoc.org/github.com/BurntSushi/toml

 Installation:

@@ -26,8 +26,7 @@ go get github.com/BurntSushi/toml/cmd/tomlv

 tomlv some-toml-file.toml

 ```

-[![Build status](https://api.travis-ci.org/BurntSushi/toml.png)](https://travis-ci.org/BurntSushi/toml)

-

+[![Build Status](https://travis-ci.org/BurntSushi/toml.svg?branch=master)](https://travis-ci.org/BurntSushi/toml) [![GoDoc](https://godoc.org/github.com/BurntSushi/toml?status.svg)](https://godoc.org/github.com/BurntSushi/toml)

 ### Testing

@@ -87,7 +86,7 @@ type TOML struct {

 ### Using the `encoding.TextUnmarshaler` interface

-Here's an example that automatically parses duration strings into 

+Here's an example that automatically parses duration strings into

 `time.Duration` values:

 ```toml

@@ -120,7 +119,7 @@ for _, s := range favorites.Song {

 }

 ```

-And you'll also need a `duration` type that satisfies the 

+And you'll also need a `duration` type that satisfies the

 `encoding.TextUnmarshaler` interface:

 ```go

@@ -217,4 +216,3 @@ Note that a case insensitive match will be tried if an exact match can't be

 found.

 A working example of the above can be found in `_examples/example.{go,toml}`.

-

@@ -10,7 +10,9 @@ import (

 	"time"

 )

-var e = fmt.Errorf

+func e(format string, args ...interface{}) error {

+	return fmt.Errorf("toml: "+format, args...)

+}

 // Unmarshaler is the interface implemented by objects that can unmarshal a

 // TOML description of themselves.

@@ -103,6 +105,13 @@ func (md *MetaData) PrimitiveDecode(primValue Primitive, v interface{}) error {

 // This decoder will not handle cyclic types. If a cyclic type is passed,

 // `Decode` will not terminate.

 func Decode(data string, v interface{}) (MetaData, error) {

+	rv := reflect.ValueOf(v)

+	if rv.Kind() != reflect.Ptr {

+		return MetaData{}, e("Decode of non-pointer %s", reflect.TypeOf(v))

+	}

+	if rv.IsNil() {

+		return MetaData{}, e("Decode of nil %s", reflect.TypeOf(v))

+	}

 	p, err := parse(data)

 	if err != nil {

 		return MetaData{}, err

@@ -111,7 +120,7 @@ func Decode(data string, v interface{}) (MetaData, error) {

 		p.mapping, p.types, p.ordered,

 		make(map[string]bool, len(p.ordered)), nil,

 	}

-	return md, md.unify(p.mapping, rvalue(v))

+	return md, md.unify(p.mapping, indirect(rv))

 }

 // DecodeFile is just like Decode, except it will automatically read the

@@ -211,7 +220,7 @@ func (md *MetaData) unify(data interface{}, rv reflect.Value) error {

 	case reflect.Interface:

 		// we only support empty interfaces.

 		if rv.NumMethod() > 0 {

-			return e("Unsupported type '%s'.", rv.Kind())

+			return e("unsupported type %s", rv.Type())

 		}

 		return md.unifyAnything(data, rv)

 	case reflect.Float32:

@@ -219,13 +228,17 @@ func (md *MetaData) unify(data interface{}, rv reflect.Value) error {

 	case reflect.Float64:

 		return md.unifyFloat64(data, rv)

 	}

-	return e("Unsupported type '%s'.", rv.Kind())

+	return e("unsupported type %s", rv.Kind())

 }

 func (md *MetaData) unifyStruct(mapping interface{}, rv reflect.Value) error {

 	tmap, ok := mapping.(map[string]interface{})

 	if !ok {

-		return mismatch(rv, "map", mapping)

+		if mapping == nil {

+			return nil

+		}

+		return e("type mismatch for %s: expected table but found %T",

+			rv.Type().String(), mapping)

 	}

 	for key, datum := range tmap {

@@ -250,14 +263,13 @@ func (md *MetaData) unifyStruct(mapping interface{}, rv reflect.Value) error {

 				md.decoded[md.context.add(key).String()] = true

 				md.context = append(md.context, key)

 				if err := md.unify(datum, subv); err != nil {

-					return e("Type mismatch for '%s.%s': %s",

-						rv.Type().String(), f.name, err)

+					return err

 				}

 				md.context = md.context[0 : len(md.context)-1]

 			} else if f.name != "" {

 				// Bad user! No soup for you!

-				return e("Field '%s.%s' is unexported, and therefore cannot "+

-					"be loaded with reflection.", rv.Type().String(), f.name)

+				return e("cannot write unexported field %s.%s",

+					rv.Type().String(), f.name)

 			}

 		}

 	}

@@ -267,6 +279,9 @@ func (md *MetaData) unifyStruct(mapping interface{}, rv reflect.Value) error {

 func (md *MetaData) unifyMap(mapping interface{}, rv reflect.Value) error {

 	tmap, ok := mapping.(map[string]interface{})

 	if !ok {

+		if tmap == nil {

+			return nil

+		}

 		return badtype("map", mapping)

 	}

 	if rv.IsNil() {

@@ -292,6 +307,9 @@ func (md *MetaData) unifyMap(mapping interface{}, rv reflect.Value) error {

 func (md *MetaData) unifyArray(data interface{}, rv reflect.Value) error {

 	datav := reflect.ValueOf(data)

 	if datav.Kind() != reflect.Slice {

+		if !datav.IsValid() {

+			return nil

+		}

 		return badtype("slice", data)

 	}

 	sliceLen := datav.Len()

@@ -305,12 +323,16 @@ func (md *MetaData) unifyArray(data interface{}, rv reflect.Value) error {

 func (md *MetaData) unifySlice(data interface{}, rv reflect.Value) error {

 	datav := reflect.ValueOf(data)

 	if datav.Kind() != reflect.Slice {

+		if !datav.IsValid() {

+			return nil

+		}

 		return badtype("slice", data)

 	}

-	sliceLen := datav.Len()

-	if rv.IsNil() {

-		rv.Set(reflect.MakeSlice(rv.Type(), sliceLen, sliceLen))

+	n := datav.Len()

+	if rv.IsNil() || rv.Cap() < n {

+		rv.Set(reflect.MakeSlice(rv.Type(), n, n))

 	}

+	rv.SetLen(n)

 	return md.unifySliceArray(datav, rv)

 }

@@ -365,15 +387,15 @@ func (md *MetaData) unifyInt(data interface{}, rv reflect.Value) error {

 				// No bounds checking necessary.

 			case reflect.Int8:

 				if num < math.MinInt8 || num > math.MaxInt8 {

-					return e("Value '%d' is out of range for int8.", num)

+					return e("value %d is out of range for int8", num)

 				}

 			case reflect.Int16:

 				if num < math.MinInt16 || num > math.MaxInt16 {

-					return e("Value '%d' is out of range for int16.", num)

+					return e("value %d is out of range for int16", num)

 				}

 			case reflect.Int32:

 				if num < math.MinInt32 || num > math.MaxInt32 {

-					return e("Value '%d' is out of range for int32.", num)

+					return e("value %d is out of range for int32", num)

 				}

 			}

 			rv.SetInt(num)

@@ -384,15 +406,15 @@ func (md *MetaData) unifyInt(data interface{}, rv reflect.Value) error {

 				// No bounds checking necessary.

 			case reflect.Uint8:

 				if num < 0 || unum > math.MaxUint8 {

-					return e("Value '%d' is out of range for uint8.", num)

+					return e("value %d is out of range for uint8", num)

 				}

 			case reflect.Uint16:

 				if num < 0 || unum > math.MaxUint16 {

-					return e("Value '%d' is out of range for uint16.", num)

+					return e("value %d is out of range for uint16", num)

 				}

 			case reflect.Uint32:

 				if num < 0 || unum > math.MaxUint32 {

-					return e("Value '%d' is out of range for uint32.", num)

+					return e("value %d is out of range for uint32", num)

 				}

 			}

 			rv.SetUint(unum)

@@ -458,7 +480,7 @@ func rvalue(v interface{}) reflect.Value {

 // interest to us (like encoding.TextUnmarshaler).

 func indirect(v reflect.Value) reflect.Value {

 	if v.Kind() != reflect.Ptr {

-		if v.CanAddr() {

+		if v.CanSet() {

 			pv := v.Addr()

 			if _, ok := pv.Interface().(TextUnmarshaler); ok {

 				return pv

@@ -483,10 +505,5 @@ func isUnifiable(rv reflect.Value) bool {

 }

 func badtype(expected string, data interface{}) error {

-	return e("Expected %s but found '%T'.", expected, data)

-}

-

-func mismatch(user reflect.Value, expected string, data interface{}) error {

-	return e("Type mismatch for %s. Expected %s but found '%T'.",

-		user.Type().String(), expected, data)

+	return e("cannot load TOML value of type %T into a Go %s", data, expected)

 }

@@ -77,9 +77,8 @@ func (k Key) maybeQuoted(i int) string {

 	}

 	if quote {

 		return "\"" + strings.Replace(k[i], "\"", "\\\"", -1) + "\""

-	} else {

-		return k[i]

 	}

+	return k[i]

 }

 func (k Key) add(piece string) Key {

@@ -4,7 +4,7 @@ files via reflection. There is also support for delaying decoding with

 the Primitive type, and querying the set of keys in a TOML document with the

 MetaData type.

-The specification implemented: https://github.com/mojombo/toml

+The specification implemented: https://github.com/toml-lang/toml

 The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify

 whether a file is a valid TOML document. It can also be used to print the

@@ -16,17 +16,17 @@ type tomlEncodeError struct{ error }

 var (

 	errArrayMixedElementTypes = errors.New(

-		"can't encode array with mixed element types")

+		"toml: cannot encode array with mixed element types")

 	errArrayNilElement = errors.New(

-		"can't encode array with nil element")

+		"toml: cannot encode array with nil element")

 	errNonString = errors.New(

-		"can't encode a map with non-string key type")

+		"toml: cannot encode a map with non-string key type")

 	errAnonNonStruct = errors.New(

-		"can't encode an anonymous field that is not a struct")

+		"toml: cannot encode an anonymous field that is not a struct")

 	errArrayNoTable = errors.New(

-		"TOML array element can't contain a table")

+		"toml: TOML array element cannot contain a table")

 	errNoKey = errors.New(

-		"top-level values must be a Go map or struct")

+		"toml: top-level values must be Go maps or structs")

 	errAnything = errors.New("") // used in testing

 )

@@ -148,7 +148,7 @@ func (enc *Encoder) encode(key Key, rv reflect.Value) {

 	case reflect.Struct:

 		enc.eTable(key, rv)

 	default:

-		panic(e("Unsupported type for key '%s': %s", key, k))

+		panic(e("unsupported type for key '%s': %s", key, k))

 	}

 }

@@ -160,7 +160,7 @@ func (enc *Encoder) eElement(rv reflect.Value) {

 		// Special case time.Time as a primitive. Has to come before

 		// TextMarshaler below because time.Time implements

 		// encoding.TextMarshaler, but we need to always use UTC.

-		enc.wf(v.In(time.FixedZone("UTC", 0)).Format("2006-01-02T15:04:05Z"))

+		enc.wf(v.UTC().Format("2006-01-02T15:04:05Z"))

 		return

 	case TextMarshaler:

 		// Special case. Use text marshaler if it's available for this value.

@@ -191,7 +191,7 @@ func (enc *Encoder) eElement(rv reflect.Value) {

 	case reflect.String:

 		enc.writeQuoted(rv.String())

 	default:

-		panic(e("Unexpected primitive type: %s", rv.Kind()))

+		panic(e("unexpected primitive type: %s", rv.Kind()))

 	}

 }

@@ -241,7 +241,7 @@ func (enc *Encoder) eArrayOfTables(key Key, rv reflect.Value) {

 func (enc *Encoder) eTable(key Key, rv reflect.Value) {

 	panicIfInvalidKey(key)

 	if len(key) == 1 {

-		// Output an extra new line between top-level tables.

+		// Output an extra newline between top-level tables.

 		// (The newline isn't written if nothing else has been written though.)

 		enc.newline()

 	}

@@ -306,19 +306,36 @@ func (enc *Encoder) eStruct(key Key, rv reflect.Value) {

 	addFields = func(rt reflect.Type, rv reflect.Value, start []int) {

 		for i := 0; i < rt.NumField(); i++ {

 			f := rt.Field(i)

-			// skip unexporded fields

-			if f.PkgPath != "" {

+			// skip unexported fields

+			if f.PkgPath != "" && !f.Anonymous {

 				continue

 			}

 			frv := rv.Field(i)

 			if f.Anonymous {

-				frv := eindirect(frv)

-				t := frv.Type()

-				if t.Kind() != reflect.Struct {

-					encPanic(errAnonNonStruct)

+				t := f.Type

+				switch t.Kind() {

+				case reflect.Struct:

+					// Treat anonymous struct fields with

+					// tag names as though they are not

+					// anonymous, like encoding/json does.

+					if getOptions(f.Tag).name == "" {

+						addFields(t, frv, f.Index)

+						continue

+					}

+				case reflect.Ptr:

+					if t.Elem().Kind() == reflect.Struct &&

+						getOptions(f.Tag).name == "" {

+						if !frv.IsNil() {

+							addFields(t.Elem(), frv.Elem(), f.Index)

+						}

+						continue

+					}

+					// Fall through to the normal field encoding logic below

+					// for non-struct anonymous fields.

 				}

-				addFields(t, frv, f.Index)

-			} else if typeIsHash(tomlTypeOfGo(frv)) {

+			}

+

+			if typeIsHash(tomlTypeOfGo(frv)) {

 				fieldsSub = append(fieldsSub, append(start, f.Index...))

 			} else {

 				fieldsDirect = append(fieldsDirect, append(start, f.Index...))

@@ -336,13 +353,21 @@ func (enc *Encoder) eStruct(key Key, rv reflect.Value) {

 				continue

 			}

-			keyName := sft.Tag.Get("toml")

-			if keyName == "-" {

+			opts := getOptions(sft.Tag)

+			if opts.skip {

 				continue

 			}

-			if keyName == "" {

-				keyName = sft.Name

+			keyName := sft.Name

+			if opts.name != "" {

+				keyName = opts.name

+			}

+			if opts.omitempty && isEmpty(sf) {

+				continue

 			}

+			if opts.omitzero && isZero(sf) {

+				continue

+			}

+

 			enc.encode(key.add(keyName), sf)

 		}

 	}

@@ -374,9 +399,8 @@ func tomlTypeOfGo(rv reflect.Value) tomlType {

 	case reflect.Array, reflect.Slice:

 		if typeEqual(tomlHash, tomlArrayType(rv)) {

 			return tomlArrayHash

-		} else {

-			return tomlArray

 		}

+		return tomlArray

 	case reflect.Ptr, reflect.Interface:

 		return tomlTypeOfGo(rv.Elem())

 	case reflect.String:

@@ -433,6 +457,54 @@ func tomlArrayType(rv reflect.Value) tomlType {

 	return firstType

 }

+type tagOptions struct {

+	skip      bool // "-"

+	name      string

+	omitempty bool

+	omitzero  bool

+}

+

+func getOptions(tag reflect.StructTag) tagOptions {

+	t := tag.Get("toml")

+	if t == "-" {

+		return tagOptions{skip: true}

+	}

+	var opts tagOptions

+	parts := strings.Split(t, ",")

+	opts.name = parts[0]

+	for _, s := range parts[1:] {

+		switch s {

+		case "omitempty":

+			opts.omitempty = true

+		case "omitzero":

+			opts.omitzero = true

+		}

+	}

+	return opts

+}

+

+func isZero(rv reflect.Value) bool {

+	switch rv.Kind() {

+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:

+		return rv.Int() == 0

+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:

+		return rv.Uint() == 0

+	case reflect.Float32, reflect.Float64:

+		return rv.Float() == 0.0

+	}

+	return false

+}

+

+func isEmpty(rv reflect.Value) bool {

+	switch rv.Kind() {

+	case reflect.Array, reflect.Slice, reflect.Map, reflect.String:

+		return rv.Len() == 0

+	case reflect.Bool:

+		return !rv.Bool()

+	}

+	return false

+}

+

 func (enc *Encoder) newline() {

 	if enc.hasWritten {

 		enc.wf("\n")

@@ -3,6 +3,7 @@ package toml

 import (

 	"fmt"

 	"strings"

+	"unicode"

 	"unicode/utf8"

 )

@@ -29,24 +30,28 @@ const (

 	itemArrayTableEnd

 	itemKeyStart

 	itemCommentStart

+	itemInlineTableStart

+	itemInlineTableEnd

 )

 const (

-	eof             = 0

-	tableStart      = '['

-	tableEnd        = ']'

-	arrayTableStart = '['

-	arrayTableEnd   = ']'

-	tableSep        = '.'

-	keySep          = '='

-	arrayStart      = '['

-	arrayEnd        = ']'

-	arrayValTerm    = ','

-	commentStart    = '#'

-	stringStart     = '"'

-	stringEnd       = '"'

-	rawStringStart  = '\''

-	rawStringEnd    = '\''

+	eof              = 0

+	comma            = ','

+	tableStart       = '['

+	tableEnd         = ']'

+	arrayTableStart  = '['

+	arrayTableEnd    = ']'

+	tableSep         = '.'

+	keySep           = '='

+	arrayStart       = '['

+	arrayEnd         = ']'

+	commentStart     = '#'

+	stringStart      = '"'

+	stringEnd        = '"'

+	rawStringStart   = '\''

+	rawStringEnd     = '\''

+	inlineTableStart = '{'

+	inlineTableEnd   = '}'

 )

 type stateFn func(lx *lexer) stateFn

@@ -55,11 +60,18 @@ type lexer struct {

 	input string

 	start int

 	pos   int

-	width int

 	line  int

 	state stateFn

 	items chan item

+	// Allow for backing up up to three runes.

+	// This is necessary because TOML contains 3-rune tokens (""" and ''').

+	prevWidths [3]int

+	nprev      int // how many of prevWidths are in use

+	// If we emit an eof, we can still back up, but it is not OK to call

+	// next again.

+	atEOF bool

+

 	// A stack of state functions used to maintain context.

 	// The idea is to reuse parts of the state machine in various places.

 	// For example, values can appear at the top level or within arbitrarily

@@ -87,7 +99,7 @@ func (lx *lexer) nextItem() item {

 func lex(input string) *lexer {

 	lx := &lexer{

-		input: input + "\n",

+		input: input,

 		state: lexTop,

 		line:  1,

 		items: make(chan item, 10),

@@ -102,7 +114,7 @@ func (lx *lexer) push(state stateFn) {

 func (lx *lexer) pop() stateFn {

 	if len(lx.stack) == 0 {

-		return lx.errorf("BUG in lexer: no states to pop.")

+		return lx.errorf("BUG in lexer: no states to pop")

 	}

 	last := lx.stack[len(lx.stack)-1]

 	lx.stack = lx.stack[0 : len(lx.stack)-1]

@@ -124,16 +136,25 @@ func (lx *lexer) emitTrim(typ itemType) {

 }

 func (lx *lexer) next() (r rune) {

+	if lx.atEOF {

+		panic("next called after EOF")

+	}

 	if lx.pos >= len(lx.input) {

-		lx.width = 0

+		lx.atEOF = true

 		return eof

 	}

 	if lx.input[lx.pos] == '\n' {

 		lx.line++

 	}

-	r, lx.width = utf8.DecodeRuneInString(lx.input[lx.pos:])

-	lx.pos += lx.width

+	lx.prevWidths[2] = lx.prevWidths[1]

+	lx.prevWidths[1] = lx.prevWidths[0]

+	if lx.nprev < 3 {

+		lx.nprev++

+	}

+	r, w := utf8.DecodeRuneInString(lx.input[lx.pos:])

+	lx.prevWidths[0] = w

+	lx.pos += w

 	return r

 }

@@ -142,9 +163,20 @@ func (lx *lexer) ignore() {

 	lx.start = lx.pos

 }

-// backup steps back one rune. Can be called only once per call of next.

+// backup steps back one rune. Can be called only twice between calls to next.

 func (lx *lexer) backup() {

-	lx.pos -= lx.width

+	if lx.atEOF {

+		lx.atEOF = false

+		return

+	}

+	if lx.nprev < 1 {

+		panic("backed up too far")

+	}

+	w := lx.prevWidths[0]

+	lx.prevWidths[0] = lx.prevWidths[1]

+	lx.prevWidths[1] = lx.prevWidths[2]

+	lx.nprev--

+	lx.pos -= w

 	if lx.pos < len(lx.input) && lx.input[lx.pos] == '\n' {

 		lx.line--

 	}

@@ -166,9 +198,22 @@ func (lx *lexer) peek() rune {

 	return r

 }

+// skip ignores all input that matches the given predicate.

+func (lx *lexer) skip(pred func(rune) bool) {

+	for {

+		r := lx.next()

+		if pred(r) {

+			continue

+		}

+		lx.backup()

+		lx.ignore()

+		return

+	}

+}

+

 // errorf stops all lexing by emitting an error and returning `nil`.

 // Note that any value that is a character is escaped if it's a special

-// character (new lines, tabs, etc.).

+// character (newlines, tabs, etc.).

 func (lx *lexer) errorf(format string, values ...interface{}) stateFn {

 	lx.items <- item{

 		itemError,

@@ -184,7 +229,6 @@ func lexTop(lx *lexer) stateFn {

 	if isWhitespace(r) || isNL(r) {

 		return lexSkip(lx, lexTop)

 	}

-

 	switch r {

 	case commentStart:

 		lx.push(lexTop)

@@ -193,7 +237,7 @@ func lexTop(lx *lexer) stateFn {

 		return lexTableStart

 	case eof:

 		if lx.pos > lx.start {

-			return lx.errorf("Unexpected EOF.")

+			return lx.errorf("unexpected EOF")

 		}

 		lx.emit(itemEOF)

 		return nil

@@ -208,12 +252,12 @@ func lexTop(lx *lexer) stateFn {

 // lexTopEnd is entered whenever a top-level item has been consumed. (A value

 // or a table.) It must see only whitespace, and will turn back to lexTop

-// upon a new line. If it sees EOF, it will quit the lexer successfully.

+// upon a newline. If it sees EOF, it will quit the lexer successfully.

 func lexTopEnd(lx *lexer) stateFn {

 	r := lx.next()

 	switch {

 	case r == commentStart:

-		// a comment will read to a new line for us.

+		// a comment will read to a newline for us.

 		lx.push(lexTop)

 		return lexCommentStart

 	case isWhitespace(r):

@@ -222,11 +266,11 @@ func lexTopEnd(lx *lexer) stateFn {

 		lx.ignore()

 		return lexTop

 	case r == eof:

-		lx.ignore()

-		return lexTop

+		lx.emit(itemEOF)

+		return nil

 	}

-	return lx.errorf("Expected a top-level item to end with a new line, "+

-		"comment or EOF, but got %q instead.", r)

+	return lx.errorf("expected a top-level item to end with a newline, "+

+		"comment, or EOF, but got %q instead", r)

 }

 // lexTable lexes the beginning of a table. Namely, it makes sure that

@@ -253,50 +297,47 @@ func lexTableEnd(lx *lexer) stateFn {

 func lexArrayTableEnd(lx *lexer) stateFn {

 	if r := lx.next(); r != arrayTableEnd {

-		return lx.errorf("Expected end of table array name delimiter %q, "+

-			"but got %q instead.", arrayTableEnd, r)

+		return lx.errorf("expected end of table array name delimiter %q, "+

+			"but got %q instead", arrayTableEnd, r)

 	}

 	lx.emit(itemArrayTableEnd)

 	return lexTopEnd

 }

 func lexTableNameStart(lx *lexer) stateFn {

+	lx.skip(isWhitespace)

 	switch r := lx.peek(); {

 	case r == tableEnd || r == eof:

-		return lx.errorf("Unexpected end of table name. (Table names cannot " +

-			"be empty.)")

+		return lx.errorf("unexpected end of table name " +

+			"(table names cannot be empty)")

 	case r == tableSep:

-		return lx.errorf("Unexpected table separator. (Table names cannot " +

-			"be empty.)")

+		return lx.errorf("unexpected table separator " +

+			"(table names cannot be empty)")

 	case r == stringStart || r == rawStringStart:

 		lx.ignore()

 		lx.push(lexTableNameEnd)

 		return lexValue // reuse string lexing

-	case isWhitespace(r):

-		return lexTableNameStart

 	default:

 		return lexBareTableName

 	}

 }

-// lexTableName lexes the name of a table. It assumes that at least one

+// lexBareTableName lexes the name of a table. It assumes that at least one

 // valid character for the table has already been read.

 func lexBareTableName(lx *lexer) stateFn {

-	switch r := lx.next(); {

-	case isBareKeyChar(r):

+	r := lx.next()

+	if isBareKeyChar(r) {

 		return lexBareTableName

-	case r == tableSep || r == tableEnd:

-		lx.backup()

-		lx.emitTrim(itemText)

-		return lexTableNameEnd

-	default:

-		return lx.errorf("Bare keys cannot contain %q.", r)

 	}

+	lx.backup()

+	lx.emit(itemText)

+	return lexTableNameEnd

 }

 // lexTableNameEnd reads the end of a piece of a table name, optionally

 // consuming whitespace.

 func lexTableNameEnd(lx *lexer) stateFn {

+	lx.skip(isWhitespace)

 	switch r := lx.next(); {

 	case isWhitespace(r):

 		return lexTableNameEnd

@@ -306,8 +347,8 @@ func lexTableNameEnd(lx *lexer) stateFn {

 	case r == tableEnd:

 		return lx.pop()

 	default:

-		return lx.errorf("Expected '.' or ']' to end table name, but got %q "+

-			"instead.", r)

+		return lx.errorf("expected '.' or ']' to end table name, "+

+			"but got %q instead", r)

 	}

 }

@@ -317,7 +358,7 @@ func lexKeyStart(lx *lexer) stateFn {

 	r := lx.peek()

 	switch {

 	case r == keySep:

-		return lx.errorf("Unexpected key separator %q.", keySep)

+		return lx.errorf("unexpected key separator %q", keySep)

 	case isWhitespace(r) || isNL(r):

 		lx.next()

 		return lexSkip(lx, lexKeyStart)

@@ -340,14 +381,15 @@ func lexBareKey(lx *lexer) stateFn {

 	case isBareKeyChar(r):

 		return lexBareKey

 	case isWhitespace(r):

-		lx.emitTrim(itemText)

+		lx.backup()

+		lx.emit(itemText)

 		return lexKeyEnd

 	case r == keySep:

 		lx.backup()

-		lx.emitTrim(itemText)

+		lx.emit(itemText)

 		return lexKeyEnd

 	default:

-		return lx.errorf("Bare keys cannot contain %q.", r)

+		return lx.errorf("bare keys cannot contain %q", r)

 	}

 }

@@ -360,7 +402,7 @@ func lexKeyEnd(lx *lexer) stateFn {

 	case isWhitespace(r):

 		return lexSkip(lx, lexKeyEnd)

 	default:

-		return lx.errorf("Expected key separator %q, but got %q instead.",

+		return lx.errorf("expected key separator %q, but got %q instead",

 			keySep, r)

 	}

 }

@@ -369,20 +411,26 @@ func lexKeyEnd(lx *lexer) stateFn {

 // lexValue will ignore whitespace.

 // After a value is lexed, the last state on the next is popped and returned.

 func lexValue(lx *lexer) stateFn {

-	// We allow whitespace to precede a value, but NOT new lines.

-	// In array syntax, the array states are responsible for ignoring new

-	// lines.

+	// We allow whitespace to precede a value, but NOT newlines.

+	// In array syntax, the array states are responsible for ignoring newlines.

 	r := lx.next()

-	if isWhitespace(r) {

+	switch {

+	case isWhitespace(r):

 		return lexSkip(lx, lexValue)

+	case isDigit(r):

+		lx.backup() // avoid an extra state and use the same as above

+		return lexNumberOrDateStart

 	}

-

-	switch {

-	case r == arrayStart:

+	switch r {

+	case arrayStart:

 		lx.ignore()

 		lx.emit(itemArray)

 		return lexArrayValue

-	case r == stringStart:

+	case inlineTableStart:

+		lx.ignore()

+		lx.emit(itemInlineTableStart)

+		return lexInlineTableValue

+	case stringStart:

 		if lx.accept(stringStart) {

 			if lx.accept(stringStart) {

 				lx.ignore() // Ignore """

@@ -392,7 +440,7 @@ func lexValue(lx *lexer) stateFn {

 		}

 		lx.ignore() // ignore the '"'

 		return lexString

-	case r == rawStringStart:

+	case rawStringStart:

 		if lx.accept(rawStringStart) {

 			if lx.accept(rawStringStart) {

 				lx.ignore() // Ignore """

@@ -402,23 +450,24 @@ func lexValue(lx *lexer) stateFn {

 		}

 		lx.ignore() // ignore the "'"

 		return lexRawString

-	case r == 't':

-		return lexTrue

-	case r == 'f':

-		return lexFalse

-	case r == '-':

+	case '+', '-':

 		return lexNumberStart

-	case isDigit(r):

-		lx.backup() // avoid an extra state and use the same as above

-		return lexNumberOrDateStart

-	case r == '.': // special error case, be kind to users

-		return lx.errorf("Floats must start with a digit, not '.'.")

+	case '.': // special error case, be kind to users

+		return lx.errorf("floats must start with a digit, not '.'")

+	}

+	if unicode.IsLetter(r) {

+		// Be permissive here; lexBool will give a nice error if the

+		// user wrote something like

+		//   x = foo

+		// (i.e. not 'true' or 'false' but is something else word-like.)

+		lx.backup()

+		return lexBool