README
¶
Package ebnf is a library for EBNF grammars salvaged from pre Go 1 exp/ebnf as other packages at github.com/cznic used to depend on it. This fork adds literal regular expression support in the EBNF grammar, so that a complete grammar with terminal definitions is possible. Install: $ go get github.com/PuerkitoBio/ebnf Godocs: http://godoc.org/github.com/PuerkitoBio/ebnf
Documentation
¶
Overview ¶
Package ebnf is a library for EBNF grammars. The input is utf8 text satisfying the following grammar (represented itself in EBNF):
Production = name "=" [ Expression ] "." . Expression = Alternative { "|" Alternative } . Alternative = Term { Term } . Term = name | regexp_lit | str_lit | char_lit [ "…" char_lit ] | Group | Option | Repetition . Group = "(" Expression ")" . Option = "[" Expression "]" . Repetition = "{" Expression "}" .
name = /[\pL_][\pL\pNd_]*/ . // unicode letter or underscore, then add unicode digits regexp_lit = /\/[^\n\/]+\// . // TODO, missing escaped slash str_lit = . // TODO, same as Go char_lit = . // TODO, same as Go
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. Regular expression literals are between forward slashes, and are validated as valid expressions according to the Go language's regexp syntax when the Verify function is called on a parsed grammar. 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() scanner.Position
type Expression ¶
type Expression interface {
// Pos is the position of the first character of the syntactic construct
Pos() scanner.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 {
Lparen scanner.Position
Body Expression // (body)
}
A Group node represents a grouped expression.
type Option ¶
type Option struct {
Lbrack scanner.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 (x *Production) Pos() scanner.Position
type Range ¶
type Range struct {
Begin, End *Token // begin ... end
}
A List node represents a range of characters.
type Repetition ¶
type Repetition struct {
Lbrace scanner.Position
Body Expression // {body}
}
A Repetition node represents a repeated expression.
func (*Repetition) Pos ¶
func (x *Repetition) Pos() scanner.Position
type Sequence ¶
type Sequence []Expression // x y z
A Sequence node represents a non-empty list of sequential expressions.
Source Files
Directories