Documentation
¶
Overview ¶
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 -> section | stmt' stmt' -> epsilon | expr expr -> value (stmt)* | equal_expr (stmt)* equal_expr -> value ( ':' | '=' ) equal_expr' equal_expr' -> number | string | quoted_string quoted_string -> " quoted_string' quoted_string' -> string quoted_string_end quoted_string_end -> " section -> [ section' section' -> section_value section_close section_value -> number | string_subset | boolean | quoted_string_subset quoted_string_subset -> " quoted_string_subset' quoted_string_subset' -> string_subset quoted_string_end quoted_string_subset -> " section_close -> ] value -> number | string_subset | boolean string -> ? UTF-8 Code-Points except '\n' (U+000A) and '\r\n' (U+000D U+000A) ? string_subset -> ? Code-points excepted by <string> grammar except ':' (U+003A), '=' (U+003D), '[' (U+005B), and ']' (U+005D) ? SkipState will skip (NL WS)+ comment -> # comment' | ; comment' comment' -> epsilon | value
Index ¶
Constants ¶
const ( ASTKindNone = ASTKind(iota) ASTKindStart ASTKindExpr ASTKindEqualExpr ASTKindStatement ASTKindSkipStatement ASTKindExprStatement ASTKindSectionStatement ASTKindNestedSectionStatement ASTKindCompletedNestedSectionStatement ASTKindCommentStatement ASTKindCompletedSectionStatement )
ASTKind* is used in the parse table to transition between the different states
const ( TokenNone = TokenType(iota) TokenLit TokenSep TokenComma TokenOp TokenWS TokenNL TokenComment )
TokenType enums
const ( NoneType = ValueType(iota) DecimalType // deprecated IntegerType // deprecated StringType QuotedStringType BoolType // deprecated )
ValueType enums
const ( // ErrCodeParseError is returned when a parsing error // has occurred. ErrCodeParseError = "INIParseError" )
const ( // ErrCodeUnableToReadFile is used when a file is failed to be // opened or read from. ErrCodeUnableToReadFile = "FailedRead" )
Variables ¶
var Start = newAST(ASTKindStart, AST{})
Start is used to indicate the starting state of the parse table.
Functions ¶
func EqualExprKey ¶
EqualExprKey will return a LHS value in the equal expr
Types ¶
type AST ¶
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
func ParseASTBytes ¶
ParseASTBytes will parse input from a byte slice using an LL(1) parser.
func (*AST) AppendChild ¶
AppendChild will append to the list of children an AST has.
func (*AST) GetChildren ¶
GetChildren will return the current AST's list of children
func (*AST) GetRoot ¶
GetRoot will return the root AST which can be the first entry in the children list or a token.
func (*AST) SetChildren ¶
SetChildren will set and override all children of the AST.
type ASTKind ¶
type ASTKind int
ASTKind represents different states in the parse table and the type of AST that is being constructed
type DefaultVisitor ¶
type DefaultVisitor struct {
Sections Sections
// contains filtered or unexported fields
}
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.
func NewDefaultVisitor ¶
func NewDefaultVisitor() *DefaultVisitor
NewDefaultVisitor return a DefaultVisitor
func (*DefaultVisitor) VisitExpr ¶
func (v *DefaultVisitor) VisitExpr(expr AST) error
VisitExpr visits expressions...
func (*DefaultVisitor) VisitStatement ¶
func (v *DefaultVisitor) VisitStatement(stmt AST) error
VisitStatement visits statements...
type ParseError ¶
type ParseError struct {
// contains filtered or unexported fields
}
ParseError is an error which is returned during any part of the parsing process.
func NewParseError ¶
func NewParseError(message string) *ParseError
NewParseError will return a new ParseError where message is the description of the error.
func (*ParseError) Code ¶
func (err *ParseError) Code() string
Code will return the ErrCodeParseError
func (*ParseError) Error ¶
func (err *ParseError) Error() string
func (*ParseError) Message ¶
func (err *ParseError) Message() string
Message returns the error's message
func (*ParseError) OrigError ¶
func (err *ParseError) OrigError() error
OrigError return nothing since there will never be any original error.
type ParseStack ¶
type ParseStack struct {
// contains filtered or unexported fields
}
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.
func (*ParseStack) MarkComplete ¶
func (s *ParseStack) MarkComplete(ast AST)
MarkComplete will append the AST to the list of completed statements
func (*ParseStack) Pop ¶
func (s *ParseStack) Pop() AST
Pop will return and truncate the last container element.
func (*ParseStack) Push ¶
func (s *ParseStack) Push(ast AST)
Push will add the new AST to the container
func (ParseStack) String ¶
func (s ParseStack) String() string
type ParseState ¶
type ParseState uint
ParseState represents the current state of the parser.
const ( InvalidState ParseState = iota // stmt -> value stmt' StatementState // stmt' -> MarkComplete | op stmt StatementPrimeState // value -> number | string | boolean | quoted_string ValueState // section -> [ section' OpenScopeState // section' -> value section_close SectionState // section_close -> ] CloseScopeState // SkipState will skip (NL WS)+ SkipState // SkipTokenState will skip any token and push the previous // state onto the stack. SkipTokenState // comment -> # comment' | ; comment' // comment' -> MarkComplete | value CommentState // MarkComplete state will complete statements and move that // to the completed AST list MarkCompleteState // TerminalState signifies that the tokens have been fully parsed TerminalState )
State enums for the parse table
type Section ¶
type Section struct {
Name string
// contains filtered or unexported fields
}
Section contains a name and values. This represent a sectioned entry in a configuration file.
type Sections ¶
type Sections struct {
// contains filtered or unexported fields
}
Sections is a map of Section structures that represent a configuration.
func ParseBytes ¶
ParseBytes will parse the given bytes and return the parsed sections.
func (Sections) GetSection ¶
GetSection will return section p. If section p does not exist, false will be returned in the second parameter.
type Token ¶
type Token struct {
ValueType ValueType
// contains filtered or unexported fields
}
Token indicates a metadata about a given value.
type Value ¶
type Value struct {
Type ValueType
// contains filtered or unexported fields
}
Value is a union container
func (Value) FloatValue ¶
FloatValue returns a float value
Source Files