3 local function finishof(node
) return node
.finish
end
4 local function startof(node
) return node
.start
end
5 local function is_comment(node
) return node
.is_comment
end
7 function M
.new(parser
, eol_at
, bol_at
)
9 local function is_line_comment(node
) return node
.is_comment
and parser
.opposite
[node
.d
] == "\n" end
11 local function in_quasilist(t
, range
)
12 return t
and t
.d
and not t
.is_list
and
13 range
.start
>= t
.start
+ #t
.d
and range
.finish
<= t
.finish
+ 1 - #parser
.opposite
[t
.d
]
16 local function sexp_at(range
, true_sexp
)
17 local node
, parent
, nth
= parser
.tree
.sexp_at(range
)
18 if not in_quasilist(node
, range
) or true_sexp
then
19 return node
, parent
, nth
21 return node
.word_at(range
), node
25 local function escaped_at(range
)
26 local node
= parser
.escaped
.around(range
)
27 -- TODO: distinguish between doublequoted strings, chars, line comments, and block comments
28 -- and use approprite offset comparisons for each
29 return node
and range
.start
> node
.start
and range
.finish
<= node
.finish
and node
32 local function find_before_innermost(t
, range
, key
, pred
)
33 if t
.is_root
or (t
.d
and t
.start
< range
.start
) then
34 if t
.d
and not t
.is_list
then
36 local start
= keypos
== startof(t
)
37 local finish
= keypos
== finishof(t
)
40 newpos
= t
.finish_before(range
.finish
)
42 newpos
= t
.start_before(range
.start
)
45 local word
= t
.word_at({start
= newpos
, finish
= newpos
})
46 if word
and pred(word
) then
52 local _
, nearest_n
= t
.before(range
.start
, startof
)
54 for n
= nearest_n
, 1, -1 do
56 if child
.d
and not child
.is_empty
then
57 local ret
= find_before_innermost(child
, range
, key
, pred
)
61 elseif key(child
) < key(range
) and pred(child
, n
, #t
) then
66 if not t
.is_root
and pred(t
) then
72 local function find_after_innermost(t
, range
, key
, pred
)
73 if t
.is_root
or (t
.d
and t
.finish
>= range
.finish
) then
74 if t
.d
and not t
.is_list
then
76 local start
= keypos
== startof(t
)
77 local finish
= keypos
== finishof(t
)
80 newpos
= t
.finish_after(math
.max(t
.start
+ #t
.d
, range
.finish
))
82 newpos
= range
.finish
< t
.start
and t
.start
+ #t
.d
or t
.start_after(range
.start
)
85 local word
= t
.word_at({start
= newpos
, finish
= newpos
})
86 if word
and pred(word
) then
92 local _
, nearest_n
= t
.after(range
.finish
, finishof
)
94 for n
= nearest_n
, #t
do
96 if child
.d
and not child
.is_empty
then
97 local ret
= find_after_innermost(child
, range
, key
, pred
)
101 elseif key(child
) >= key(range
) and pred(child
, n
, #t
) then
106 if not t
.is_root
and pred(t
) then
114 start_before
= function(range
, skip
)
115 local _
, parent
= parser
.tree
.sexp_at(range
)
116 local node
= parent
.before(range
.start
, startof
, skip
)
117 return node
and startof(node
)
120 start_after
= function(range
, skip
)
121 local _
, parent
= parser
.tree
.sexp_at(range
)
122 local node
= parent
.after(range
.finish
, startof
, skip
)
123 return node
and startof(node
)
126 finish_before
= function(range
, skip
)
127 local _
, parent
= parser
.tree
.sexp_at(range
)
128 local node
= parent
.before(range
.start
, finishof
, skip
)
129 return node
and finishof(node
) + 1
132 finish_after
= function(range
, skip
)
133 local _
, parent
= parser
.tree
.sexp_at(range
)
134 local node
= parent
.after(range
.finish
, finishof
, skip
)
135 return node
and finishof(node
) + 1
138 start_down_after
= function(range
, skip
)
139 local node
, parent
= parser
.tree
.sexp_at(range
)
140 if in_quasilist(node
, range
) then return end
141 if node
and node
.p
then
142 -- XXX: if we are past a prefix start, this will prevent skipping over its list
143 range
.start
= node
.start
145 local next_list
= parent
.find_after(range
, function(t
) return t
.is_list
end)
147 local first
= next_list
.after(range
.finish
, startof
, skip
)
151 return next_list
.start
+ (next_list
.p
and #next_list
.p
or 0) + 1
156 start_up_before
= function(range
)
157 local _
, parent
= sexp_at(range
)
158 return parent
.d
and parent
.start
161 finish_down_before
= function(range
, skip
)
162 local node
, parent
= parser
.tree
.sexp_at(range
)
163 if in_quasilist(node
, range
) then return end
164 local prev_list
= parent
.find_before(range
, function(t
) return t
.is_list
end)
166 local last
= prev_list
.before(range
.start
, finishof
, skip
)
168 return (last
.finish
or last
.p
and last
.start
+ #last
.p
) + 1, prev_list
170 return prev_list
.finish
, prev_list
175 finish_up_after
= function(range
)
176 local _
, parent
= sexp_at(range
)
177 return parent
.d
and parent
.finish
+ 1
180 indented_before
= function(range
)
181 return find_before_innermost(parser
.tree
, range
, startof
, function(t
) return t
.indent
end)
184 start_float_before
= function(range
, up_empty_list
)
185 if up_empty_list
then
186 local _
, parent
= sexp_at(range
)
187 if parent
.is_empty
then
188 return parent
.start
, parent
191 local node
= find_before_innermost(parser
.tree
, range
, startof
, function(t
, n
, _
)
192 return not t
.d
or t
.is_empty
and n
== 1 end)
193 return node
and node
.start
, node
196 finish_float_after
= function(range
, up_empty_list
)
197 if up_empty_list
then
198 local _
, parent
= sexp_at(range
)
199 if parent
.is_empty
then
200 return parent
.finish
+ 1, parent
203 local node
= find_after_innermost(parser
.tree
, range
, finishof
, function(t
, n
, max_n
)
204 return not t
.d
or t
.is_empty
and n
== max_n
end)
205 return node
and node
.finish
+ 1, node
208 start_word_after
= function(t
, range
)
209 local newpos
= t
.start_after(range
.start
)
211 local word
= t
.word_at({start
= newpos
, finish
= newpos
})
212 return word
and word
.start
214 local _
, parent
, n
= sexp_at(range
, true)
215 local cur
, nxt
= parent
[n
], parent
[n
+ 1]
216 if nxt
and is_line_comment(cur
) and is_line_comment(nxt
) then
217 return nxt
.start_after(range
.start
)
222 finish_word_after
= function(t
, range
)
223 local newpos
= t
.finish_after(math
.max(t
.start
+ #t
.d
, range
.finish
))
225 local word
= t
.word_at({start
= newpos
, finish
= newpos
})
226 return word
and word
.finish
+ 1
228 local _
, parent
, n
= sexp_at(range
, true)
229 local cur
, nxt
= parent
[n
], parent
[n
+ 1]
230 if nxt
and is_line_comment(cur
) and is_line_comment(nxt
) then
231 return nxt
.finish_after(range
.start
)
236 start_word_before
= function(t
, range
)
237 local newpos
= t
.start_before(range
.start
)
239 local word
= t
.word_at({start
= newpos
, finish
= newpos
})
240 return word
and word
.start
242 local _
, parent
, n
= sexp_at(range
, true)
243 local cur
, prev
= parent
[n
], parent
[n
- 1]
244 if prev
and is_line_comment(cur
) and is_line_comment(prev
) then
245 return prev
.start_before(range
.start
)
250 finish_word_before
= function(t
, range
)
251 local newpos
= t
.finish_before(range
.finish
)
253 local word
= t
.word_at({start
= newpos
, finish
= newpos
})
254 return word
and word
.finish
+ 1
256 local _
, parent
, n
= sexp_at(range
, true)
257 local cur
, prev
= parent
[n
], parent
[n
- 1]
258 if prev
and is_line_comment(cur
) and is_line_comment(prev
) then
259 return prev
.finish_before(range
.start
)
264 prev_start_wrapped
= function(range
)
265 local node
, parent
= parser
.tree
.sexp_at(range
)
266 if in_quasilist(node
, range
) then parent
= node
end
267 local pstart
= parent
.start
and (parent
.start
+ (parent
.p
and #parent
.p
or 0) + #parent
.d
)
268 local bol
= bol_at(range
.start
)
269 local prev_wrapped
= (parent
.is_list
or parent
.is_root
) and parent
.find_before(range
,
270 function(t
) return t
.start
< bol
and t
.finish
> bol
end,
271 function(t
) return t
.finish
< bol
273 local prev_start
= prev_wrapped
and prev_wrapped
.start
or bol
274 pstart
= pstart
or prev_start
275 return math
.max(pstart
, prev_start
)
278 next_finish_wrapped
= function(range
)
279 local node
, parent
= parser
.tree
.sexp_at(range
)
280 if in_quasilist(node
, range
) then parent
= node
end
281 local pfinish
= parent
.finish
and parent
.finish
+ 1 - #parser
.opposite
[parent
.d
]
282 local eol
= eol_at(range
.start
)
283 local next_wrapped
= (parent
.is_list
or parent
.is_root
) and parent
.find_after(range
,
284 function(t
) return t
.start
< eol
and t
.finish
> eol
end,
285 function(t
) return t
.start
> eol
287 local next_finish
= next_wrapped
and next_wrapped
.finish
+ 1 or eol
288 -- XXX: second return value, to be used for safe line-commenting:
289 local next_start_on_line
= math
.min(pfinish
or range
.start
, next_wrapped
and next_wrapped
.start
or eol
)
290 return math
.min(pfinish
or next_finish
, next_finish
), next_start_on_line
< eol
and next_start_on_line
or nil
293 paragraph_start_before
= function(range
, prev_line
)
294 local prev
, n
= parser
.tree
.before(range
.start
, startof
, is_comment
)
295 if not prev_line
then
296 return prev
and prev
.start
298 local pprev
= n
and parser
.tree
[n
- 1]
299 local has_eol
= pprev
and is_line_comment(pprev
)
300 local adjacent
= pprev
and prev
and prev
.start
- (pprev
.finish
+ (has_eol
and 0 or 1)) <= 1
301 return prev
and prev
.start
- ((adjacent
or prev
.start
== 0) and 0 or 1)
304 paragraph_finish_after
= function(range
, next_line
)
305 local node
= parser
.tree
.around(range
)
306 local nxt
, n
= parser
.tree
.find_after(node
or range
, function(t
)
307 return not t
.is_comment
and t
.finish
> range
.finish
309 return nxt
and nxt
.finish
+ 1 + (next_line
and parser
.tree
[n
+ 1] and parser
.tree
[n
+ 1].indent
and 1 or 0)
312 beginning_of_quasilist
= function(range
)
313 local _
, parent
= sexp_at(range
)
314 return parent
.start
and (parent
.start
+ (parent
.p
and #parent
.p
or 0) + #parent
.d
)
317 end_of_quasilist
= function(range
)
318 local _
, parent
= sexp_at(range
)
319 return parent
.finish
and parent
.finish
+ 1 - #parser
.opposite
[parent
.d
]
322 repl_line_begin
= function(range
)
323 local _
, parent
= parser
.tree
.sexp_at(range
)
324 if not parent
.is_root
then return end
325 local prev_indent
= parent
.find_before(range
, function(t
) return t
.indent
end)
326 return prev_indent
and prev_indent
.start
329 wider_than
= function(range
)
330 local node
, parent
= parser
.tree
.sexp_at(range
)
331 if not node
and parent
.is_root
then return end
332 local pstart
, pfinish
333 if in_quasilist(node
, range
) then
335 node
= node
.word_at(range
)
337 if not parent
.is_root
then
338 pstart
, pfinish
= parent
.start
+ (parent
.p
and #parent
.p
or 0) + #parent
.d
,
339 parent
.finish
+ 1 - #parser
.opposite
[parent
.d
]
341 local same_as_inner
= range
.start
== pstart
and range
.finish
== pfinish
342 local same_as_node
= node
and range
.start
== node
.start
and range
.finish
- 1 == node
.finish
343 if node
and not same_as_node
then
344 return node
.start
, node
.finish
+ 1
345 elseif not same_as_inner
then
346 return pstart
, pfinish
348 return parent
.start
, parent
.finish
+ 1
351 -- opening: nil - bracketed list; false - any quasilist;
352 quasilist_at
= function(range
, opening
)
353 if opening
and opening
:match
'[%;%"]' then
354 local escaped
= escaped_at(range
)
355 return escaped
and escaped
.d
:find("^"..opening
) and escaped
357 local _
, nodes
= parser
.tree
.sexp_path(range
)
359 local up
= #nodes
- 1
363 until not parent
or (opening
== false or not opening
or parent
.d
== opening
)
369 escaped_at
= escaped_at
,
370 paragraph_at
= parser
.tree
.around
,
371 goto_path
= parser
.tree
.goto_path
,
372 sexp_path
= parser
.tree
.sexp_path
,
373 find_after
= parser
.tree
.find_after
,
374 find_before
= parser
.tree
.find_before
,