aws-sdk-go: github.com/aws/aws-sdk-go/internal/ini Index | Files

package ini

import "github.com/aws/aws-sdk-go/internal/ini"

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

Index

Package Files

ast.go comma_token.go comment_token.go doc.go 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

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 (
    InvalidState = 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

const (
    NoneType = ValueType(iota)
    DecimalType
    IntegerType
    StringType
    QuotedStringType
    BoolType
)

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.

func EqualExprKey Uses

func EqualExprKey(ast AST) string

EqualExprKey will return a LHS value in the equal expr

func Walk Uses

func Walk(tree []AST, v Visitor) error

Walk will traverse the AST using the v, the Visitor.

type AST Uses

type AST struct {
    Kind      ASTKind
    Root      Token
    RootToken bool
    Children  []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 ParseAST Uses

func ParseAST(r io.Reader) ([]AST, error)

ParseAST will parse input from an io.Reader using an LL(1) parser.

func ParseASTBytes Uses

func ParseASTBytes(b []byte) ([]AST, error)

ParseASTBytes will parse input from a byte slice using an LL(1) parser.

func (*AST) AppendChild Uses

func (a *AST) AppendChild(child AST)

AppendChild will append to the list of children an AST has.

func (*AST) GetChildren Uses

func (a *AST) GetChildren() []AST

GetChildren will return the current AST's list of children

func (*AST) GetRoot Uses

func (a *AST) GetRoot() AST

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

func (*AST) SetChildren Uses

func (a *AST) SetChildren(children []AST)

SetChildren will set and override all children of the AST.

type ASTKind Uses

type ASTKind int

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

func (ASTKind) String Uses

func (k ASTKind) String() string

type DefaultVisitor Uses

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 Uses

func NewDefaultVisitor() *DefaultVisitor

NewDefaultVisitor return a DefaultVisitor

func (*DefaultVisitor) VisitExpr Uses

func (v *DefaultVisitor) VisitExpr(expr AST) error

VisitExpr visits expressions...

func (*DefaultVisitor) VisitStatement Uses

func (v *DefaultVisitor) VisitStatement(stmt AST) error

VisitStatement visits statements...

type ParseError Uses

type ParseError struct {
    // contains filtered or unexported fields
}

ParseError is an error which is returned during any part of the parsing process.

func NewParseError Uses

func NewParseError(message string) *ParseError

NewParseError will return a new ParseError where message is the description of the error.

func (*ParseError) Code Uses

func (err *ParseError) Code() string

Code will return the ErrCodeParseError

func (*ParseError) Error Uses

func (err *ParseError) Error() string

func (*ParseError) Message Uses

func (err *ParseError) Message() string

Message returns the error's message

func (*ParseError) OrigError Uses

func (err *ParseError) OrigError() error

OrigError return nothing since there will never be any original error.

type ParseStack Uses

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) Len Uses

func (s *ParseStack) Len() int

Len will return the length of the container

func (ParseStack) List Uses

func (s ParseStack) List() []AST

List will return the completed statements

func (*ParseStack) MarkComplete Uses

func (s *ParseStack) MarkComplete(ast AST)

MarkComplete will append the AST to the list of completed statements

func (*ParseStack) Pop Uses

func (s *ParseStack) Pop() AST

Pop will return and truncate the last container element.

func (*ParseStack) Push Uses

func (s *ParseStack) Push(ast AST)

Push will add the new AST to the container

func (ParseStack) String Uses

func (s ParseStack) String() string

type Section Uses

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.

func (Section) Bool Uses

func (t Section) Bool(k string) bool

Bool returns a bool value at k

func (Section) Float64 Uses

func (t Section) Float64(k string) float64

Float64 returns a float value at k

func (Section) Has Uses

func (t Section) Has(k string) bool

Has will return whether or not an entry exists in a given section

func (Section) Int Uses

func (t Section) Int(k string) int64

Int returns an integer value at k

func (Section) String Uses

func (t Section) String(k string) string

String returns the string value at k

func (Section) ValueType Uses

func (t Section) 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.

type Sections Uses

type Sections struct {
    // contains filtered or unexported fields
}

Sections is a map of Section structures that represent a configuration.

func OpenFile Uses

func OpenFile(path string) (Sections, error)

OpenFile takes a path to a given file, and will open and parse that file.

func Parse Uses

func Parse(f io.Reader) (Sections, error)

Parse will parse the given file using the shared config visitor.

func ParseBytes Uses

func ParseBytes(b []byte) (Sections, error)

ParseBytes will parse the given bytes and return the parsed sections.

func (Sections) GetSection Uses

func (t Sections) GetSection(p string) (Section, bool)

GetSection will return section p. If section p does not exist, false will be returned in the second parameter.

func (Sections) List Uses

func (t Sections) List() []string

List will return a list of all sections that were successfully parsed.

type Token Uses

type Token struct {
    ValueType ValueType
    // contains filtered or unexported fields
}

Token indicates a metadata about a given value.

func (Token) Raw Uses

func (tok Token) Raw() []rune

Raw return the raw runes that were consumed

func (Token) Type Uses

func (tok Token) Type() TokenType

Type returns the token type

type TokenType Uses

type TokenType int

TokenType represents the various different tokens types

func (TokenType) String Uses

func (t TokenType) String() string

type Value Uses

type Value struct {
    Type ValueType
    // contains filtered or unexported fields
}

Value is a union container

func (*Value) Append Uses

func (v *Value) Append(tok Token)

Append will append values and change the type to a string type.

func (Value) BoolValue Uses

func (v Value) BoolValue() bool

BoolValue returns a bool value

func (Value) FloatValue Uses

func (v Value) FloatValue() float64

FloatValue returns a float value

func (Value) IntValue Uses

func (v Value) IntValue() int64

IntValue returns an integer value

func (Value) String Uses

func (v Value) String() string

func (Value) StringValue Uses

func (v Value) StringValue() string

StringValue returns the string value

type ValueType Uses

type ValueType int

ValueType is an enum that will signify what type the Value is

func (ValueType) String Uses

func (v ValueType) String() string

type Visitor Uses

type Visitor interface {
    VisitExpr(AST) error
    VisitStatement(AST) error
}

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

Package ini imports 10 packages (graph) and is imported by 18 packages. Updated 2019-05-31. Refresh now. Tools for package owners.