initial commit

Author: swilly22

helpers.go

@@ -0,0 +1,15 @@
+package json_parser
+
+import (
+	"strings"
+)
+
+func isNumeric(r rune) bool {
+	digits := "+-0987654321"
+	return strings.IndexRune(digits, r) >= 0
+}
+
+func isAlphaNumeric(r rune) bool {
+	digits := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+	return strings.IndexRune(digits, r) >= 0
+}

item.go

@@ -0,0 +1,51 @@
+package json_parser
+
+import (
+	"fmt"
+)
+
+// item represents a token returned from the scanner.
+type item struct {
+	typ itemType // Type, such as itemNumber.
+	val string   // Value, such as "23.2"
+}
+
+func (i item) String() string {
+	switch i.typ {
+	case itemEOF:
+		return "EOF"
+	case itemError:
+		return i.val
+	}
+	if len(i.val) > 10 {
+		return fmt.Sprintf("%.10q...", i.val)
+	}
+	return fmt.Sprintf("%q", i.val)
+}
+
+// itemType identifies the type of lex items.
+type itemType int
+
+const (
+	itemError itemType = iota // error occurred
+	itemText
+	itemLeftMeta
+	itemRightMeta
+	itemLeftBracket
+	itemRightBracket
+	itemIdentifier
+	itemNumber
+	itemString
+	itemComma
+	itemEOF
+)
+
+const (
+	eof           = -1
+	leftMeta      = '{'
+	rightMeta     = '}'
+	leftBracket   = '['
+	rightBracket  = ']'
+	comma         = ','
+	quotationMark = '"'
+)

lexer.go

@@ -0,0 +1,101 @@
+package json_parser
+
+import (
+	"fmt"
+	"strings"
+	"unicode/utf8"
+)
+
+type lexer struct {
+	name  string    // used only for error reports.
+	input string    // the string being scanned.
+	start int       // start position of this item.
+	pos   int       // current position in the input.
+	width int       // width of last rune read.
+	items chan item // channel of scanned items.
+}
+
+func Lex(name, input string) (*lexer, chan item) {
+	l := &lexer{
+		name:  name,
+		input: input,
+		items: make(chan item, 2),
+	}
+
+	go l.run() // Concurrently run state machine.
+	return l, l.items
+}
+
+// run lexes the input by executing state functions untill
+// the state is nil.
+func (l *lexer) run() {
+	for state := initState; state != nil; {
+		state = state(l)
+	}
+	close(l.items) // No more tokens will be delivered.
+}
+
+// emit passes an item back to the client.
+func (l *lexer) emit(t itemType) {
+	l.items <- item{t, l.input[l.start:l.pos]}
+	l.start = l.pos
+}
+
+func (l *lexer) next() rune {
+	if l.pos >= len(l.input) {
+		l.width = 0
+		return eof
+	}
+
+	r, width := utf8.DecodeRuneInString(l.input[l.pos:])
+	l.width = width
+	l.pos += l.width
+	return r
+}
+
+// ignore skips over the pending input before this point.
+func (l *lexer) ignore() {
+	l.start = l.pos
+}
+
+// backup steps bacl one rune.
+// Can be called only once per call of next.
+func (l *lexer) backup() {
+	l.pos -= l.width
+}
+
+// peek returns but does not consume
+// the next rune in the input.
+func (l *lexer) peek() rune {
+	r := l.next()
+	l.backup()
+	return r
+}
+
+// accept consumes the next rune
+// if it's from the valid set
+func (l *lexer) accept(valid string) bool {
+	if strings.IndexRune(valid, l.next()) >= 0 {
+		return true
+	}
+	l.backup()
+	return false
+}
+
+// acceptRun consumes a run of runes from the valid set.
+func (l *lexer) acceptRun(valid string) {
+	for strings.IndexRune(valid, l.next()) >= 0 {
+	}
+	l.backup()
+}
+
+// errorf returns an error token and terminates the scan
+// by passing back a nil pointer that will be the next
+// state, terminating l.run
+func (l *lexer) errorf(format string, args ...interface{}) stateFunc {
+	l.items <- item{
+		itemError,
+		fmt.Sprintf(format, args...),
+	}
+	return nil
+}