68 lines
2.3 KiB
Go
68 lines
2.3 KiB
Go
package parsekit
|
|
|
|
import (
|
|
"unicode/utf8"
|
|
)
|
|
|
|
// P holds the internal state of the parser.
|
|
type P struct {
|
|
state StateFn // the function that handles the current state
|
|
nextState StateFn // the function that will handle the next state
|
|
stack []StateFn // state function stack, for nested parsing
|
|
input string // the scanned input
|
|
len int // the total length of the input in bytes
|
|
pos int // current byte scanning position in the input
|
|
newline bool // keep track of when we have scanned a newline
|
|
cursorRow int // current row number in the input
|
|
cursorColumn int // current column position in the input
|
|
buffer stringBuffer // an efficient buffer, used to build string values
|
|
items chan Item // channel of resulting Parser items
|
|
item Item // the current item as reached by Next() and retrieved by Get()
|
|
err *Error // an error when lexing failed, retrieved by Error()
|
|
}
|
|
|
|
// StateFn defines the type of function that can be used to
|
|
// handle a parser state.
|
|
type StateFn func(*P)
|
|
|
|
// ItemType represents the type of a parser Item.
|
|
type ItemType int
|
|
|
|
// ItemEOF is a built-in parser item type that is used for flagging that the
|
|
// end of the input was reached.
|
|
const ItemEOF ItemType = -1
|
|
|
|
// ItemError is a built-in parser item type that is used for flagging that
|
|
// an error has occurred during parsing.
|
|
const ItemError ItemType = -2
|
|
|
|
// Item represents an item returned from the parser.
|
|
type Item struct {
|
|
Type ItemType
|
|
Value string
|
|
}
|
|
|
|
// Error is used as the error type when parsing errors occur.
|
|
// The error includes some extra meta information to allow for useful
|
|
// error messages to the user.
|
|
type Error struct {
|
|
Message string
|
|
Row int
|
|
Column int
|
|
}
|
|
|
|
func (err *Error) Error() string {
|
|
return err.Message
|
|
}
|
|
|
|
// EOF is a special rune, which is used to indicate an end of file when
|
|
// reading a character from the input.
|
|
// It can be treated as a rune when writing parsing rules, so a valid way to
|
|
// say 'I now expect the end of the file' is using something like:
|
|
// if (p.On(c.Rune(EOF)).Skip()) { ... }
|
|
const EOF rune = -1
|
|
|
|
// INVALID is a special rune, which is used to indicate an invalid UTF8
|
|
// rune on the input.
|
|
const INVALID rune = utf8.RuneError
|