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
|
---@class vm
local vm = require 'vm.vm'
local guide = require 'parser.guide'
---@alias vm.runner.callback fun(src: parser.object, node: vm.node)
---@class vm.runner
---@field _loc parser.object
---@field _objs parser.object[]
---@field _callback vm.runner.callback
local mt = {}
mt.__index = mt
mt._index = 1
---@return parser.object[]
function mt:_getCasts()
local root = guide.getRoot(self._loc)
if not root._casts then
root._casts = {}
local docs = root.docs
for _, doc in ipairs(docs) do
if doc.type == 'doc.cast' and doc.loc then
root._casts[#root._casts+1] = doc
end
end
end
return root._casts
end
function mt:_collect()
local startPos = self._loc.start
local finishPos = 0
for _, ref in ipairs(self._loc.ref) do
if ref.type == 'getlocal'
or ref.type == 'setlocal' then
self._objs[#self._objs+1] = ref
if ref.start > finishPos then
finishPos = ref.start
end
end
end
if #self._objs == 0 then
return
end
local casts = self:_getCasts()
for _, cast in ipairs(casts) do
if cast.loc[1] == self._loc[1]
and cast.start > startPos
and cast.finish < finishPos
and guide.getLocal(self._loc, self._loc[1], cast.start) == self._loc then
self._objs[#self._objs+1] = cast
end
end
table.sort(self._objs, function (a, b)
return (a.range or a.start) < (b.range or b.start)
end)
end
---@param pos integer
---@param node vm.node
---@return vm.node
---@return parser.object?
function mt:_fastWard(pos, node)
for i = self._index, #self._objs do
local obj = self._objs[i]
if obj.start > pos then
self._index = i
return node, obj
end
if obj.type == 'getlocal' then
self._callback(obj, node)
elseif obj.type == 'setlocal' then
local newNode = self._callback(obj, node)
if newNode then
node = newNode:copy()
end
else
error('unexpected type: ' .. obj.type)
end
end
self._index = math.huge
return node, nil
end
---@param action parser.object
---@param topNode vm.node
---@param outNode? vm.node
---@return vm.node
function mt:_lookInto(action, topNode, outNode)
action = vm.getObjectValue(action) or action
if action.type == 'function' then
self:_launchBlock(action, topNode:copy())
elseif action.type == 'if' then
local mainNode = topNode:copy()
local blockNode = topNode:copy()
for _, subBlock in ipairs(action) do
if subBlock.type == 'ifblock' then
blockNode, mainNode = self:_lookInto(subBlock.filter, blockNode, mainNode)
local neverReturn
blockNode, neverReturn = self:_launchBlock(subBlock, blockNode)
if not neverReturn then
mainNode:merge(blockNode)
end
end
end
topNode = mainNode
elseif action.type == 'getlocal' then
if action.node == self._loc then
topNode = self:_fastWard(action.finish, topNode)
topNode = topNode:copy():setTruthy()
if outNode then
outNode:setFalsy()
end
end
elseif action.type == 'unary' then
if action.op.type == 'not' then
outNode, topNode = self:_lookInto(action[1], topNode, outNode)
end
elseif action.type == 'binary' then
if action.op.type == 'and' then
topNode = self:_lookInto(action[1], topNode)
topNode = self:_lookInto(action[2], topNode)
end
end
return topNode, outNode
end
---@param block parser.object
---@param node vm.node
---@return vm.node
---@return boolean neverReturn
function mt:_launchBlock(block, node)
local neverReturn = false
local topNode, top = self:_fastWard(block.start, node)
if not top then
return topNode, neverReturn
end
for _, action in ipairs(block) do
if action.type == 'return' then
neverReturn = true
end
local finish = action.range or action.finish
if finish < top.start then
goto CONTINUE
end
topNode = self:_lookInto(action, topNode)
topNode, top = self:_fastWard(action.finish, topNode)
if not top then
return topNode, neverReturn
end
::CONTINUE::
end
topNode = self:_fastWard(block.finish, topNode)
return topNode, neverReturn
end
---@param loc parser.object
---@param callback vm.runner.callback
function vm.launchRunner(loc, callback)
local self = setmetatable({
_loc = loc,
_objs = {},
_callback = callback,
}, mt)
self:_collect()
if #self._objs == 0 then
return
end
self:_launchBlock(guide.getParentBlock(loc), vm.getNode(loc):copy())
end
|
