prattle

This example demonstrates parsing a simple programming language that consists of a sequence of statements.

package main

import (
	"fmt"
	"strconv"
	"unicode"

	"github.com/askeladdk/prattle"
)

const (
	ksemicolon = 1 + iota
	kassign
	kplus
	kident
	knumber
)

func testScan(s *prattle.Scanner) int {
	s.ExpectAny(unicode.IsSpace)
	s.Skip()

	switch {
	case s.Done():
		return 0
	case s.ExpectOne(unicode.IsLetter):
		s.ExpectAny(unicode.IsLetter)
		return kident
	case s.ExpectOne(unicode.IsDigit):
		s.ExpectAny(unicode.IsDigit)
		return knumber
	case s.Expect('='):
		return kassign
	case s.Expect('+'):
		return kplus
	case s.Expect(';'):
		return ksemicolon
	}

	s.Advance()
	return -1
}

type testDriver struct {
	stack  []prattle.Token
	idents map[string]int
}

func (d *testDriver) pop() (v prattle.Token) {
	if n := len(d.stack); n > 0 {
		v, d.stack = d.stack[n-1], d.stack[:n-1]
	}
	return v
}

func (d *testDriver) push(v prattle.Token) {
	d.stack = append(d.stack, v)
}

func (d *testDriver) Precedence(kind int) int {
	return kind
}

func (d *testDriver) tonumber(t prattle.Token) int {
	if t.Kind == kident {
		return d.idents[t.Text]
	}
	num, _ := strconv.Atoi(t.Text)
	return num
}

func (d *testDriver) plus(p *prattle.Parser, t prattle.Token) error {
	if err := p.Parse(d.Precedence(t.Kind)); err != nil {
		return err
	}
	right := d.tonumber(d.pop())
	left := d.tonumber(d.pop())
	d.push(prattle.Token{
		Kind: knumber,
		Text: strconv.Itoa(left + right),
	})
	return nil
}

func (d *testDriver) assign(p *prattle.Parser, t prattle.Token) error {
	if err := p.Parse(d.Precedence(kassign)); err != nil {
		return err
	}

	right := d.pop()
	left := d.pop()
	d.idents[left.Text] = d.tonumber(right)
	return nil
}

func (d *testDriver) primitive(p *prattle.Parser, t prattle.Token) error {
	d.push(t)
	return nil
}

func (d *testDriver) Prefix(kind int) prattle.ParseFunc {
	switch kind {
	default:
		return nil
	case kident, knumber:
		return d.primitive
	}
}

func (d *testDriver) Infix(kind int) prattle.ParseFunc {
	switch kind {
	default:
		return nil
	case kplus:
		return d.plus
	case kassign:
		return d.assign
	}
}

func (d *testDriver) ParseError(t prattle.Token) error {
	return fmt.Errorf("%s: unexpected '%s'", t.Position, t.Text)
}

// This example demonstrates parsing a simple programming language that consists of a sequence of statements.
func main() {
	c := testDriver{
		idents: make(map[string]int),
	}

	source := "a = 1;\nb = 2;\nc = a+b+b+a;\n"

	s := prattle.Scanner{Scan: testScan}
	p := prattle.Parser{Driver: &c}
	p.Init(s.InitWithString(source))

	// Parse expressions separated by semicolons.
	for p.Peek().Kind != 0 {
		if err := p.Parse(ksemicolon); err != nil {
			fmt.Println(err)
			return
		} else if !p.Expect(ksemicolon) {
			fmt.Println("expected semicolon")
			return
		}
	}

	fmt.Printf("c = %d\n", c.idents["c"])

}

Output:
c = 6

This example is described in the readme.

package main

import (
	"fmt"
	"strconv"
	"unicode"

	"github.com/askeladdk/prattle"
)

type driver struct {
	stack []int
}

func (d *driver) push(i int) {
	d.stack = append(d.stack, i)
}

func (d *driver) pop() (i int) {
	n := len(d.stack)
	i, d.stack = d.stack[n-1], d.stack[:n-1]
	return
}

func (d *driver) number(p *prattle.Parser, t prattle.Token) error {
	n, _ := strconv.Atoi(t.Text)
	d.push(n)
	return nil
}

func (d *driver) add(p *prattle.Parser, t prattle.Token) error {
	// First parse the right hand operator.
	if err := p.Parse(d.Precedence(t.Kind)); err != nil {
		return err
	}

	right := d.pop()
	left := d.pop()
	acc := left + right
	fmt.Printf("%d + %d = %d\n", left, right, acc)
	d.push(acc)
	return nil
}

func (d *driver) Prefix(k int) prattle.ParseFunc {
	if k == 2 {
		return d.number
	}
	return nil
}

func (d *driver) Infix(k int) prattle.ParseFunc {
	if k == 1 {
		return d.add
	}
	return nil
}

func (d *driver) Precedence(k int) int {
	return k
}

func (d *driver) ParseError(t prattle.Token) error {
	return fmt.Errorf("%s", t)
}

// This example is described in the readme.
func main() {
	scanner := prattle.Scanner{
		Scan: func(s *prattle.Scanner) int {
			// Skip whitespaces.
			s.ExpectAny(unicode.IsSpace)
			s.Skip()
			switch {
			case s.Done(): // Stop if the entire input has been consumed.
				return 0
			case s.Expect('+'):
				return 1
			case s.ExpectOne(unicode.IsDigit): // Read a number consisting of one or more digits.
				s.ExpectAny(unicode.IsDigit)
				return 2
			}

			s.Advance()
			return -1
		},
	}

	parser := prattle.Parser{
		Driver: &driver{},
	}

	source := "1 + 23 + 456 + 7890"
	scanner.InitWithString(source)
	if err := parser.Init(&scanner).Parse(0); err != nil {
		fmt.Println(err)
	}

}

Output:
1 + 23 = 24
24 + 456 = 480
480 + 7890 = 8370

This example demonstrates tokenising a sentence into words and punctuation.

package main

import (
	"fmt"
	"unicode"

	"github.com/askeladdk/prattle"
)

func main() {
	scan := func(s *prattle.Scanner) int {
		// Skip any whitespace.
		s.ExpectAny(unicode.IsSpace)
		s.Skip()

		// Return an appropriate token kind.
		switch {
		case s.Done(): // EOF
			return 0
		case s.ExpectOne(unicode.IsLetter): // Word
			s.ExpectAny(unicode.IsLetter)
			return 1
		case s.ExpectOne(unicode.IsPunct): // Punctuation
			return 2
		}

		// Unrecognized character.
		s.Advance()
		return -1
	}

	sentence := "I love it when a plan comes together!"

	s := (&prattle.Scanner{
		Scan: scan,
	}).InitWithString(sentence)

	for tok, ok := s.Next(); ok; tok, ok = s.Next() {
		fmt.Printf("[%d] %s\n", tok.Kind, tok.Text)
	}

}

Output:
[1] I
[1] love
[1] it
[1] when
[1] a
[1] plan
[1] comes
[1] together
[2] !