1363 lines
24 KiB
Go
1363 lines
24 KiB
Go
package bleve
|
|
|
|
import (
|
|
"bufio"
|
|
"io"
|
|
"strings"
|
|
)
|
|
|
|
type frame struct {
|
|
i int
|
|
s string
|
|
line, column int
|
|
}
|
|
type lexer struct {
|
|
// The lexer runs in its own goroutine, and communicates via channel 'ch'.
|
|
ch chan frame
|
|
// We record the level of nesting because the action could return, and a
|
|
// subsequent call expects to pick up where it left off. In other words,
|
|
// we're simulating a coroutine.
|
|
// TODO: Support a channel-based variant that compatible with Go's yacc.
|
|
stack []frame
|
|
stale bool
|
|
|
|
// The 'l' and 'c' fields were added for
|
|
// https://github.com/wagerlabs/docker/blob/65694e801a7b80930961d70c69cba9f2465459be/buildfile.nex
|
|
// Since then, I introduced the built-in Line() and Column() functions.
|
|
l, c int
|
|
|
|
// The following line makes it easy for scripts to insert fields in the
|
|
// generated code.
|
|
// [NEX_END_OF_LEXER_STRUCT]
|
|
}
|
|
|
|
// newLexerWithInit creates a new lexer object, runs the given callback on it,
|
|
// then returns it.
|
|
func newLexerWithInit(in io.Reader, initFun func(*lexer)) *lexer {
|
|
type dfa struct {
|
|
acc []bool // Accepting states.
|
|
f []func(rune) int // Transitions.
|
|
startf, endf []int // Transitions at start and end of input.
|
|
nest []dfa
|
|
}
|
|
yylex := new(lexer)
|
|
if initFun != nil {
|
|
initFun(yylex)
|
|
}
|
|
yylex.ch = make(chan frame)
|
|
var scan func(in *bufio.Reader, ch chan frame, family []dfa, line, column int)
|
|
scan = func(in *bufio.Reader, ch chan frame, family []dfa, line, column int) {
|
|
// Index of DFA and length of highest-precedence match so far.
|
|
matchi, matchn := 0, -1
|
|
var buf []rune
|
|
n := 0
|
|
checkAccept := func(i int, st int) bool {
|
|
// Higher precedence match? DFAs are run in parallel, so matchn is at most len(buf), hence we may omit the length equality check.
|
|
if family[i].acc[st] && (matchn < n || matchi > i) {
|
|
matchi, matchn = i, n
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
var state [][2]int
|
|
for i := 0; i < len(family); i++ {
|
|
mark := make([]bool, len(family[i].startf))
|
|
// Every DFA starts at state 0.
|
|
st := 0
|
|
for {
|
|
state = append(state, [2]int{i, st})
|
|
mark[st] = true
|
|
// As we're at the start of input, follow all ^ transitions and append to our list of start states.
|
|
st = family[i].startf[st]
|
|
if -1 == st || mark[st] {
|
|
break
|
|
}
|
|
// We only check for a match after at least one transition.
|
|
checkAccept(i, st)
|
|
}
|
|
}
|
|
atEOF := false
|
|
for {
|
|
if n == len(buf) && !atEOF {
|
|
r, _, err := in.ReadRune()
|
|
switch err {
|
|
case io.EOF:
|
|
atEOF = true
|
|
case nil:
|
|
buf = append(buf, r)
|
|
default:
|
|
panic(err)
|
|
}
|
|
}
|
|
if !atEOF {
|
|
r := buf[n]
|
|
n++
|
|
var nextState [][2]int
|
|
for _, x := range state {
|
|
x[1] = family[x[0]].f[x[1]](r)
|
|
if -1 == x[1] {
|
|
continue
|
|
}
|
|
nextState = append(nextState, x)
|
|
checkAccept(x[0], x[1])
|
|
}
|
|
state = nextState
|
|
} else {
|
|
dollar: // Handle $.
|
|
for _, x := range state {
|
|
mark := make([]bool, len(family[x[0]].endf))
|
|
for {
|
|
mark[x[1]] = true
|
|
x[1] = family[x[0]].endf[x[1]]
|
|
if -1 == x[1] || mark[x[1]] {
|
|
break
|
|
}
|
|
if checkAccept(x[0], x[1]) {
|
|
// Unlike before, we can break off the search. Now that we're at the end, there's no need to maintain the state of each DFA.
|
|
break dollar
|
|
}
|
|
}
|
|
}
|
|
state = nil
|
|
}
|
|
|
|
if state == nil {
|
|
lcUpdate := func(r rune) {
|
|
if r == '\n' {
|
|
line++
|
|
column = 0
|
|
} else {
|
|
column++
|
|
}
|
|
}
|
|
// All DFAs stuck. Return last match if it exists, otherwise advance by one rune and restart all DFAs.
|
|
if matchn == -1 {
|
|
if len(buf) == 0 { // This can only happen at the end of input.
|
|
break
|
|
}
|
|
lcUpdate(buf[0])
|
|
buf = buf[1:]
|
|
} else {
|
|
text := string(buf[:matchn])
|
|
buf = buf[matchn:]
|
|
matchn = -1
|
|
ch <- frame{matchi, text, line, column}
|
|
if len(family[matchi].nest) > 0 {
|
|
scan(bufio.NewReader(strings.NewReader(text)), ch, family[matchi].nest, line, column)
|
|
}
|
|
if atEOF {
|
|
break
|
|
}
|
|
for _, r := range text {
|
|
lcUpdate(r)
|
|
}
|
|
}
|
|
n = 0
|
|
for i := 0; i < len(family); i++ {
|
|
state = append(state, [2]int{i, 0})
|
|
}
|
|
}
|
|
}
|
|
ch <- frame{-1, "", line, column}
|
|
}
|
|
go scan(bufio.NewReader(in), yylex.ch, []dfa{
|
|
// \"((\\\")|(\\\\)|(\\\/)|(\\b)|(\\f)|(\\n)|(\\r)|(\\t)|(\\u[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F])|[^\"])*\"
|
|
{[]bool{false, false, false, true, false, false, false, true, false, false, false, false, false, false, false, false, false, false}, []func(rune) int{ // Transitions
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return 1
|
|
case 47:
|
|
return -1
|
|
case 92:
|
|
return -1
|
|
case 98:
|
|
return -1
|
|
case 102:
|
|
return -1
|
|
case 110:
|
|
return -1
|
|
case 114:
|
|
return -1
|
|
case 116:
|
|
return -1
|
|
case 117:
|
|
return -1
|
|
}
|
|
switch {
|
|
case 97 <= r && r <= 102:
|
|
return -1
|
|
case 65 <= r && r <= 70:
|
|
return -1
|
|
case 48 <= r && r <= 57:
|
|
return -1
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return 3
|
|
case 47:
|
|
return 2
|
|
case 92:
|
|
return 4
|
|
case 98:
|
|
return 2
|
|
case 102:
|
|
return 2
|
|
case 110:
|
|
return 2
|
|
case 114:
|
|
return 2
|
|
case 116:
|
|
return 2
|
|
case 117:
|
|
return 2
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 57:
|
|
return 2
|
|
case 65 <= r && r <= 70:
|
|
return 2
|
|
case 97 <= r && r <= 102:
|
|
return 2
|
|
}
|
|
return 2
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return 3
|
|
case 47:
|
|
return 2
|
|
case 92:
|
|
return 4
|
|
case 98:
|
|
return 2
|
|
case 102:
|
|
return 2
|
|
case 110:
|
|
return 2
|
|
case 114:
|
|
return 2
|
|
case 116:
|
|
return 2
|
|
case 117:
|
|
return 2
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 57:
|
|
return 2
|
|
case 65 <= r && r <= 70:
|
|
return 2
|
|
case 97 <= r && r <= 102:
|
|
return 2
|
|
}
|
|
return 2
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return -1
|
|
case 47:
|
|
return -1
|
|
case 92:
|
|
return -1
|
|
case 98:
|
|
return -1
|
|
case 102:
|
|
return -1
|
|
case 110:
|
|
return -1
|
|
case 114:
|
|
return -1
|
|
case 116:
|
|
return -1
|
|
case 117:
|
|
return -1
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 57:
|
|
return -1
|
|
case 65 <= r && r <= 70:
|
|
return -1
|
|
case 97 <= r && r <= 102:
|
|
return -1
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return 7
|
|
case 47:
|
|
return 8
|
|
case 92:
|
|
return 12
|
|
case 98:
|
|
return 13
|
|
case 102:
|
|
return 9
|
|
case 110:
|
|
return 10
|
|
case 114:
|
|
return 5
|
|
case 116:
|
|
return 6
|
|
case 117:
|
|
return 11
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 57:
|
|
return 2
|
|
case 65 <= r && r <= 70:
|
|
return 2
|
|
case 97 <= r && r <= 102:
|
|
return 2
|
|
}
|
|
return 2
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return 3
|
|
case 47:
|
|
return 2
|
|
case 92:
|
|
return 4
|
|
case 98:
|
|
return 2
|
|
case 102:
|
|
return 2
|
|
case 110:
|
|
return 2
|
|
case 114:
|
|
return 2
|
|
case 116:
|
|
return 2
|
|
case 117:
|
|
return 2
|
|
}
|
|
switch {
|
|
case 97 <= r && r <= 102:
|
|
return 2
|
|
case 65 <= r && r <= 70:
|
|
return 2
|
|
case 48 <= r && r <= 57:
|
|
return 2
|
|
}
|
|
return 2
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return 3
|
|
case 47:
|
|
return 2
|
|
case 92:
|
|
return 4
|
|
case 98:
|
|
return 2
|
|
case 102:
|
|
return 2
|
|
case 110:
|
|
return 2
|
|
case 114:
|
|
return 2
|
|
case 116:
|
|
return 2
|
|
case 117:
|
|
return 2
|
|
}
|
|
switch {
|
|
case 97 <= r && r <= 102:
|
|
return 2
|
|
case 65 <= r && r <= 70:
|
|
return 2
|
|
case 48 <= r && r <= 57:
|
|
return 2
|
|
}
|
|
return 2
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return 3
|
|
case 47:
|
|
return 2
|
|
case 92:
|
|
return 4
|
|
case 98:
|
|
return 2
|
|
case 102:
|
|
return 2
|
|
case 110:
|
|
return 2
|
|
case 114:
|
|
return 2
|
|
case 116:
|
|
return 2
|
|
case 117:
|
|
return 2
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 57:
|
|
return 2
|
|
case 97 <= r && r <= 102:
|
|
return 2
|
|
case 65 <= r && r <= 70:
|
|
return 2
|
|
}
|
|
return 2
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return 3
|
|
case 47:
|
|
return 2
|
|
case 92:
|
|
return 4
|
|
case 98:
|
|
return 2
|
|
case 102:
|
|
return 2
|
|
case 110:
|
|
return 2
|
|
case 114:
|
|
return 2
|
|
case 116:
|
|
return 2
|
|
case 117:
|
|
return 2
|
|
}
|
|
switch {
|
|
case 97 <= r && r <= 102:
|
|
return 2
|
|
case 65 <= r && r <= 70:
|
|
return 2
|
|
case 48 <= r && r <= 57:
|
|
return 2
|
|
}
|
|
return 2
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return 3
|
|
case 47:
|
|
return 2
|
|
case 92:
|
|
return 4
|
|
case 98:
|
|
return 2
|
|
case 102:
|
|
return 2
|
|
case 110:
|
|
return 2
|
|
case 114:
|
|
return 2
|
|
case 116:
|
|
return 2
|
|
case 117:
|
|
return 2
|
|
}
|
|
switch {
|
|
case 65 <= r && r <= 70:
|
|
return 2
|
|
case 97 <= r && r <= 102:
|
|
return 2
|
|
case 48 <= r && r <= 57:
|
|
return 2
|
|
}
|
|
return 2
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return 3
|
|
case 47:
|
|
return 2
|
|
case 92:
|
|
return 4
|
|
case 98:
|
|
return 2
|
|
case 102:
|
|
return 2
|
|
case 110:
|
|
return 2
|
|
case 114:
|
|
return 2
|
|
case 116:
|
|
return 2
|
|
case 117:
|
|
return 2
|
|
}
|
|
switch {
|
|
case 97 <= r && r <= 102:
|
|
return 2
|
|
case 65 <= r && r <= 70:
|
|
return 2
|
|
case 48 <= r && r <= 57:
|
|
return 2
|
|
}
|
|
return 2
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return 3
|
|
case 47:
|
|
return 2
|
|
case 92:
|
|
return 4
|
|
case 98:
|
|
return 14
|
|
case 102:
|
|
return 14
|
|
case 110:
|
|
return 2
|
|
case 114:
|
|
return 2
|
|
case 116:
|
|
return 2
|
|
case 117:
|
|
return 2
|
|
}
|
|
switch {
|
|
case 97 <= r && r <= 102:
|
|
return 14
|
|
case 48 <= r && r <= 57:
|
|
return 14
|
|
case 65 <= r && r <= 70:
|
|
return 14
|
|
}
|
|
return 2
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return 7
|
|
case 47:
|
|
return 8
|
|
case 92:
|
|
return 12
|
|
case 98:
|
|
return 13
|
|
case 102:
|
|
return 9
|
|
case 110:
|
|
return 10
|
|
case 114:
|
|
return 5
|
|
case 116:
|
|
return 6
|
|
case 117:
|
|
return 11
|
|
}
|
|
switch {
|
|
case 97 <= r && r <= 102:
|
|
return 2
|
|
case 65 <= r && r <= 70:
|
|
return 2
|
|
case 48 <= r && r <= 57:
|
|
return 2
|
|
}
|
|
return 2
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return 3
|
|
case 47:
|
|
return 2
|
|
case 92:
|
|
return 4
|
|
case 98:
|
|
return 2
|
|
case 102:
|
|
return 2
|
|
case 110:
|
|
return 2
|
|
case 114:
|
|
return 2
|
|
case 116:
|
|
return 2
|
|
case 117:
|
|
return 2
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 57:
|
|
return 2
|
|
case 97 <= r && r <= 102:
|
|
return 2
|
|
case 65 <= r && r <= 70:
|
|
return 2
|
|
}
|
|
return 2
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return 3
|
|
case 47:
|
|
return 2
|
|
case 92:
|
|
return 4
|
|
case 98:
|
|
return 15
|
|
case 102:
|
|
return 15
|
|
case 110:
|
|
return 2
|
|
case 114:
|
|
return 2
|
|
case 116:
|
|
return 2
|
|
case 117:
|
|
return 2
|
|
}
|
|
switch {
|
|
case 97 <= r && r <= 102:
|
|
return 15
|
|
case 65 <= r && r <= 70:
|
|
return 15
|
|
case 48 <= r && r <= 57:
|
|
return 15
|
|
}
|
|
return 2
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return 3
|
|
case 47:
|
|
return 2
|
|
case 92:
|
|
return 4
|
|
case 98:
|
|
return 16
|
|
case 102:
|
|
return 16
|
|
case 110:
|
|
return 2
|
|
case 114:
|
|
return 2
|
|
case 116:
|
|
return 2
|
|
case 117:
|
|
return 2
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 57:
|
|
return 16
|
|
case 97 <= r && r <= 102:
|
|
return 16
|
|
case 65 <= r && r <= 70:
|
|
return 16
|
|
}
|
|
return 2
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return 3
|
|
case 47:
|
|
return 2
|
|
case 92:
|
|
return 4
|
|
case 98:
|
|
return 17
|
|
case 102:
|
|
return 17
|
|
case 110:
|
|
return 2
|
|
case 114:
|
|
return 2
|
|
case 116:
|
|
return 2
|
|
case 117:
|
|
return 2
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 57:
|
|
return 17
|
|
case 97 <= r && r <= 102:
|
|
return 17
|
|
case 65 <= r && r <= 70:
|
|
return 17
|
|
}
|
|
return 2
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 34:
|
|
return 3
|
|
case 47:
|
|
return 2
|
|
case 92:
|
|
return 4
|
|
case 98:
|
|
return 2
|
|
case 102:
|
|
return 2
|
|
case 110:
|
|
return 2
|
|
case 114:
|
|
return 2
|
|
case 116:
|
|
return 2
|
|
case 117:
|
|
return 2
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 57:
|
|
return 2
|
|
case 97 <= r && r <= 102:
|
|
return 2
|
|
case 65 <= r && r <= 70:
|
|
return 2
|
|
}
|
|
return 2
|
|
},
|
|
}, []int{ /* Start-of-input transitions */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, []int{ /* End-of-input transitions */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, nil},
|
|
|
|
// \+
|
|
{[]bool{false, true}, []func(rune) int{ // Transitions
|
|
func(r rune) int {
|
|
switch r {
|
|
case 43:
|
|
return 1
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 43:
|
|
return -1
|
|
}
|
|
return -1
|
|
},
|
|
}, []int{ /* Start-of-input transitions */ -1, -1}, []int{ /* End-of-input transitions */ -1, -1}, nil},
|
|
|
|
// -
|
|
{[]bool{false, true}, []func(rune) int{ // Transitions
|
|
func(r rune) int {
|
|
switch r {
|
|
case 45:
|
|
return 1
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 45:
|
|
return -1
|
|
}
|
|
return -1
|
|
},
|
|
}, []int{ /* Start-of-input transitions */ -1, -1}, []int{ /* End-of-input transitions */ -1, -1}, nil},
|
|
|
|
// :
|
|
{[]bool{false, true}, []func(rune) int{ // Transitions
|
|
func(r rune) int {
|
|
switch r {
|
|
case 58:
|
|
return 1
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 58:
|
|
return -1
|
|
}
|
|
return -1
|
|
},
|
|
}, []int{ /* Start-of-input transitions */ -1, -1}, []int{ /* End-of-input transitions */ -1, -1}, nil},
|
|
|
|
// \^
|
|
{[]bool{false, true}, []func(rune) int{ // Transitions
|
|
func(r rune) int {
|
|
switch r {
|
|
case 94:
|
|
return 1
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 94:
|
|
return -1
|
|
}
|
|
return -1
|
|
},
|
|
}, []int{ /* Start-of-input transitions */ -1, -1}, []int{ /* End-of-input transitions */ -1, -1}, nil},
|
|
|
|
// \(
|
|
{[]bool{false, true}, []func(rune) int{ // Transitions
|
|
func(r rune) int {
|
|
switch r {
|
|
case 40:
|
|
return 1
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 40:
|
|
return -1
|
|
}
|
|
return -1
|
|
},
|
|
}, []int{ /* Start-of-input transitions */ -1, -1}, []int{ /* End-of-input transitions */ -1, -1}, nil},
|
|
|
|
// \)
|
|
{[]bool{false, true}, []func(rune) int{ // Transitions
|
|
func(r rune) int {
|
|
switch r {
|
|
case 41:
|
|
return 1
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 41:
|
|
return -1
|
|
}
|
|
return -1
|
|
},
|
|
}, []int{ /* Start-of-input transitions */ -1, -1}, []int{ /* End-of-input transitions */ -1, -1}, nil},
|
|
|
|
// >
|
|
{[]bool{false, true}, []func(rune) int{ // Transitions
|
|
func(r rune) int {
|
|
switch r {
|
|
case 62:
|
|
return 1
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 62:
|
|
return -1
|
|
}
|
|
return -1
|
|
},
|
|
}, []int{ /* Start-of-input transitions */ -1, -1}, []int{ /* End-of-input transitions */ -1, -1}, nil},
|
|
|
|
// <
|
|
{[]bool{false, true}, []func(rune) int{ // Transitions
|
|
func(r rune) int {
|
|
switch r {
|
|
case 60:
|
|
return 1
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 60:
|
|
return -1
|
|
}
|
|
return -1
|
|
},
|
|
}, []int{ /* Start-of-input transitions */ -1, -1}, []int{ /* End-of-input transitions */ -1, -1}, nil},
|
|
|
|
// =
|
|
{[]bool{false, true}, []func(rune) int{ // Transitions
|
|
func(r rune) int {
|
|
switch r {
|
|
case 61:
|
|
return 1
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 61:
|
|
return -1
|
|
}
|
|
return -1
|
|
},
|
|
}, []int{ /* Start-of-input transitions */ -1, -1}, []int{ /* End-of-input transitions */ -1, -1}, nil},
|
|
|
|
// ~([0-9]|[1-9][0-9]*)
|
|
{[]bool{false, false, true, true, true}, []func(rune) int{ // Transitions
|
|
func(r rune) int {
|
|
switch r {
|
|
case 126:
|
|
return 1
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 48:
|
|
return -1
|
|
case 49 <= r && r <= 57:
|
|
return -1
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 126:
|
|
return -1
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 48:
|
|
return 2
|
|
case 49 <= r && r <= 57:
|
|
return 3
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 126:
|
|
return -1
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 48:
|
|
return -1
|
|
case 49 <= r && r <= 57:
|
|
return -1
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 126:
|
|
return -1
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 48:
|
|
return 4
|
|
case 49 <= r && r <= 57:
|
|
return 4
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 126:
|
|
return -1
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 48:
|
|
return 4
|
|
case 49 <= r && r <= 57:
|
|
return 4
|
|
}
|
|
return -1
|
|
},
|
|
}, []int{ /* Start-of-input transitions */ -1, -1, -1, -1, -1}, []int{ /* End-of-input transitions */ -1, -1, -1, -1, -1}, nil},
|
|
|
|
// ~
|
|
{[]bool{false, true}, []func(rune) int{ // Transitions
|
|
func(r rune) int {
|
|
switch r {
|
|
case 126:
|
|
return 1
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 126:
|
|
return -1
|
|
}
|
|
return -1
|
|
},
|
|
}, []int{ /* Start-of-input transitions */ -1, -1}, []int{ /* End-of-input transitions */ -1, -1}, nil},
|
|
|
|
// -?([0-9]|[1-9][0-9]*)(\.[0-9][0-9]*)?
|
|
{[]bool{false, false, true, true, false, true, true, true}, []func(rune) int{ // Transitions
|
|
func(r rune) int {
|
|
switch r {
|
|
case 45:
|
|
return 1
|
|
case 46:
|
|
return -1
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 48:
|
|
return 2
|
|
case 49 <= r && r <= 57:
|
|
return 3
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 45:
|
|
return -1
|
|
case 46:
|
|
return -1
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 48:
|
|
return 2
|
|
case 49 <= r && r <= 57:
|
|
return 3
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 45:
|
|
return -1
|
|
case 46:
|
|
return 4
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 48:
|
|
return -1
|
|
case 49 <= r && r <= 57:
|
|
return -1
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 45:
|
|
return -1
|
|
case 46:
|
|
return 4
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 48:
|
|
return 5
|
|
case 49 <= r && r <= 57:
|
|
return 5
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 45:
|
|
return -1
|
|
case 46:
|
|
return -1
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 48:
|
|
return 6
|
|
case 49 <= r && r <= 57:
|
|
return 6
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 45:
|
|
return -1
|
|
case 46:
|
|
return 4
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 48:
|
|
return 5
|
|
case 49 <= r && r <= 57:
|
|
return 5
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 45:
|
|
return -1
|
|
case 46:
|
|
return -1
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 48:
|
|
return 7
|
|
case 49 <= r && r <= 57:
|
|
return 7
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 45:
|
|
return -1
|
|
case 46:
|
|
return -1
|
|
}
|
|
switch {
|
|
case 48 <= r && r <= 48:
|
|
return 7
|
|
case 49 <= r && r <= 57:
|
|
return 7
|
|
}
|
|
return -1
|
|
},
|
|
}, []int{ /* Start-of-input transitions */ -1, -1, -1, -1, -1, -1, -1, -1}, []int{ /* End-of-input transitions */ -1, -1, -1, -1, -1, -1, -1, -1}, nil},
|
|
|
|
// [ \t\n]+
|
|
{[]bool{false, true}, []func(rune) int{ // Transitions
|
|
func(r rune) int {
|
|
switch r {
|
|
case 9:
|
|
return 1
|
|
case 10:
|
|
return 1
|
|
case 32:
|
|
return 1
|
|
}
|
|
return -1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 9:
|
|
return 1
|
|
case 10:
|
|
return 1
|
|
case 32:
|
|
return 1
|
|
}
|
|
return -1
|
|
},
|
|
}, []int{ /* Start-of-input transitions */ -1, -1}, []int{ /* End-of-input transitions */ -1, -1}, nil},
|
|
|
|
// [^\t\n\f\r :^\+\-><=~][^\t\n\f\r :^~]*
|
|
{[]bool{false, true, true}, []func(rune) int{ // Transitions
|
|
func(r rune) int {
|
|
switch r {
|
|
case 9:
|
|
return -1
|
|
case 10:
|
|
return -1
|
|
case 12:
|
|
return -1
|
|
case 13:
|
|
return -1
|
|
case 32:
|
|
return -1
|
|
case 58:
|
|
return -1
|
|
case 60:
|
|
return -1
|
|
case 61:
|
|
return -1
|
|
case 94:
|
|
return -1
|
|
case 126:
|
|
return -1
|
|
}
|
|
switch {
|
|
case 43 <= r && r <= 62:
|
|
return -1
|
|
}
|
|
return 1
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 9:
|
|
return -1
|
|
case 10:
|
|
return -1
|
|
case 12:
|
|
return -1
|
|
case 13:
|
|
return -1
|
|
case 32:
|
|
return -1
|
|
case 58:
|
|
return -1
|
|
case 60:
|
|
return 2
|
|
case 61:
|
|
return 2
|
|
case 94:
|
|
return -1
|
|
case 126:
|
|
return -1
|
|
}
|
|
switch {
|
|
case 43 <= r && r <= 62:
|
|
return 2
|
|
}
|
|
return 2
|
|
},
|
|
func(r rune) int {
|
|
switch r {
|
|
case 9:
|
|
return -1
|
|
case 10:
|
|
return -1
|
|
case 12:
|
|
return -1
|
|
case 13:
|
|
return -1
|
|
case 32:
|
|
return -1
|
|
case 58:
|
|
return -1
|
|
case 60:
|
|
return 2
|
|
case 61:
|
|
return 2
|
|
case 94:
|
|
return -1
|
|
case 126:
|
|
return -1
|
|
}
|
|
switch {
|
|
case 43 <= r && r <= 62:
|
|
return 2
|
|
}
|
|
return 2
|
|
},
|
|
}, []int{ /* Start-of-input transitions */ -1, -1, -1}, []int{ /* End-of-input transitions */ -1, -1, -1}, nil},
|
|
}, 0, 0)
|
|
return yylex
|
|
}
|
|
|
|
func newLexer(in io.Reader) *lexer {
|
|
return newLexerWithInit(in, nil)
|
|
}
|
|
|
|
// Text returns the matched text.
|
|
func (yylex *lexer) Text() string {
|
|
return yylex.stack[len(yylex.stack)-1].s
|
|
}
|
|
|
|
// Line returns the current line number.
|
|
// The first line is 0.
|
|
func (yylex *lexer) Line() int {
|
|
return yylex.stack[len(yylex.stack)-1].line
|
|
}
|
|
|
|
// Column returns the current column number.
|
|
// The first column is 0.
|
|
func (yylex *lexer) Column() int {
|
|
return yylex.stack[len(yylex.stack)-1].column
|
|
}
|
|
|
|
func (yylex *lexer) next(lvl int) int {
|
|
if lvl == len(yylex.stack) {
|
|
l, c := 0, 0
|
|
if lvl > 0 {
|
|
l, c = yylex.stack[lvl-1].line, yylex.stack[lvl-1].column
|
|
}
|
|
yylex.stack = append(yylex.stack, frame{0, "", l, c})
|
|
}
|
|
if lvl == len(yylex.stack)-1 {
|
|
p := &yylex.stack[lvl]
|
|
*p = <-yylex.ch
|
|
yylex.stale = false
|
|
} else {
|
|
yylex.stale = true
|
|
}
|
|
return yylex.stack[lvl].i
|
|
}
|
|
func (yylex *lexer) pop() {
|
|
yylex.stack = yylex.stack[:len(yylex.stack)-1]
|
|
}
|
|
func (yylex lexer) Error(e string) {
|
|
panic(e)
|
|
}
|
|
|
|
// Lex runs the lexer. Always returns 0.
|
|
// When the -s option is given, this function is not generated;
|
|
// instead, the NN_FUN macro runs the lexer.
|
|
func (yylex *lexer) Lex(lval *yySymType) int {
|
|
OUTER0:
|
|
for {
|
|
switch yylex.next(0) {
|
|
case 0:
|
|
{
|
|
lval.s = yylex.Text()[1 : len(yylex.Text())-1]
|
|
logDebugTokens("PHRASE - %s", lval.s)
|
|
return tPHRASE
|
|
}
|
|
case 1:
|
|
{
|
|
logDebugTokens("PLUS")
|
|
return tPLUS
|
|
}
|
|
case 2:
|
|
{
|
|
logDebugTokens("MINUS")
|
|
return tMINUS
|
|
}
|
|
case 3:
|
|
{
|
|
logDebugTokens("COLON")
|
|
return tCOLON
|
|
}
|
|
case 4:
|
|
{
|
|
logDebugTokens("BOOST")
|
|
return tBOOST
|
|
}
|
|
case 5:
|
|
{
|
|
logDebugTokens("LPAREN")
|
|
return tLPAREN
|
|
}
|
|
case 6:
|
|
{
|
|
logDebugTokens("RPAREN")
|
|
return tRPAREN
|
|
}
|
|
case 7:
|
|
{
|
|
logDebugTokens("GREATER")
|
|
return tGREATER
|
|
}
|
|
case 8:
|
|
{
|
|
logDebugTokens("LESS")
|
|
return tLESS
|
|
}
|
|
case 9:
|
|
{
|
|
logDebugTokens("EQUAL")
|
|
return tEQUAL
|
|
}
|
|
case 10:
|
|
{
|
|
lval.s = yylex.Text()[1:]
|
|
logDebugTokens("TILDENUMBER - %s", lval.s)
|
|
return tTILDENUMBER
|
|
}
|
|
case 11:
|
|
{
|
|
logDebugTokens("TILDE")
|
|
return tTILDE
|
|
}
|
|
case 12:
|
|
{
|
|
lval.s = yylex.Text()
|
|
logDebugTokens("NUMBER - %s", lval.s)
|
|
return tNUMBER
|
|
}
|
|
case 13:
|
|
{
|
|
logDebugTokens("WHITESPACE (count=%d)", len(yylex.Text())) /* eat up whitespace */
|
|
}
|
|
case 14:
|
|
{
|
|
lval.s = yylex.Text()
|
|
logDebugTokens("STRING - %s", lval.s)
|
|
return tSTRING
|
|
}
|
|
default:
|
|
break OUTER0
|
|
}
|
|
continue
|
|
}
|
|
yylex.pop()
|
|
|
|
return 0
|
|
}
|
|
func logDebugTokens(format string, v ...interface{}) {
|
|
if debugLexer {
|
|
logger.Printf(format, v...)
|
|
}
|
|
}
|