1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
// Package lex представляет собой достаточно простой лексер произвольных выражений.
// Практически полностью аналогичен лексеру от Роба Пайка.
package lex
import (
"bufio"
"strings"
)
func Do(initState StateFunc, input *bufio.Reader) <-chan Token {
t := &Lexer{
input: input,
ch: make(chan Token),
buf: []rune{},
}
go func() {
defer close(t.ch)
for state := initState; state != nil; {
state = state(t)
}
}()
return t.ch
}
type Lexer struct {
input *bufio.Reader
width int
ch chan Token
buf []rune
pos int
}
func (l *Lexer) Next() (ch rune, err error) {
ch, l.width, err = l.input.ReadRune()
if err != nil {
return 0, err
}
l.buf = append(l.buf, ch)
return ch, nil
}
func (l *Lexer) Peek() (rune, error) {
ch, err := l.Next()
if err != nil {
return 0, err
}
return ch, l.input.UnreadRune()
}
func (l *Lexer) Back() error {
if len(l.buf) == 0 {
return nil
}
l.pos -= l.width
l.buf = l.buf[:len(l.buf)-1]
return l.input.UnreadRune()
}
func (l *Lexer) Skip() {
l.buf = l.buf[:]
}
func (l *Lexer) EmitToken(typ Typ) {
l.ch <- Token{
Typ: typ,
Value: string(l.buf),
Pos: l.pos,
}
l.buf = l.buf[:]
}
func (l *Lexer) EmitError(err error) {
l.ch <- Token{
Error: err,
Value: string(l.buf),
Pos: l.pos,
}
l.buf = l.buf[:]
}
func (l *Lexer) Accept(valid string) bool {
ch, err := l.Next()
if err != nil {
l.Back()
return false
}
if strings.ContainsRune(valid, ch) {
return true
}
l.Back()
return false
}
func (l *Lexer) AcceptRun(valid string) bool {
ok := false
for l.Accept(valid) {
ok = true
}
return ok
}
func (l *Lexer) AcceptNotRun(invalid string, greedy bool) bool {
ok := false
for {
ch, err := l.Next()
if err != nil {
return ok
}
if strings.ContainsRune(invalid, ch) {
if !greedy {
l.Back()
}
return ok
}
ok = true
}
}
func (l *Lexer) AcceptAlph() bool {
ch, err := l.Next()
if err != nil {
l.Back()
return false
}
if 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' {
return true
}
l.Back()
return false
}
func (l *Lexer) AcceptDigit() bool {
ch, err := l.Next()
if err != nil {
l.Back()
return false
}
if '0' <= ch && ch <= '9' {
return true
}
l.Back()
return false
}
func (l *Lexer) AcceptSpace() bool {
return l.Accept(" \r\n\t")
}
func (l *Lexer) Empty() bool {
return len(l.buf) == 0
}
|
