gordy

README

Gordy the Recursive Descent Parser Helper for Golang

This is a small library that provides helpers for building recursive descent parsers by hand.

Documentation

Overview

Package gordy provides recursive descent parser helpers. This provides objects, functions, and methods to help build a recursive descent parser.

Index

• type ATag
• type Match
  • func BuildMatch(t ATag, ms ...interface{}) (m *Match)
  • func MatchLongest(cs []byte, ms ...Matcher) (*Match, []byte)
  • func MatchMany(t ATag, cs []byte, min int, mtch Matcher) (*Match, []byte)
  • func MatchManyWithSep(t ATag, cs []byte, min int, mtch Matcher, sep Matcher) (*Match, []byte)
  • func MatchOne(t ATag, cs []byte, pred func(c byte) bool) (*Match, []byte)
  • func MatchOneRune(t ATag, cs []byte, c rune) (*Match, []byte)
  • func (m *Match) Length() int
• type Matcher

Types

type ATag

type ATag int

ATag is the type used to tag matches by type.

const (
	TNone ATag = iota
	TLiteral
	TLast
)

A few standard tags for matches.

type Match

type Match struct {
	Tag      ATag              // an identifier describing what the match represents
	Content  []byte            // the full content of the match
	Group    map[string]*Match // identifies named submatches
	Submatch []*Match          // identifies a list of submatches
	Made     interface{}       // a place to put high-level objects generated from this match
}

Match is the object used to represent some segment of a parsed string.

func BuildMatch

func BuildMatch(t ATag, ms ...interface{}) (m *Match)

BuildMatch is a short hand for building a match with named submatches.

func MatchLongest

func MatchLongest(cs []byte, ms ...Matcher) (*Match, []byte)

MatchLongest tries all the given matchers against the current input. It then returns whichever of these matches works to match the most input.

func MatchMany

func MatchMany(t ATag, cs []byte, min int, mtch Matcher) (*Match, []byte)

MatchMany matches the given matcher as many times as possible one after another on the input. If the number of matches is fewer than min, it returns a failure.

func MatchManyWithSep

func MatchManyWithSep(t ATag, cs []byte, min int, mtch Matcher, sep Matcher) (*Match, []byte)

MatchManyWithSep matches the given matcher against the input provided that the separator matcher matches in between. It returns a match containing those matches. If fewer than min matches are present, the match returns no match.

func MatchOne

func MatchOne(t ATag, cs []byte, pred func(c byte) bool) (*Match, []byte)

MatchOne matches exactly one byte if the next byte in the input matches the given predicate.

func MatchOneRune

func MatchOneRune(t ATag, cs []byte, c rune) (*Match, []byte)

MatchOneRune matches the next byte if it exactly matches the given rune.

func (*Match) Length

func (m *Match) Length() int

Length returns the number of bytes matched for this match.

type Matcher

type Matcher func(cs []byte) (*Match, []byte)

Matcher is the type for matching functions. These accept a list of bytes to start matching from and return a pointer to a Match and a list of remaining unmatched bytes.

If the match is successful, then a pointer to a Match is returned and the remaining input is also returned. It is possible for a match to match zero bytes.

If the match fails, then the Match should be returned as nil. Usually the remaining input is also returned as nil in that case.