package ini

Import Path
	github.com/aws/aws-sdk-go/internal/ini (on go.dev)

Dependency Relation
	imports 10 packages, and imported by 2 packages

Involved Source Files

	      ast.go
	      comma_token.go
	      comment_token.go
	   d➜ doc.go
		Package ini is an LL(1) parser for configuration files.

			Example:
			sections, err := ini.OpenFile("/path/to/file")
			if err != nil {
				panic(err)
			}

			profile := "foo"
			section, ok := sections.GetSection(profile)
			if !ok {
				fmt.Printf("section %q could not be found", profile)
			}

		Below is the BNF that describes this parser
			Grammar:
			stmt -> value stmt'
			stmt' -> epsilon | op stmt
			value -> number | string | boolean | quoted_string

			section -> [ section'
			section' -> value section_close
			section_close -> ]

			SkipState will skip (NL WS)+

			comment -> # comment' | ; comment'
			comment' -> epsilon | value

	      empty_token.go
	      expression.go
	      ini.go
	      ini_lexer.go
	      ini_parser.go
	      literal_tokens.go
	      newline_token.go
	      number_helper.go
	      op_tokens.go
	      parse_error.go
	      parse_stack.go
	      sep_tokens.go
	      skipper.go
	      statement.go
	      value_util.go
	      visitor.go
	      walker.go
	      ws_token.go
