abnf

type Alternation ¶

type Alternation struct {
	Concatenations []*Concatenation
}

Alternation is an ABNF alternation: a choice between concatenations.

func (alternation *Alternation) String() string

type CharValElement ¶

type CharValElement struct {
	Sensitive bool
	Value     string
}

CharValElement is an ABNF char-val element: a literal string of printable US-ASCII characters. Matching is case-insensitive unless Sensitive is set (the RFC 7405 "%s" form).

func (element *CharValElement) String() string

type Concatenation ¶

type Concatenation struct {
	Repetitions []*Repetition
}

Concatenation is an ABNF concatenation: an ordered sequence of repetitions.

func (concatenation *Concatenation) String() string

type CoreRuleModificationError ¶

type CoreRuleModificationError struct {
	Rulename string
}

CoreRuleModificationError is returned when a grammar attempts to redefine or extend a core rule.

func (coreRuleModificationError *CoreRuleModificationError) Error() string

type DependencyNotFoundError ¶

type DependencyNotFoundError struct {
	Rulename string
}

DependencyNotFoundError is returned during semantic validation when a rule references a rule that does not exist.

func (dependencyNotFoundError *DependencyNotFoundError) Error() string

type DuplicatedRuleError ¶

type DuplicatedRuleError struct {
	Rulename string
}

DuplicatedRuleError is returned when a grammar defines the same rule more than once.

func (duplicatedRuleError *DuplicatedRuleError) Error() string

type Element ¶

type Element interface {
	fmt.Stringer
	// contains filtered or unexported methods
}

Element is the interface implemented by all ABNF element variants: *RulenameElement, *GroupElement, *OptionElement, *CharValElement, *NumValElement and *ProseValElement.

type Grammar ¶

type Grammar struct {
	// Rules holds the rules in definition order.
	Rules []*Rule
	// Rulemap indexes the rules of Rules by lowercase rule name.
	Rulemap map[string]*Rule
}

Grammar is an ABNF grammar as defined by RFC 5234: a set of uniquely named rules.

func ParseABNF(input []byte) (*Grammar, error)

func (grammar *Grammar) Rule(rulename string) *Rule

func (grammar *Grammar) String() string

type GroupElement ¶

type GroupElement struct {
	Alternation *Alternation
}

GroupElement is an ABNF group element: a parenthesised alternation.

func (element *GroupElement) String() string

type InvalidNumeralError ¶

type InvalidNumeralError struct {
	Base, Value string
}

InvalidNumeralError is returned when a num-val numeral cannot be represented as a Unicode code point in its base.

func (invalidNumeralError *InvalidNumeralError) Error() string

type InvalidRepetitionError ¶

type InvalidRepetitionError struct {
	Repetition *Repetition
}

InvalidRepetitionError is returned during semantic validation when a repetition has a minimum greater than its maximum.

func (invalidRepetitionError *InvalidRepetitionError) Error() string

type ListElement ¶ added in v1.14.0

type ListElement struct {
	Min, Max int
	Element  Element
	// Expansion is the standard ABNF the operator stands for, as
	// RFC 7230 Section 7 gives it. It holds Element itself rather than a
	// copy of it, so rewriting an element of a parsed grammar in place
	// rewrites it here too; treat a list element as a whole.
	Expansion *Alternation
}

ListElement is the "#" list operator of RFC 9110 Section 5.6.1: a list of Min to Max occurrences of an element, separated by commas and optional whitespace. Max may be Inf.

RFC 5234 defines no such operator. The HTTP specifications define it in terms of standard ABNF, and Expansion holds that standard ABNF, which is what matching against the element uses.

func (element *ListElement) String() string

type MultipleSolutionsFoundError ¶

type MultipleSolutionsFoundError struct {
	Paths []*Path
}

MultipleSolutionsFoundError is returned when parsing found multiple solutions where at most one was expected.

func (multipleSolutionsFoundError *MultipleSolutionsFoundError) Error() string

type NumValElement ¶

type NumValElement struct {
	// Base is the num-val base character: "b", "d" or "x".
	Base   string
	Status NumValStatus
	Values []string
}

NumValElement is an ABNF num-val element: numeric character values in a given base, either as a series or as a range.

func (element *NumValElement) String() string

type NumValStatus ¶

type NumValStatus int

NumValStatus defines how the values of a NumValElement combine.

const (
	// NumValStatusSeries matches each value in order.
	NumValStatusSeries NumValStatus = iota
	// NumValStatusRange matches any value within the two bounds.
	NumValStatusRange
)

type OptionElement ¶

type OptionElement struct {
	Alternation *Alternation
}

OptionElement is an ABNF option element: a bracketed alternation, equivalent to a 0*1 repetition of it.

func (element *OptionElement) String() string

type Path ¶

type Path struct {
	// Subpaths are the ordered child paths.
	Subpaths []*Path
	// MatchRule is the name of the matched rule in the source grammar, or
	// empty for structural paths.
	MatchRule string
	// Start and End delimit the matched input bytes; Start <= End.
	Start, End int
}

Path describes a portion of an input that matched a grammar rule, from a start index to an end index, with a composite structure.

func Parse(input []byte, grammar *Grammar, rootRulename string) ([]*Path, error)

type ProseValElement ¶

type ProseValElement struct {
	Value string
}

ProseValElement is an ABNF prose-val element: a free-form prose description that cannot be matched against input.

func (element *ProseValElement) String() string

type Repetition ¶

type Repetition struct {
	Min, Max int
	Element  Element
}

Repetition is an ABNF repetition of an element. Max may be Inf (-1) for an unbounded repetition.

func (repetition *Repetition) String() string

type Rule ¶

type Rule struct {
	// Name is the rule name, case-insensitive according to RFC 5234
	// Section 2.1.
	Name        string
	Alternation *Alternation
}

Rule is an ABNF rule: a unique name and its defining alternation.

func (rule *Rule) String() string

type RuleNotFoundError ¶

type RuleNotFoundError struct {
	Rulename string
}

RuleNotFoundError is returned when a rule is not part of the grammar.

func (ruleNotFoundError *RuleNotFoundError) Error() string

type RulenameElement ¶

type RulenameElement struct {
	// Name is the referenced rule name, case-insensitive according to
	// RFC 5234 Section 2.1.
	Name string
}

RulenameElement is an ABNF rulename element: a reference to another rule.

func (element *RulenameElement) String() string