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

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

Decode will decode the contents of `data` in TOML format into a pointer `v`. TOML hashes correspond to Go structs or maps. (Dealer's choice. They can

Type returns a string representation of the type of the key specified. Type will return the empty string if given an empty key or a key that does not

ignore skips over the pending input before this point.

isWhitespace returns true if `r` is a whitespace character according to the spec.

typeEqual accepts any two types and returns true if they are equal.

typeOfPrimitive returns a tomlType of any primitive value in TOML. Primitive values are: Integer, Float, Datetime, String and Bool. Passing a lexer i

accept consumes the next rune if it's equal to `valid`.

lexSkip ignores all slurped input and moves on to the next state.

unify performs a sort of type unification based on the structure of `rv`, which is the client representation. Any type mismatch produces an error. Fi

Sort sorts the provided slice using the function less. If slice is not a slice, Sort panics.

tomlTypeName returns the TOML type name of the Go value's type. It is used to determine whether the types of array elements are mixed (which is forbid

Encode writes a TOML representation of the Go value to the underlying io.Writer. If the value given cannot be encoded to a valid TOML document, then a

NewEncoder returns a TOML encoder that encodes Go values to the io.Writer given. By default, a single indentation level is 2 spaces.

indirect returns the value pointed to by a pointer. Pointers are followed until the value is not a pointer. New values are allocated for each nil poin

peek returns but does not consume the next rune in the input.

rvalue returns a reflect.Value of `v`. All pointers are resolved.

Gets a string for a key (or part of a key in a table name).

setType sets the type of a particular value at a given key. It should be called immediately AFTER setValue. Note that if `key` is empty, then the typ

Expand expands s into IP addresses. A successful return will consist of valid IP addresses or "*". The following process is repeated until there are n

SortInterface returns a sort.Interface to sort the provided slice using the function less.

Undecoded returns all keys that have not been decoded in the order in which they appear in the original TOML document. This includes keys that haven'

eElement encodes any value that can be an array element (primitives and arrays).

establishContext sets the current context of the parser, where the context is either a hash or an array of hashes. Which one is set depends on the val

By the TOML spec, all floats must have a decimal with at least one number on either side.

lexConst consumes the s[1:] in s. It assumes that s[0] has already been consumed.

setValue sets the given key to the given value in the current context. It will make sure that the key hasn't already been defined, account for implici

value translates an expected value from the lexer into a Go value wrapped as an empty interface.

Cases computes the actual test cases from a test plan. filter and no10 are described in Plans.Test.

IsDefined returns true if the key given exists in the TOML data. The key should be specified hierarchially. e.g., // access the TOML key 'a.b.c' Is

PrimitiveDecode is just like the other `Decode*` functions, except it decodes a TOML value that has already been parsed. Valid primitive values can *o

Test performs tests. Filter optionally specifies an IP filter to use. no10 disallows 10.* addresses. It returns a channel where results will be sent w

Unmarshal decodes the contents of `p` in TOML format into a pointer `v`.

addImplicit sets the given Key as having been created implicitly.

cachedTypeFields is like typeFields but uses a cache to avoid repeated work.

current returns the full key name of the current context.

dominantField looks through the fields, all of which are known to have the same name, to find the single field that dominates the others using Go's em