<- Back to shtanton's homepage
aboutsummaryrefslogtreecommitdiff
path: root/subex/subexstate.go
blob: 7ffd592db4090dc6d83617dd146f83d861b314c0 (plain)
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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
package subex

// TODO: Simplify this implementation by combining similar states into one type
// e.g. Combine all of the copy states into a single type that has a filter function

import (
	"main/walk"
)

// A state of execution for the transducer
type SubexState interface {
	// Eat a Atom and transition to any number of new states
	eat(aux auxiliaryState, char walk.Edible) []SubexBranch
	// Find accepting states reachable through epsilon transitions and return their outputs
	accepting(aux auxiliaryState) []OutputStack
}

// Try first, if it fails then try second
type SubexGroupState struct {
	first, second SubexState
}
func (state SubexGroupState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	otherAux := aux.cloneStore()
	return append(state.first.eat(aux, char), state.second.eat(otherAux, char)...)
}
func (state SubexGroupState) accepting(aux auxiliaryState) []OutputStack {
	otherAux := aux.cloneStore()
	return append(state.first.accepting(aux), state.second.accepting(otherAux)...)
}

type SubexCopyState struct {
	next SubexState
	filter valueFilter
}
func (state SubexCopyState) eat(aux auxiliaryState, edible walk.Edible) []SubexBranch {
	value, isValue := edible.(walk.Value)
	if !isValue || !state.filter.valueFilter(value) {
		return nil
	}
	return []SubexBranch{{
		state: state.next,
		aux: aux.topAppend(walk.ValueList{value}),
	}}
}
func (state SubexCopyState) accepting(aux auxiliaryState) []OutputStack {
	return nil
}

type SubexCopyRuneState struct {
	next SubexState
	filter runeFilter
}
func (state SubexCopyRuneState) eat(aux auxiliaryState, edible walk.Edible) []SubexBranch {
	r, isRune := edible.(walk.StringRuneAtom)
	if !isRune || !state.filter.runeFilter(r) {
		return nil
	}
	return []SubexBranch{{
		state: state.next,
		aux: aux.topAppend(walk.RuneList{r}),
	}}
}
func (state SubexCopyRuneState) accepting(aux auxiliaryState) []OutputStack {
	return nil
}

// Just pushes to the OutputStack and hands over to the next state
// Used to capture the output of the state being handed over to
type SubexCaptureBeginState struct {
	next SubexState
}
func (state SubexCaptureBeginState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	return state.next.eat(aux.pushOutput(walk.ValueList{}), char)
}
func (state SubexCaptureBeginState) accepting(aux auxiliaryState) []OutputStack {
	return state.next.accepting(aux.pushOutput(walk.ValueList{}))
}
func (state SubexCaptureBeginState) String() string {
	return "CaptureBeginState"
}

type SubexCaptureRunesBeginState struct {
	next SubexState
}
func (state SubexCaptureRunesBeginState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	return state.next.eat(aux.pushOutput(walk.RuneList{}), char)
}
func (state SubexCaptureRunesBeginState) accepting(aux auxiliaryState) []OutputStack {
	return state.next.accepting(aux.pushOutput(walk.RuneList{}))
}

// Discard the top of the OutputStack
type SubexDiscardState struct {
	next SubexState
}
func (state SubexDiscardState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	_, newAux := aux.popOutput()
	return state.next.eat(newAux, char)
}
func (state SubexDiscardState) accepting(aux auxiliaryState) []OutputStack {
	_, newAux := aux.popOutput()
	return state.next.accepting(newAux)
}

// Pop the top of the OutputStack which contains the stuff outputted since the start of the store
// This outputted data gets stored in a slot
type SubexStoreEndState struct {
	slot int
	next SubexState
}
func (state SubexStoreEndState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	toStore, aux := aux.popOutput()
	aux = aux.withValue(state.slot, toStore)
	return state.next.eat(aux, char)
}
func (state SubexStoreEndState) accepting(aux auxiliaryState) []OutputStack {
	toStore, aux := aux.popOutput()
	aux = aux.withValue(state.slot, toStore)
	return state.next.accepting(aux)
}

// A part of an output literal, either an Atom or a slot from which to load
type OutputContent interface {
	// Given the current store, return the []Atom produced by the TransducerOutput
	build(Store) walk.ValueList
}

// An OutputContent which is just an Atom literal
type OutputAtomLiteral struct {
	atom walk.Value
}
func (replacement OutputAtomLiteral) build(store Store) walk.ValueList {
	return walk.ValueList{replacement.atom}
}

// An OutputContent which is a slot that is loaded from
type OutputLoad struct {
	slot int
}
func (replacement OutputLoad) build(store Store) walk.ValueList {
	values, isValues := store[replacement.slot].(walk.ValueList)
	if !isValues {
		panic("Tried to output non-values list")
	}
	return values
}

// Don't read in anything, just output the series of data and slots specified
type SubexOutputState struct {
	content []OutputContent
	next SubexState
}
// Given a store, return what is outputted by an epsilon transition from this state
// TODO: separate into buildValues and buildRunes
func (state SubexOutputState) build(store Store) walk.ValueList {
	var result walk.ValueList
	for _, part := range state.content {
		result = append(result, part.build(store)...)
	}
	return result
}
func (state SubexOutputState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	content := state.build(aux.store)
	nextStates := state.next.eat(aux.topAppend(content), char)
	return nextStates
}
func (state SubexOutputState) accepting(aux auxiliaryState) []OutputStack {
	content := state.build(aux.store)
	outputStacks := state.next.accepting(aux.topAppend(content))
	return outputStacks
}

