parser

type AnnotatedNode struct {
	Node       Node   // The wrapped node
	Annotation string // The annotation text
}

type BaseState struct {
	Tab Table // The table for the parse
}

type BinaryOperator struct {
	Loc scanner.Location // The location of the expression
	Op  *lexer.Token     // The unary operator
	L   Node             // The left-hand side expression
	R   Node             // The right-hand side expression
}

type Entry struct {
	Power int       // The binding power of the token type
	First ExprFirst // The function to call for an initial token
	Next  ExprNext  // The function to call for the next token
	Stmt  Statement // The function to call for statement tokens
}

type ExprFirst func(parser *Parser, power int, tok *lexer.Token) (Node, error)

type ExprNext func(parser *Parser, power int, left Node, tok *lexer.Token) (Node, error)

type IPushBackLexer interface {
	lexer.ILexer

	// PushBack pushes a token back into the lexer.  This token
	// will be returned on the next call to the Next method.
	PushBack(tok *lexer.Token)
}

type Node interface {
	// Location returns the node's location range.
	Location() scanner.Location

	// Children returns a list of child nodes.
	Children() []Node

	// String returns a string describing the node.  This should
	// include the location range that encompasses all of the
	// node's tokens.
	String() string
}

type Parser struct {
	Lexer IPushBackLexer // The lexer providing the tokens
	State State          // The state of the parser
}

type PushBackLexer struct {
	Lexer lexer.ILexer // The source lexer
	// contains filtered or unexported fields
}

type State interface {
	// Table must return the parser table to use.  It is safe for
	// the application to return different Table implementations
	// depending on the parser state.
	Table() Table
}

type Statement func(parser *Parser, tok *lexer.Token) (Node, error)

type Table map[string]Entry

type TokenNode struct {
	*lexer.Token
}

type UnaryOperator struct {
	Loc scanner.Location // The location of the expression
	Op  *lexer.Token     // The unary operator
	Exp Node             // The expression acted upon
}