2014-07-30 18:30:38 +02:00
|
|
|
package bleve
|
2014-07-11 20:49:59 +02:00
|
|
|
import ("bufio";"io";"strings")
|
|
|
|
type frame struct {
|
2014-12-30 02:41:15 +01:00
|
|
|
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
|
2014-07-11 20:49:59 +02:00
|
|
|
}
|
2014-12-30 02:41:15 +01:00
|
|
|
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)
|
2014-07-11 20:49:59 +02:00
|
|
|
}
|
|
|
|
}
|
2014-12-30 02:41:15 +01:00
|
|
|
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})
|
|
|
|
}
|
|
|
|
}
|
2014-07-11 20:49:59 +02:00
|
|
|
}
|
2014-12-30 02:41:15 +01:00
|
|
|
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, true, false, false, false, false, false, false, false, false, false, false, true, 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 48 <= r && r <= 57: return -1
|
|
|
|
case 97 <= r && r <= 102: return -1
|
|
|
|
case 65 <= r && r <= 70: return -1
|
|
|
|
}
|
|
|
|
return -1
|
|
|
|
},
|
|
|
|
func(r rune) int {
|
|
|
|
switch(r) {
|
|
|
|
case 34: return 2
|
|
|
|
case 47: return 3
|
|
|
|
case 92: return 4
|
|
|
|
case 98: return 3
|
|
|
|
case 102: return 3
|
|
|
|
case 110: return 3
|
|
|
|
case 114: return 3
|
|
|
|
case 116: return 3
|
|
|
|
case 117: return 3
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case 97 <= r && r <= 102: return 3
|
|
|
|
case 65 <= r && r <= 70: return 3
|
|
|
|
case 48 <= r && r <= 57: return 3
|
|
|
|
}
|
|
|
|
return 3
|
|
|
|
},
|
|
|
|
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 97 <= r && r <= 102: return -1
|
|
|
|
case 65 <= r && r <= 70: return -1
|
|
|
|
}
|
|
|
|
return -1
|
|
|
|
},
|
|
|
|
func(r rune) int {
|
|
|
|
switch(r) {
|
|
|
|
case 34: return 2
|
|
|
|
case 47: return 3
|
|
|
|
case 92: return 4
|
|
|
|
case 98: return 3
|
|
|
|
case 102: return 3
|
|
|
|
case 110: return 3
|
|
|
|
case 114: return 3
|
|
|
|
case 116: return 3
|
|
|
|
case 117: return 3
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case 65 <= r && r <= 70: return 3
|
|
|
|
case 48 <= r && r <= 57: return 3
|
|
|
|
case 97 <= r && r <= 102: return 3
|
|
|
|
}
|
|
|
|
return 3
|
|
|
|
},
|
|
|
|
func(r rune) int {
|
|
|
|
switch(r) {
|
|
|
|
case 34: return 13
|
|
|
|
case 47: return 5
|
|
|
|
case 92: return 10
|
|
|
|
case 98: return 11
|
|
|
|
case 102: return 6
|
|
|
|
case 110: return 7
|
|
|
|
case 114: return 8
|
|
|
|
case 116: return 12
|
|
|
|
case 117: return 9
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case 97 <= r && r <= 102: return 3
|
|
|
|
case 65 <= r && r <= 70: return 3
|
|
|
|
case 48 <= r && r <= 57: return 3
|
|
|
|
}
|
|
|
|
return 3
|
|
|
|
},
|
|
|
|
func(r rune) int {
|
|
|
|
switch(r) {
|
|
|
|
case 34: return 2
|
|
|
|
case 47: return 3
|
|
|
|
case 92: return 4
|
|
|
|
case 98: return 3
|
|
|
|
case 102: return 3
|
|
|
|
case 110: return 3
|
|
|
|
case 114: return 3
|
|
|
|
case 116: return 3
|
|
|
|
case 117: return 3
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case 97 <= r && r <= 102: return 3
|
|
|
|
case 65 <= r && r <= 70: return 3
|
|
|
|
case 48 <= r && r <= 57: return 3
|
|
|
|
}
|
|
|
|
return 3
|
|
|
|
},
|
|
|
|
func(r rune) int {
|
|
|
|
switch(r) {
|
|
|
|
case 34: return 2
|
|
|
|
case 47: return 3
|
|
|
|
case 92: return 4
|
|
|
|
case 98: return 3
|
|
|
|
case 102: return 3
|
|
|
|
case 110: return 3
|
|
|
|
case 114: return 3
|
|
|
|
case 116: return 3
|
|
|
|
case 117: return 3
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case 97 <= r && r <= 102: return 3
|
|
|
|
case 65 <= r && r <= 70: return 3
|
|
|
|
case 48 <= r && r <= 57: return 3
|
|
|
|
}
|
|
|
|
return 3
|
|
|
|
},
|
|
|
|
func(r rune) int {
|
|
|
|
switch(r) {
|
|
|
|
case 34: return 2
|
|
|
|
case 47: return 3
|
|
|
|
case 92: return 4
|
|
|
|
case 98: return 3
|
|
|
|
case 102: return 3
|
|
|
|
case 110: return 3
|
|
|
|
case 114: return 3
|
|
|
|
case 116: return 3
|
|
|
|
case 117: return 3
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case 97 <= r && r <= 102: return 3
|
|
|
|
case 65 <= r && r <= 70: return 3
|
|
|
|
case 48 <= r && r <= 57: return 3
|
|
|
|
}
|
|
|
|
return 3
|
|
|
|
},
|
|
|
|
func(r rune) int {
|
|
|
|
switch(r) {
|
|
|
|
case 34: return 2
|
|
|
|
case 47: return 3
|
|
|
|
case 92: return 4
|
|
|
|
case 98: return 3
|
|
|
|
case 102: return 3
|
|
|
|
case 110: return 3
|
|
|
|
case 114: return 3
|
|
|
|
case 116: return 3
|
|
|
|
case 117: return 3
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case 97 <= r && r <= 102: return 3
|
|
|
|
case 65 <= r && r <= 70: return 3
|
|
|
|
case 48 <= r && r <= 57: return 3
|
|
|
|
}
|
|
|
|
return 3
|
|
|
|
},
|
|
|
|
func(r rune) int {
|
|
|
|
switch(r) {
|
|
|
|
case 34: return 2
|
|
|
|
case 47: return 3
|
|
|
|
case 92: return 4
|
|
|
|
case 98: return 14
|
|
|
|
case 102: return 14
|
|
|
|
case 110: return 3
|
|
|
|
case 114: return 3
|
|
|
|
case 116: return 3
|
|
|
|
case 117: return 3
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case 97 <= r && r <= 102: return 14
|
|
|
|
case 65 <= r && r <= 70: return 14
|
|
|
|
case 48 <= r && r <= 57: return 14
|
|
|
|
}
|
|
|
|
return 3
|
|
|
|
},
|
|
|
|
func(r rune) int {
|
|
|
|
switch(r) {
|
|
|
|
case 34: return 13
|
|
|
|
case 47: return 5
|
|
|
|
case 92: return 10
|
|
|
|
case 98: return 11
|
|
|
|
case 102: return 6
|
|
|
|
case 110: return 7
|
|
|
|
case 114: return 8
|
|
|
|
case 116: return 12
|
|
|
|
case 117: return 9
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case 97 <= r && r <= 102: return 3
|
|
|
|
case 65 <= r && r <= 70: return 3
|
|
|
|
case 48 <= r && r <= 57: return 3
|
|
|
|
}
|
|
|
|
return 3
|
|
|
|
},
|
|
|
|
func(r rune) int {
|
|
|
|
switch(r) {
|
|
|
|
case 34: return 2
|
|
|
|
case 47: return 3
|
|
|
|
case 92: return 4
|
|
|
|
case 98: return 3
|
|
|
|
case 102: return 3
|
|
|
|
case 110: return 3
|
|
|
|
case 114: return 3
|
|
|
|
case 116: return 3
|
|
|
|
case 117: return 3
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case 48 <= r && r <= 57: return 3
|
|
|
|
case 65 <= r && r <= 70: return 3
|
|
|
|
case 97 <= r && r <= 102: return 3
|
|
|
|
}
|
|
|
|
return 3
|
|
|
|
},
|
|
|
|
func(r rune) int {
|
|
|
|
switch(r) {
|
|
|
|
case 34: return 2
|
|
|
|
case 47: return 3
|
|
|
|
case 92: return 4
|
|
|
|
case 98: return 3
|
|
|
|
case 102: return 3
|
|
|
|
case 110: return 3
|
|
|
|
case 114: return 3
|
|
|
|
case 116: return 3
|
|
|
|
case 117: return 3
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case 48 <= r && r <= 57: return 3
|
|
|
|
case 97 <= r && r <= 102: return 3
|
|
|
|
case 65 <= r && r <= 70: return 3
|
|
|
|
}
|
|
|
|
return 3
|
|
|
|
},
|
|
|
|
func(r rune) int {
|
|
|
|
switch(r) {
|
|
|
|
case 34: return 2
|
|
|
|
case 47: return 3
|
|
|
|
case 92: return 4
|
|
|
|
case 98: return 3
|
|
|
|
case 102: return 3
|
|
|
|
case 110: return 3
|
|
|
|
case 114: return 3
|
|
|
|
case 116: return 3
|
|
|
|
case 117: return 3
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case 97 <= r && r <= 102: return 3
|
|
|
|
case 65 <= r && r <= 70: return 3
|
|
|
|
case 48 <= r && r <= 57: return 3
|
|
|
|
}
|
|
|
|
return 3
|
|
|
|
},
|
|
|
|
func(r rune) int {
|
|
|
|
switch(r) {
|
|
|
|
case 34: return 2
|
|
|
|
case 47: return 3
|
|
|
|
case 92: return 4
|
|
|
|
case 98: return 15
|
|
|
|
case 102: return 15
|
|
|
|
case 110: return 3
|
|
|
|
case 114: return 3
|
|
|
|
case 116: return 3
|
|
|
|
case 117: return 3
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case 97 <= r && r <= 102: return 15
|
|
|
|
case 65 <= r && r <= 70: return 15
|
|
|
|
case 48 <= r && r <= 57: return 15
|
|
|
|
}
|
|
|
|
return 3
|
|
|
|
},
|
|
|
|
func(r rune) int {
|
|
|
|
switch(r) {
|
|
|
|
case 34: return 2
|
|
|
|
case 47: return 3
|
|
|
|
case 92: return 4
|
|
|
|
case 98: return 16
|
|
|
|
case 102: return 16
|
|
|
|
case 110: return 3
|
|
|
|
case 114: return 3
|
|
|
|
case 116: return 3
|
|
|
|
case 117: return 3
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case 65 <= r && r <= 70: return 16
|
|
|
|
case 48 <= r && r <= 57: return 16
|
|
|
|
case 97 <= r && r <= 102: return 16
|
|
|
|
}
|
|
|
|
return 3
|
|
|
|
},
|
|
|
|
func(r rune) int {
|
|
|
|
switch(r) {
|
|
|
|
case 34: return 2
|
|
|
|
case 47: return 3
|
|
|
|
case 92: return 4
|
|
|
|
case 98: return 17
|
|
|
|
case 102: return 17
|
|
|
|
case 110: return 3
|
|
|
|
case 114: return 3
|
|
|
|
case 116: return 3
|
|
|
|
case 117: return 3
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case 65 <= r && r <= 70: return 17
|
|
|
|
case 48 <= r && r <= 57: return 17
|
|
|
|
case 97 <= r && r <= 102: return 17
|
|
|
|
}
|
|
|
|
return 3
|
|
|
|
},
|
|
|
|
func(r rune) int {
|
|
|
|
switch(r) {
|
|
|
|
case 34: return 2
|
|
|
|
case 47: return 3
|
|
|
|
case 92: return 4
|
|
|
|
case 98: return 3
|
|
|
|
case 102: return 3
|
|
|
|
case 110: return 3
|
|
|
|
case 114: return 3
|
|
|
|
case 116: return 3
|
|
|
|
case 117: return 3
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case 48 <= r && r <= 57: return 3
|
|
|
|
case 97 <= r && r <= 102: return 3
|
|
|
|
case 65 <= r && r <= 70: return 3
|
|
|
|
}
|
|
|
|
return 3
|
|
|
|
},
|
|
|
|
}, []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 {
|
|
|
|
return -1
|
|
|
|
},
|
|
|
|
func(r rune) int {
|
|
|
|
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]
|
2014-07-11 20:49:59 +02:00
|
|
|
}
|
2014-08-30 05:31:40 +02:00
|
|
|
func (yylex lexer) Error(e string) {
|
2014-07-11 20:49:59 +02:00
|
|
|
panic(e)
|
|
|
|
}
|
2014-12-30 02:41:15 +01:00
|
|
|
// 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 {
|
|
|
|
for { switch yylex.next(0) {
|
|
|
|
case 0:
|
|
|
|
{
|
2014-07-11 20:49:59 +02:00
|
|
|
lval.s = yylex.Text()[1:len(yylex.Text())-1]
|
|
|
|
logDebugTokens("PHRASE - %s", lval.s);
|
2014-08-29 20:37:38 +02:00
|
|
|
return tPHRASE
|
2014-07-11 20:49:59 +02:00
|
|
|
}
|
2014-12-30 02:41:15 +01:00
|
|
|
continue
|
|
|
|
case 1:
|
|
|
|
{ logDebugTokens("PLUS"); return tPLUS }
|
|
|
|
continue
|
|
|
|
case 2:
|
|
|
|
{ logDebugTokens("MINUS"); return tMINUS }
|
|
|
|
continue
|
|
|
|
case 3:
|
|
|
|
{ logDebugTokens("COLON"); return tCOLON }
|
|
|
|
continue
|
|
|
|
case 4:
|
|
|
|
{ logDebugTokens("BOOST"); return tBOOST }
|
|
|
|
continue
|
|
|
|
case 5:
|
|
|
|
{ logDebugTokens("LPAREN"); return tLPAREN }
|
|
|
|
continue
|
|
|
|
case 6:
|
|
|
|
{ logDebugTokens("RPAREN"); return tRPAREN }
|
|
|
|
continue
|
|
|
|
case 7:
|
|
|
|
{ logDebugTokens("GREATER"); return tGREATER }
|
|
|
|
continue
|
|
|
|
case 8:
|
|
|
|
{ logDebugTokens("LESS"); return tLESS }
|
|
|
|
continue
|
|
|
|
case 9:
|
|
|
|
{ logDebugTokens("EQUAL"); return tEQUAL }
|
|
|
|
continue
|
|
|
|
case 10:
|
|
|
|
{
|
2014-10-24 19:39:48 +02:00
|
|
|
lval.s = yylex.Text()[1:]
|
|
|
|
logDebugTokens("TILDENUMBER - %s", lval.s);
|
|
|
|
return tTILDENUMBER
|
|
|
|
}
|
2014-12-30 02:41:15 +01:00
|
|
|
continue
|
|
|
|
case 11:
|
|
|
|
{ logDebugTokens("TILDE"); return tTILDE }
|
|
|
|
continue
|
|
|
|
case 12:
|
|
|
|
{
|
2014-10-11 05:36:31 +02:00
|
|
|
lval.s = yylex.Text()
|
2014-10-23 21:56:59 +02:00
|
|
|
logDebugTokens("NUMBER - %s", lval.s);
|
2014-08-29 20:37:38 +02:00
|
|
|
return tNUMBER
|
2014-07-11 20:49:59 +02:00
|
|
|
}
|
2014-12-30 02:41:15 +01:00
|
|
|
continue
|
|
|
|
case 13:
|
|
|
|
{ logDebugTokens("WHITESPACE (count=%d)", len(yylex.Text())) /* eat up whitespace */ }
|
|
|
|
continue
|
|
|
|
case 14:
|
|
|
|
{
|
2014-07-11 20:49:59 +02:00
|
|
|
lval.s = yylex.Text()
|
|
|
|
logDebugTokens("STRING - %s", lval.s);
|
2014-08-29 20:37:38 +02:00
|
|
|
return tSTRING
|
2014-07-11 20:49:59 +02:00
|
|
|
}
|
2014-12-30 02:41:15 +01:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
break
|
|
|
|
}
|
|
|
|
yylex.pop()
|
|
|
|
|
|
|
|
return 0
|
2014-07-11 20:49:59 +02:00
|
|
|
}
|
|
|
|
func logDebugTokens(format string, v ...interface{}) {
|
|
|
|
if debugLexer {
|
2014-12-28 21:14:48 +01:00
|
|
|
logger.Printf(format, v...)
|
2014-07-11 20:49:59 +02:00
|
|
|
}
|
2014-08-30 05:31:40 +02:00
|
|
|
}
|