internal

Documentation

Overview

Package internal is 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 [ "-" 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

• func Verify(grammar Grammar, start string) error
• type Alternative
  • func (x Alternative) Pos() scanner.Position
• type Bad
  • func (x *Bad) Pos() scanner.Position
• type Expression
• type Grammar
  • func Parse(filename string, src io.Reader) (Grammar, error)
• type Group
  • func (x *Group) Pos() scanner.Position
• type Name
  • func (x *Name) Pos() scanner.Position
• type NamedProduction
• type Option
  • func (x *Option) Pos() scanner.Position
• type Production
  • func (x *Production) Pos() scanner.Position
• type Range
  • func (x *Range) Pos() scanner.Position
• type Repetition
  • func (x *Repetition) Pos() scanner.Position
• type Sequence
  • func (x Sequence) Pos() scanner.Position
• type Token
  • func (x *Token) Pos() scanner.Position

Functions

func Verify

func Verify(grammar Grammar, start string) error

Verify checks that:

• all productions used are defined
• all productions defined are used when beginning at start
• lexical productions refer only to other lexical productions

Position information is interpreted relative to the file set fset.

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 Bad

type Bad struct {
	TokPos scanner.Position
	Error  string // parser error message
}

A Bad node stands for pieces of source code that lead to a parse error.

func (*Bad) Pos

func (x *Bad) 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 struct {
	Index       map[string]*Production
	Productions []*NamedProduction
}

A Grammar is a set of EBNF productions. The map is indexed by production name.

func Parse

func Parse(filename string, src io.Reader) (Grammar, error)

Parse parses a set of EBNF productions from source src. It returns a set of productions. Errors are reported for incorrect syntax and if a production is declared more than once; the filename is used only for error positions.

type Group

type Group struct {
	Lparen scanner.Position
	Body   Expression // (body)
}

A Group node represents a grouped expression.

func (*Group) Pos

func (x *Group) Pos() scanner.Position

type Name

type Name struct {
	StringPos scanner.Position
	String    string
}

A Name node represents a production name.

func (*Name) Pos

func (x *Name) Pos() scanner.Position

type NamedProduction

type NamedProduction struct {
	Name       string
	Production *Production
}

A NamedProduction is an ordered Production.

type Option

type Option struct {
	Lbrack scanner.Position
	Body   Expression // [body]
}

An Option node represents an optional expression.

func (*Option) Pos

func (x *Option) Pos() scanner.Position

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
	Exclude    Expression // - token or range
}

A Range node represents a range of characters.

func (*Range) Pos

func (x *Range) Pos() scanner.Position

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.

func (Sequence) Pos

func (x Sequence) Pos() scanner.Position

type Token

type Token struct {
	StringPos scanner.Position
	String    string
}

A Token node represents a literal.

func (*Token) Pos

func (x *Token) Pos() scanner.Position