// A final state, transitions to nothing but is accepting
type SubexNoneState struct {}
func (state SubexNoneState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	return nil
}
func (state SubexNoneState) accepting(aux auxiliaryState) []OutputStack {
	return []OutputStack{aux.outputStack}
}

// A dead end state, handy for making internals work nicer but technically redundant
type SubexDeadState struct {}
func (state SubexDeadState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	return nil
}
func (state SubexDeadState) accepting (aux auxiliaryState) []OutputStack {
	return nil
}

// Read in an Atom and apply a map to generate an Atom to output
// If the input isn't in the map transition to nothing
// TODO
// type SubexRangeState struct {
// 	parts map[walk.Atom]walk.Atom
// 	next SubexState
// }
// func (state SubexRangeState) eat(aux auxiliaryState, char walk.Atom) []SubexBranch {
// 	out, exists := state.parts[char]
// 	if !exists {
// 		return nil
// 	} else {
// 		return []SubexBranch{{
// 			state: state.next,
// 			outputStack: topAppend(outputStack, []walk.Atom{out}),
// 			store: store,
// 		}}
// 	}
// }
// func (state SubexRangeState) accepting(aux auxiliaryState) []OutputStack {
// 	return nil
// }


type SubexArithmeticEndState struct {
	next SubexState
	calculate func(walk.ValueList) (walk.ValueList, error)
}
func (state SubexArithmeticEndState) eat(aux auxiliaryState, char walk.Edible) []SubexBranch {
	toCompute, aux := aux.popOutput()
	values, isValues := toCompute.(walk.ValueList)
	if !isValues {
		panic("Tried to do arithmetic on non-values")
	}
	result, err := state.calculate(values)
	if err != nil {
		return nil
	}
	return state.next.eat(aux.topAppend(result), char)
}
func (state SubexArithmeticEndState) accepting(aux auxiliaryState) []OutputStack {
	toCompute, aux := aux.popOutput()
	values, isValues := toCompute.(walk.ValueList)
	if !isValues {
		panic("Tried to do arithmetic on non-values")
	}
	result, err := state.calculate(values)
	if err != nil {
		return nil
	}
	return state.next.accepting(aux.topAppend(result))
}

type SubexDiscardTerminalState struct {
	terminal walk.Terminal
	next SubexState
}
func (state SubexDiscardTerminalState) eat(aux auxiliaryState, edible walk.Edible) []SubexBranch {
	if edible != state.terminal {
		return nil
	}
	return []SubexBranch{{
		state: state.next,
		aux: aux,
	}}
}
func (state SubexDiscardTerminalState) accepting(aux auxiliaryState) []OutputStack {
	return nil
}

type SubexConstructArrayState struct {
	next SubexState
}
func (state SubexConstructArrayState) eat(aux auxiliaryState, edible walk.Edible) []SubexBranch {
	outputs, aux := aux.popOutput()
	values, isValues := outputs.(walk.ValueList)
	if !isValues {
		panic("Tried to create an array from non-values")
	}
	array := walk.ArrayStructure(values)
	return state.next.eat(aux.topAppend(walk.ValueList{array}), edible)
}
func (state SubexConstructArrayState) accepting(aux auxiliaryState) []OutputStack {
	outputs, aux := aux.popOutput()
	values, isValues := outputs.(walk.ValueList)
	if !isValues {
		panic("Tried to create an array from non-values")
	}
	array := walk.ArrayStructure(values)
	return state.next.accepting(aux.topAppend(walk.ValueList{array}))
}

type SubexConstructStringState struct {
	next SubexState
}
func (state SubexConstructStringState) eat(aux auxiliaryState, edible walk.Edible) []SubexBranch {
	outputs, aux := aux.popOutput()
	runes, isRunes := outputs.(walk.RuneList)
	if !isRunes {
		panic("Tried to create a string from non-runes")
	}
	s := walk.StringStructure(runes)
	return state.next.eat(aux.topAppend(walk.ValueList{s}), edible)
}
func (state SubexConstructStringState) accepting(aux auxiliaryState) []OutputStack {
	outputs, aux := aux.popOutput()
	runes, isRunes := outputs.(walk.RuneList)
	if !isRunes {
		panic("Tried to create a string from non-runes")
	}
	s := walk.StringStructure(runes)
	return state.next.accepting(aux.topAppend(walk.ValueList{s}))
}

type SubexIncrementNestState struct {
	next SubexState
}
func (state SubexIncrementNestState) eat(aux auxiliaryState, edible walk.Edible) []SubexBranch {
	return state.next.eat(aux.incNest(), edible)
}
func (state SubexIncrementNestState) accepting(aux auxiliaryState) []OutputStack {
	return state.next.accepting(aux.incNest())
}
func (state SubexIncrementNestState) String() string {
	return "IncrementNestState"
}

type SubexDecrementNestState struct {
	next SubexState
}
func (state SubexDecrementNestState) eat(aux auxiliaryState, edible walk.Edible) []SubexBranch {
	return state.next.eat(aux.decNest(), edible)
}
func (state SubexDecrementNestState) accepting(aux auxiliaryState) []OutputStack {
	return state.next.accepting(aux.decNest())
}