Package-Level Type Names (total 17, in which 12 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type AST (struct)
		AST interface allows us to determine what kind of node we
		are on and casting may not need to be necessary.

		The root is always the first node in Children

		Fields (total 4, all are exported)
			Children []AST
			Kind ASTKind
			Root Token
			RootToken bool
		Methods (total 4, all are exported)
			(*T) AppendChild(child AST)
				AppendChild will append to the list of children an AST has.

			(*T) GetChildren() []AST
				GetChildren will return the current AST's list of children

			(*T) GetRoot() AST
				GetRoot will return the root AST which can be the first entry
				in the children list or a token.

			(*T) SetChildren(children []AST)
				SetChildren will set and override all children of the AST.

		As Outputs Of (at least 18, in which 6 are exported)
			func ParseAST(r io.Reader) ([]AST, error)
			func ParseASTBytes(b []byte) ([]AST, error)
			func (*AST).GetChildren() []AST
			func (*AST).GetRoot() AST
			func ParseStack.List() []AST
			func (*ParseStack).Pop() AST
			/* 12+ unexporteds ... *//* 12+ unexporteds: */
			func newAST(kind ASTKind, root AST, children ...AST) AST
			func newASTWithRootToken(kind ASTKind, root Token, children ...AST) AST
			func newCommentStatement(tok Token) AST
			func newCompletedSectionStatement(ast AST) AST
			func newEqualExpr(left AST, tok Token) AST
			func newExpression(tok Token) AST
			func newExprStatement(ast AST) AST
			func newSectionStatement(tok Token) AST
			func newSkipStatement(ast AST) AST
			func newStatement() AST
			func parse(tokens []Token) ([]AST, error)
			func trimSpaces(k AST) AST
		As Inputs Of (at least 18, in which 10 are exported)
			func EqualExprKey(ast AST) string
			func Walk(tree []AST, v Visitor) error
			func (*AST).AppendChild(child AST)
			func (*AST).SetChildren(children []AST)
			func (*DefaultVisitor).VisitExpr(expr AST) error
			func (*DefaultVisitor).VisitStatement(stmt AST) error
			func (*ParseStack).MarkComplete(ast AST)
			func (*ParseStack).Push(ast AST)
			func Visitor.VisitExpr(AST) error
			func Visitor.VisitStatement(AST) error
			/* 8+ unexporteds ... *//* 8+ unexporteds: */
			func newAST(kind ASTKind, root AST, children ...AST) AST
			func newAST(kind ASTKind, root AST, children ...AST) AST
			func newASTWithRootToken(kind ASTKind, root Token, children ...AST) AST
			func newCompletedSectionStatement(ast AST) AST
			func newEqualExpr(left AST, tok Token) AST
			func newExprStatement(ast AST) AST
			func newSkipStatement(ast AST) AST
			func trimSpaces(k AST) AST
		As Types Of (only one, which is exported)
			  var Start

	 type ASTKind int (basic type)
		ASTKind represents different states in the parse table
		and the type of AST that is being constructed

		Methods (only one, which is exported)
			( T) String() string
		Implements (at least 4, in which 2 are exported)
			 T : expvar.Var
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer
		As Inputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func newAST(kind ASTKind, root AST, children ...AST) AST
			func newASTWithRootToken(kind ASTKind, root Token, children ...AST) AST
		As Types Of (total 12, all are exported)
			const ASTKindCommentStatement
			const ASTKindCompletedNestedSectionStatement
			const ASTKindCompletedSectionStatement
			const ASTKindEqualExpr
			const ASTKindExpr
			const ASTKindExprStatement
			const ASTKindNestedSectionStatement
			const ASTKindNone
			const ASTKindSectionStatement
			const ASTKindSkipStatement
			const ASTKindStart
			const ASTKindStatement

	 type DefaultVisitor (struct)
		DefaultVisitor is used to visit statements and expressions
		and ensure that they are both of the correct format.
		In addition, upon visiting this will build sections and populate
		the Sections field which can be used to retrieve profile
		configuration.

		Fields (total 2, in which 1 are exported)
			Sections Sections
			/* one unexported ... *//* one unexported: */
			scope string
		Methods (total 2, both are exported)
			(*T) VisitExpr(expr AST) error
				VisitExpr visits expressions...

			(*T) VisitStatement(stmt AST) error
				VisitStatement visits statements...

		Implements (at least one exported)
			*T : Visitor
		As Outputs Of (at least one exported)
			func NewDefaultVisitor() *DefaultVisitor

	 type ParseError (struct)
		ParseError is an error which is returned during any part of
		the parsing process.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			msg string
		Methods (total 4, all are exported)
			(*T) Code() string
				Code will return the ErrCodeParseError

			(*T) Error() string
			(*T) Message() string
				Message returns the error's message

			(*T) OrigError() error
				OrigError return nothing since there will never be any
				original error.

		Implements (at least one exported)
			*T : error
		As Outputs Of (at least one exported)
			func NewParseError(message string) *ParseError

	 type ParseStack (struct)
		ParseStack is a stack that contains a container, the stack portion,
		and the list which is the list of ASTs that have been successfully
		parsed.

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			container []AST
			index int
			list []AST
			top int
		Methods (total 6, all are exported)
			(*T) Len() int
				Len will return the length of the container

			( T) List() []AST
				List will return the completed statements

			(*T) MarkComplete(ast AST)
				MarkComplete will append the AST to the list of completed statements

			(*T) Pop() AST
				Pop will return and truncate the last container element.

			(*T) Push(ast AST)
				Push will add the new AST to the container

			( T) String() string
		Implements (at least 5, in which 2 are exported)
			 T : expvar.Var
			 T : fmt.Stringer
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*T : github.com/aws/aws-sdk-go/aws/corehandlers.lener
			 T : context.stringer
			 T : runtime.stringer
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newParseStack(sizeContainer, sizeList int) ParseStack

	 type Section (struct)
		Section contains a name and values. This represent
		a sectioned entry in a configuration file.

		Fields (total 2, in which 1 are exported)
			Name string
			/* one unexported ... *//* one unexported: */
			values values
		Methods (total 6, all are exported)
			( T) Bool(k string) bool
				Bool returns a bool value at k

			( T) Float64(k string) float64
				Float64 returns a float value at k

			( T) Has(k string) bool
				Has will return whether or not an entry exists in a given section

			( T) Int(k string) int64
				Int returns an integer value at k

			( T) String(k string) string
				String returns the string value at k

			( T) ValueType(k string) (ValueType, bool)
				ValueType will returned what type the union is set to. If
				k was not found, the NoneType will be returned.

		As Outputs Of (at least one exported)
			func Sections.GetSection(p string) (Section, bool)
		As Inputs Of (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func github.com/aws/aws-sdk-go/aws/session.updateBool(dst *bool, section Section, key string)
			func github.com/aws/aws-sdk-go/aws/session.updateBoolPtr(dst **bool, section Section, key string)
			func github.com/aws/aws-sdk-go/aws/session.updateString(dst *string, section Section, key string)

	 type Sections (struct)
		Sections is a map of Section structures that represent
		a configuration.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			container map[string]Section
		Methods (total 2, both are exported)
			( T) GetSection(p string) (Section, bool)
				GetSection will return section p. If section p does not exist,
				false will be returned in the second parameter.

			( T) List() []string
				List will return a list of all sections that were successfully
				parsed.

		As Outputs Of (at least 3, all are exported)
			func OpenFile(path string) (Sections, error)
			func Parse(f io.Reader) (Sections, error)
			func ParseBytes(b []byte) (Sections, error)

	 type Token (struct)
		Token indicates a metadata about a given value.

		Fields (total 4, in which 1 are exported)
			ValueType ValueType
			/* 3 unexporteds ... *//* 3 unexporteds: */
			base int
			raw []rune
			t TokenType
		Methods (total 2, both are exported)
			( T) Raw() []rune
				Raw return the raw runes that were consumed

			( T) Type() TokenType
				Type returns the token type

		As Outputs Of (at least 8, none are exported)
			/* 8+ unexporteds ... *//* 8+ unexporteds: */
			func newCommaToken() Token
			func newCommentToken(b []rune) (Token, int, error)
			func newLitToken(b []rune) (Token, int, error)
			func newNewlineToken(b []rune) (Token, int, error)
			func newOpToken(b []rune) (Token, int, error)
			func newSepToken(b []rune) (Token, int, error)
			func newToken(t TokenType, raw []rune, v ValueType) Token
			func newWSToken(b []rune) (Token, int, error)
		As Inputs Of (at least 7, in which 1 are exported)
			func (*Value).Append(tok Token)
			/* 6+ unexporteds ... *//* 6+ unexporteds: */
			func newASTWithRootToken(kind ASTKind, root Token, children ...AST) AST
			func newCommentStatement(tok Token) AST
			func newEqualExpr(left AST, tok Token) AST
			func newExpression(tok Token) AST
			func newSectionStatement(tok Token) AST
			func parse(tokens []Token) ([]AST, error)
		As Types Of (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			  var emptyToken

	 type TokenType int (basic type)
		TokenType represents the various different tokens types

		Methods (only one, which is exported)
			( T) String() string
		Implements (at least 4, in which 2 are exported)
			 T : expvar.Var
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer
		As Outputs Of (at least one exported)
			func Token.Type() TokenType
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newToken(t TokenType, raw []rune, v ValueType) Token
		As Types Of (total 8, all are exported)
			const TokenComma
			const TokenComment
			const TokenLit
			const TokenNL
			const TokenNone
			const TokenOp
			const TokenSep
			const TokenWS

	 type Value (struct)
		Value is a union container

		Fields (total 6, in which 1 are exported)
			Type ValueType
			/* 5 unexporteds ... *//* 5 unexporteds: */
			boolean bool
			decimal float64
			integer int64
			raw []rune
			str string
		Methods (total 6, all are exported)
			(*T) Append(tok Token)
				Append will append values and change the type to a string
				type.

			( T) BoolValue() bool
				BoolValue returns a bool value

			( T) FloatValue() float64
				FloatValue returns a float value

			( T) IntValue() int64
				IntValue returns an integer value

			( T) String() string
			( T) StringValue() string
				StringValue returns the string value

		Implements (at least 4, in which 2 are exported)
			 T : expvar.Var
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newValue(t ValueType, base int, raw []rune) (Value, error)
		As Types Of (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			  var emptyValue

	 type ValueType int (basic type)
		ValueType is an enum that will signify what type
		the Value is

		Methods (only one, which is exported)
			( T) String() string
		Implements (at least 4, in which 2 are exported)
			 T : expvar.Var
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer
		As Outputs Of (at least one exported)
			func Section.ValueType(k string) (ValueType, bool)
		As Inputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func newToken(t TokenType, raw []rune, v ValueType) Token
			func newValue(t ValueType, base int, raw []rune) (Value, error)
		As Types Of (total 6, all are exported)
			const BoolType
			const DecimalType
			const IntegerType
			const NoneType
			const QuotedStringType
			const StringType

	 type Visitor (interface)
		Visitor is an interface used by walkers that will
		traverse an array of ASTs.

		Methods (total 2, both are exported)
			( T) VisitExpr(AST) error
			( T) VisitStatement(AST) error
		Implemented By (at least one exported)
			*DefaultVisitor
		As Inputs Of (at least one exported)
			func Walk(tree []AST, v Visitor) error

	/* 5 unexporteds ... *//* 5 unexporteds: */
	 type iniLexer (struct)

		Methods (total 2, in which 1 are exported)
			(*T) Tokenize(r io.Reader) ([]Token, error)
				Tokenize will return a list of tokens during lexical analysis of the
				io.Reader.

			/* one unexported ... *//* one unexported: */
			(*T) tokenize(b []byte) ([]Token, error)

	 type numberFormat int (basic type)

		As Types Of (total 6, none are exported)
			/* 6 unexporteds ... *//* 6 unexporteds: */
			const binary
			const decimal
			const exponent
			const hex
			const none
			const octal

	 type numberHelper (struct)
		numberHelper is used to dictate what format a number is in
		and what to do for negative values. Since -1e-4 is a valid
		number, we cannot just simply check for duplicate negatives.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			negative bool
			negativeExponent bool
			numberFormat numberFormat
		Methods (total 6, all are exported)
			( T) Base() int
			( T) CorrectByte(c rune) bool
			(*T) Determine(c rune) error
			( T) Exists() bool
			( T) IsNegative() bool
			( T) String() string
		Implements (at least 4, in which 2 are exported)
			 T : expvar.Var
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer

	 type skipper (struct)
		skipper is used to skip certain blocks of an ini file.
		Currently skipper is used to skip nested blocks of ini
		files. See example below

			[ foo ]
			nested = ; this section will be skipped
				a=b
				c=d
			bar=baz ; this will be included

		Fields (total 3, in which 1 are exported)
			TokenSet bool
			/* 2 unexporteds ... *//* 2 unexporteds: */
			prevTok Token
			shouldSkip bool
		Methods (total 3, all are exported)
			(*T) Continue()
			(*T) ShouldSkip(tok Token) bool
			(*T) Skip()
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newSkipper() skipper

	 type values (map)
		values represents a map of union values.



Package-Level Functions (total 60, in which 9 are exported)

	 func EqualExprKey(ast AST) string
		EqualExprKey will return a LHS value in the equal expr

	 func NewDefaultVisitor() *DefaultVisitor
		NewDefaultVisitor return a DefaultVisitor

	 func NewParseError(message string) *ParseError
		NewParseError will return a new ParseError where message
		is the description of the error.

	 func OpenFile(path string) (Sections, error)
		OpenFile takes a path to a given file, and will open  and parse
		that file.

	 func Parse(f io.Reader) (Sections, error)
		Parse will parse the given file using the shared config
		visitor.

	 func ParseAST(r io.Reader) ([]AST, error)
		ParseAST will parse input from an io.Reader using
		an LL(1) parser.

	 func ParseASTBytes(b []byte) ([]AST, error)
		ParseASTBytes will parse input from a byte slice using
		an LL(1) parser.

	 func ParseBytes(b []byte) (Sections, error)
		ParseBytes will parse the given bytes and return the parsed sections.

	 func Walk(tree []AST, v Visitor) error
		Walk will traverse the AST using the v, the Visitor.

	/* 51 unexporteds ... *//* 51 unexporteds: */
	 func contains(runes []rune, c rune) bool
	 func countTokens(runes []rune) int
	 func getBoolValue(b []rune) (int, error)
		getBoolValue will return a boolean and the amount
		of bytes read

		an error will be returned if the boolean is not of a correct
		value

	 func getEscapedByte(b rune) (rune, error)
	 func getNegativeNumber(b []rune) int
		getNegativeNumber will return a negative number from a
		byte slice. This will iterate through all characters until
		a non-digit has been found.

	 func getNumericalValue(b []rune) (int, int, error)
		getNumericalValue will return a numerical string, the amount
		of bytes read, and the base of the number

		an error will be returned if the number is not of a correct
		value

	 func getStringValue(b []rune) (int, error)
		getStringValue will return a quoted string and the amount
		of bytes read

		an error will be returned if the string is not properly formatted

	 func getValue(b []rune) (int, error)
	 func hasExponent(v []rune) bool
	 func isBinaryByte(b rune) bool
	 func isBoolValue(b []rune) bool
	 func isComma(b rune) bool
	 func isComment(b []rune) bool
		isComment will return whether or not the next byte(s) is a
		comment.

	 func isDigit(b rune) bool
		isDigit will return whether or not something is an integer

	 func isEscaped(value []rune, b rune) bool
		isEscaped will return whether or not the character is an escaped
		character.

	 func isHexByte(b rune) bool
	 func isLitValue(want, have []rune) bool
	 func isNewline(b []rune) bool
	 func isNumberValue(b []rune) bool
		isNumberValue will return whether not the leading characters in
		a byte slice is a number. A number is delimited by whitespace or
		the newline token.

		A number is defined to be in a binary, octal, decimal (int | float), hex format,
		or in scientific notation.

	 func isOctalByte(b rune) bool
	 func isOp(b []rune) bool
	 func isSep(b []rune) bool
	 func isTrimmable(r rune) bool
	 func isValid(b []rune) (bool, int, error)
	 func isValidRune(r rune) bool
	 func isWhitespace(c rune) bool
		isWhitespace will return whether or not the character is
		a whitespace character.

		Whitespace is defined as a space or tab.

	 func newAST(kind ASTKind, root AST, children ...AST) AST
	 func newASTWithRootToken(kind ASTKind, root Token, children ...AST) AST
	 func newCommaToken() Token
	 func newCommentStatement(tok Token) AST
		CommentStatement represents a comment in the ini definition.

			grammar:
			comment -> #comment' | ;comment'
			comment' -> epsilon | value

	 func newCommentToken(b []rune) (Token, int, error)
		newCommentToken will create a comment token and
		return how many bytes were read.

	 func newCompletedSectionStatement(ast AST) AST
		CompletedSectionStatement represents a completed section

	 func newEqualExpr(left AST, tok Token) AST
	 func newExpression(tok Token) AST
		newExpression will return an expression AST.
		Expr represents an expression

			grammar:
			expr -> string | number

	 func newExprStatement(ast AST) AST
		ExprStatement represents a completed expression AST

	 func newLitToken(b []rune) (Token, int, error)
	 func newNewlineToken(b []rune) (Token, int, error)
	 func newOpToken(b []rune) (Token, int, error)
	 func newParseStack(sizeContainer, sizeList int) ParseStack
	 func newSectionStatement(tok Token) AST
		SectionStatement represents a section AST

	 func newSepToken(b []rune) (Token, int, error)
	 func newSkipper() skipper
	 func newSkipStatement(ast AST) AST
		SkipStatement is used to skip whole statements

	 func newStatement() AST
		Statement is an empty AST mostly used for transitioning states.

	 func newToken(t TokenType, raw []rune, v ValueType) Token
	 func newValue(t ValueType, base int, raw []rune) (Value, error)
	 func newWSToken(b []rune) (Token, int, error)
	 func parse(tokens []Token) ([]AST, error)
	 func removeEscapedCharacters(b []rune) []rune
	 func runeCompare(v1 []rune, v2 []rune) bool
	 func trimSpaces(k AST) AST
		trimSpaces will trim spaces on the left and right hand side of
		the literal.


Package-Level Variables (total 13, in which 1 are exported)

	  var Start AST
		Start is used to indicate the starting state of the parse table.

	/* 12 unexporteds ... *//* 12 unexporteds: */
	  var closeBrace []rune
	  var commaRunes []rune
	  var emptyRunes []rune
	  var emptyToken Token
		emptyToken is used to satisfy the Token interface

	  var emptyValue Value
	  var equalColonOp []rune
	  var equalOp []rune
	  var literalValues [][]rune
	  var openBrace []rune
	  var parseTable map[ASTKind]map[TokenType]int
		parseTable is a state machine to dictate the grammar above.

	  var runesFalse []rune
	  var runesTrue []rune
Package-Level Constants (total 46, in which 40 are exported)

	const ASTKindCommentStatement ASTKind = 10
		ASTKind* is used in the parse table to transition between
		the different states

	const ASTKindCompletedNestedSectionStatement ASTKind = 9
		ASTKind* is used in the parse table to transition between
		the different states

	const ASTKindCompletedSectionStatement ASTKind = 11
		ASTKind* is used in the parse table to transition between
		the different states

	const ASTKindEqualExpr ASTKind = 3
		ASTKind* is used in the parse table to transition between
		the different states

	const ASTKindExpr ASTKind = 2
		ASTKind* is used in the parse table to transition between
		the different states

	const ASTKindExprStatement ASTKind = 6
		ASTKind* is used in the parse table to transition between
		the different states

	const ASTKindNestedSectionStatement ASTKind = 8
		ASTKind* is used in the parse table to transition between
		the different states

	const ASTKindNone ASTKind = 0
		ASTKind* is used in the parse table to transition between
		the different states

	const ASTKindSectionStatement ASTKind = 7
		ASTKind* is used in the parse table to transition between
		the different states

	const ASTKindSkipStatement ASTKind = 5
		ASTKind* is used in the parse table to transition between
		the different states

	const ASTKindStart ASTKind = 1
		ASTKind* is used in the parse table to transition between
		the different states

	const ASTKindStatement ASTKind = 4
		ASTKind* is used in the parse table to transition between
		the different states

	const BoolType ValueType = 5
		ValueType enums

	const CloseScopeState = 6
		section_close -> ]

	const CommentState = 9
		comment -> # comment' | ; comment'
		comment' -> MarkComplete | value

	const DecimalType ValueType = 1
		ValueType enums

	const ErrCodeParseError = "INIParseError"
		ErrCodeParseError is returned when a parsing error
		has occurred.

	const ErrCodeUnableToReadFile = "FailedRead"
		ErrCodeUnableToReadFile is used when a file is failed to be
		opened or read from.

	const IntegerType ValueType = 2
		ValueType enums

	const InvalidState = 0
		State enums for the parse table

	const MarkCompleteState = 10
		MarkComplete state will complete statements and move that
		to the completed AST list

	const NoneType ValueType = 0
		ValueType enums

	const OpenScopeState = 4
		section -> [ section'

	const QuotedStringType ValueType = 4
		ValueType enums

	const SectionState = 5
		section' -> value section_close

	const SkipState = 7
		SkipState will skip (NL WS)+

	const SkipTokenState = 8
		SkipTokenState will skip any token and push the previous
		state onto the stack.

	const StatementPrimeState = 2
		stmt' -> MarkComplete | op stmt

	const StatementState = 1
		stmt -> value stmt'

	const StringType ValueType = 3
		ValueType enums

	const TerminalState = 11
		TerminalState signifies that the tokens have been fully parsed

	const TokenComma TokenType = 3
		TokenType enums

	const TokenComment TokenType = 7
		TokenType enums

	const TokenLit TokenType = 1
		TokenType enums

	const TokenNL TokenType = 6
		TokenType enums

	const TokenNone TokenType = 0
		TokenType enums

	const TokenOp TokenType = 4
		TokenType enums

	const TokenSep TokenType = 2
		TokenType enums

	const TokenWS TokenType = 5
		TokenType enums

	const ValueState = 3
		value -> number | string | boolean | quoted_string

	/* 6 unexporteds ... *//* 6 unexporteds: */
	const binary numberFormat = 1
	const decimal numberFormat = 3
	const exponent numberFormat = 5
	const hex numberFormat = 4
	const none numberFormat = 0
	const octal numberFormat = 2

The pages are generated with Golds v0.3.2-preview. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.