Ready-Made Parsers

Parsers for common languages, written in PEGO and generated into Go with pego gen. Each is a Go module of its own that depends only on the standard library and the PEGO runtime (github.com/ornew/pego/runtime): import it and parse, with nothing to generate or compile at run time.

#Install

Until PEGO publishes a release, the ready-made parser modules depend on the github.com/ornew/pego module through a local replace directive (replace github.com/ornew/pego => ../.. in each parser's go.mod). That directive only applies inside the repository, so go get github.com/ornew/pego/parsers/json does not work from another module. Use a parser from a checkout of the repository, in one of two ways.

With a go.work file next to your module's go.mod:

go work init .
go work use ~/src/pego ~/src/pego/parsers/json

or with replace directives in your own go.mod, which the go.mod of the parser cannot supply for you:

require github.com/ornew/pego/parsers/json v0.0.0

replace github.com/ornew/pego/parsers/json => /path/to/pego/parsers/json
replace github.com/ornew/pego => /path/to/pego

(/path/to/pego is the full path of your checkout; go.mod does not expand ~.) Run go mod tidy afterwards to record the requirement of the github.com/ornew/pego module.

import "github.com/ornew/pego/parsers/json"

v, err := json.Decode(`{"name": "pego", "tags": ["peg", "operators-rule"]}`) // map[string]any{...}
ast, err := json.ParseAST(src)                                      // typed values with positions

Every parser has the API of a parser generated with pego gen -types -recognize (see code generation), plus functions written for its language:

Positions are in code points by default; pass Bytes for byte offsets.

#Layout

Each directory holds:

#Development

go generate ./parsers                 # regenerate every parser (after changing a grammar, the runtime or the generator)
go test ./parsers                     # generated files up to date; golden files on every backend of the engine
go test ./parsers -update             # rewrite the golden files from the engine
parsers/test.sh                       # both, and the tests of every module (fetches the test corpora first)
cd parsers/json && go test ./...      # the tests of one module

The generation commands are the go:generate lines of generate.go; the up-to-date test reads them, so a new parser needs only a new line there. The third-party corpora of the tests are fetched, not stored here (see development); a test whose corpus is not fetched is skipped with the command to run. The modules are not part of the main module's go test ./...: run parsers/test.sh after changing the engine or the generator.