]> git.wincent.com - docvim.git/blob - tests/fixtures/integration/ferret/golden/ast.golden
fix: add extra space after images
[docvim.git] / tests / fixtures / integration / ferret / golden / ast.golden
1 Project
2   [ HeaderAnnotation
3   , ImageAnnotation
4       "https://raw.githubusercontent.com/wincent/ferret/media/ferret.jpg"
5       (Just "center")
6   , ImageAnnotation
7       "https://raw.githubusercontent.com/wincent/ferret/media/ferret.gif"
8       (Just "center")
9   , Project
10       [ Unit
11           [ FunctionDeclaration
12               { functionBang = True
13               , functionName = "ferret#get_default_arguments"
14               , functionArguments = ArgumentList [ Argument "executable" ]
15               , functionAttributes = [ "abort" ]
16               , functionBody =
17                   [ GenericStatement
18                       "return get(ferret#private#executables(), a:executable, '')"
19                   ]
20               }
21           ]
22       , Unit
23           [ FunctionDeclaration
24               { functionBang = True
25               , functionName = "s:is_quickfix"
26               , functionArguments = ArgumentList []
27               , functionAttributes = []
28               , functionBody =
29                   [ GenericStatement "if exists('*getwininfo')"
30                   , LetStatement
31                       { letLexpr = "l:info" , letValue = "getwininfo(win_getid())[0]" }
32                   , GenericStatement "return l:info.quickfix && !l:info.loclist"
33                   , GenericStatement "else"
34                   , GenericStatement "return 1"
35                   , GenericStatement "endif"
36                   ]
37               }
38           , FunctionDeclaration
39               { functionBang = True
40               , functionName = "s:delete"
41               , functionArguments =
42                   ArgumentList [ Argument "first" , Argument "last" ]
43               , functionAttributes = []
44               , functionBody =
45                   [ LetStatement
46                       { letLexpr = "l:type"
47                       , letValue = "s:is_quickfix() ? 'qf' : 'location'"
48                       }
49                   , LetStatement
50                       { letLexpr = "l:list"
51                       , letValue = "l:type == 'qf' ? getqflist() : getloclist(0)"
52                       }
53                   , LetStatement { letLexpr = "l:line" , letValue = "a:first" }
54                   , GenericStatement "while l:line >= a:first && l:line <= a:last"
55                   , LetStatement { letLexpr = "l:list[l:line - 1]" , letValue = "0" }
56                   , LetStatement { letLexpr = "l:line" , letValue = "l:line + 1" }
57                   , GenericStatement "endwhile"
58                   , GenericStatement "if l:type ==# 'qf'"
59                   , GenericStatement "call setqflist(l:list, 'r')"
60                   , GenericStatement "execute 'cc ' . a:first"
61                   , GenericStatement "else"
62                   , GenericStatement "call setloclist(0, l:list, 'r')"
63                   , GenericStatement "execute 'll ' . a:first"
64                   , GenericStatement "endif"
65                   , GenericStatement "execute \"normal \\<C-W>\\<C-P>\""
66                   ]
67               }
68           , FunctionDeclaration
69               { functionBang = True
70               , functionName = "ferret#private#nvim"
71               , functionArguments = ArgumentList []
72               , functionAttributes = []
73               , functionBody =
74                   [ Empty
75                   , LetStatement
76                       { letLexpr = "l:nvim" , letValue = "get(g:, 'FerretNvim', 1)" }
77                   , GenericStatement "return l:nvim && has('nvim')"
78                   ]
79               }
80           , FunctionDeclaration
81               { functionBang = True
82               , functionName = "ferret#private#async"
83               , functionArguments = ArgumentList []
84               , functionAttributes = []
85               , functionBody =
86                   [ Empty
87                   , LetStatement
88                       { letLexpr = "l:async" , letValue = "get(g:, 'FerretJob', 1)" }
89                   , GenericStatement "return l:async && has('patch-7-4-1829')"
90                   ]
91               }
92           , FunctionDeclaration
93               { functionBang = True
94               , functionName = "ferret#private#error"
95               , functionArguments = ArgumentList [ Argument "message" ]
96               , functionAttributes = [ "abort" ]
97               , functionBody =
98                   [ GenericStatement "if has('lambda') && has('timers')"
99                   , GenericStatement
100                       "call timer_start(100, {-> s:print_error_with_echomsg(a:message)})"
101                   , GenericStatement "else"
102                   , GenericStatement "call inputsave()"
103                   , GenericStatement "echohl ErrorMsg"
104                   , GenericStatement
105                       "unsilent call input(a:message . ': press ENTER to continue')"
106                   , GenericStatement "echohl NONE"
107                   , GenericStatement "call inputrestore()"
108                   , GenericStatement "unsilent echo"
109                   , GenericStatement "redraw!"
110                   , GenericStatement "endif"
111                   ]
112               }
113           , FunctionDeclaration
114               { functionBang = True
115               , functionName = "s:print_error_with_echomsg"
116               , functionArguments = ArgumentList [ Argument "message" ]
117               , functionAttributes = []
118               , functionBody =
119                   [ GenericStatement "redraw!"
120                   , GenericStatement "echohl ErrorMsg"
121                   , GenericStatement "echomsg a:message"
122                   , GenericStatement "echohl NONE"
123                   ]
124               }
125           , FunctionDeclaration
126               { functionBang = True
127               , functionName = "s:parse"
128               , functionArguments = ArgumentList [ Argument "args" ]
129               , functionAttributes = [ "abort" ]
130               , functionBody =
131                   [ GenericStatement "if exists('g:ferret_lastsearch')"
132                   , UnletStatement
133                       { unletBang = False , unletBody = "g:ferret_lastsearch" }
134                   , GenericStatement "endif"
135                   , LetStatement
136                       { letLexpr = "l:odd_number_of_backslashes"
137                       , letValue = "'\\\\\\@<!\\\\\\(\\\\\\\\\\)*\\\\\\@!'"
138                       }
139                   , LetStatement
140                       { letLexpr = "l:unescaped_space"
141                       , letValue = "'\\('.l:odd_number_of_backslashes.'\\)\\@<! '"
142                       }
143                   , LetStatement
144                       { letLexpr = "l:args"
145                       , letValue = "split(a:args, l:unescaped_space)"
146                       }
147                   , LetStatement { letLexpr = "l:expanded_args" , letValue = "[]" }
148                   , GenericStatement "for l:arg in l:args"
149                   , LetStatement
150                       { letLexpr = "l:arg"
151                       , letValue = "substitute(l:arg, '\\\\ ', ' ', 'g')"
152                       }
153                   , GenericStatement "if ferret#private#option(l:arg)"
154                   , GenericStatement "call add(l:expanded_args, l:arg)"
155                   , GenericStatement "elseif exists('g:ferret_lastsearch')"
156                   , LetStatement
157                       { letLexpr = "l:file_args"
158                       , letValue =
159                           "glob(l:arg, 1, 1) \" Ignore 'wildignore', return a list."
160                       }
161                   , GenericStatement "if len(l:file_args)"
162                   , GenericStatement "call extend(l:expanded_args, l:file_args)"
163                   , GenericStatement "else"
164                   , GenericStatement "call add(l:expanded_args, l:arg)"
165                   , GenericStatement "endif"
166                   , GenericStatement "else"
167                   , LetStatement
168                       { letLexpr = "g:ferret_lastsearch" , letValue = "l:arg" }
169                   , GenericStatement "call add(l:expanded_args, l:arg)"
170                   , GenericStatement "endif"
171                   , GenericStatement "endfor"
172                   , GenericStatement
173                       "if ferret#private#nvim() || ferret#private#async()"
174                   , GenericStatement "return l:expanded_args"
175                   , GenericStatement "endif"
176                   , LetStatement
177                       { letLexpr = "l:each_word_shell_escaped"
178                       , letValue = "map(l:expanded_args, 'shellescape(v:val)')"
179                       }
180                   , LetStatement
181                       { letLexpr = "l:joined"
182                       , letValue = "join(l:each_word_shell_escaped)"
183                       }
184                   , GenericStatement "return escape(l:joined, '<>#')"
185                   ]
186               }
187           , FunctionDeclaration
188               { functionBang = True
189               , functionName = "ferret#private#clearautocmd"
190               , functionArguments = ArgumentList []
191               , functionAttributes = [ "abort" ]
192               , functionBody =
193                   [ GenericStatement "if has('autocmd')"
194                   , GenericStatement "augroup FerretPostQF"
195                   , GenericStatement "autocmd!"
196                   , GenericStatement "augroup END"
197                   , GenericStatement "endif"
198                   ]
199               }
200           , FunctionDeclaration
201               { functionBang = True
202               , functionName = "s:qfsize"
203               , functionArguments = ArgumentList [ Argument "type" ]
204               , functionAttributes = [ "abort" ]
205               , functionBody =
206                   [ GenericStatement "if has('patch-8.0.1112')"
207                   , GenericStatement "if a:type ==# 'qf'"
208                   , GenericStatement "return get(getqflist({'size' : 0}), 'size', 0)"
209                   , GenericStatement "else"
210                   , GenericStatement
211                       "return get(getloclist(0, {'size' : 0}), 'size', 0)"
212                   , GenericStatement "endif"
213                   , GenericStatement "else"
214                   , LetStatement
215                       { letLexpr = "l:qflist"
216                       , letValue = "a:type ==# 'qf' ? getqflist() : getloclist(0)"
217                       }
218                   , GenericStatement "return len(l:qflist)"
219                   , GenericStatement "endif"
220                   ]
221               }
222           , FunctionDeclaration
223               { functionBang = True
224               , functionName = "ferret#private#post"
225               , functionArguments = ArgumentList [ Argument "type" ]
226               , functionAttributes = [ "abort" ]
227               , functionBody =
228                   [ GenericStatement "call ferret#private#clearautocmd()"
229                   , LetStatement
230                       { letLexpr = "l:lastsearch"
231                       , letValue = "get(g:, 'ferret_lastsearch', '')"
232                       }
233                   , LetStatement
234                       { letLexpr = "l:tip"
235                       , letValue = "' [see `:help ferret-quotes`]'"
236                       }
237                   , LetStatement
238                       { letLexpr = "l:len" , letValue = "s:qfsize(a:type)" }
239                   , GenericStatement "if l:len == 0"
240                   , LetStatement
241                       { letLexpr = "l:base"
242                       , letValue =
243                           "'No results for search pattern `' . l:lastsearch . '`'"
244                       }
245                   , GenericStatement
246                       "if l:lastsearch =~ '\\v^([' . \"'\" . '\"])[^ \\1]+\\1$'"
247                   , GenericStatement "call ferret#private#error(l:base . l:tip)"
248                   , GenericStatement "else"
249                   , GenericStatement "call ferret#private#error(l:base)"
250                   , GenericStatement "endif"
251                   , GenericStatement "else"
252                   , LetStatement
253                       { letLexpr = "l:qflist"
254                       , letValue = "a:type ==# 'qf' ? getqflist() : getloclist(0)"
255                       }
256                   , LetStatement
257                       { letLexpr = "l:invalid"
258                       , letValue = "filter(copy(l:qflist), 'v:val.valid == 0')"
259                       }
260                   , GenericStatement "if len(l:invalid) == l:len"
261                   , GenericStatement "redraw!"
262                   , GenericStatement "echohl ErrorMsg"
263                   , GenericStatement "for l:item in l:invalid"
264                   , GenericStatement "unsilent echomsg l:item.text"
265                   , GenericStatement "endfor"
266                   , GenericStatement "echohl NONE"
267                   , LetStatement
268                       { letLexpr = "l:base"
269                       , letValue = "'Search for `' . l:lastsearch . '` failed'"
270                       }
271                   , GenericStatement
272                       "if l:lastsearch =~ '\\v^[' . \"'\" . '\"].+[^' . \"'\" . '\"]$'"
273                   , GenericStatement "call ferret#private#error(l:base . l:tip)"
274                   , GenericStatement "else"
275                   , GenericStatement "call ferret#private#error(l:base)"
276                   , GenericStatement "endif"
277                   , GenericStatement "endif"
278                   , GenericStatement "endif"
279                   , GenericStatement "return l:len"
280                   ]
281               }
282           , FunctionDeclaration
283               { functionBang = True
284               , functionName = "ferret#private#ack"
285               , functionArguments =
286                   ArgumentList [ Argument "bang" , Argument "args" ]
287               , functionAttributes = [ "abort" ]
288               , functionBody =
289                   [ LetStatement
290                       { letLexpr = "l:command" , letValue = "s:parse(a:args)" }
291                   , GenericStatement "call ferret#private#hlsearch()"
292                   , LetStatement
293                       { letLexpr = "l:executable"
294                       , letValue = "ferret#private#executable()"
295                       }
296                   , GenericStatement "if empty(l:executable)"
297                   , GenericStatement "call ferret#private#installprompt()"
298                   , GenericStatement "return"
299                   , GenericStatement "endif"
300                   , GenericStatement "if ferret#private#nvim()"
301                   , GenericStatement
302                       "call ferret#private#nvim#search(l:command, 1, a:bang)"
303                   , GenericStatement "elseif ferret#private#async()"
304                   , GenericStatement
305                       "call ferret#private#async#search(l:command, 1, a:bang)"
306                   , GenericStatement "else"
307                   , GenericStatement
308                       "call ferret#private#vanilla#search(l:command, 1)"
309                   , GenericStatement "endif"
310                   ]
311               }
312           , FunctionDeclaration
313               { functionBang = True
314               , functionName = "ferret#private#buflist"
315               , functionArguments = ArgumentList []
316               , functionAttributes = [ "abort" ]
317               , functionBody =
318                   [ LetStatement
319                       { letLexpr = "l:buflist"
320                       , letValue = "getbufinfo({'buflisted': 1})"
321                       }
322                   , LetStatement
323                       { letLexpr = "l:bufpaths"
324                       , letValue =
325                           "filter(map(l:buflist, 'v:val.name'), 'v:val !=# \"\"')"
326                       }
327                   , GenericStatement "return join(l:bufpaths, ' ')"
328                   ]
329               }
330           , FunctionDeclaration
331               { functionBang = True
332               , functionName = "ferret#private#back"
333               , functionArguments =
334                   ArgumentList [ Argument "bang" , Argument "args" ]
335               , functionAttributes = [ "abort" ]
336               , functionBody =
337                   [ GenericStatement
338                       "call call('ferret#private#ack', [a:bang, a:args . ' ' . ferret#private#buflist()])"
339                   ]
340               }
341           , FunctionDeclaration
342               { functionBang = True
343               , functionName = "ferret#private#black"
344               , functionArguments =
345                   ArgumentList [ Argument "bang" , Argument "args" ]
346               , functionAttributes = [ "abort" ]
347               , functionBody =
348                   [ GenericStatement
349                       "call call('ferret#private#lack', [a:bang, a:args . ' ' . ferret#private#buflist()])"
350                   ]
351               }
352           , FunctionDeclaration
353               { functionBang = True
354               , functionName = "ferret#private#quack"
355               , functionArguments =
356                   ArgumentList [ Argument "bang" , Argument "args" ]
357               , functionAttributes = [ "abort" ]
358               , functionBody =
359                   [ GenericStatement "if s:qfsize('qf') == 0"
360                   , GenericStatement
361                       "call ferret#private#error('Cannot search in empty quickfix list')"
362                   , GenericStatement "else"
363                   , GenericStatement
364                       "call call('ferret#private#ack', [a:bang, a:args . ' ' . ferret#private#args('qf')])"
365                   , GenericStatement "endif"
366                   ]
367               }
368           , FunctionDeclaration
369               { functionBang = True
370               , functionName = "ferret#private#installprompt"
371               , functionArguments = ArgumentList []
372               , functionAttributes = [ "abort" ]
373               , functionBody =
374                   [ GenericStatement
375                       "call ferret#private#error( 'Unable to find suitable executable; install rg, ag, ack or ack-grep' )"
376                   ]
377               }
378           , FunctionDeclaration
379               { functionBang = True
380               , functionName = "ferret#private#lack"
381               , functionArguments =
382                   ArgumentList [ Argument "bang" , Argument "args" ]
383               , functionAttributes = [ "abort" ]
384               , functionBody =
385                   [ LetStatement
386                       { letLexpr = "l:command" , letValue = "s:parse(a:args)" }
387                   , GenericStatement "call ferret#private#hlsearch()"
388                   , LetStatement
389                       { letLexpr = "l:executable"
390                       , letValue = "ferret#private#executable()"
391                       }
392                   , GenericStatement "if empty(l:executable)"
393                   , GenericStatement "call ferret#private#installprompt()"
394                   , GenericStatement "return"
395                   , GenericStatement "endif"
396                   , GenericStatement "if ferret#private#nvim()"
397                   , GenericStatement
398                       "call ferret#private#nvim#search(l:command, 0, a:bang)"
399                   , GenericStatement "elseif ferret#private#async()"
400                   , GenericStatement
401                       "call ferret#private#async#search(l:command, 0, a:bang)"
402                   , GenericStatement "else"
403                   , GenericStatement
404                       "call ferret#private#vanilla#search(l:command, 0)"
405                   , GenericStatement "endif"
406                   ]
407               }
408           , FunctionDeclaration
409               { functionBang = True
410               , functionName = "ferret#private#hlsearch"
411               , functionArguments = ArgumentList []
412               , functionAttributes = [ "abort" ]
413               , functionBody =
414                   [ GenericStatement "if has('extra_search')"
415                   , Empty
416                   , LetStatement
417                       { letLexpr = "l:hlsearch"
418                       , letValue = "get(g:, 'FerretHlsearch', &hlsearch)"
419                       }
420                   , GenericStatement "if l:hlsearch && exists('g:ferret_lastsearch')"
421                   , LetStatement
422                       { letLexpr = "@/" , letValue = "g:ferret_lastsearch" }
423                   , GenericStatement
424                       "call feedkeys(\":let &hlsearch=1 | echo \\<CR>\", 'n')"
425                   , GenericStatement "endif"
426                   , GenericStatement "endif"
427                   ]
428               }
429           , FunctionDeclaration
430               { functionBang = True
431               , functionName = "ferret#private#acks"
432               , functionArguments =
433                   ArgumentList [ Argument "command" , Argument "type" ]
434               , functionAttributes = [ "abort" ]
435               , functionBody =
436                   [ LetStatement
437                       { letLexpr = "l:matches"
438                       , letValue =
439                           "matchlist(a:command, '\\v\\C^(([^|\"\\\\a-zA-Z0-9]).+\\2.*\\2)([cgeiI]*)$')"
440                       }
441                   , GenericStatement "if !len(l:matches)"
442                   , GenericStatement
443                       "call ferret#private#error( 'Ferret: Expected a substitution expression (/foo/bar/); got: ' . a:command )"
444                   , GenericStatement "return"
445                   , GenericStatement "endif"
446                   , LetStatement
447                       { letLexpr = "l:pattern" , letValue = "l:matches[1]" }
448                   , LetStatement
449                       { letLexpr = "l:options" , letValue = "l:matches[3]" }
450                   , GenericStatement "if l:options !~# 'e'"
451                   , LetStatement { letLexpr = "l:options." , letValue = "'e'" }
452                   , GenericStatement "endif"
453                   , GenericStatement "if !&gdefault"
454                   , GenericStatement "if l:options !~# 'g'"
455                   , LetStatement { letLexpr = "l:options." , letValue = "'g'" }
456                   , GenericStatement "else"
457                   , LetStatement
458                       { letLexpr = "l:options"
459                       , letValue = "substitute(l:options, 'g', '', 'g') . 'g'"
460                       }
461                   , GenericStatement "endif"
462                   , GenericStatement "elseif &gdefault && l:options =~# 'g'"
463                   , LetStatement
464                       { letLexpr = "l:options"
465                       , letValue = "substitute(l:options, 'g', '', 'g')"
466                       }
467                   , GenericStatement "endif"
468                   , LetStatement
469                       { letLexpr = "l:cdo"
470                       , letValue = "has('listcmds') && exists(':cdo') == 2"
471                       }
472                   , GenericStatement "if !l:cdo"
473                   , LetStatement
474                       { letLexpr = "l:filenames"
475                       , letValue = "ferret#private#args(a:type)"
476                       }
477                   , GenericStatement "if l:filenames ==# ''"
478                   , GenericStatement
479                       "call ferret#private#error( 'Ferret: Quickfix filenames must be present, but there are none ' . '(must use :Ack to find files before :Acks can be used)' )"
480                   , GenericStatement "return"
481                   , GenericStatement "endif"
482                   , GenericStatement "execute 'args' l:filenames"
483                   , GenericStatement "endif"
484                   , GenericStatement "call ferret#private#autocmd('FerretWillWrite')"
485                   , GenericStatement "if l:cdo"
486                   , GenericStatement "if a:type == 'qf'"
487                   , Empty
488                   , GenericStatement
489                       "if get(g:, 'FerretAcksCommand', 'cdo') == 'cfdo'"
490                   , LetStatement { letLexpr = "l:command" , letValue = "'cfdo'" }
491                   , LetStatement
492                       { letLexpr = "l:substitute" , letValue = "'%substitute'" }
493                   , GenericStatement "else"
494                   , LetStatement { letLexpr = "l:command" , letValue = "'cdo'" }
495                   , LetStatement
496                       { letLexpr = "l:substitute" , letValue = "'substitute'" }
497                   , GenericStatement "endif"
498                   , GenericStatement "else"
499                   , Empty
500                   , GenericStatement
501                       "if get(g:, 'FerretLacksCommand', 'ldo') == 'lfdo'"
502                   , LetStatement { letLexpr = "l:command" , letValue = "'lfdo'" }
503                   , LetStatement
504                       { letLexpr = "l:substitute" , letValue = "'%substitute'" }
505                   , GenericStatement "else"
506                   , LetStatement { letLexpr = "l:command" , letValue = "'ldo'" }
507                   , LetStatement
508                       { letLexpr = "l:substitute" , letValue = "'substitute'" }
509                   , GenericStatement "endif"
510                   , GenericStatement "endif"
511                   , GenericStatement "else"
512                   , LetStatement { letLexpr = "l:command" , letValue = "'argdo'" }
513                   , LetStatement
514                       { letLexpr = "l:substitute" , letValue = "'%substitute'" }
515                   , GenericStatement "endif"
516                   , GenericStatement
517                       "execute l:command l:substitute . l:pattern . l:options . ' | update'"
518                   , GenericStatement "call ferret#private#autocmd('FerretDidWrite')"
519                   ]
520               }
521           , FunctionDeclaration
522               { functionBang = True
523               , functionName = "ferret#private#acks_prompt"
524               , functionArguments = ArgumentList []
525               , functionAttributes = [ "abort" ]
526               , functionBody =
527                   [ LetStatement
528                       { letLexpr = "l:magic"
529                       , letValue = "get(g:, 'FerretVeryMagic', 1)"
530                       }
531                   , LetStatement
532                       { letLexpr = "l:mode" , letValue = "l:magic ? '\\v' : ''" }
533                   , GenericStatement "if exists('g:ferret_lastsearch')"
534                   , GenericStatement
535                       "return '/' . l:mode . g:ferret_lastsearch . '// '"
536                   , GenericStatement "else"
537                   , GenericStatement "return '/' . l:mode . '//'"
538                   , GenericStatement "endif"
539                   ]
540               }
541           , FunctionDeclaration
542               { functionBang = True
543               , functionName = "ferret#private#autocmd"
544               , functionArguments = ArgumentList [ Argument "cmd" ]
545               , functionAttributes = [ "abort" ]
546               , functionBody =
547                   [ GenericStatement
548                       "if v:version > 703 || v:version == 703 && has('patch438')"
549                   , GenericStatement
550                       "execute 'silent doautocmd <nomodeline> User ' . a:cmd"
551                   , GenericStatement "else"
552                   , GenericStatement "execute 'silent doautocmd User ' . a:cmd"
553                   , GenericStatement "endif"
554                   ]
555               }
556           , FunctionDeclaration
557               { functionBang = True
558               , functionName = "s:split"
559               , functionArguments = ArgumentList [ Argument "str" ]
560               , functionAttributes = [ "abort" ]
561               , functionBody =
562                   [ GenericStatement
563                       "return split(a:str, '\\%(\\%(\\%(^\\|[^\\\\]\\)\\\\\\)\\@<!\\s\\)\\+\\zs')"
564                   ]
565               }
566           , FunctionDeclaration
567               { functionBang = True
568               , functionName = "ferret#private#ackcomplete"
569               , functionArguments =
570                   ArgumentList
571                     [ Argument "arglead" , Argument "cmdline" , Argument "cursorpos" ]
572               , functionAttributes = [ "abort" ]
573               , functionBody =
574                   [ GenericStatement
575                       "return ferret#private#complete('Ack', a:arglead, a:cmdline, a:cursorpos, 1)"
576                   ]
577               }
578           , FunctionDeclaration
579               { functionBang = True
580               , functionName = "ferret#private#backcomplete"
581               , functionArguments =
582                   ArgumentList
583                     [ Argument "arglead" , Argument "cmdline" , Argument "cursorpos" ]
584               , functionAttributes = [ "abort" ]
585               , functionBody =
586                   [ GenericStatement
587                       "return ferret#private#complete('Back', a:arglead, a:cmdline, a:cursorpos, 0)"
588                   ]
589               }
590           , FunctionDeclaration
591               { functionBang = True
592               , functionName = "ferret#private#blackcomplete"
593               , functionArguments =
594                   ArgumentList
595                     [ Argument "arglead" , Argument "cmdline" , Argument "cursorpos" ]
596               , functionAttributes = [ "abort" ]
597               , functionBody =
598                   [ GenericStatement
599                       "return ferret#private#complete('Black', a:arglead, a:cmdline, a:cursorpos, 0)"
600                   ]
601               }
602           , FunctionDeclaration
603               { functionBang = True
604               , functionName = "ferret#private#lackcomplete"
605               , functionArguments =
606                   ArgumentList
607                     [ Argument "arglead" , Argument "cmdline" , Argument "cursorpos" ]
608               , functionAttributes = [ "abort" ]
609               , functionBody =
610                   [ GenericStatement
611                       "return ferret#private#complete('Lack', a:arglead, a:cmdline, a:cursorpos, 1)"
612                   ]
613               }
614           , FunctionDeclaration
615               { functionBang = True
616               , functionName = "ferret#private#quackcomplete"
617               , functionArguments =
618                   ArgumentList
619                     [ Argument "arglead" , Argument "cmdline" , Argument "cursorpos" ]
620               , functionAttributes = [ "abort" ]
621               , functionBody =
622                   [ GenericStatement
623                       "return ferret#private#complete('Quack', a:arglead, a:cmdline, a:cursorpos, 0)"
624                   ]
625               }
626           , FunctionDeclaration
627               { functionBang = True
628               , functionName = "ferret#private#executable_name"
629               , functionArguments = ArgumentList []
630               , functionAttributes = []
631               , functionBody =
632                   [ LetStatement
633                       { letLexpr = "l:executable"
634                       , letValue = "ferret#private#executable()"
635                       }
636                   , GenericStatement "return matchstr(l:executable, '\\v\\w+')"
637                   ]
638               }
639           , LetStatement { letLexpr = "s:options" , letValue = "{" }
640           , GenericStatement
641               "\\ 'ack': [ '--ignore-ack-defaults', '--ignore-case', '--ignore-dir', '--ignore-directory', '--invert-match', '--known-types', '--literal', '--no-recurse', '--recurse', '--sort-files', '--type', '--word-regexp', '-1', '-Q', '-R', '-i', '-k', '-r', '-v', '-w', ], 'ag': [ '--all-types', '--all-text', '--case-sensitive', '--depth', '--follow', '--ignore', '--ignore-case', '--ignore-dir', '--invert-match', '--literal', '--max-count', '--skip-vcs-ignores', '--unrestricted', '--word-regexp', '-Q', '-U', '-a', '-i', '-m', '-s', '-t', '-u', '-v', '-w' ], 'rg': [ '--case-sensitive', '--files-with-matches', '--follow', '--glob', '--hidden', '--ignore-case', '--invert-match', '--max-count', '--maxdepth', '--mmap', '--no-ignore', '--no-ignore-parent', '--no-ignore-vcs', '--no-mmap', '--regexp', '--smart-case', '--text', '--threads', '--type', '--type-not', '--unrestricted', '--word-regexp', '-F', '-L', '-R', '-T', '-a', '-e', '-g', '-i', '-j', '-m', '-s', '-t', '-u', '-v', '-w' ] }"
642           , LetStatement
643               { letLexpr = "s:options['ack-grep']"
644               , letValue = "s:options['ack']"
645               }
646           , FunctionDeclaration
647               { functionBang = True
648               , functionName = "ferret#private#complete"
649               , functionArguments =
650                   ArgumentList
651                     [ Argument "cmd"
652                     , Argument "arglead"
653                     , Argument "cmdline"
654                     , Argument "cursorpos"
655                     , Argument "files"
656                     ]
657               , functionAttributes = [ "abort" ]
658               , functionBody =
659                   [ LetStatement
660                       { letLexpr = "l:args"
661                       , letValue = "s:split(a:cmdline[:a:cursorpos])"
662                       }
663                   , LetStatement { letLexpr = "l:command_seen" , letValue = "0" }
664                   , LetStatement { letLexpr = "l:pattern_seen" , letValue = "0" }
665                   , LetStatement { letLexpr = "l:position" , letValue = "0" }
666                   , GenericStatement "for l:arg in l:args"
667                   , LetStatement
668                       { letLexpr = "l:position" , letValue = "l:position + len(l:arg)" }
669                   , LetStatement
670                       { letLexpr = "l:stripped"
671                       , letValue = "substitute(l:arg, '\\s\\+$', '', '')"
672                       }
673                   , GenericStatement "if ferret#private#option(l:stripped)"
674                   , GenericStatement "if a:cursorpos <= l:position"
675                   , LetStatement
676                       { letLexpr = "l:options"
677                       , letValue = "get(s:options, ferret#private#executable_name(), [])"
678                       }
679                   , GenericStatement
680                       "return filter(l:options, 'match(v:val, l:stripped) == 0')"
681                   , GenericStatement "endif"
682                   , GenericStatement "elseif l:pattern_seen && a:files"
683                   , GenericStatement "if a:cursorpos <= l:position"
684                   , GenericStatement "return glob(a:arglead . '*', 1, 1)"
685                   , GenericStatement "end"
686                   , GenericStatement "elseif l:command_seen"
687                   , LetStatement { letLexpr = "l:pattern_seen" , letValue = "1" }
688                   , GenericStatement "elseif l:stripped ==# a:cmd"
689                   , LetStatement { letLexpr = "l:command_seen" , letValue = "1" }
690                   , GenericStatement "else"
691                   , GenericStatement "end"
692                   , GenericStatement "endfor"
693                   , GenericStatement "return []"
694                   ]
695               }
696           , FunctionDeclaration
697               { functionBang = True
698               , functionName = "ferret#private#option"
699               , functionArguments = ArgumentList [ Argument "str" ]
700               , functionAttributes = [ "abort" ]
701               , functionBody = [ GenericStatement "return a:str =~# '^-'" ]
702               }
703           , FunctionDeclaration
704               { functionBang = True
705               , functionName = "ferret#private#args"
706               , functionArguments = ArgumentList [ Argument "type" ]
707               , functionAttributes = [ "abort" ]
708               , functionBody =
709                   [ LetStatement { letLexpr = "l:buffer_numbers" , letValue = "{}" }
710                   , LetStatement
711                       { letLexpr = "l:items"
712                       , letValue = "a:type == 'qf' ? getqflist() : getloclist(0)"
713                       }
714                   , GenericStatement "for l:item in l:items"
715                   , LetStatement
716                       { letLexpr = "l:number" , letValue = "l:item['bufnr']" }
717                   , GenericStatement "if !has_key(l:buffer_numbers, l:number)"
718                   , LetStatement
719                       { letLexpr = "l:buffer_numbers[l:number]"
720                       , letValue = "bufname(l:number)"
721                       }
722                   , GenericStatement "endif"
723                   , GenericStatement "endfor"
724                   , GenericStatement
725                       "return join(map(values(l:buffer_numbers), 'fnameescape(v:val)'))"
726                   ]
727               }
728           , FunctionDeclaration
729               { functionBang = True
730               , functionName = "ferret#private#qf_delete"
731               , functionArguments = ArgumentList []
732               , functionAttributes = [ "range" ]
733               , functionBody =
734                   [ GenericStatement "call s:delete(a:firstline, a:lastline)" ]
735               }
736           , FunctionDeclaration
737               { functionBang = True
738               , functionName = "ferret#private#qf_delete_motion"
739               , functionArguments =
740                   ArgumentList [ Argument "type" , Argument "..." ]
741               , functionAttributes = []
742               , functionBody =
743                   [ LetStatement
744                       { letLexpr = "l:selection" , letValue = "&selection" }
745                   , LetStatement
746                       { letLexpr = "&selection" , letValue = "'inclusive'" }
747                   , LetStatement
748                       { letLexpr = "l:firstline" , letValue = "line(\"'[\")" }
749                   , LetStatement
750                       { letLexpr = "l:lastline" , letValue = "line(\"']\")" }
751                   , GenericStatement "call s:delete(l:firstline, l:lastline)"
752                   , LetStatement
753                       { letLexpr = "&selection" , letValue = "l:selection" }
754                   ]
755               }
756           , LetStatement
757               { letLexpr = "s:force"
758               , letValue = "get(g:, 'FerretExecutable', 'rg,ag,ack,ack-grep')"
759               }
760           , LetStatement { letLexpr = "s:executables" , letValue = "{" }
761           , GenericStatement
762               "\\ 'rg': '--vimgrep --no-heading', 'ag': '', 'ack': '--column --with-filename', 'ack-grep': '--column --with-filename' }"
763           , LetStatement { letLexpr = "s:init_done" , letValue = "0" }
764           , FunctionDeclaration
765               { functionBang = True
766               , functionName = "ferret#private#executables"
767               , functionArguments = ArgumentList []
768               , functionAttributes = [ "abort" ]
769               , functionBody = [ GenericStatement "return copy(s:executables)" ]
770               }
771           , FunctionDeclaration
772               { functionBang = True
773               , functionName = "ferret#private#init"
774               , functionArguments = ArgumentList []
775               , functionAttributes = [ "abort" ]
776               , functionBody =
777                   [ GenericStatement "if s:init_done"
778                   , GenericStatement "return"
779                   , GenericStatement "endif"
780                   , GenericStatement "if executable('rg')"
781                   , LetStatement
782                       { letLexpr = "l:rg_help" , letValue = "system('rg --help')" }
783                   , GenericStatement "if match(l:rg_help, '--no-config') != -1"
784                   , LetStatement
785                       { letLexpr = "s:executables['rg']." , letValue = "' --no-config'" }
786                   , GenericStatement "endif"
787                   , GenericStatement "if match(l:rg_help, '--max-columns') != -1"
788                   , LetStatement
789                       { letLexpr = "s:executables['rg']."
790                       , letValue = "' --max-columns 4096'"
791                       }
792                   , GenericStatement "endif"
793                   , GenericStatement "endif"
794                   , GenericStatement "if executable('ag')"
795                   , LetStatement
796                       { letLexpr = "l:ag_help" , letValue = "system('ag --help')" }
797                   , GenericStatement "if match(l:ag_help, '--vimgrep') != -1"
798                   , LetStatement
799                       { letLexpr = "s:executables['ag']." , letValue = "'--vimgrep'" }
800                   , GenericStatement "else"
801                   , LetStatement
802                       { letLexpr = "s:executables['ag']." , letValue = "'--column'" }
803                   , GenericStatement "endif"
804                   , GenericStatement "if match(l:ag_help, '--width') != -1"
805                   , LetStatement
806                       { letLexpr = "s:executables['ag']."
807                       , letValue = "' --width 4096'"
808                       }
809                   , GenericStatement "endif"
810                   , GenericStatement "endif"
811                   , LetStatement
812                       { letLexpr = "l:executable"
813                       , letValue = "ferret#private#executable()"
814                       }
815                   , GenericStatement "if !empty(l:executable)"
816                   , LetStatement
817                       { letLexpr = "&grepprg" , letValue = "l:executable" }
818                   , LetStatement
819                       { letLexpr = "&grepformat" , letValue = "g:FerretFormat" }
820                   , GenericStatement "endif"
821                   , LetStatement { letLexpr = "s:init_done" , letValue = "1" }
822                   ]
823               }
824           , FunctionDeclaration
825               { functionBang = True
826               , functionName = "ferret#private#executable"
827               , functionArguments = ArgumentList []
828               , functionAttributes = [ "abort" ]
829               , functionBody =
830                   [ LetStatement
831                       { letLexpr = "l:valid" , letValue = "keys(s:executables)" }
832                   , LetStatement
833                       { letLexpr = "l:executables"
834                       , letValue = "split(s:force, '\\v\\s*,\\s*')"
835                       }
836                   , LetStatement
837                       { letLexpr = "l:executables"
838                       , letValue = "filter(l:executables, 'index(l:valid, v:val) != -1')"
839                       }
840                   , GenericStatement "if index(l:executables, 'rg') == -1"
841                   , GenericStatement "call add(l:executables, 'rg')"
842                   , GenericStatement "endif"
843                   , GenericStatement "if index(l:executables, 'ag') == -1"
844                   , GenericStatement "call add(l:executables, 'ag')"
845                   , GenericStatement "endif"
846                   , GenericStatement "if index(l:executables, 'ack') == -1"
847                   , GenericStatement "call add(l:executables, 'ack')"
848                   , GenericStatement "endif"
849                   , GenericStatement "if index(l:executables, 'ack-grep') == -1"
850                   , GenericStatement "call add(l:executables, 'ack-grep')"
851                   , GenericStatement "endif"
852                   , GenericStatement "for l:executable in l:executables"
853                   , GenericStatement "if executable(l:executable)"
854                   , Empty
855                   , LetStatement
856                       { letLexpr = "l:overrides"
857                       , letValue = "get(g:, 'FerretExecutableArguments', {})"
858                       }
859                   , LetStatement
860                       { letLexpr = "l:type"
861                       , letValue = "exists('v:t_dict') ? v:t_dict : 4"
862                       }
863                   , GenericStatement
864                       "if type(l:overrides) == l:type && has_key(l:overrides, l:executable)"
865                   , GenericStatement
866                       "return l:executable . ' ' . l:overrides[l:executable]"
867                   , GenericStatement "else"
868                   , GenericStatement
869                       "return l:executable . ' ' . s:executables[l:executable]"
870                   , GenericStatement "endif"
871                   , GenericStatement "endif"
872                   , GenericStatement "endfor"
873                   , GenericStatement "return ''"
874                   ]
875               }
876           , FunctionDeclaration
877               { functionBang = True
878               , functionName = "ferret#private#limit"
879               , functionArguments = ArgumentList []
880               , functionAttributes = [ "abort" ]
881               , functionBody =
882                   [ Empty
883                   , GenericStatement
884                       "return max([1, +get(g:, 'FerretMaxResults', 100000)]) - 1"
885                   ]
886               }
887           , GenericStatement "call ferret#private#init()"
888           ]
889       , Unit
890           [ LetStatement { letLexpr = "s:jobs" , letValue = "{}" }
891           , FunctionDeclaration
892               { functionBang = True
893               , functionName = "s:info_from_channel"
894               , functionArguments = ArgumentList [ Argument "channel" ]
895               , functionAttributes = []
896               , functionBody =
897                   [ LetStatement
898                       { letLexpr = "l:channel_id"
899                       , letValue = "ch_info(a:channel)['id']"
900                       }
901                   , GenericStatement "if has_key(s:jobs, l:channel_id)"
902                   , GenericStatement "return s:jobs[l:channel_id]"
903                   , GenericStatement "endif"
904                   ]
905               }
906           , FunctionDeclaration
907               { functionBang = True
908               , functionName = "ferret#private#async#search"
909               , functionArguments =
910                   ArgumentList
911                     [ Argument "command" , Argument "ack" , Argument "bang" ]
912               , functionAttributes = [ "abort" ]
913               , functionBody =
914                   [ GenericStatement "call ferret#private#async#cancel()"
915                   , GenericStatement
916                       "call ferret#private#autocmd('FerretAsyncStart')"
917                   , LetStatement
918                       { letLexpr = "l:command_and_args"
919                       , letValue =
920                           "extend(split(ferret#private#executable()), a:command)"
921                       }
922                   , LetStatement
923                       { letLexpr = "l:job"
924                       , letValue = "job_start(l:command_and_args, {"
925                       }
926                   , GenericStatement
927                       "\\ 'in_io': 'null', 'err_cb': 'ferret#private#async#err_cb', 'out_cb': 'ferret#private#async#out_cb', 'close_cb': 'ferret#private#async#close_cb', 'err_mode': 'raw', 'out_mode': 'raw' })"
928                   , LetStatement
929                       { letLexpr = "l:channel" , letValue = "job_getchannel(l:job)" }
930                   , LetStatement
931                       { letLexpr = "l:channel_id"
932                       , letValue = "ch_info(l:channel)['id']"
933                       }
934                   , LetStatement
935                       { letLexpr = "s:jobs[l:channel_id]" , letValue = "{" }
936                   , GenericStatement
937                       "\\ 'channel_id': l:channel_id, 'job': l:job, 'errors': [], 'output': [], 'pending_error': '', 'pending_output': '', 'pending_error_length': 0, 'pending_output_length': 0, 'result_count': 0, 'ack': a:ack, 'bang': a:bang, 'window': win_getid() }"
938                   ]
939               }
940           , LetStatement
941               { letLexpr = "s:max_line_length" , letValue = "4096" }
942           , FunctionDeclaration
943               { functionBang = True
944               , functionName = "ferret#private#async#err_cb"
945               , functionArguments =
946                   ArgumentList [ Argument "channel" , Argument "msg" ]
947               , functionAttributes = []
948               , functionBody =
949                   [ LetStatement
950                       { letLexpr = "l:info"
951                       , letValue = "s:info_from_channel(a:channel)"
952                       }
953                   , GenericStatement "if type(l:info) == 4"
954                   , LetStatement
955                       { letLexpr = "l:lines" , letValue = "split(a:msg, '\\n', 1)" }
956                   , LetStatement { letLexpr = "l:count" , letValue = "len(l:lines)" }
957                   , GenericStatement "for l:i in range(l:count)"
958                   , LetStatement { letLexpr = "l:line" , letValue = "l:lines[l:i]" }
959                   , GenericStatement
960                       "if l:i != l:count - 1 || l:line == '' && l:info.pending_error_length"
961                   , GenericStatement
962                       "if l:info.pending_error_length < s:max_line_length"
963                   , LetStatement { letLexpr = "l:rest" , letValue = "strpart(" }
964                   , GenericStatement
965                       "\\ l:line, 0, s:max_line_length - l:info.pending_error_length )"
966                   , GenericStatement
967                       "call add(l:info.errors, l:info.pending_error . l:rest)"
968                   , GenericStatement "else"
969                   , GenericStatement "call add(l:info.errors, l:info.pending_error)"
970                   , GenericStatement "endif"
971                   , LetStatement
972                       { letLexpr = "l:info.pending_error" , letValue = "''" }
973                   , LetStatement
974                       { letLexpr = "l:info.pending_error_length" , letValue = "0" }
975                   , GenericStatement
976                       "elseif l:info.pending_error_length < s:max_line_length"
977                   , LetStatement
978                       { letLexpr = "l:info.pending_error." , letValue = "l:line" }
979                   , LetStatement
980                       { letLexpr = "l:info.pending_error_length+"
981                       , letValue = "strlen(l:line)"
982                       }
983                   , GenericStatement "endif"
984                   , GenericStatement "endfor"
985                   , GenericStatement "endif"
986                   ]
987               }
988           , LetStatement
989               { letLexpr = "s:limit" , letValue = "ferret#private#limit()" }
990           , FunctionDeclaration
991               { functionBang = True
992               , functionName = "ferret#private#async#out_cb"
993               , functionArguments =
994                   ArgumentList [ Argument "channel" , Argument "msg" ]
995               , functionAttributes = []
996               , functionBody =
997                   [ LetStatement
998                       { letLexpr = "l:info"
999                       , letValue = "s:info_from_channel(a:channel)"
1000                       }
1001                   , GenericStatement "if type(l:info) == 4"
1002                   , GenericStatement
1003                       "if !l:info.bang && l:info.result_count > s:limit"
1004                   , GenericStatement "call s:MaxResultsExceeded(l:info)"
1005                   , GenericStatement "return"
1006                   , GenericStatement "endif"
1007                   , LetStatement
1008                       { letLexpr = "l:lines" , letValue = "split(a:msg, '\\n', 1)" }
1009                   , LetStatement { letLexpr = "l:count" , letValue = "len(l:lines)" }
1010                   , GenericStatement "for l:i in range(l:count)"
1011                   , LetStatement { letLexpr = "l:line" , letValue = "l:lines[l:i]" }
1012                   , GenericStatement
1013                       "if l:i != l:count - 1 || l:line == '' && l:info.pending_output_length"
1014                   , GenericStatement
1015                       "if l:info.pending_output_length < s:max_line_length"
1016                   , LetStatement { letLexpr = "l:rest" , letValue = "strpart(" }
1017                   , GenericStatement
1018                       "\\ l:line, 0, s:max_line_length - l:info.pending_output_length )"
1019                   , GenericStatement
1020                       "call add(l:info.output, l:info.pending_output . l:rest)"
1021                   , GenericStatement "else"
1022                   , GenericStatement "call add(l:info.output, l:info.pending_output)"
1023                   , GenericStatement "endif"
1024                   , LetStatement
1025                       { letLexpr = "l:info.pending_output" , letValue = "''" }
1026                   , LetStatement
1027                       { letLexpr = "l:info.pending_output_length" , letValue = "0" }
1028                   , GenericStatement "if !l:info.bang"
1029                   , LetStatement
1030                       { letLexpr = "l:info.result_count+" , letValue = "1" }
1031                   , GenericStatement "if l:info.result_count > s:limit"
1032                   , GenericStatement "call s:MaxResultsExceeded(l:info)"
1033                   , GenericStatement "break"
1034                   , GenericStatement "endif"
1035                   , GenericStatement "endif"
1036                   , GenericStatement
1037                       "elseif l:info.pending_output_length < s:max_line_length"
1038                   , LetStatement
1039                       { letLexpr = "l:info.pending_output." , letValue = "l:line" }
1040                   , LetStatement
1041                       { letLexpr = "l:info.pending_output_length+"
1042                       , letValue = "strlen(l:line)"
1043                       }
1044                   , GenericStatement "endif"
1045                   , GenericStatement "endfor"
1046                   , GenericStatement "endif"
1047                   ]
1048               }
1049           , FunctionDeclaration
1050               { functionBang = True
1051               , functionName = "ferret#private#async#close_cb"
1052               , functionArguments = ArgumentList [ Argument "channel" ]
1053               , functionAttributes = [ "abort" ]
1054               , functionBody =
1055                   [ LetStatement
1056                       { letLexpr = "l:info"
1057                       , letValue = "s:info_from_channel(a:channel)"
1058                       }
1059                   , GenericStatement "if type(l:info) == 4"
1060                   , GenericStatement "call remove(s:jobs, l:info.channel_id)"
1061                   , GenericStatement
1062                       "call ferret#private#autocmd('FerretAsyncFinish')"
1063                   , GenericStatement "if !l:info.ack"
1064                   , GenericStatement "call win_gotoid(l:info.window)"
1065                   , GenericStatement "endif"
1066                   , GenericStatement
1067                       "call ferret#private#shared#finalize_search(l:info.output, l:info.ack)"
1068                   , GenericStatement "for l:error in l:info.errors"
1069                   , GenericStatement "unsilent echomsg l:error"
1070                   , GenericStatement "endfor"
1071                   , GenericStatement "endif"
1072                   ]
1073               }
1074           , FunctionDeclaration
1075               { functionBang = True
1076               , functionName = "ferret#private#async#pull"
1077               , functionArguments = ArgumentList []
1078               , functionAttributes = [ "abort" ]
1079               , functionBody =
1080                   [ GenericStatement "for l:channel_id in keys(s:jobs)"
1081                   , LetStatement
1082                       { letLexpr = "l:info" , letValue = "s:jobs[l:channel_id]" }
1083                   , GenericStatement
1084                       "call ferret#private#shared#finalize_search(l:info.output, l:info.ack)"
1085                   , GenericStatement "endfor"
1086                   ]
1087               }
1088           , FunctionDeclaration
1089               { functionBang = True
1090               , functionName = "ferret#private#async#cancel"
1091               , functionArguments = ArgumentList []
1092               , functionAttributes = [ "abort" ]
1093               , functionBody =
1094                   [ LetStatement { letLexpr = "l:canceled" , letValue = "0" }
1095                   , GenericStatement "for l:channel_id in keys(s:jobs)"
1096                   , LetStatement
1097                       { letLexpr = "l:info" , letValue = "s:jobs[l:channel_id]" }
1098                   , GenericStatement "call job_stop(l:info.job)"
1099                   , GenericStatement "call remove(s:jobs, l:channel_id)"
1100                   , LetStatement { letLexpr = "l:canceled" , letValue = "1" }
1101                   , GenericStatement "endfor"
1102                   , GenericStatement "if l:canceled"
1103                   , GenericStatement
1104                       "call ferret#private#autocmd('FerretAsyncFinish')"
1105                   , GenericStatement "endif"
1106                   ]
1107               }
1108           , FunctionDeclaration
1109               { functionBang = True
1110               , functionName = "s:MaxResultsExceeded"
1111               , functionArguments = ArgumentList [ Argument "info" ]
1112               , functionAttributes = []
1113               , functionBody =
1114                   [ GenericStatement
1115                       "call ferret#private#shared#finalize_search(a:info.output, a:info.ack)"
1116                   , GenericStatement "call job_stop(a:info.job)"
1117                   , GenericStatement "call remove(s:jobs, a:info.channel_id)"
1118                   , GenericStatement
1119                       "call ferret#private#autocmd('FerretAsyncFinish')"
1120                   , GenericStatement
1121                       "call ferret#private#error( 'Maximum result count exceeded. ' . 'Either increase g:FerretMaxResults or ' . 're-run the search with :Ack!, :Lack! etc.' )"
1122                   ]
1123               }
1124           , FunctionDeclaration
1125               { functionBang = True
1126               , functionName = "ferret#private#async#debug"
1127               , functionArguments = ArgumentList []
1128               , functionAttributes = [ "abort" ]
1129               , functionBody = [ GenericStatement "return s:jobs" ]
1130               }
1131           ]
1132       , Unit
1133           [ FunctionDeclaration
1134               { functionBang = True
1135               , functionName = "ferret#private#dispatch#search"
1136               , functionArguments = ArgumentList [ Argument "command" ]
1137               , functionAttributes = [ "abort" ]
1138               , functionBody =
1139                   [ GenericStatement "if has('autocmd')"
1140                   , GenericStatement "augroup FerretPostQF"
1141                   , GenericStatement "autocmd!"
1142                   , GenericStatement
1143                       "autocmd QuickfixCmdPost cgetfile call ferret#private#post('qf')"
1144                   , GenericStatement "augroup END"
1145                   , GenericStatement "endif"
1146                   , LetStatement
1147                       { letLexpr = "l:original_makeprg" , letValue = "&l:makeprg" }
1148                   , LetStatement
1149                       { letLexpr = "l:original_errorformat"
1150                       , letValue = "&l:errorformat"
1151                       }
1152                   , GenericStatement "try"
1153                   , LetStatement
1154                       { letLexpr = "&l:makeprg"
1155                       , letValue = "ferret#private#executable() . ' ' . a:command"
1156                       }
1157                   , LetStatement
1158                       { letLexpr = "&l:errorformat" , letValue = "g:FerretFormat" }
1159                   , GenericStatement "Make"
1160                   , GenericStatement "catch"
1161                   , GenericStatement "call ferret#private#clearautocmd()"
1162                   , GenericStatement "finally"
1163                   , LetStatement
1164                       { letLexpr = "&l:makeprg" , letValue = "l:original_makeprg" }
1165                   , LetStatement
1166                       { letLexpr = "&l:errorformat"
1167                       , letValue = "l:original_errorformat"
1168                       }
1169                   , GenericStatement "endtry"
1170                   ]
1171               }
1172           ]
1173       , Unit
1174           [ LetStatement { letLexpr = "s:jobs" , letValue = "{}" }
1175           , FunctionDeclaration
1176               { functionBang = True
1177               , functionName = "s:info_from_job"
1178               , functionArguments = ArgumentList [ Argument "job" ]
1179               , functionAttributes = []
1180               , functionBody =
1181                   [ GenericStatement "if has_key(s:jobs, a:job)"
1182                   , GenericStatement "return s:jobs[a:job]"
1183                   , GenericStatement "endif"
1184                   ]
1185               }
1186           , FunctionDeclaration
1187               { functionBang = True
1188               , functionName = "ferret#private#nvim#search"
1189               , functionArguments =
1190                   ArgumentList
1191                     [ Argument "command" , Argument "ack" , Argument "bang" ]
1192               , functionAttributes = [ "abort" ]
1193               , functionBody =
1194                   [ GenericStatement "call ferret#private#nvim#cancel()"
1195                   , GenericStatement
1196                       "call ferret#private#autocmd('FerretAsyncStart')"
1197                   , LetStatement
1198                       { letLexpr = "l:command_and_args"
1199                       , letValue =
1200                           "extend(split(ferret#private#executable()), a:command)"
1201                       }
1202                   , LetStatement
1203                       { letLexpr = "l:job"
1204                       , letValue = "jobstart(l:command_and_args, {"
1205                       }
1206                   , GenericStatement
1207                       "\\ 'on_stderr': 'ferret#private#nvim#err_cb', 'on_stdout': 'ferret#private#nvim#out_cb', 'on_exit': 'ferret#private#nvim#close_cb' })"
1208                   , LetStatement { letLexpr = "s:jobs[l:job]" , letValue = "{" }
1209                   , GenericStatement
1210                       "\\ 'job': l:job, 'errors': [], 'output': [], 'pending_error': '', 'pending_output': '', 'pending_error_length': 0, 'pending_output_length': 0, 'result_count': 0, 'ack': a:ack, 'bang': a:bang, 'window': win_getid() }"
1211                   ]
1212               }
1213           , LetStatement
1214               { letLexpr = "s:max_line_length" , letValue = "4096" }
1215           , FunctionDeclaration
1216               { functionBang = True
1217               , functionName = "ferret#private#nvim#err_cb"
1218               , functionArguments =
1219                   ArgumentList
1220                     [ Argument "job" , Argument "lines" , Argument "event" ]
1221               , functionAttributes = [ "dict" ]
1222               , functionBody =
1223                   [ LetStatement
1224                       { letLexpr = "l:info" , letValue = "s:info_from_job(a:job)" }
1225                   , GenericStatement "if type(l:info) == 4"
1226                   , LetStatement { letLexpr = "l:count" , letValue = "len(a:lines)" }
1227                   , GenericStatement "for l:i in range(l:count)"
1228                   , LetStatement { letLexpr = "l:line" , letValue = "a:lines[l:i]" }
1229                   , GenericStatement
1230                       "if l:i != l:count - 1 || l:line == '' && l:info.pending_error_length"
1231                   , GenericStatement
1232                       "if l:info.pending_error_length < s:max_line_length"
1233                   , LetStatement { letLexpr = "l:rest" , letValue = "strpart(" }
1234                   , GenericStatement
1235                       "\\ l:line, 0, s:max_line_length - l:info.pending_error_length )"
1236                   , GenericStatement
1237                       "call add(l:info.errors, l:info.pending_error . l:rest)"
1238                   , GenericStatement "else"
1239                   , GenericStatement "call add(l:info.errors, l:info.pending_error)"
1240                   , GenericStatement "endif"
1241                   , LetStatement
1242                       { letLexpr = "l:info.pending_error" , letValue = "''" }
1243                   , LetStatement
1244                       { letLexpr = "l:info.pending_error_length" , letValue = "0" }
1245                   , GenericStatement
1246                       "elseif l:info.pending_error_length < s:max_line_length"
1247                   , LetStatement
1248                       { letLexpr = "l:info.pending_error." , letValue = "l:line" }
1249                   , LetStatement
1250                       { letLexpr = "l:info.pending_error_length+"
1251                       , letValue = "strlen(l:line)"
1252                       }
1253                   , GenericStatement "endif"
1254                   , GenericStatement "endfor"
1255                   , GenericStatement "endif"
1256                   ]
1257               }
1258           , LetStatement
1259               { letLexpr = "s:limit" , letValue = "ferret#private#limit()" }
1260           , FunctionDeclaration
1261               { functionBang = True
1262               , functionName = "ferret#private#nvim#out_cb"
1263               , functionArguments =
1264                   ArgumentList
1265                     [ Argument "job" , Argument "lines" , Argument "event" ]
1266               , functionAttributes = [ "dict" ]
1267               , functionBody =
1268                   [ LetStatement
1269                       { letLexpr = "l:info" , letValue = "s:info_from_job(a:job)" }
1270                   , GenericStatement "if type(l:info) == 4"
1271                   , GenericStatement
1272                       "if !l:info.bang && l:info.result_count > s:limit"
1273                   , GenericStatement "call s:MaxResultsExceeded(l:info)"
1274                   , GenericStatement "return"
1275                   , GenericStatement "endif"
1276                   , LetStatement { letLexpr = "l:count" , letValue = "len(a:lines)" }
1277                   , GenericStatement "for l:i in range(l:count)"
1278                   , LetStatement { letLexpr = "l:line" , letValue = "a:lines[l:i]" }
1279                   , GenericStatement
1280                       "if l:i != l:count - 1 || l:line == '' && l:info.pending_output_length"
1281                   , GenericStatement
1282                       "if l:info.pending_output_length < s:max_line_length"
1283                   , LetStatement { letLexpr = "l:rest" , letValue = "strpart(" }
1284                   , GenericStatement
1285                       "\\ l:line, 0, s:max_line_length - l:info.pending_output_length )"
1286                   , GenericStatement
1287                       "call add(l:info.output, l:info.pending_output . l:rest)"
1288                   , GenericStatement "else"
1289                   , GenericStatement "call add(l:info.output, l:info.pending_output)"
1290                   , GenericStatement "endif"
1291                   , LetStatement
1292                       { letLexpr = "l:info.pending_output" , letValue = "''" }
1293                   , LetStatement
1294                       { letLexpr = "l:info.pending_output_length" , letValue = "0" }
1295                   , GenericStatement "if !l:info.bang"
1296                   , LetStatement
1297                       { letLexpr = "l:info.result_count+" , letValue = "1" }
1298                   , GenericStatement "if l:info.result_count > s:limit"
1299                   , GenericStatement "call s:MaxResultsExceeded(l:info)"
1300                   , GenericStatement "break"
1301                   , GenericStatement "endif"
1302                   , GenericStatement "endif"
1303                   , GenericStatement
1304                       "elseif l:info.pending_output_length < s:max_line_length"
1305                   , LetStatement
1306                       { letLexpr = "l:info.pending_output." , letValue = "l:line" }
1307                   , LetStatement
1308                       { letLexpr = "l:info.pending_output_length+"
1309                       , letValue = "strlen(l:line)"
1310                       }
1311                   , GenericStatement "endif"
1312                   , GenericStatement "endfor"
1313                   , GenericStatement "endif"
1314                   ]
1315               }
1316           , FunctionDeclaration
1317               { functionBang = True
1318               , functionName = "ferret#private#nvim#close_cb"
1319               , functionArguments =
1320                   ArgumentList
1321                     [ Argument "job" , Argument "data" , Argument "event" ]
1322               , functionAttributes = [ "abort" , "dict" ]
1323               , functionBody =
1324                   [ LetStatement
1325                       { letLexpr = "l:info" , letValue = "s:info_from_job(a:job)" }
1326                   , GenericStatement "if type(l:info) == 4"
1327                   , GenericStatement "call remove(s:jobs, a:job)"
1328                   , GenericStatement
1329                       "call ferret#private#autocmd('FerretAsyncFinish')"
1330                   , GenericStatement "if !l:info.ack"
1331                   , GenericStatement "call win_gotoid(l:info.window)"
1332                   , GenericStatement "endif"
1333                   , GenericStatement
1334                       "call ferret#private#shared#finalize_search(l:info.output, l:info.ack)"
1335                   , GenericStatement "for l:error in l:info.errors"
1336                   , GenericStatement "unsilent echomsg l:error"
1337                   , GenericStatement "endfor"
1338                   , GenericStatement "endif"
1339                   ]
1340               }
1341           , FunctionDeclaration
1342               { functionBang = True
1343               , functionName = "ferret#private#nvim#pull"
1344               , functionArguments = ArgumentList []
1345               , functionAttributes = [ "abort" ]
1346               , functionBody =
1347                   [ GenericStatement "for l:job in keys(s:jobs)"
1348                   , LetStatement { letLexpr = "l:info" , letValue = "s:jobs[l:job]" }
1349                   , GenericStatement
1350                       "call ferret#private#shared#finalize_search(l:info.output, l:info.ack)"
1351                   , GenericStatement "endfor"
1352                   ]
1353               }
1354           , FunctionDeclaration
1355               { functionBang = True
1356               , functionName = "ferret#private#nvim#cancel"
1357               , functionArguments = ArgumentList []
1358               , functionAttributes = [ "abort" ]
1359               , functionBody =
1360                   [ LetStatement { letLexpr = "l:canceled" , letValue = "0" }
1361                   , GenericStatement "for l:job in keys(s:jobs)"
1362                   , GenericStatement "call jobstop(l:job)"
1363                   , GenericStatement "call remove(s:jobs, l:job)"
1364                   , LetStatement { letLexpr = "l:canceled" , letValue = "1" }
1365                   , GenericStatement "endfor"
1366                   , GenericStatement "if l:canceled"
1367                   , GenericStatement
1368                       "call ferret#private#autocmd('FerretAsyncFinish')"
1369                   , GenericStatement "endif"
1370                   ]
1371               }
1372           , FunctionDeclaration
1373               { functionBang = True
1374               , functionName = "s:MaxResultsExceeded"
1375               , functionArguments = ArgumentList [ Argument "info" ]
1376               , functionAttributes = []
1377               , functionBody =
1378                   [ GenericStatement
1379                       "call ferret#private#shared#finalize_search(a:info.output, a:info.ack)"
1380                   , GenericStatement "call jobstop(a:info.job)"
1381                   , GenericStatement "call remove(s:jobs, a:info.job)"
1382                   , GenericStatement
1383                       "call ferret#private#autocmd('FerretAsyncFinish')"
1384                   , GenericStatement
1385                       "call ferret#private#error( 'Maximum result count exceeded. ' . 'Either increase g:FerretMaxResults or ' . 're-run the search with :Ack!, :Lack! etc.' )"
1386                   ]
1387               }
1388           , FunctionDeclaration
1389               { functionBang = True
1390               , functionName = "ferret#private#nvim#debug"
1391               , functionArguments = ArgumentList []
1392               , functionAttributes = [ "abort" ]
1393               , functionBody = [ GenericStatement "return s:jobs" ]
1394               }
1395           ]
1396       , Unit
1397           [ FunctionDeclaration
1398               { functionBang = True
1399               , functionName = "s:autojump"
1400               , functionArguments = ArgumentList []
1401               , functionAttributes = []
1402               , functionBody =
1403                   [ LetStatement
1404                       { letLexpr = "l:autojump"
1405                       , letValue = "get(g:, 'FerretAutojump', 1)"
1406                       }
1407                   , GenericStatement
1408                       "if l:autojump != 0 && l:autojump != 1 && l:autojump != 2"
1409                   , LetStatement { letLexpr = "l:autojump" , letValue = "1" }
1410                   , GenericStatement "endif"
1411                   , GenericStatement "return l:autojump"
1412                   ]
1413               }
1414           , FunctionDeclaration
1415               { functionBang = True
1416               , functionName = "s:set_title"
1417               , functionArguments =
1418                   ArgumentList [ Argument "type" , Argument "title" ]
1419               , functionAttributes = []
1420               , functionBody =
1421                   [ GenericStatement "if has('patch-7.4.2200')"
1422                   , GenericStatement "if a:type ==# 'qf'"
1423                   , GenericStatement "call setqflist([], 'a', {'title' : a:title})"
1424                   , GenericStatement "else"
1425                   , GenericStatement
1426                       "call setloclist(0, [], 'a', {'title' : a:title})"
1427                   , GenericStatement "endif"
1428                   , GenericStatement "elseif a:type ==# 'qf'"
1429                   , LetStatement
1430                       { letLexpr = "w:quickfix_title" , letValue = "a:title" }
1431                   , GenericStatement "endif"
1432                   ]
1433               }
1434           , FunctionDeclaration
1435               { functionBang = True
1436               , functionName = "ferret#private#shared#finalize_search"
1437               , functionArguments =
1438                   ArgumentList [ Argument "output" , Argument "ack" ]
1439               , functionAttributes = []
1440               , functionBody =
1441                   [ LetStatement
1442                       { letLexpr = "l:lastsearch "
1443                       , letValue = "get(g:, 'ferret_lastsearch', '')"
1444                       }
1445                   , LetStatement
1446                       { letLexpr = "l:original_errorformat" , letValue = "&errorformat" }
1447                   , LetStatement
1448                       { letLexpr = "l:autojump" , letValue = "s:autojump()" }
1449                   , GenericStatement "if a:ack"
1450                   , LetStatement
1451                       { letLexpr = "l:prefix"
1452                       , letValue = "'c' \" Will use cexpr, cgetexpr."
1453                       }
1454                   , Empty
1455                   , LetStatement
1456                       { letLexpr = "l:handler"
1457                       , letValue = "get(g:, 'FerretQFHandler', 'botright copen')"
1458                       }
1459                   , LetStatement { letLexpr = "l:post" , letValue = "'qf'" }
1460                   , GenericStatement "else"
1461                   , LetStatement
1462                       { letLexpr = "l:prefix"
1463                       , letValue = "'l' \" Will use lexpr, lgetexpr."
1464                       }
1465                   , Empty
1466                   , LetStatement
1467                       { letLexpr = "l:handler"
1468                       , letValue = "get(g:, 'FerretLLHandler', 'lopen')"
1469                       }
1470                   , LetStatement { letLexpr = "l:post" , letValue = "'location'" }
1471                   , GenericStatement "endif"
1472                   , GenericStatement "try"
1473                   , LetStatement
1474                       { letLexpr = "&errorformat" , letValue = "g:FerretFormat" }
1475                   , GenericStatement
1476                       "if l:autojump == 2 \" Show listing and jump to first result."
1477                   , GenericStatement
1478                       "call s:swallow(l:prefix . 'expr a:1', a:output)"
1479                   , GenericStatement "else"
1480                   , GenericStatement
1481                       "call s:swallow(l:prefix . 'getexpr a:1', a:output)"
1482                   , GenericStatement "endif"
1483                   , GenericStatement
1484                       "call s:set_title(l:post, 'Search `' . l:lastsearch . '`')"
1485                   , LetStatement { letLexpr = "l:before" , letValue = "winnr()" }
1486                   , LetStatement
1487                       { letLexpr = "l:len" , letValue = "ferret#private#post(l:post)" }
1488                   , GenericStatement "if l:len"
1489                   , GenericStatement "execute l:handler"
1490                   , GenericStatement
1491                       "if l:autojump != 1 \" Show listing, but don't jump anywhere."
1492                   , LetStatement { letLexpr = "l:after" , letValue = "winnr()" }
1493                   , GenericStatement "if l:before != l:after"
1494                   , GenericStatement "execute l:before . 'wincmd w'"
1495                   , GenericStatement "end"
1496                   , GenericStatement "endif"
1497                   , GenericStatement "endif"
1498                   , GenericStatement "finally"
1499                   , LetStatement
1500                       { letLexpr = "&errorformat" , letValue = "l:original_errorformat" }
1501                   , GenericStatement "endtry"
1502                   ]
1503               }
1504           , FunctionDeclaration
1505               { functionBang = True
1506               , functionName = "s:swallow"
1507               , functionArguments =
1508                   ArgumentList [ Argument "executable" , Argument "..." ]
1509               , functionAttributes = []
1510               , functionBody =
1511                   [ GenericStatement "try"
1512                   , GenericStatement "execute a:executable"
1513                   , GenericStatement "catch"
1514                   , GenericStatement "echomsg 'Caught: ' . v:exception"
1515                   , GenericStatement "endtry"
1516                   ]
1517               }
1518           ]
1519       , Unit
1520           [ FunctionDeclaration
1521               { functionBang = True
1522               , functionName = "ferret#private#vanilla#search"
1523               , functionArguments =
1524                   ArgumentList [ Argument "command" , Argument "ack" ]
1525               , functionAttributes = [ "abort" ]
1526               , functionBody =
1527                   [ LetStatement
1528                       { letLexpr = "l:executable"
1529                       , letValue = "ferret#private#executable()"
1530                       }
1531                   , LetStatement
1532                       { letLexpr = "l:output"
1533                       , letValue = "system(l:executable . ' ' . a:command)"
1534                       }
1535                   , GenericStatement
1536                       "call ferret#private#shared#finalize_search(l:output, a:ack)"
1537                   ]
1538               }
1539           ]
1540       , Unit
1541           [ LetStatement
1542               { letLexpr = "s:options"
1543               , letValue = "get(g:, 'FerretQFOptions', 1)"
1544               }
1545           , GenericStatement "if s:options"
1546           , GenericStatement "setlocal nolist"
1547           , GenericStatement "if exists('+relativenumber')"
1548           , GenericStatement "setlocal norelativenumber"
1549           , GenericStatement "endif"
1550           , GenericStatement "setlocal nowrap"
1551           , GenericStatement "setlocal number"
1552           , GenericStatement "if !exists('s:original_scrolloff')"
1553           , LetStatement
1554               { letLexpr = "s:original_scrolloff" , letValue = "&scrolloff" }
1555           , GenericStatement "endif"
1556           , GenericStatement "set scrolloff=0"
1557           , GenericStatement "if has('autocmd')"
1558           , GenericStatement "augroup FerretQF"
1559           , GenericStatement "autocmd!"
1560           , GenericStatement
1561               "autocmd BufLeave <buffer> execute 'set scrolloff=' . s:original_scrolloff"
1562           , GenericStatement
1563               "autocmd BufEnter <buffer> set scrolloff=0 | setlocal nocursorline"
1564           , GenericStatement "augroup END"
1565           , GenericStatement "endif"
1566           , GenericStatement "endif"
1567           , LetStatement
1568               { letLexpr = "s:map" , letValue = "get(g:, 'FerretQFMap', 1)" }
1569           , GenericStatement "if s:map"
1570           , GenericStatement
1571               "nnoremap <buffer> <silent> d :set operatorfunc=ferret#private#qf_delete_motion<CR>g@"
1572           , GenericStatement
1573               "nnoremap <buffer> <silent> dd :call ferret#private#qf_delete()<CR>"
1574           , GenericStatement
1575               "vnoremap <buffer> <silent> d :call ferret#private#qf_delete()<CR>"
1576           , GenericStatement "endif"
1577           ]
1578       , Unit
1579           [ GenericStatement
1580               "if exists('g:FerretLoaded') || &compatible || v:version < 700"
1581           , GenericStatement "finish"
1582           , GenericStatement "endif"
1583           , LetStatement { letLexpr = "g:FerretLoaded " , letValue = "1" }
1584           , LetStatement
1585               { letLexpr = "s:cpoptions " , letValue = "&cpoptions" }
1586           , GenericStatement "set cpoptions&vim"
1587           , GenericStatement "if !get(g:, 'FerretLazyInit', 1)"
1588           , GenericStatement "call ferret#private#init()"
1589           , GenericStatement "endif"
1590           , GenericStatement
1591               "command! -bang -nargs=1 -complete=customlist,ferret#private#ackcomplete Ack call ferret#private#ack(<bang>0, <q-args>)"
1592           , GenericStatement
1593               "command! -bang -nargs=1 -complete=customlist,ferret#private#lackcomplete Lack call ferret#private#lack(<bang>0, <q-args>)"
1594           , GenericStatement
1595               "command! -bang -nargs=1 -complete=customlist,ferret#private#backcomplete Back call ferret#private#back(<bang>0, <q-args>)"
1596           , GenericStatement
1597               "command! -bang -nargs=1 -complete=customlist,ferret#private#blackcomplete Black call ferret#private#black(<bang>0, <q-args>)"
1598           , GenericStatement
1599               "command! -bang -nargs=1 -complete=customlist,ferret#private#quackcomplete Quack call ferret#private#quack(<bang>0, <q-args>)"
1600           , GenericStatement
1601               "command! -nargs=1 Acks call ferret#private#acks(<q-args>, 'qf')"
1602           , GenericStatement
1603               "command! -nargs=1 Lacks call ferret#private#acks(<q-args>, 'location')"
1604           , GenericStatement
1605               "command! FerretCancelAsync call ferret#private#async#cancel()"
1606           , GenericStatement
1607               "command! FerretPullAsync call ferret#private#async#pull()"
1608           , GenericStatement "nnoremap <Plug>(FerretAck) :Ack<space>"
1609           , GenericStatement "nnoremap <Plug>(FerretLack) :Lack<space>"
1610           , GenericStatement
1611               "nnoremap <Plug>(FerretAckWord) :Ack <C-r><C-w><CR>"
1612           , GenericStatement
1613               "nnoremap <Plug>(FerretAcks) :Acks <c-r>=(ferret#private#acks_prompt())<CR><Left><Left>"
1614           , LetStatement
1615               { letLexpr = "s:map" , letValue = "get(g:, 'FerretMap', 1)" }
1616           , GenericStatement "if s:map"
1617           , GenericStatement
1618               "if !hasmapto('<Plug>(FerretAck)') && maparg('<leader>a', 'n') ==# ''"
1619           , GenericStatement "nmap <unique> <leader>a <Plug>(FerretAck)"
1620           , GenericStatement "endif"
1621           , GenericStatement
1622               "if !hasmapto('<Plug>FerretLack') && maparg('<leader>l', 'n') ==# ''"
1623           , GenericStatement "nmap <unique> <leader>l <Plug>(FerretLack)"
1624           , GenericStatement "endif"
1625           , GenericStatement
1626               "if !hasmapto('<Plug>(FerretAckWord)') && maparg('<leader>s', 'n') ==# ''"
1627           , GenericStatement "nmap <unique> <leader>s <Plug>(FerretAckWord)"
1628           , GenericStatement "endif"
1629           , GenericStatement
1630               "if !hasmapto('<Plug>(FerretAcks)') && maparg('<leader>r', 'n') ==# ''"
1631           , GenericStatement "nmap <unique> <leader>r <Plug>(FerretAcks)"
1632           , GenericStatement "endif"
1633           , GenericStatement "endif"
1634           , GenericStatement
1635               "command! -bar Qargs execute 'args' ferret#private#args('qf')"
1636           , GenericStatement
1637               "command! -bar Largs execute 'args' ferret#private#args('location')"
1638           , LetStatement
1639               { letLexpr = "s:commands"
1640               , letValue = "get(g:, 'FerretQFCommands', 1)"
1641               }
1642           , GenericStatement "if s:commands"
1643           , GenericStatement
1644               "cabbrev <silent> <expr> cn ((getcmdtype() == ':' && getcmdpos() == 3) ? 'cn <bar> normal zz' : 'cn')"
1645           , GenericStatement
1646               "cabbrev <silent> <expr> cnf ((getcmdtype() == ':' && getcmdpos() == 4) ? 'cnf <bar> normal zz' : 'cnf')"
1647           , GenericStatement
1648               "cabbrev <silent> <expr> cp ((getcmdtype() == ':' && getcmdpos() == 3) ? 'cp <bar> normal zz' : 'cp')"
1649           , GenericStatement
1650               "cabbrev <silent> <expr> cpf ((getcmdtype() == ':' && getcmdpos() == 4) ? 'cpf <bar> normal zz' : 'cpf')"
1651           , GenericStatement "endif"
1652           , LetStatement
1653               { letLexpr = "g:FerretFormat"
1654               , letValue = "get(g:, 'FerretFormat', '%f:%l:%c:%m')"
1655               }
1656           , LetStatement
1657               { letLexpr = "&cpoptions " , letValue = "s:cpoptions" }
1658           , UnletStatement { unletBang = False , unletBody = "s:cpoptions" }
1659           ]
1660       ]
1661   , DocBlock
1662       [ PluginAnnotation "ferret" "Ferret plug-in for Vim"
1663       , TOC
1664           [ "Intro"
1665           , "Installation"
1666           , "Commands"
1667           , "Mappings"
1668           , "Options"
1669           , "Functions"
1670           , "Custom autocommands"
1671           , "Overrides"
1672           , "Troubleshooting"
1673           , "FAQ"
1674           , "Related"
1675           , "Website"
1676           , "License"
1677           , "Development"
1678           , "Authors"
1679           , "History"
1680           ]
1681       ]
1682   , HeadingAnnotation "Intro"
1683   , Blockquote
1684       [ Paragraph
1685           [ Plaintext "\"ferret"
1686           , Whitespace
1687           , Plaintext "(verb)"
1688           , BreakTag
1689           , Plaintext "(ferret"
1690           , Whitespace
1691           , Plaintext "something"
1692           , Whitespace
1693           , Plaintext "out)"
1694           , Whitespace
1695           , Plaintext "search"
1696           , Whitespace
1697           , Plaintext "tenaciously"
1698           , Whitespace
1699           , Plaintext "for"
1700           , Whitespace
1701           , Plaintext "and"
1702           , Whitespace
1703           , Plaintext "find"
1704           , Whitespace
1705           , Plaintext "something:"
1706           , Whitespace
1707           , Plaintext "she"
1708           , Whitespace
1709           , Plaintext "had"
1710           , Whitespace
1711           , Plaintext "the"
1712           , Whitespace
1713           , Plaintext "ability"
1714           , Whitespace
1715           , Plaintext "to"
1716           , Whitespace
1717           , Plaintext "ferret"
1718           , Whitespace
1719           , Plaintext "out"
1720           , Whitespace
1721           , Plaintext "the"
1722           , Whitespace
1723           , Plaintext "facts.\""
1724           ]
1725       ]
1726   , LinkTargets [ "ferret-features" ]
1727   , Paragraph
1728       [ Plaintext "Ferret"
1729       , Whitespace
1730       , Plaintext "improves"
1731       , Whitespace
1732       , Plaintext "Vim's"
1733       , Whitespace
1734       , Plaintext "multi-file"
1735       , Whitespace
1736       , Plaintext "search"
1737       , Whitespace
1738       , Plaintext "in"
1739       , Whitespace
1740       , Plaintext "four"
1741       , Whitespace
1742       , Plaintext "ways:"
1743       ]
1744   , SubheadingAnnotation "1. Powerful multi-file search"
1745   , Paragraph
1746       [ Plaintext "Ferret"
1747       , Whitespace
1748       , Plaintext "provides"
1749       , Whitespace
1750       , Plaintext "an"
1751       , Whitespace
1752       , Link ":Ack"
1753       , Whitespace
1754       , Plaintext "command"
1755       , Whitespace
1756       , Plaintext "for"
1757       , Whitespace
1758       , Plaintext "searching"
1759       , Whitespace
1760       , Plaintext "across"
1761       , Whitespace
1762       , Plaintext "multiple"
1763       , Whitespace
1764       , Plaintext "files"
1765       , Whitespace
1766       , Plaintext "using"
1767       , Whitespace
1768       , Plaintext "ripgrep"
1769       , Whitespace
1770       , Plaintext "(https://github.com/BurntSushi/ripgrep),"
1771       , Whitespace
1772       , Plaintext "The"
1773       , Whitespace
1774       , Plaintext "Silver"
1775       , Whitespace
1776       , Plaintext "Searcher"
1777       , Whitespace
1778       , Plaintext "(https://github.com/ggreer/the_silver_searcher),"
1779       , Whitespace
1780       , Plaintext "or"
1781       , Whitespace
1782       , Plaintext "Ack"
1783       , Whitespace
1784       , Plaintext "(http://beyondgrep.com/)."
1785       , Whitespace
1786       , Plaintext "Support"
1787       , Whitespace
1788       , Plaintext "for"
1789       , Whitespace
1790       , Plaintext "passing"
1791       , Whitespace
1792       , Plaintext "options"
1793       , Whitespace
1794       , Plaintext "through"
1795       , Whitespace
1796       , Plaintext "to"
1797       , Whitespace
1798       , Plaintext "the"
1799       , Whitespace
1800       , Plaintext "underlying"
1801       , Whitespace
1802       , Plaintext "search"
1803       , Whitespace
1804       , Plaintext "command"
1805       , Whitespace
1806       , Plaintext "exists,"
1807       , Whitespace
1808       , Plaintext "along"
1809       , Whitespace
1810       , Plaintext "with"
1811       , Whitespace
1812       , Plaintext "the"
1813       , Whitespace
1814       , Plaintext "ability"
1815       , Whitespace
1816       , Plaintext "to"
1817       , Whitespace
1818       , Plaintext "use"
1819       , Whitespace
1820       , Plaintext "full"
1821       , Whitespace
1822       , Plaintext "regular"
1823       , Whitespace
1824       , Plaintext "expression"
1825       , Whitespace
1826       , Plaintext "syntax"
1827       , Whitespace
1828       , Plaintext "without"
1829       , Whitespace
1830       , Plaintext "doing"
1831       , Whitespace
1832       , Plaintext "special"
1833       , Whitespace
1834       , Plaintext "escaping."
1835       , Whitespace
1836       , Plaintext "On"
1837       , Whitespace
1838       , Plaintext "modern"
1839       , Whitespace
1840       , Plaintext "versions"
1841       , Whitespace
1842       , Plaintext "of"
1843       , Whitespace
1844       , Plaintext "Vim"
1845       , Whitespace
1846       , Plaintext "(version"
1847       , Whitespace
1848       , Plaintext "8"
1849       , Whitespace
1850       , Plaintext "or"
1851       , Whitespace
1852       , Plaintext "higher,"
1853       , Whitespace
1854       , Plaintext "or"
1855       , Whitespace
1856       , Plaintext "Neovim),"
1857       , Whitespace
1858       , Plaintext "searches"
1859       , Whitespace
1860       , Plaintext "are"
1861       , Whitespace
1862       , Plaintext "performed"
1863       , Whitespace
1864       , Plaintext "asynchronously"
1865       , Whitespace
1866       , Plaintext "(without"
1867       , Whitespace
1868       , Plaintext "blocking"
1869       , Whitespace
1870       , Plaintext "the"
1871       , Whitespace
1872       , Plaintext "UI)."
1873       ]
1874   , Paragraph
1875       [ Plaintext "Shortcut"
1876       , Whitespace
1877       , Plaintext "mappings"
1878       , Whitespace
1879       , Plaintext "are"
1880       , Whitespace
1881       , Plaintext "provided"
1882       , Whitespace
1883       , Plaintext "to"
1884       , Whitespace
1885       , Plaintext "start"
1886       , Whitespace
1887       , Plaintext "an"
1888       , Whitespace
1889       , Link ":Ack"
1890       , Whitespace
1891       , Plaintext "search"
1892       , Whitespace
1893       , Plaintext "(<leader>a)"
1894       , Whitespace
1895       , Plaintext "or"
1896       , Whitespace
1897       , Plaintext "to"
1898       , Whitespace
1899       , Plaintext "search"
1900       , Whitespace
1901       , Plaintext "for"
1902       , Whitespace
1903       , Plaintext "the"
1904       , Whitespace
1905       , Plaintext "word"
1906       , Whitespace
1907       , Plaintext "currently"
1908       , Whitespace
1909       , Plaintext "under"
1910       , Whitespace
1911       , Plaintext "the"
1912       , Whitespace
1913       , Plaintext "cursor"
1914       , Whitespace
1915       , Plaintext "(<leader>s)."
1916       ]
1917   , Paragraph
1918       [ Plaintext "Results"
1919       , Whitespace
1920       , Plaintext "are"
1921       , Whitespace
1922       , Plaintext "normally"
1923       , Whitespace
1924       , Plaintext "displayed"
1925       , Whitespace
1926       , Plaintext "in"
1927       , Whitespace
1928       , Plaintext "the"
1929       , Whitespace
1930       , Link "quickfix"
1931       , Whitespace
1932       , Plaintext "window,"
1933       , Whitespace
1934       , Plaintext "but"
1935       , Whitespace
1936       , Plaintext "Ferret"
1937       , Whitespace
1938       , Plaintext "also"
1939       , Whitespace
1940       , Plaintext "provides"
1941       , Whitespace
1942       , Plaintext "a"
1943       , Whitespace
1944       , Link ":Lack"
1945       , Whitespace
1946       , Plaintext "command"
1947       , Whitespace
1948       , Plaintext "that"
1949       , Whitespace
1950       , Plaintext "behaves"
1951       , Whitespace
1952       , Plaintext "like"
1953       , Whitespace
1954       , Link ":Ack"
1955       , Whitespace
1956       , Plaintext "but"
1957       , Whitespace
1958       , Plaintext "uses"
1959       , Whitespace
1960       , Plaintext "the"
1961       , Whitespace
1962       , Link "location-list"
1963       , Whitespace
1964       , Plaintext "instead,"
1965       , Whitespace
1966       , Plaintext "and"
1967       , Whitespace
1968       , Plaintext "a"
1969       , Whitespace
1970       , Plaintext "<leader>l"
1971       , Whitespace
1972       , Plaintext "mapping"
1973       , Whitespace
1974       , Plaintext "as"
1975       , Whitespace
1976       , Plaintext "a"
1977       , Whitespace
1978       , Plaintext "shortcut"
1979       , Whitespace
1980       , Plaintext "to"
1981       , Whitespace
1982       , Link ":Lack"
1983       , Plaintext "."
1984       ]
1985   , Paragraph
1986       [ Link ":Back"
1987       , Whitespace
1988       , Plaintext "and"
1989       , Whitespace
1990       , Link ":Black"
1991       , Whitespace
1992       , Plaintext "are"
1993       , Whitespace
1994       , Plaintext "analogous"
1995       , Whitespace
1996       , Plaintext "to"
1997       , Whitespace
1998       , Link ":Ack"
1999       , Whitespace
2000       , Plaintext "and"
2001       , Whitespace
2002       , Link ":Lack"
2003       , Plaintext ","
2004       , Whitespace
2005       , Plaintext "but"
2006       , Whitespace
2007       , Plaintext "scoped"
2008       , Whitespace
2009       , Plaintext "to"
2010       , Whitespace
2011       , Plaintext "search"
2012       , Whitespace
2013       , Plaintext "within"
2014       , Whitespace
2015       , Plaintext "currently"
2016       , Whitespace
2017       , Plaintext "open"
2018       , Whitespace
2019       , Plaintext "buffers"
2020       , Whitespace
2021       , Plaintext "only."
2022       , Whitespace
2023       , Link ":Quack"
2024       , Whitespace
2025       , Plaintext "is"
2026       , Whitespace
2027       , Plaintext "scoped"
2028       , Whitespace
2029       , Plaintext "to"
2030       , Whitespace
2031       , Plaintext "search"
2032       , Whitespace
2033       , Plaintext "among"
2034       , Whitespace
2035       , Plaintext "the"
2036       , Whitespace
2037       , Plaintext "files"
2038       , Whitespace
2039       , Plaintext "currently"
2040       , Whitespace
2041       , Plaintext "in"
2042       , Whitespace
2043       , Plaintext "the"
2044       , Whitespace
2045       , Link "quickfix"
2046       , Whitespace
2047       , Plaintext "list."
2048       ]
2049   , SubheadingAnnotation "2. Streamlined multi-file replace"
2050   , Paragraph
2051       [ Plaintext "The"
2052       , Whitespace
2053       , Plaintext "companion"
2054       , Whitespace
2055       , Plaintext "to"
2056       , Whitespace
2057       , Link ":Ack"
2058       , Whitespace
2059       , Plaintext "is"
2060       , Whitespace
2061       , Link ":Acks"
2062       , Whitespace
2063       , Plaintext "(mnemonic:"
2064       , Whitespace
2065       , Plaintext "\"Ack"
2066       , Whitespace
2067       , Plaintext "substitute\","
2068       , Whitespace
2069       , Plaintext "accessible"
2070       , Whitespace
2071       , Plaintext "via"
2072       , Whitespace
2073       , Plaintext "shortcut"
2074       , Whitespace
2075       , Plaintext "<leader>r),"
2076       , Whitespace
2077       , Plaintext "which"
2078       , Whitespace
2079       , Plaintext "allows"
2080       , Whitespace
2081       , Plaintext "you"
2082       , Whitespace
2083       , Plaintext "to"
2084       , Whitespace
2085       , Plaintext "run"
2086       , Whitespace
2087       , Plaintext "a"
2088       , Whitespace
2089       , Plaintext "multi-file"
2090       , Whitespace
2091       , Plaintext "replace"
2092       , Whitespace
2093       , Plaintext "across"
2094       , Whitespace
2095       , Plaintext "all"
2096       , Whitespace
2097       , Plaintext "the"
2098       , Whitespace
2099       , Plaintext "files"
2100       , Whitespace
2101       , Plaintext "placed"
2102       , Whitespace
2103       , Plaintext "in"
2104       , Whitespace
2105       , Plaintext "the"
2106       , Whitespace
2107       , Link "quickfix"
2108       , Whitespace
2109       , Plaintext "window"
2110       , Whitespace
2111       , Plaintext "by"
2112       , Whitespace
2113       , Plaintext "a"
2114       , Whitespace
2115       , Plaintext "previous"
2116       , Whitespace
2117       , Plaintext "invocation"
2118       , Whitespace
2119       , Plaintext "of"
2120       , Whitespace
2121       , Link ":Ack"
2122       , Whitespace
2123       , Plaintext "(or"
2124       , Whitespace
2125       , Link ":Back"
2126       , Plaintext ","
2127       , Whitespace
2128       , Plaintext "or"
2129       , Whitespace
2130       , Link ":Quack"
2131       , Plaintext ")."
2132       ]
2133   , Paragraph
2134       [ Plaintext "Correspondingly,"
2135       , Whitespace
2136       , Plaintext "results"
2137       , Whitespace
2138       , Plaintext "obtained"
2139       , Whitespace
2140       , Plaintext "by"
2141       , Whitespace
2142       , Link ":Lack"
2143       , Whitespace
2144       , Plaintext "can"
2145       , Whitespace
2146       , Plaintext "be"
2147       , Whitespace
2148       , Plaintext "targeted"
2149       , Whitespace
2150       , Plaintext "for"
2151       , Whitespace
2152       , Plaintext "replacement"
2153       , Whitespace
2154       , Plaintext "with"
2155       , Whitespace
2156       , Link ":Lacks"
2157       , Plaintext "."
2158       ]
2159   , SubheadingAnnotation "3. Quickfix listing enhancements"
2160   , Paragraph
2161       [ Plaintext "The"
2162       , Whitespace
2163       , Link "quickfix"
2164       , Whitespace
2165       , Plaintext "listing"
2166       , Whitespace
2167       , Plaintext "itself"
2168       , Whitespace
2169       , Plaintext "is"
2170       , Whitespace
2171       , Plaintext "enhanced"
2172       , Whitespace
2173       , Plaintext "with"
2174       , Whitespace
2175       , Plaintext "settings"
2176       , Whitespace
2177       , Plaintext "to"
2178       , Whitespace
2179       , Plaintext "improve"
2180       , Whitespace
2181       , Plaintext "its"
2182       , Whitespace
2183       , Plaintext "usability,"
2184       , Whitespace
2185       , Plaintext "and"
2186       , Whitespace
2187       , Plaintext "natural"
2188       , Whitespace
2189       , Plaintext "mappings"
2190       , Whitespace
2191       , Plaintext "that"
2192       , Whitespace
2193       , Plaintext "allow"
2194       , Whitespace
2195       , Plaintext "quick"
2196       , Whitespace
2197       , Plaintext "removal"
2198       , Whitespace
2199       , Plaintext "of"
2200       , Whitespace
2201       , Plaintext "items"
2202       , Whitespace
2203       , Plaintext "from"
2204       , Whitespace
2205       , Plaintext "the"
2206       , Whitespace
2207       , Plaintext "list"
2208       , Whitespace
2209       , Plaintext "(for"
2210       , Whitespace
2211       , Plaintext "example,"
2212       , Whitespace
2213       , Plaintext "you"
2214       , Whitespace
2215       , Plaintext "can"
2216       , Whitespace
2217       , Plaintext "reduce"
2218       , Whitespace
2219       , Plaintext "clutter"
2220       , Whitespace
2221       , Plaintext "in"
2222       , Whitespace
2223       , Plaintext "the"
2224       , Whitespace
2225       , Plaintext "listing"
2226       , Whitespace
2227       , Plaintext "by"
2228       , Whitespace
2229       , Plaintext "removing"
2230       , Whitespace
2231       , Plaintext "lines"
2232       , Whitespace
2233       , Plaintext "that"
2234       , Whitespace
2235       , Plaintext "you"
2236       , Whitespace
2237       , Plaintext "don't"
2238       , Whitespace
2239       , Plaintext "intend"
2240       , Whitespace
2241       , Plaintext "to"
2242       , Whitespace
2243       , Plaintext "make"
2244       , Whitespace
2245       , Plaintext "changes"
2246       , Whitespace
2247       , Plaintext "to)."
2248       ]
2249   , Paragraph
2250       [ Plaintext "Additionally,"
2251       , Whitespace
2252       , Plaintext "Vim's"
2253       , Whitespace
2254       , Link ":cn"
2255       , Plaintext ","
2256       , Whitespace
2257       , Link ":cp"
2258       , Plaintext ","
2259       , Whitespace
2260       , Link ":cnf"
2261       , Whitespace
2262       , Plaintext "and"
2263       , Whitespace
2264       , Link ":cpf"
2265       , Whitespace
2266       , Plaintext "commands"
2267       , Whitespace
2268       , Plaintext "are"
2269       , Whitespace
2270       , Plaintext "tweaked"
2271       , Whitespace
2272       , Plaintext "to"
2273       , Whitespace
2274       , Plaintext "make"
2275       , Whitespace
2276       , Plaintext "it"
2277       , Whitespace
2278       , Plaintext "easier"
2279       , Whitespace
2280       , Plaintext "to"
2281       , Whitespace
2282       , Plaintext "immediately"
2283       , Whitespace
2284       , Plaintext "identify"
2285       , Whitespace
2286       , Plaintext "matches"
2287       , Whitespace
2288       , Plaintext "by"
2289       , Whitespace
2290       , Plaintext "centering"
2291       , Whitespace
2292       , Plaintext "them"
2293       , Whitespace
2294       , Plaintext "within"
2295       , Whitespace
2296       , Plaintext "the"
2297       , Whitespace
2298       , Plaintext "viewport."
2299       ]
2300   , SubheadingAnnotation
2301       "4. Easy operations on files in the quickfix listing"
2302   , Paragraph
2303       [ Plaintext "Finally,"
2304       , Whitespace
2305       , Plaintext "Ferret"
2306       , Whitespace
2307       , Plaintext "provides"
2308       , Whitespace
2309       , Plaintext "a"
2310       , Whitespace
2311       , Link ":Qargs"
2312       , Whitespace
2313       , Plaintext "command"
2314       , Whitespace
2315       , Plaintext "that"
2316       , Whitespace
2317       , Plaintext "puts"
2318       , Whitespace
2319       , Plaintext "the"
2320       , Whitespace
2321       , Plaintext "files"
2322       , Whitespace
2323       , Plaintext "currently"
2324       , Whitespace
2325       , Plaintext "in"
2326       , Whitespace
2327       , Plaintext "the"
2328       , Whitespace
2329       , Link "quickfix"
2330       , Whitespace
2331       , Plaintext "listing"
2332       , Whitespace
2333       , Plaintext "into"
2334       , Whitespace
2335       , Plaintext "the"
2336       , Whitespace
2337       , Link ":args"
2338       , Whitespace
2339       , Plaintext "list,"
2340       , Whitespace
2341       , Plaintext "where"
2342       , Whitespace
2343       , Plaintext "they"
2344       , Whitespace
2345       , Plaintext "can"
2346       , Whitespace
2347       , Plaintext "be"
2348       , Whitespace
2349       , Plaintext "operated"
2350       , Whitespace
2351       , Plaintext "on"
2352       , Whitespace
2353       , Plaintext "in"
2354       , Whitespace
2355       , Plaintext "bulk"
2356       , Whitespace
2357       , Plaintext "via"
2358       , Whitespace
2359       , Plaintext "the"
2360       , Whitespace
2361       , Link ":argdo"
2362       , Whitespace
2363       , Plaintext "command."
2364       , Whitespace
2365       , Plaintext "This"
2366       , Whitespace
2367       , Plaintext "is"
2368       , Whitespace
2369       , Plaintext "what's"
2370       , Whitespace
2371       , Plaintext "used"
2372       , Whitespace
2373       , Plaintext "under"
2374       , Whitespace
2375       , Plaintext "the"
2376       , Whitespace
2377       , Plaintext "covers"
2378       , Whitespace
2379       , Plaintext "on"
2380       , Whitespace
2381       , Plaintext "older"
2382       , Whitespace
2383       , Plaintext "versions"
2384       , Whitespace
2385       , Plaintext "of"
2386       , Whitespace
2387       , Plaintext "Vim"
2388       , Whitespace
2389       , Plaintext "by"
2390       , Whitespace
2391       , Link ":Acks"
2392       , Whitespace
2393       , Plaintext "to"
2394       , Whitespace
2395       , Plaintext "do"
2396       , Whitespace
2397       , Plaintext "its"
2398       , Whitespace
2399       , Plaintext "work"
2400       , Whitespace
2401       , Plaintext "(on"
2402       , Whitespace
2403       , Plaintext "newer"
2404       , Whitespace
2405       , Plaintext "versions"
2406       , Whitespace
2407       , Plaintext "the"
2408       , Whitespace
2409       , Plaintext "built-in"
2410       , Whitespace
2411       , Link ":cdo"
2412       , Whitespace
2413       , Plaintext "or"
2414       , Whitespace
2415       , Link ":cfdo"
2416       , Whitespace
2417       , Plaintext "are"
2418       , Whitespace
2419       , Plaintext "used"
2420       , Whitespace
2421       , Plaintext "instead)."
2422       ]
2423   , Paragraph
2424       [ Plaintext "Ferret"
2425       , Whitespace
2426       , Plaintext "also"
2427       , Whitespace
2428       , Plaintext "provides"
2429       , Whitespace
2430       , Plaintext "a"
2431       , Whitespace
2432       , Link ":Largs"
2433       , Whitespace
2434       , Plaintext "command,"
2435       , Whitespace
2436       , Plaintext "which"
2437       , Whitespace
2438       , Plaintext "is"
2439       , Whitespace
2440       , Plaintext "a"
2441       , Whitespace
2442       , Link "location-list"
2443       , Whitespace
2444       , Plaintext "analog"
2445       , Whitespace
2446       , Plaintext "for"
2447       , Whitespace
2448       , Link ":Qargs"
2449       , Plaintext "."
2450       ]
2451   , HeadingAnnotation "Installation"
2452   , Paragraph
2453       [ Plaintext "To"
2454       , Whitespace
2455       , Plaintext "install"
2456       , Whitespace
2457       , Plaintext "Ferret,"
2458       , Whitespace
2459       , Plaintext "use"
2460       , Whitespace
2461       , Plaintext "your"
2462       , Whitespace
2463       , Plaintext "plug-in"
2464       , Whitespace
2465       , Plaintext "management"
2466       , Whitespace
2467       , Plaintext "system"
2468       , Whitespace
2469       , Plaintext "of"
2470       , Whitespace
2471       , Plaintext "choice."
2472       ]
2473   , Paragraph
2474       [ Plaintext "If"
2475       , Whitespace
2476       , Plaintext "you"
2477       , Whitespace
2478       , Plaintext "don't"
2479       , Whitespace
2480       , Plaintext "have"
2481       , Whitespace
2482       , Plaintext "a"
2483       , Whitespace
2484       , Plaintext "\"plug-in"
2485       , Whitespace
2486       , Plaintext "management"
2487       , Whitespace
2488       , Plaintext "system"
2489       , Whitespace
2490       , Plaintext "of"
2491       , Whitespace
2492       , Plaintext "choice\","
2493       , Whitespace
2494       , Plaintext "I"
2495       , Whitespace
2496       , Plaintext "recommend"
2497       , Whitespace
2498       , Plaintext "Pathogen"
2499       , Whitespace
2500       , Plaintext "(https://github.com/tpope/vim-pathogen)"
2501       , Whitespace
2502       , Plaintext "due"
2503       , Whitespace
2504       , Plaintext "to"
2505       , Whitespace
2506       , Plaintext "its"
2507       , Whitespace
2508       , Plaintext "simplicity"
2509       , Whitespace
2510       , Plaintext "and"
2511       , Whitespace
2512       , Plaintext "robustness."
2513       , Whitespace
2514       , Plaintext "Assuming"
2515       , Whitespace
2516       , Plaintext "that"
2517       , Whitespace
2518       , Plaintext "you"
2519       , Whitespace
2520       , Plaintext "have"
2521       , Whitespace
2522       , Plaintext "Pathogen"
2523       , Whitespace
2524       , Plaintext "installed"
2525       , Whitespace
2526       , Plaintext "and"
2527       , Whitespace
2528       , Plaintext "configured,"
2529       , Whitespace
2530       , Plaintext "and"
2531       , Whitespace
2532       , Plaintext "that"
2533       , Whitespace
2534       , Plaintext "you"
2535       , Whitespace
2536       , Plaintext "want"
2537       , Whitespace
2538       , Plaintext "to"
2539       , Whitespace
2540       , Plaintext "install"
2541       , Whitespace
2542       , Plaintext "Ferret"
2543       , Whitespace
2544       , Plaintext "into"
2545       , Whitespace
2546       , Code "~/.vim/bundle"
2547       , Plaintext ","
2548       , Whitespace
2549       , Plaintext "you"
2550       , Whitespace
2551       , Plaintext "can"
2552       , Whitespace
2553       , Plaintext "do"
2554       , Whitespace
2555       , Plaintext "so"
2556       , Whitespace
2557       , Plaintext "with:"
2558       ]
2559   , Fenced
2560       [ "git clone https://github.com/wincent/ferret.git ~/.vim/bundle/ferret"
2561       ]
2562   , Paragraph
2563       [ Plaintext "Alternatively,"
2564       , Whitespace
2565       , Plaintext "if"
2566       , Whitespace
2567       , Plaintext "you"
2568       , Whitespace
2569       , Plaintext "use"
2570       , Whitespace
2571       , Plaintext "a"
2572       , Whitespace
2573       , Plaintext "Git"
2574       , Whitespace
2575       , Plaintext "submodule"
2576       , Whitespace
2577       , Plaintext "for"
2578       , Whitespace
2579       , Plaintext "each"
2580       , Whitespace
2581       , Plaintext "Vim"
2582       , Whitespace
2583       , Plaintext "plug-in,"
2584       , Whitespace
2585       , Plaintext "you"
2586       , Whitespace
2587       , Plaintext "could"
2588       , Whitespace
2589       , Plaintext "do"
2590       , Whitespace
2591       , Plaintext "the"
2592       , Whitespace
2593       , Plaintext "following"
2594       , Whitespace
2595       , Plaintext "after"
2596       , Whitespace
2597       , Code "cd"
2598       , Plaintext "-ing"
2599       , Whitespace
2600       , Plaintext "into"
2601       , Whitespace
2602       , Plaintext "the"
2603       , Whitespace
2604       , Plaintext "top-level"
2605       , Whitespace
2606       , Plaintext "of"
2607       , Whitespace
2608       , Plaintext "your"
2609       , Whitespace
2610       , Plaintext "Git"
2611       , Whitespace
2612       , Plaintext "superproject:"
2613       ]
2614   , Fenced
2615       [ "git submodule add https://github.com/wincent/ferret.git ~/vim/bundle/ferret"
2616       , "git submodule init"
2617       ]
2618   , Paragraph
2619       [ Plaintext "To"
2620       , Whitespace
2621       , Plaintext "generate"
2622       , Whitespace
2623       , Plaintext "help"
2624       , Whitespace
2625       , Plaintext "tags"
2626       , Whitespace
2627       , Plaintext "under"
2628       , Whitespace
2629       , Plaintext "Pathogen,"
2630       , Whitespace
2631       , Plaintext "you"
2632       , Whitespace
2633       , Plaintext "can"
2634       , Whitespace
2635       , Plaintext "do"
2636       , Whitespace
2637       , Plaintext "so"
2638       , Whitespace
2639       , Plaintext "from"
2640       , Whitespace
2641       , Plaintext "inside"
2642       , Whitespace
2643       , Plaintext "Vim"
2644       , Whitespace
2645       , Plaintext "with:"
2646       ]
2647   , Fenced [ ":call pathogen#helptags()" ]
2648   , CommandsAnnotation
2649   , CommandAnnotation "Ack" (Just "{pattern} {options}")
2650   , Paragraph
2651       [ Plaintext "Searches"
2652       , Whitespace
2653       , Plaintext "for"
2654       , Whitespace
2655       , Plaintext "{pattern}"
2656       , Whitespace
2657       , Plaintext "in"
2658       , Whitespace
2659       , Plaintext "all"
2660       , Whitespace
2661       , Plaintext "the"
2662       , Whitespace
2663       , Plaintext "files"
2664       , Whitespace
2665       , Plaintext "under"
2666       , Whitespace
2667       , Plaintext "the"
2668       , Whitespace
2669       , Plaintext "current"
2670       , Whitespace
2671       , Plaintext "directory"
2672       , Whitespace
2673       , Plaintext "(see"
2674       , Whitespace
2675       , Link ":pwd"
2676       , Plaintext "),"
2677       , Whitespace
2678       , Plaintext "unless"
2679       , Whitespace
2680       , Plaintext "otherwise"
2681       , Whitespace
2682       , Plaintext "overridden"
2683       , Whitespace
2684       , Plaintext "via"
2685       , Whitespace
2686       , Plaintext "{options},"
2687       , Whitespace
2688       , Plaintext "and"
2689       , Whitespace
2690       , Plaintext "displays"
2691       , Whitespace
2692       , Plaintext "the"
2693       , Whitespace
2694       , Plaintext "results"
2695       , Whitespace
2696       , Plaintext "in"
2697       , Whitespace
2698       , Plaintext "the"
2699       , Whitespace
2700       , Link "quickfix"
2701       , Whitespace
2702       , Plaintext "listing."
2703       ]
2704   , Paragraph
2705       [ Code "rg"
2706       , Whitespace
2707       , Plaintext "(ripgrep)"
2708       , Whitespace
2709       , Plaintext "then"
2710       , Whitespace
2711       , Code "ag"
2712       , Whitespace
2713       , Plaintext "(The"
2714       , Whitespace
2715       , Plaintext "Silver"
2716       , Whitespace
2717       , Plaintext "Searcher)"
2718       , Whitespace
2719       , Plaintext "will"
2720       , Whitespace
2721       , Plaintext "be"
2722       , Whitespace
2723       , Plaintext "used"
2724       , Whitespace
2725       , Plaintext "preferentially"
2726       , Whitespace
2727       , Plaintext "if"
2728       , Whitespace
2729       , Plaintext "present"
2730       , Whitespace
2731       , Plaintext "on"
2732       , Whitespace
2733       , Plaintext "the"
2734       , Whitespace
2735       , Plaintext "system,"
2736       , Whitespace
2737       , Plaintext "because"
2738       , Whitespace
2739       , Plaintext "they"
2740       , Whitespace
2741       , Plaintext "are"
2742       , Whitespace
2743       , Plaintext "faster,"
2744       , Whitespace
2745       , Plaintext "falling"
2746       , Whitespace
2747       , Plaintext "back"
2748       , Whitespace
2749       , Plaintext "to"
2750       , Whitespace
2751       , Code "ack"
2752       , Plaintext "/"
2753       , Code "ack-grep"
2754       , Whitespace
2755       , Plaintext "as"
2756       , Whitespace
2757       , Plaintext "needed."
2758       ]
2759   , Paragraph
2760       [ Plaintext "On"
2761       , Whitespace
2762       , Plaintext "newer"
2763       , Whitespace
2764       , Plaintext "versions"
2765       , Whitespace
2766       , Plaintext "of"
2767       , Whitespace
2768       , Plaintext "Vim"
2769       , Whitespace
2770       , Plaintext "(version"
2771       , Whitespace
2772       , Plaintext "8"
2773       , Whitespace
2774       , Plaintext "and"
2775       , Whitespace
2776       , Plaintext "above),"
2777       , Whitespace
2778       , Plaintext "the"
2779       , Whitespace
2780       , Plaintext "search"
2781       , Whitespace
2782       , Plaintext "process"
2783       , Whitespace
2784       , Plaintext "runs"
2785       , Whitespace
2786       , Plaintext "asynchronously"
2787       , Whitespace
2788       , Plaintext "in"
2789       , Whitespace
2790       , Plaintext "the"
2791       , Whitespace
2792       , Plaintext "background"
2793       , Whitespace
2794       , Plaintext "and"
2795       , Whitespace
2796       , Plaintext "does"
2797       , Whitespace
2798       , Plaintext "not"
2799       , Whitespace
2800       , Plaintext "block"
2801       , Whitespace
2802       , Plaintext "the"
2803       , Whitespace
2804       , Plaintext "UI."
2805       ]
2806   , Paragraph
2807       [ Plaintext "Asynchronous"
2808       , Whitespace
2809       , Plaintext "searches"
2810       , Whitespace
2811       , Plaintext "are"
2812       , Whitespace
2813       , Plaintext "preferred"
2814       , Whitespace
2815       , Plaintext "because"
2816       , Whitespace
2817       , Plaintext "they"
2818       , Whitespace
2819       , Plaintext "do"
2820       , Whitespace
2821       , Plaintext "not"
2822       , Whitespace
2823       , Plaintext "block,"
2824       , Whitespace
2825       , Plaintext "despite"
2826       , Whitespace
2827       , Plaintext "the"
2828       , Whitespace
2829       , Plaintext "fact"
2830       , Whitespace
2831       , Plaintext "that"
2832       , Whitespace
2833       , Plaintext "Vim"
2834       , Whitespace
2835       , Plaintext "itself"
2836       , Whitespace
2837       , Plaintext "is"
2838       , Whitespace
2839       , Plaintext "single"
2840       , Whitespace
2841       , Plaintext "threaded."
2842       ]
2843   , Paragraph
2844       [ Plaintext "The"
2845       , Whitespace
2846       , Plaintext "{pattern}"
2847       , Whitespace
2848       , Plaintext "is"
2849       , Whitespace
2850       , Plaintext "passed"
2851       , Whitespace
2852       , Plaintext "through"
2853       , Whitespace
2854       , Plaintext "as-is"
2855       , Whitespace
2856       , Plaintext "to"
2857       , Whitespace
2858       , Plaintext "the"
2859       , Whitespace
2860       , Plaintext "underlying"
2861       , Whitespace
2862       , Plaintext "search"
2863       , Whitespace
2864       , Plaintext "program,"
2865       , Whitespace
2866       , Plaintext "and"
2867       , Whitespace
2868       , Plaintext "no"
2869       , Whitespace
2870       , Plaintext "escaping"
2871       , Whitespace
2872       , Plaintext "is"
2873       , Whitespace
2874       , Plaintext "required"
2875       , Whitespace
2876       , Plaintext "other"
2877       , Whitespace
2878       , Plaintext "than"
2879       , Whitespace
2880       , Plaintext "preceding"
2881       , Whitespace
2882       , Plaintext "spaces"
2883       , Whitespace
2884       , Plaintext "by"
2885       , Whitespace
2886       , Plaintext "a"
2887       , Whitespace
2888       , Plaintext "single"
2889       , Whitespace
2890       , Plaintext "backslash."
2891       , Whitespace
2892       , Plaintext "For"
2893       , Whitespace
2894       , Plaintext "example,"
2895       , Whitespace
2896       , Plaintext "to"
2897       , Whitespace
2898       , Plaintext "search"
2899       , Whitespace
2900       , Plaintext "for"
2901       , Whitespace
2902       , Plaintext "\"\\bfoo[0-9]{2}"
2903       , Whitespace
2904       , Plaintext "bar\\b\""
2905       , Whitespace
2906       , Plaintext "(ie."
2907       , Whitespace
2908       , Plaintext "using"
2909       , Whitespace
2910       , Code "ag"
2911       , Plaintext "'s"
2912       , Whitespace
2913       , Plaintext "Perl-style"
2914       , Whitespace
2915       , Plaintext "regular"
2916       , Whitespace
2917       , Plaintext "expression"
2918       , Whitespace
2919       , Plaintext "syntax),"
2920       , Whitespace
2921       , Plaintext "you"
2922       , Whitespace
2923       , Plaintext "could"
2924       , Whitespace
2925       , Plaintext "do:"
2926       ]
2927   , Fenced [ ":Ack \\bfoo[0-9]{2}\\ bar\\b" ]
2928   , Paragraph
2929       [ Plaintext "Likewise,"
2930       , Whitespace
2931       , Plaintext "{options}"
2932       , Whitespace
2933       , Plaintext "are"
2934       , Whitespace
2935       , Plaintext "passed"
2936       , Whitespace
2937       , Plaintext "through."
2938       , Whitespace
2939       , Plaintext "In"
2940       , Whitespace
2941       , Plaintext "this"
2942       , Whitespace
2943       , Plaintext "example,"
2944       , Whitespace
2945       , Plaintext "we"
2946       , Whitespace
2947       , Plaintext "pass"
2948       , Whitespace
2949       , Plaintext "the"
2950       , Whitespace
2951       , Code "-w"
2952       , Whitespace
2953       , Plaintext "option"
2954       , Whitespace
2955       , Plaintext "(to"
2956       , Whitespace
2957       , Plaintext "search"
2958       , Whitespace
2959       , Plaintext "on"
2960       , Whitespace
2961       , Plaintext "word"
2962       , Whitespace
2963       , Plaintext "boundaries),"
2964       , Whitespace
2965       , Plaintext "and"
2966       , Whitespace
2967       , Plaintext "scope"
2968       , Whitespace
2969       , Plaintext "the"
2970       , Whitespace
2971       , Plaintext "search"
2972       , Whitespace
2973       , Plaintext "to"
2974       , Whitespace
2975       , Plaintext "the"
2976       , Whitespace
2977       , Plaintext "\"foo\""
2978       , Whitespace
2979       , Plaintext "and"
2980       , Whitespace
2981       , Plaintext "\"bar\""
2982       , Whitespace
2983       , Plaintext "subdirectories:"
2984       ]
2985   , Fenced [ ":Ack -w something foo bar" ]
2986   , Paragraph
2987       [ Plaintext "As"
2988       , Whitespace
2989       , Plaintext "a"
2990       , Whitespace
2991       , Plaintext "convenience"
2992       , Whitespace
2993       , Plaintext "<leader>a"
2994       , Whitespace
2995       , Plaintext "is"
2996       , Whitespace
2997       , Plaintext "set-up"
2998       , Whitespace
2999       , Plaintext "("
3000       , Link "<Plug>(FerretAck)"
3001       , Plaintext ")"
3002       , Whitespace
3003       , Plaintext "as"
3004       , Whitespace
3005       , Plaintext "a"
3006       , Whitespace
3007       , Plaintext "shortcut"
3008       , Whitespace
3009       , Plaintext "to"
3010       , Whitespace
3011       , Plaintext "enter"
3012       , Whitespace
3013       , Link "Cmdline-mode"
3014       , Whitespace
3015       , Plaintext "with"
3016       , Whitespace
3017       , Code ":Ack"
3018       , Whitespace
3019       , Plaintext "inserted"
3020       , Whitespace
3021       , Plaintext "on"
3022       , Whitespace
3023       , Plaintext "the"
3024       , Whitespace
3025       , Link "Cmdline"
3026       , Plaintext "."
3027       , Whitespace
3028       , Plaintext "Likewise"
3029       , Whitespace
3030       , Plaintext "<leader>s"
3031       , Whitespace
3032       , Plaintext "("
3033       , Link "<Plug>(FerretAckWord)"
3034       , Plaintext ")"
3035       , Whitespace
3036       , Plaintext "is"
3037       , Whitespace
3038       , Plaintext "a"
3039       , Whitespace
3040       , Plaintext "shortcut"
3041       , Whitespace
3042       , Plaintext "for"
3043       , Whitespace
3044       , Plaintext "running"
3045       , Whitespace
3046       , Link ":Ack"
3047       , Whitespace
3048       , Plaintext "with"
3049       , Whitespace
3050       , Plaintext "the"
3051       , Whitespace
3052       , Plaintext "word"
3053       , Whitespace
3054       , Plaintext "currently"
3055       , Whitespace
3056       , Plaintext "under"
3057       , Whitespace
3058       , Plaintext "the"
3059       , Whitespace
3060       , Plaintext "cursor."
3061       ]
3062   , CommandAnnotation "Ack!" (Just "{pattern} {options}")
3063   , Paragraph
3064       [ Plaintext "Like"
3065       , Whitespace
3066       , Link ":Ack"
3067       , Plaintext ","
3068       , Whitespace
3069       , Plaintext "but"
3070       , Whitespace
3071       , Plaintext "returns"
3072       , Whitespace
3073       , Plaintext "all"
3074       , Whitespace
3075       , Plaintext "results"
3076       , Whitespace
3077       , Plaintext "irrespective"
3078       , Whitespace
3079       , Plaintext "of"
3080       , Whitespace
3081       , Plaintext "the"
3082       , Whitespace
3083       , Plaintext "value"
3084       , Whitespace
3085       , Plaintext "of"
3086       , Whitespace
3087       , Link "g:FerretMaxResults"
3088       , Plaintext "."
3089       ]
3090   , CommandAnnotation "Lack" (Just "{pattern} {options}")
3091   , Paragraph
3092       [ Plaintext "Just"
3093       , Whitespace
3094       , Plaintext "like"
3095       , Whitespace
3096       , Link ":Ack"
3097       , Plaintext ","
3098       , Whitespace
3099       , Plaintext "but"
3100       , Whitespace
3101       , Plaintext "instead"
3102       , Whitespace
3103       , Plaintext "of"
3104       , Whitespace
3105       , Plaintext "using"
3106       , Whitespace
3107       , Plaintext "the"
3108       , Whitespace
3109       , Link "quickfix"
3110       , Whitespace
3111       , Plaintext "listing,"
3112       , Whitespace
3113       , Plaintext "which"
3114       , Whitespace
3115       , Plaintext "is"
3116       , Whitespace
3117       , Plaintext "global"
3118       , Whitespace
3119       , Plaintext "across"
3120       , Whitespace
3121       , Plaintext "an"
3122       , Whitespace
3123       , Plaintext "entire"
3124       , Whitespace
3125       , Plaintext "Vim"
3126       , Whitespace
3127       , Plaintext "instance,"
3128       , Whitespace
3129       , Plaintext "it"
3130       , Whitespace
3131       , Plaintext "uses"
3132       , Whitespace
3133       , Plaintext "the"
3134       , Whitespace
3135       , Link "location-list"
3136       , Plaintext ","
3137       , Whitespace
3138       , Plaintext "which"
3139       , Whitespace
3140       , Plaintext "is"
3141       , Whitespace
3142       , Plaintext "a"
3143       , Whitespace
3144       , Plaintext "per-window"
3145       , Whitespace
3146       , Plaintext "construct."
3147       ]
3148   , Paragraph
3149       [ Plaintext "Note"
3150       , Whitespace
3151       , Plaintext "that"
3152       , Whitespace
3153       , Link ":Lack"
3154       , Whitespace
3155       , Plaintext "always"
3156       , Whitespace
3157       , Plaintext "runs"
3158       , Whitespace
3159       , Plaintext "synchronously"
3160       , Whitespace
3161       , Plaintext "via"
3162       , Whitespace
3163       , Link ":cexpr"
3164       , Plaintext "."
3165       ]
3166   , CommandAnnotation "Lack!" (Just "{pattern} {options}")
3167   , Paragraph
3168       [ Plaintext "Like"
3169       , Whitespace
3170       , Link ":Lack"
3171       , Plaintext ","
3172       , Whitespace
3173       , Plaintext "but"
3174       , Whitespace
3175       , Plaintext "returns"
3176       , Whitespace
3177       , Plaintext "all"
3178       , Whitespace
3179       , Plaintext "results"
3180       , Whitespace
3181       , Plaintext "irrespective"
3182       , Whitespace
3183       , Plaintext "of"
3184       , Whitespace
3185       , Plaintext "the"
3186       , Whitespace
3187       , Plaintext "value"
3188       , Whitespace
3189       , Plaintext "of"
3190       , Whitespace
3191       , Link "g:FerretMaxResults"
3192       , Plaintext "."
3193       ]
3194   , CommandAnnotation "Back" (Just "{pattern} {options}")
3195   , Paragraph
3196       [ Plaintext "Like"
3197       , Whitespace
3198       , Link ":Ack"
3199       , Plaintext ","
3200       , Whitespace
3201       , Plaintext "but"
3202       , Whitespace
3203       , Plaintext "searches"
3204       , Whitespace
3205       , Plaintext "only"
3206       , Whitespace
3207       , Plaintext "listed"
3208       , Whitespace
3209       , Plaintext "buffers."
3210       , Whitespace
3211       , Plaintext "Note"
3212       , Whitespace
3213       , Plaintext "that"
3214       , Whitespace
3215       , Plaintext "the"
3216       , Whitespace
3217       , Plaintext "search"
3218       , Whitespace
3219       , Plaintext "is"
3220       , Whitespace
3221       , Plaintext "still"
3222       , Whitespace
3223       , Plaintext "delegated"
3224       , Whitespace
3225       , Plaintext "to"
3226       , Whitespace
3227       , Plaintext "the"
3228       , Whitespace
3229       , Plaintext "underlying"
3230       , Whitespace
3231       , Link "'grepprg'"
3232       , Whitespace
3233       , Plaintext "("
3234       , Code "rg"
3235       , Plaintext ","
3236       , Whitespace
3237       , Code "ag"
3238       , Plaintext ","
3239       , Whitespace
3240       , Code "ack"
3241       , Whitespace
3242       , Plaintext "or"
3243       , Whitespace
3244       , Code "ack-grep"
3245       , Plaintext "),"
3246       , Whitespace
3247       , Plaintext "which"
3248       , Whitespace
3249       , Plaintext "means"
3250       , Whitespace
3251       , Plaintext "that"
3252       , Whitespace
3253       , Plaintext "only"
3254       , Whitespace
3255       , Plaintext "buffers"
3256       , Whitespace
3257       , Plaintext "written"
3258       , Whitespace
3259       , Plaintext "to"
3260       , Whitespace
3261       , Plaintext "disk"
3262       , Whitespace
3263       , Plaintext "will"
3264       , Whitespace
3265       , Plaintext "be"
3266       , Whitespace
3267       , Plaintext "searched."
3268       , Whitespace
3269       , Plaintext "If"
3270       , Whitespace
3271       , Plaintext "no"
3272       , Whitespace
3273       , Plaintext "buffers"
3274       , Whitespace
3275       , Plaintext "are"
3276       , Whitespace
3277       , Plaintext "written"
3278       , Whitespace
3279       , Plaintext "to"
3280       , Whitespace
3281       , Plaintext "disk,"
3282       , Whitespace
3283       , Plaintext "then"
3284       , Whitespace
3285       , Link ":Back"
3286       , Whitespace
3287       , Plaintext "behaves"
3288       , Whitespace
3289       , Plaintext "exactly"
3290       , Whitespace
3291       , Plaintext "like"
3292       , Whitespace
3293       , Link ":Ack"
3294       , Whitespace
3295       , Plaintext "and"
3296       , Whitespace
3297       , Plaintext "will"
3298       , Whitespace
3299       , Plaintext "search"
3300       , Whitespace
3301       , Plaintext "all"
3302       , Whitespace
3303       , Plaintext "files"
3304       , Whitespace
3305       , Plaintext "in"
3306       , Whitespace
3307       , Plaintext "the"
3308       , Whitespace
3309       , Plaintext "current"
3310       , Whitespace
3311       , Plaintext "directory."
3312       ]
3313   , CommandAnnotation "Back!" (Just "{pattern} {options}")
3314   , Paragraph
3315       [ Plaintext "Like"
3316       , Whitespace
3317       , Link ":Back"
3318       , Plaintext ","
3319       , Whitespace
3320       , Plaintext "but"
3321       , Whitespace
3322       , Plaintext "returns"
3323       , Whitespace
3324       , Plaintext "all"
3325       , Whitespace
3326       , Plaintext "results"
3327       , Whitespace
3328       , Plaintext "irrespective"
3329       , Whitespace
3330       , Plaintext "of"
3331       , Whitespace
3332       , Plaintext "the"
3333       , Whitespace
3334       , Plaintext "value"
3335       , Whitespace
3336       , Plaintext "of"
3337       , Whitespace
3338       , Link "g:FerretMaxResults"
3339       , Plaintext "."
3340       ]
3341   , CommandAnnotation "Black" (Just "{pattern} {options}")
3342   , Paragraph
3343       [ Plaintext "Like"
3344       , Whitespace
3345       , Link ":Lack"
3346       , Plaintext ","
3347       , Whitespace
3348       , Plaintext "but"
3349       , Whitespace
3350       , Plaintext "searches"
3351       , Whitespace
3352       , Plaintext "only"
3353       , Whitespace
3354       , Plaintext "listed"
3355       , Whitespace
3356       , Plaintext "buffers."
3357       , Whitespace
3358       , Plaintext "As"
3359       , Whitespace
3360       , Plaintext "with"
3361       , Whitespace
3362       , Link ":Back"
3363       , Plaintext ","
3364       , Whitespace
3365       , Plaintext "the"
3366       , Whitespace
3367       , Plaintext "search"
3368       , Whitespace
3369       , Plaintext "is"
3370       , Whitespace
3371       , Plaintext "still"
3372       , Whitespace
3373       , Plaintext "delegated"
3374       , Whitespace
3375       , Plaintext "to"
3376       , Whitespace
3377       , Plaintext "the"
3378       , Whitespace
3379       , Plaintext "underlying"
3380       , Whitespace
3381       , Link "'grepprg'"
3382       , Whitespace
3383       , Plaintext "("
3384       , Code "rg"
3385       , Plaintext ","
3386       , Whitespace
3387       , Code "ag"
3388       , Plaintext ","
3389       , Whitespace
3390       , Code "ack"
3391       , Whitespace
3392       , Plaintext "or"
3393       , Whitespace
3394       , Code "ack-grep"
3395       , Plaintext "),"
3396       , Whitespace
3397       , Plaintext "which"
3398       , Whitespace
3399       , Plaintext "means"
3400       , Whitespace
3401       , Plaintext "that"
3402       , Whitespace
3403       , Plaintext "only"
3404       , Whitespace
3405       , Plaintext "buffers"
3406       , Whitespace
3407       , Plaintext "written"
3408       , Whitespace
3409       , Plaintext "to"
3410       , Whitespace
3411       , Plaintext "disk"
3412       , Whitespace
3413       , Plaintext "will"
3414       , Whitespace
3415       , Plaintext "be"
3416       , Whitespace
3417       , Plaintext "searched."
3418       , Whitespace
3419       , Plaintext "Likewise,"
3420       , Whitespace
3421       , Plaintext "If"
3422       , Whitespace
3423       , Plaintext "no"
3424       , Whitespace
3425       , Plaintext "buffers"
3426       , Whitespace
3427       , Plaintext "are"
3428       , Whitespace
3429       , Plaintext "written"
3430       , Whitespace
3431       , Plaintext "to"
3432       , Whitespace
3433       , Plaintext "disk,"
3434       , Whitespace
3435       , Plaintext "then"
3436       , Whitespace
3437       , Link ":Black"
3438       , Whitespace
3439       , Plaintext "behaves"
3440       , Whitespace
3441       , Plaintext "exactly"
3442       , Whitespace
3443       , Plaintext "like"
3444       , Whitespace
3445       , Link ":Lack"
3446       , Whitespace
3447       , Plaintext "and"
3448       , Whitespace
3449       , Plaintext "will"
3450       , Whitespace
3451       , Plaintext "search"
3452       , Whitespace
3453       , Plaintext "all"
3454       , Whitespace
3455       , Plaintext "files"
3456       , Whitespace
3457       , Plaintext "in"
3458       , Whitespace
3459       , Plaintext "the"
3460       , Whitespace
3461       , Plaintext "current"
3462       , Whitespace
3463       , Plaintext "directory."
3464       ]
3465   , CommandAnnotation "Black!" (Just "{pattern} {options}")
3466   , Paragraph
3467       [ Plaintext "Like"
3468       , Whitespace
3469       , Link ":Black"
3470       , Plaintext ","
3471       , Whitespace
3472       , Plaintext "but"
3473       , Whitespace
3474       , Plaintext "returns"
3475       , Whitespace
3476       , Plaintext "all"
3477       , Whitespace
3478       , Plaintext "results"
3479       , Whitespace
3480       , Plaintext "irrespective"
3481       , Whitespace
3482       , Plaintext "of"
3483       , Whitespace
3484       , Plaintext "the"
3485       , Whitespace
3486       , Plaintext "value"
3487       , Whitespace
3488       , Plaintext "of"
3489       , Whitespace
3490       , Link "g:FerretMaxResults"
3491       , Plaintext "."
3492       ]
3493   , CommandAnnotation "Quack" (Just "{pattern} {options}")
3494   , Paragraph
3495       [ Plaintext "Like"
3496       , Whitespace
3497       , Link ":Ack"
3498       , Plaintext ","
3499       , Whitespace
3500       , Plaintext "but"
3501       , Whitespace
3502       , Plaintext "searches"
3503       , Whitespace
3504       , Plaintext "only"
3505       , Whitespace
3506       , Plaintext "among"
3507       , Whitespace
3508       , Plaintext "files"
3509       , Whitespace
3510       , Plaintext "currently"
3511       , Whitespace
3512       , Plaintext "in"
3513       , Whitespace
3514       , Plaintext "the"
3515       , Whitespace
3516       , Link "quickfix"
3517       , Whitespace
3518       , Plaintext "listing."
3519       , Whitespace
3520       , Plaintext "Note"
3521       , Whitespace
3522       , Plaintext "that"
3523       , Whitespace
3524       , Plaintext "the"
3525       , Whitespace
3526       , Plaintext "search"
3527       , Whitespace
3528       , Plaintext "is"
3529       , Whitespace
3530       , Plaintext "still"
3531       , Whitespace
3532       , Plaintext "delegated"
3533       , Whitespace
3534       , Plaintext "to"
3535       , Whitespace
3536       , Plaintext "the"
3537       , Whitespace
3538       , Plaintext "underlying"
3539       , Whitespace
3540       , Link "'grepprg'"
3541       , Whitespace
3542       , Plaintext "("
3543       , Code "rg"
3544       , Plaintext ","
3545       , Whitespace
3546       , Code "ag"
3547       , Plaintext ","
3548       , Whitespace
3549       , Code "ack"
3550       , Whitespace
3551       , Plaintext "or"
3552       , Whitespace
3553       , Code "ack-grep"
3554       , Plaintext "),"
3555       , Whitespace
3556       , Plaintext "which"
3557       , Whitespace
3558       , Plaintext "means"
3559       , Whitespace
3560       , Plaintext "that"
3561       , Whitespace
3562       , Plaintext "only"
3563       , Whitespace
3564       , Plaintext "buffers"
3565       , Whitespace
3566       , Plaintext "written"
3567       , Whitespace
3568       , Plaintext "to"
3569       , Whitespace
3570       , Plaintext "disk"