Documentation
¶
Overview ¶
A library for EBNF grammars. The input is text ([]byte) satisfying the following grammar (represented itself in EBNF):
Production = name "=" Expression "." .
Expression = Alternative { "|" Alternative } .
Alternative = Term { Term } .
Term = name | token [ "..." token ] | Group | Option | Repetition .
Group = "(" Expression ")" .
Option = "[" Expression "]" .
Repetition = "{" Expression "}" .
A name is a Go identifier, a token is a Go string, and comments and white space follow the same rules as for the Go language. Production names starting with an uppercase Unicode letter denote non-terminal productions (i.e., productions which allow white-space and comments between tokens); all other production names denote lexical productions.
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
Types ¶
type Alternative ¶
type Alternative []Expression // x | y | z
An Alternative node represents a non-empty list of alternative expressions.
func (Alternative) Pos ¶
func (x Alternative) Pos() token.Position
type Expression ¶
type Expression interface {
// Pos is the position of the first character of the syntactic construct
Pos() token.Position
}
An Expression node represents a production expression.
type Grammar ¶
type Grammar map[string]*Production
A Grammar is a set of EBNF productions. The map is indexed by production name.
type Group ¶
type Group struct {
token.Position
Body Expression // (body)
}
A Group node represents a grouped expression.
type Option ¶
type Option struct {
token.Position
Body Expression // [body]
}
An Option node represents an optional expression.
type Production ¶
type Production struct {
Name *Name
Expr Expression
}
A Production node represents an EBNF production.
func (*Production) Pos ¶
func (p *Production) Pos() token.Position
type Range ¶
type Range struct {
Begin, End *Token // begin ... end
}
A List node represents a range of characters.
type Repetition ¶
type Repetition struct {
token.Position
Body Expression // {body}
}
A Repetition node represents a repeated expression.
type Sequence ¶
type Sequence []Expression // x y z
A Sequence node represents a non-empty list of sequential expressions.
Source Files