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
|
package main
import (
"strings"
"fmt"
"main/subex"
)
type parser struct {
tokenStream chan Token
rewinds []Token
}
func (p *parser) next() Token {
var token Token
if len(p.rewinds) == 0 {
token = <- p.tokenStream
} else {
token = p.rewinds[len(p.rewinds)-1]
p.rewinds = p.rewinds[:len(p.rewinds)-1]
}
if token.typ == TokenErr {
fmt.Println(token)
panic("Lexing error")
}
return token
}
func (p *parser) rewind(token Token) {
p.rewinds = append(p.rewinds, token)
}
func (p *parser) peek() Token {
token := p.next()
p.rewind(token)
return token
}
func (p *parser) parseSubex() subex.SubexState {
delim := p.next()
if delim.typ != TokenSubstituteDelimiter {
panic("Missing substitute delimiter")
}
subexProgramToken := p.next()
if subexProgramToken.typ != TokenSubex {
panic("Missing subex from substitution")
}
reader := subex.NewStringRuneReader(subexProgramToken.val)
subexAST := subex.Parse(reader)
subex := subex.CompileTransducer(subexAST)
delim = p.next()
if delim.typ != TokenSubstituteDelimiter {
panic("Missing end substitute delimiter")
}
return subex
}
func (p *parser) parseBasicCommand(commandChar rune) Command {
switch commandChar {
case 'p':
return PrintValueCommand{}
case 'd':
return DeleteAllCommand{}
case 'n':
return NextCommand{}
case 'N':
return AppendNextCommand{}
case 's', 'S':
subex := p.parseSubex()
var next Command
token := p.peek()
switch token.typ {
case TokenEOF, TokenRBrace:
next = NoopCommand{}
default:
next = p.parseCommand()
}
if (commandChar == 's') {
return SubstituteValueCommand {
subex: subex,
next: next,
}
} else {
return SubstitutePathCommand {
subex: subex,
next: next,
}
}
case 'o':
return NoopCommand{}
case 'x':
return SwapXRegCommand{}
case 'X':
return AppendXRegCommand{}
case 'k':
return SwapPathCommand{}
case 'K':
return AppendPathCommand{}
default:
panic("Invalid command")
}
}
func (p *parser) parseCommand() Command {
token := p.next()
switch token.typ {
case TokenLBrace:
commands := p.parseCommands()
if p.next().typ != TokenRBrace {
panic("Missing matching }")
}
return SequenceCommand {commands}
case TokenCommand:
commandChar, _, err := strings.NewReader(token.val).ReadRune()
if err != nil {
panic("Error reading a command character!?")
}
return p.parseBasicCommand(commandChar)
default:
panic("Invalid token, expected command")
}
}
func (p *parser) parseCommands() []Command {
var commands []Command
for {
nextToken := p.peek()
if nextToken.typ == TokenEOF || nextToken.typ == TokenRBrace {
return commands
}
commands = append(commands, p.parseCommand())
endToken := p.peek()
if endToken.typ == TokenEOF || endToken.typ == TokenRBrace {
return commands
}
}
}
func Parse(tokens chan Token) []Command {
p := parser {
tokenStream: tokens,
}
return p.parseCommands()
}
|
