json

README

JSON

This package is a JSON lexer (ECMA-404) written in Go. It follows the specification at JSON. The lexer takes an io.Reader and converts it into tokens until the EOF.

Installation

Run the following command

go get github.com/tdewolff/parse/json

or add the following import and run project with go get

import "github.com/tdewolff/parse/json"

Parser

Usage

The following initializes a new Parser with io.Reader r:

p := json.NewParser(r)

To tokenize until EOF an error, use:

for {
	gt, text := p.Next()
	switch gt {
	case json.ErrorGrammar:
		// error or EOF set in p.Err()
		return
	// ...
	}
}

All grammars:

ErrorGrammar       GrammarType = iota // extra grammar when errors occur
WhitespaceGrammar                     // space \t \r \n
LiteralGrammar                        // null true false
NumberGrammar
StringGrammar
StartObjectGrammar // {
EndObjectGrammar   // }
StartArrayGrammar  // [
EndArrayGrammar    // ]

Examples

package main

import (
	"os"

	"github.com/tdewolff/parse/json"
)

// Tokenize JSON from stdin.
func main() {
	p := json.NewParser(os.Stdin)
	for {
		gt, text := p.Next()
		switch gt {
		case json.ErrorGrammar:
			if p.Err() != io.EOF {
				fmt.Println("Error on line", p.Line(), ":", p.Err())
			}
			return
		case json.LiteralGrammar:
			fmt.Println("Literal", string(text))
		case json.NumberGrammar:
			fmt.Println("Number", string(text))
		// ...
		}
	}
}

License

Released under the MIT license.

Documentation

Overview

Package json is a JSON parser following the specifications at http://json.org/.

Index

• type GrammarType
  • func (gt GrammarType) String() string
• type Parser
  • func NewParser(r io.Reader) *Parser
  • func (p *Parser) Err() error
  • func (p *Parser) Next() (GrammarType, []byte)
  • func (p *Parser) Restore()
  • func (p *Parser) State() State
• type State
  • func (state State) String() string

Examples

• NewParser

Types

type GrammarType

type GrammarType uint32

GrammarType determines the type of grammar

const (
	ErrorGrammar GrammarType = iota // extra grammar when errors occur
	WhitespaceGrammar
	LiteralGrammar
	NumberGrammar
	StringGrammar
	StartObjectGrammar // {
	EndObjectGrammar   // }
	StartArrayGrammar  // [
	EndArrayGrammar    // ]
)

GrammarType values.

func (GrammarType) String

func (gt GrammarType) String() string

String returns the string representation of a GrammarType.

type Parser

type Parser struct {
	// contains filtered or unexported fields
}

Parser is the state for the lexer.

func NewParser

func NewParser(r io.Reader) *Parser

NewParser returns a new Parser for a given io.Reader.

Example

p := NewParser(bytes.NewBufferString(`{"key": 5}`))
out := ""
for {
	state := p.State()
	gt, data := p.Next()
	if gt == ErrorGrammar {
		break
	}
	out += string(data)
	if state == ObjectKeyState && gt != EndObjectGrammar {
		out += ":"
	}
	// not handling comma insertion
}
fmt.Println(out)

Output:

{"key":5}

func (*Parser) Err

func (p *Parser) Err() error

Err returns the error encountered during tokenization, this is often io.EOF but also other errors can be returned.

func (*Parser) Next

func (p *Parser) Next() (GrammarType, []byte)

Next returns the next Grammar. It returns ErrorGrammar when an error was encountered. Using Err() one can retrieve the error message.

func (*Parser) Restore

func (p *Parser) Restore()

Restore restores the NULL byte at the end of the buffer.

func (*Parser) State

func (p *Parser) State() State

State returns the state the parser is currently in (ie. which token is expected).

type State

type State uint32

State determines the current state the parser is in.

const (
	ValueState State = iota // extra token when errors occur
	ObjectKeyState
	ObjectValueState
	ArrayState
)

State values.

func (State) String

func (state State) String() string

String returns the string representation of a State.