antlr4 Go parsers

Compiled by Andrew Brampton (bramp.net)

Precompiled Go parsers of many of the grammars on github.com/antlr/grammars-v4.

The Antlr's Go Target is still a work in progress. As such, many of the grammars fail to compile, or only pass simple tests. To report issues with the grammar go here, to report issues with Antlr's Go Target go here.

Quick Start

Just import one of the parser listed in the table below:

import (
    "bramp.net/antlr4/<name of grammar>"
)

Then the Antlr Lexer, Parser, and Listeners are available. More information on each Grammar's API is found on the godocs with examples.

Full Example (using the json parser)

import (
    "fmt"

    "bramp.net/antlr4/json"                    // The parser
    "github.com/antlr/antlr4/runtime/Go/antlr" // The antlr library
)

// exampleListener is an event-driven callback for the parser.
type exampleListener struct {
    *json.BaseJSONListener // https://godoc.org/bramp.net/antlr4/json#BaseJSONListener
}

func (l *exampleListener) EnterObj(ctx *json.ObjContext) {
    fmt.Printf("Object: %s\n", ctx.GetText())
}

func (l *exampleListener) EnterPair(ctx *json.PairContext) {
    fmt.Printf("Pair: %s\n", ctx.GetText())
}

func (l *exampleListener) EnterArray(ctx *json.ArrayContext) {
    fmt.Printf("Array: %s\n", ctx.GetText())
}

// Example shows how to use the JSON lexer and parser.
func Example() {
    // Setup the input
    is := antlr.NewInputStream(`{"example": "json", "with": ["an", "array"]}`)

    // Create the Lexer
    lexer := json.NewJSONLexer(is)
    stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)

    // Create the Parser
    p := json.NewJSONParser(stream)
    p.BuildParseTrees = true
    p.AddErrorListener(antlr.NewDiagnosticErrorListener(true))

    // Finally walk the tree
    tree := p.Json()
    antlr.ParseTreeWalkerDefault.Walk(&exampleListener{}, tree)

    // Output:
    // Object: {"example":"json","with":["an","array"]}
    // Pair: "example":"json"
    // Pair: "with":["an","array"]
    // Array: ["an","array"]
}

Supported Languages

The failures are broken down like so:

• antlr - ANTLR failed to generate Go code from the grammar.
• build - The generated Go code failed to build.
• test - The generated Go code failed the unit tests for that language.

If you wish to help fix the situation then please submit fixes back to the ANTLR Go target, or the Gramamers Github Repo.

Build

The grammars above are ready to use, but if you wish to change them, or build them yourself for any reason just run:

make <name of grammar>

To update all the grammars

# Fetch the latest set of grammars
git submodule init
git submodule update
git submodule foreach git pull origin master

# Run make and all the magic will happen
make

# Update the table in the README.md with the output

Licence (Apache 2)

Each grammar has its own licence, but the compiled code is licenced under Apache 2.

This is not an official Google product (experimental or otherwise), it is just code that happens to be owned by Google.

Copyright 2017 Google Inc.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.