├── README
├── plugin
    ├── EasyGrepFileAssociations
    └── EasyGrep.vim
└── doc
    └── EasyGrep.txt


/README:
--------------------------------------------------------------------------------
 1 | This is a mirror of http://www.vim.org/scripts/script.php?script_id=2438
 2 | 
 3 | EasyGrep is a plugin for performing search and replace operations through multiple files. Vim already has builtin support for searching through files with its 'vimgrep' and 'grep' commands, but EasyGrep makes using them much, much easier. It also provides a powerful "Replace in Files" operation, something that is not very easy to do in Vim by default. With EasyGrep, you can specify with high-precision exactly the type of files you want to search, whether it be all files, only open buffers, only files matching a pattern, etc. Additionally, you can easily specify searching through hidden files, case-sensitivity, performing a recursive search, and many more options that make searching more easy.
 4 | 
 5 | EasyGrep provides both key mappings and commands to make search and replace easy. When using EasyGrep, searching for a word is as easy as typing <leader>vv (v v, not double-u) over the word for which you want to search.  This search can also be accomplished with the :Grep command and a user-specified pattern. Performing a "replace in files" is similar; type <leader>vr or use the :Replace command. Setting options is easy, simply type <leader>vo or :GrepOptions.  EasyGrep provides a great set of defaults but can also be configured to start up just how you like it; see the script for these options.  Most vimgrep (and grepprg) options are supported.  
 6 | 
 7 | For a screencast of the script in action go here: http://downloads.veryspeedy.net/vim/EasyGrep.gif
 8 | 
 9 | Keymappings:
10 | 
11 |     <Leader>vv  - Grep for the word under the cursor, match all occurences,
12 |                   like |gstar|
13 |     <Leader>vV  - Grep for the word under the cursor, match whole word, like 
14 |                   |star|
15 |     <Leader>va  - Like vv, but add to existing list
16 |     <Leader>vA  - Like vV, but add to existing list
17 |     <Leader>vr  - Perform a global search search on the word under the cursor
18 |                   and prompt for a pattern with which to replace it.
19 |     <Leader>vo  - Select the files to search in and set grep options
20 | 
21 | Commands:
22 | 
23 |     :Grep [arg]
24 |         Search for the specified arg, like <Leader>vv.  When an ! is added,
25 |         search like <Leader>vV
26 | 
27 |     :GrepAdd [arg]
28 |         Search for the specified arg, add to existing file list, as in
29 |         <Leader>va.  When an ! is added, search like <Leader>vA
30 | 
31 |     :Replace [target] [replacement]
32 |         Perform a global search and replace.  The function searches
33 |         the same set of files a grep for the desired target and opens a dialog to
34 |         confirm replacement.
35 |     
36 |     :ReplaceUndo
37 |         Undoes the last :Replace operation.  Does not stack successive
38 |         searches; only the last replace may be undone.  This function may not
39 |         work well when edits are made between a call to Replace and a call to
40 |         ReplaceUndo.
41 | 
42 |     :GrepOptions [arg]
43 |         Open a window to set grep options.
44 | 


--------------------------------------------------------------------------------
/plugin/EasyGrepFileAssociations:
--------------------------------------------------------------------------------
 1 | " EasyGrepFileAssociations
 2 | " Version 0.96
 3 | "
 4 | " This file is made up of Key-value pairs that associate file types
 5 | " individual file extensions should only show up in one pair; behavior may be
 6 | " inconsistent if they show up in several.  To include filetypes in multiple
 7 | " groups, you can link to a group using <Key> where key is a groupname
 8 | " Note that individual file extensions need not be listed in this file if they
 9 | " do not have associated file types
10 | " extensions should not be complicated regular expressions for matching to
11 | " happen correctly
12 | " TODO: consider how extensions dominate another, try this syntax <!C>
13 | " TODO: consider extension ordering for dominating
14 | " TODO: consider syntax to set exclusions
15 | " TODO: perhaps have a global exclude flag
16 | 
17 | Ada=*.adb *.ads *.ada *.gpr *.ada_m *.adc
18 | Assembly=*.asm *.[sS] *.[aA] *.mac *.lst *.i
19 | B=*.mch *.ref *.imp
20 | Basic=*.vbs *.dsm *.ctl *.bas *.frm *.sba *.iba *.ibi *.fb *.bi
21 | BibTeX=*.bib *.bst <TeX>
22 | C#=*.cs <C++>
23 | C++=*.cpp *.hpp *.cxx *.hxx *.cc *.hh *.c++ *.inl <C>
24 | C=*.c *.h
25 | CUDA=*.cu *.cuh <C++>
26 | Cobol=*.cbl *.cob
27 | ColdFusion=*.cfm *.cfi *.cfc
28 | Configuration=.*rc *.conf *.cf *.cfg *.config *.ini
29 | D=*.d <C++>
30 | Diff=*.diff *.rej *.patch
31 | EDIF=*.edf *.edif *.edn *.edo
32 | Eiffel=*.[eE]
33 | Erlang=*.erl *.hrl *.yaws
34 | Forth=*.fs *.ft *.frt
35 | Fortran=*.[fF] *.for *.FOR *.fortran *.fpp *.FPP *.ftn *.FTN *.[fF]77 *.[fF]90 *.[fF]95
36 | HDL=*.hdl *.vhd *.vhdl *.vbe *.vst *.v *.va *.vams *.tdf
37 | Haskell=*.hs *.lhs *.chs
38 | Image=*.xpm *.xpm2
39 | Jam=Prl*.* JAM*.* Jamroot Jamfile *.jpl *.jpr
40 | Java=*.java *.jav *.jj *.jjt
41 | Lex=*.lex *.l *.ll
42 | Lisp=*.lsp *.lisp *.el *.cl *.jl *.L
43 | Make=*.m4 *.ac *.in *.am *[mM]akefile *.mk *.mak *.dsp
44 | Math=*.m *.asv *.mv *.mpl *.mws *.nb
45 | OCAML=*.ml *.mli *.mll *.mly
46 | ObjectiveC=*.m *.mm <C>
47 | Oracle=*.tyb *.typ *.tyc *.pkb *.pks *.ora <SQL>
48 | PHP=*.php *.phtml *.ctp
49 | Perl=*.pl *.PL *.pm *.pod
50 | PostScript=*.ps *.pfa *.afm *.eps *.epsf *.epsi *.ai *.ppd
51 | Python=*.py *.pyw
52 | Qt=*.moc *.qmake *.ui *.ts <C++>
53 | Ruby=*.rb *.rbw *.gem *.gemspec [rR]akefile *.erb *.rhtml
54 | RubyOnRails=*.builder *.rxml *.rjs <Ruby>
55 | SQL=*.sql *.sqlj *.msql *.mysql *.pls *.plsql *.zsql
56 | Scheme=*.scm *.ss
57 | Shell=*.sh *.bash *.ebuild *.ksh *.tcsh *.cmd *.bat
58 | Spice=*.sp *.spice *.spy *.spi
59 | Tcl=*.tcl *.tk *.itcl *.itk *.jacl
60 | TeX=*.tex *.latex *.sty *.dtx *.ltx *.bbl *.mkii *.mkiv *.texinfo *.texi *.txi
61 | Text=*.txt *.inf *.INF
62 | Vera=*.vr *.vri *.vrh
63 | Vim=*.vim .vimrc .gvimrc *.vba .exrc _exrc .vim*
64 | Virata=*.hw *.module *.pkg
65 | VisualStudioProject=*.sln *.vcproj *.icproj *.csproj *.rc *.def
66 | Web=*.htm *.html *.shtml *.stm *.xhtml *.xht *.css *.js *.javascript *.es *.jsp *.asp *.asa
67 | X11=XF86* .X* *.ad <Configuration>
68 | XML=*.xml *.dtd
69 | Xquery=*.xq *.xql *.xqm *.xquery *.xqy
70 | Xsd=*.xsd <XML>
71 | Xslt=*.xsl *.xslt <XML>
72 | Yacc=*.y *.yy
73 | Yaml=*.yaml *.yml
74 | 
75 | 


--------------------------------------------------------------------------------
/doc/EasyGrep.txt:
--------------------------------------------------------------------------------
  1 | *EasyGrep.txt*
  2 | ==============================================================================
  3 |   EasyGrep                                                          *EasyGrep*
  4 | ==============================================================================
  5 | 
  6 | Author:      Dan Price   vim@danprice.fastmail.net       *EasyGrep_Author*
  7 | 
  8 | Goal:        To be an easy to use, powerful find and     |EasyGrep_Motivation|
  9 |              replace tool for users of all skill levels.
 10 | Version:     1.1                                         |EasyGrep_History|
 11 | 
 12 | License:     Public domain, no restrictions whatsoever   |EasyGrep_License|
 13 | Contribute:  Please report any bugs or suggestions       |EasyGrep_Bugs|
 14 |              to the address above.                       |EasyGrep_Future|
 15 | 
 16 | 
 17 | ==============================================================================
 18 |   Table of Contents                                        *EasyGrep_Contents*
 19 | ==============================================================================
 20 | 
 21 | 
 22 |              1. Motivation.................|EasyGrep_Motivation|
 23 |              2. Operation..................|EasyGrep_Operation|
 24 |                 2.1 Modes..................|EasyGrep_OperationModes|
 25 |                 2.2 Performance............|EasyGrep_Performance|
 26 |              3. Keymaps....................|EasyGrep_Keymaps|
 27 |                 3.1 Default Bindings ......|EasyGrep_KeymapsDefault|
 28 |                 3.2 Option Mappings........|EasyGrep_KeymapsOptions|
 29 |                 3.3 Mapping Customization..|EasyGrep_KeymapsCustomization|
 30 |              4. Commands...................|EasyGrep_Commands|
 31 |              5. Options....................|EasyGrep_Options|
 32 |                 5.1 Summary................|EasyGrep_OptionsSummary|
 33 |                 5.2 Explorer...............|EasyGrep_OptionsExplorer|
 34 |                 5.3 Details................|EasyGrep_OptionsDetail|
 35 |              6. Bugs.......................|EasyGrep_Bugs|
 36 |              7. Future.....................|EasyGrep_Future|
 37 |              8. History....................|EasyGrep_History|
 38 |              9. License....................|EasyGrep_License|
 39 | 
 40 | 
 41 | ==============================================================================
 42 |   1. Motivation                                          *EasyGrep_Motivation*
 43 | ==============================================================================
 44 | 
 45 | EasyGrep's main goal is to make search and replace in files easy.  Other Vim
 46 | plugins provide similar functionality, but few provide the same level of
 47 | functionality with as little configuration as EasyGrep does.  In the common
 48 | case, all it takes to search for a string across multiple files is three
 49 | keypresses: <leader>vv.  No clicks, no commands, no project/tags setup -- just
 50 | three keys.  When you need a substitution, it also takes the same number of
 51 | keys to start a replace in files.  After using EasyGrep, you'll wonder at how
 52 | you got around without it.
 53 | 
 54 | While EasyGrep's default configuration will satisfy many users, it provides
 55 | more than a dozen options for those who need more control |EasyGrep_Options|.
 56 | When you need to change options, EasyGrep provides an options explorer that
 57 | indicates which files will be searched and allows visual customization of its
 58 | options |EasyGrep_OptionsExplorer|.  When this isn't fast enough, EasyGrep
 59 | provides key mappings for each option to toggle its value
 60 | |EasyGrep_KeymapsOptions|.  If you can't find an option you need, contact me
 61 | |EasyGrep_Author| and if it doesn't already exist, we'll make it happen.
 62 | 
 63 | I hope that EasyGrep makes Vim more fun, productive, and easy for you to use.
 64 | 
 65 |                                 Happy Vimming!
 66 | 
 67 | 
 68 | ==============================================================================
 69 |   2. Operation                                            *EasyGrep_Operation*
 70 | ==============================================================================
 71 | 
 72 | EasyGrep makes using Vim's grep capabilities easier.  When using EasyGrep,
 73 | searching for a word in multiple files is as easy as typing a simple mapping
 74 | (see |EasyGrep_Keymaps)|.  In addition to keymaps, search and replace can be
 75 | invoked through commands (see |EasyGrep_Commands)|.
 76 | 
 77 | To determine which files to search, EasyGrep provides several builtinmodes,
 78 | described in the next section.
 79 | 
 80 | ------------------------------------------------------------------------------
 81 |  2.1 Search Modes                                    *EasyGrep_OperationModes*
 82 | ------------------------------------------------------------------------------
 83 | 
 84 | All
 85 |     All files will be searched  (default).
 86 | 
 87 | Buffers
 88 |     Files currently open in vim will be searched.  Recursion has no meaning in
 89 |     this mode, and will be turned off.
 90 | 
 91 | TrackExt
 92 |     Files that match the extension of the currently opened file will be
 93 |     searched.  Additionally, this extension can be mapped to a user defined
 94 |     set of extensions that will also be searched |EasyGrepFileAssociations|.
 95 | 
 96 |     For example: in the default configuration, when test.cpp is open, files
 97 |     that match any one of
 98 | 
 99 |         *.cpp *.hpp *.cxx *.hxx *.cc *.c *.h
100 | 
101 |     will be searched when a Grep is initiated.  I find this mode to be the
102 |     most useful.
103 | 
104 | User
105 |     Specify a custom set of file extensions to search.
106 | 
107 | 
108 | The startup mode is indicated by |EasyGrepMode|. These modes can be quickly
109 | changed through the |EasyGrep_OptionsExplorer| or |EasyGrep_KeymapsOptions|.
110 | 
111 | 
112 | ------------------------------------------------------------------------------
113 |  2.2 Performance                                         *EasyGrep_Performance*
114 | ------------------------------------------------------------------------------
115 | 
116 | By default, EasyGrep completes its searches using Vim's vimgrep command. While
117 | easy to use, vimgrep's searching time can be considerably longer than
118 | traditional tools like your system's grep command. Because of this, EasyGrep
119 | provides several options to allow you to control your performance:
120 | 
121 | - Consider setting EasyGrep to use your system's grep command.
122 |   (see |EasyGrepCommand|)
123 | - Consider whether recursive operation is set and whether you need it on all
124 |   the time. Note that it can be toggled easily with '<leader>vyr'.
125 |   (see |EasyGrepRecursive|)
126 | - Consider setting grep exclusions if your grep command supports it.
127 |   (see |EasyGrepFilesToExclude|)
128 | 
129 | 
130 | ==============================================================================
131 |   3. Keymaps                                                *EasyGrep_Keymaps*
132 | ==============================================================================
133 | 
134 | This section discusses EasyGrep's default keybindings and how to customize
135 | them.
136 | 
137 | ------------------------------------------------------------------------------
138 |  3.1 Default Bindings                                *EasyGrep_KeymapsDefault*
139 | ------------------------------------------------------------------------------
140 | 
141 | EasyGrep uses Vim's leader key, which is by default '\'.  For information on
142 | this key, type ":help mapleader".
143 | 
144 | <Leader>vv  - Grep for the word under the cursor, match all occurences,
145 |               like 'g*'.  See ":help gstar".
146 | <Leader>vV  - Grep for the word under the cursor, match whole word, like
147 |               '*'.  See ":help star".
148 | <Leader>va  - Like vv, but add to existing list.
149 | <Leader>vA  - Like vV, but add to existing list.
150 | 
151 | <Leader>vr  - Perform a global search on the word under the cursor
152 |               and prompt for a pattern with which to replace it.
153 | <Leader>vR  - Like vr, but match whole word.
154 | 
155 | Each of these commands has an 'all occurences' and 'whole word' option,
156 | designated by the case of the last character.  If you would prefer that these
157 | be reversed, see |EasyGrepInvertWholeWord|.
158 | 
159 | In addition to grepping the word under the cursor, text may be visually
160 | selected and these mappings may be used analogously to as they are used above.
161 | Visual selections will automatically be escaped so as not to confuse the
162 | selection with a regular expression.
163 | 
164 |     e.g. Selecting the text inside the quotes here "/<word\>" will match
165 |     against "\<word\>" but not against "word".
166 | 
167 | To search with a regular expression, see the :Grep command |EasyGrep_Commands|
168 | 
169 | Each of the above commands will search files according to settings
170 | controlled by:
171 | 
172 | <Leader>vo  - Open an options explorer to select the files to search in and
173 |               set grep options.
174 | 
175 | For the options provided, see |EasyGrep_Options|.
176 | 
177 | 
178 | ------------------------------------------------------------------------------
179 |  3.2 Option Mappings                                 *EasyGrep_KeymapsOptions*
180 | ------------------------------------------------------------------------------
181 | 
182 | For each of the options presented in the options explorer, there is a mapping
183 | that allows a direct change of this option.  The mapping for option is
184 | <Leader>vy<option>, where <option> is the character listed in the options
185 | window for each of the options.
186 | 
187 |     e.g. To change to buffers mode, type '\vyb'
188 |     e.g. To toggle recursive search, type '\vyr'
189 | 
190 | See |EasyGrepOptionPrefix| to change the prefix from '\vy' or to turn these
191 | keymappings off.
192 | 
193 | 
194 | ------------------------------------------------------------------------------
195 |  3.3 Mapping Customization                     *EasyGrep_KeymapsCustomization*
196 | ------------------------------------------------------------------------------
197 | 
198 | Beyond EasyGrepOptionPrefix, other keymaps may be remapped to your liking.
199 | See the "Keymaps" section of EasyGrep.vim for the names of these items.
200 | 
201 | Mappings take the form:
202 | 
203 |     map <silent> (keycombination) <plug>(MappingName)
204 | e.g.
205 |     map <silent> ,op <plug>EgMapGrepOptions
206 | 
207 | 
208 | ==============================================================================
209 |   4. Commands                                              *EasyGrep_Commands*
210 | ==============================================================================
211 | 
212 |                                                                        *:Grep*
213 | :Grep [arg]
214 |     Search for the specified arg, like <Leader>vv.  When an ! is added,
215 |     search like <Leader>vV
216 | 
217 |                                                                     *:GrepAdd*
218 | :GrepAdd [arg]
219 |     Search for the specified arg, add to existing file list, as in
220 |     <Leader>va.  When an ! is added, search like <Leader>vA
221 | 
222 |     The Above commands can additionally accept command switches that override
223 |     the configured settings:
224 |     -r   Perform a recursive search
225 |     -R   Perform a recursive search
226 |     -i   Perform a case-insensitive search
227 |     -I   Perform a case-sensitive search
228 |     -m   Specify the number of matches to get
229 | 
230 |                                                                     *:Replace*
231 | :Replace [target] [replacement]
232 | :Replace /[target]/[replacement]/
233 |     Perform a global search and replace.  The function searches
234 |     the same set of files a grep for the desired target and opens a dialog to
235 |     confirm replacement.  In the second, forward slash delineated form, back
236 |     and forward slashes must be explicitly escaped.
237 | 
238 |                                                                 *:ReplaceUndo*
239 | :ReplaceUndo
240 |     Undoes the last :Replace operation.  Does not stack successive
241 |     searches; only the last replace may be undone.  This function may not
242 |     work well when edits are made between a call to Replace and a call to
243 |     ReplaceUndo.
244 | 
245 |                                                                 *:GrepOptions*
246 | :GrepOptions
247 |     Open the options explorer to set options.
248 | 
249 | 
250 | For each of the search and replace commands, searching with regular
251 | expressions is supported.  Note that regular expressions are handled as
252 | indicated by the 'magic' option (see ":help 'magic'").
253 | 
254 |                                                             *:ResultListFilter*
255 | :ResultListFilter [args]
256 |     Removes entries from the error list according to whether or not they match
257 |     a set of specified patterns.  The default behaviour is to save all entries
258 |     that match one of the patterns and remove those that do not.
259 | 
260 |     The Above command can additionally accept command switches:
261 |     -v   Switch the criteria for matching; remove entries matching one of the
262 |          specified patterns instead of saving them
263 | 
264 |                                                              *:ResultListOpen*
265 | :ResultListOpen
266 |     Opens all of the entries in the current result list in a new tab.
267 | 
268 | 
269 | ==============================================================================
270 |   5. Options                                                *EasyGrep_Options*
271 | ==============================================================================
272 | 
273 | ------------------------------------------------------------------------------
274 |  5.1 Options Summary                                 *EasyGrep_OptionsSummary*
275 | ------------------------------------------------------------------------------
276 | 
277 |  Option                               Description
278 | `````````````````````````````````   ````````````````````````````````````````
279 | o |EasyGrepFileAssociations|            - Specifies the location of the EasyGrep
280 |                                         file associations
281 | o |EasyGrepMode|                        - Mode of operation
282 | o |EasyGrepCommand|                     - Whether to use vimgrep or grepprg
283 | o |EasyGrepRecursive|                   - Recursive searching
284 | o |EasyGrepIgnoreCase|                  - Case-sensitivity in searches
285 | o |EasyGrepHidden|                      - Include hidden files in searches
286 | o |EasyGrepFilesToExclude|              - Comma-separated list of files patterns
287 |                                         that will be excluded from the search
288 | o |EasyGrepAllOptionsInExplorer|        - How many options to show in the explorer
289 | o |EasyGrepWindow|                      - Quickfix or location list
290 | o |EasyGrepWindowPosition|              - Where the error list window is opened
291 | o |EasyGrepOpenWindowOnMatch|           - Open grep window on successful match
292 | o |EasyGrepEveryMatch|                  - Match multiple times per line
293 | o |EasyGrepJumpToMatch|                 - Jump to first match
294 | o |EasyGrepSearchCurrentBufferDir|      - Whether to search current buffers dir
295 |                                         in addition to working dir
296 | o |EasyGrepInvertWholeWord|             - Invert the meaning of whole word for vv
297 |                                         and vV keymaps
298 | o |EasyGrepFileAssociationsInExplorer|  - Whether to show the file associations
299 |                                         list in the options explorer
300 | o |EasyGrepReplaceWindowMode|           - Controls whether to use tabs or splits
301 |                                         when replacing in files
302 | o |EasyGrepReplaceAllPerFile|           - Replace on per file or global basis
303 | o |EasyGrepOptionPrefix|                - Specify the keymap for toggling options
304 | o |EasyGrepExtraWarnings|               - Whether to show extra warnings
305 | o |EasyGrepDefaultUserPattern|          - The default 'User' mode pattern
306 | 
307 | 
308 | ------------------------------------------------------------------------------
309 |  5.2 Options Explorer                              *EasyGrep_OptionsExplorer*
310 | ------------------------------------------------------------------------------
311 | 
312 |     To invoke the options explorer, type '\vo' (default).  The options
313 |     explorer presents all of EasyGrep's customizable options and provides
314 |     information on the file patterns that will be searched when invoking a
315 |     Grep.
316 | 
317 |     A useful exercise for beginners is to toggle between EasyGrep's options
318 |     and modes (|EasyGrep_OperationModes|) and type 'e' to see which files will
319 |     be searched for a given configuration.
320 | 
321 | 
322 | ------------------------------------------------------------------------------
323 |  5.3 Options Details                                 *EasyGrep_OptionsDetail*
324 | ------------------------------------------------------------------------------
325 | 
326 | *EasyGrepFileAssociations*
327 | [default=&runtimepath/plugin/EasyGrepFileAssociations]
328 | 
329 | Specifies the location of a file that contains groups of files that should be
330 | associated with one another.  When set to an empty string "", no file read
331 | will be attempted.
332 | 
333 | This file has a simple syntax used to logically link different files types.
334 | A simple configuration is shown below:
335 | 
336 |      C=*.c *.h
337 |      C++=*.cpp *.hpp *.cxx *.hxx *.cc <C>
338 |      VHDL=*.hdl *.vhd *.vhdl *.vbe *.vst
339 |      Web=*.htm *.html *.js
340 | 
341 | For example, in this configuration, whenever the active file has the .c
342 | extension, files with the .h extension will also be search.  A special feature
343 | of this syntax is the ability to link groups together.  For example, the C++
344 | group links to all files that are in the C group.
345 | 
346 | *EasyGrepMode*  [default=0]
347 | Specifies the mode in which to start.
348 | 0 - All files
349 | 1 - Open Buffers
350 | 2 - Track the current extension
351 | 3 - User mode -- Use a custom, on demand set of extensions
352 | 
353 | Note: I find option 2 to be the most powerful, but option 0 is activated by
354 | default because it is the most intuitive for users who haven't take the
355 | time to understand how the script works.  See |EasyGrep_OperationModes|.
356 | 
357 | *EasyGrepCommand*  [default=0]
358 | Specifies the grep command to use.
359 | 
360 | 0 - vimgrep
361 | 1 - grep (follows grepprg)
362 | 
363 | When the grep command is set to vimgrep, Vim's builtin |:vimgrep| command will
364 | be used.
365 | When the grep command is set to , Vim's builtin |:grep| command will be used.
366 | This command inspects the 'grepprg' variable to determine the external tool
367 | that will be used for the search. Note that an external tool is often faster
368 | to search than vimgrep (see |EasyGrep_Performance|).
369 | 
370 | *EasyGrepRecursive*  [default=0]
371 | Specifies that recursive search be activated on start.
372 | 
373 | *EasyGrepIgnoreCase*  [default=&ignorecase]
374 | Specifies the case sensitivity of searches.  Note that this can be further
375 | overrided for vimgrep searches with \c and \C.
376 | 
377 | *EasyGrepHidden*  [default=0]
378 | Specifies that hidden files search be activated on start.  Note that hidden
379 | implies the unix meaning of those files that are prepended with a '.', and not
380 | the Windows meaning of those files with a hidden attribute.
381 | 
382 | *EasyGrepFilesToExclude*  [default=""]
383 | Specifies a list of file patterns that will be excluded from the search.
384 | Multiple exclusions must be separated by commas. Note that these patterns will
385 | be passed unmodified on to the search program.
386 | 
387 | Currently only supported when EasyGrepCommand=1 and your grepprg is "grep" or
388 | "ack".
389 | 
390 | *EasyGrepAllOptionsInExplorer*  [default=0]
391 | Specifies that all options be included in the explorer window.
392 | 
393 | Note: settting this option is very useful when you want to try out and
394 | learn all of the options available in this script.
395 | 
396 | *EasyGrepWindow*  [default=0]
397 | Specifies the window to use for matches.
398 | 0 - quickfix
399 | 1 - location list
400 | 
401 | *EasyGrepWindowPosition*  [default=""]
402 | Specifies where the error list window is opened.  If empty, the default
403 | behavior for Vim's error list opening commands will be used. If not empty, the
404 | value of this option must match one of Vim's splitting positional window
405 | commands, such as topleft or botright.
406 | 
407 | *EasyGrepOpenWindowOnMatch*  [default=1]
408 | Specifies whether to open the with matches after a search.
409 | 
410 | *EasyGrepEveryMatch*  [default=0]
411 | Specifies that multiple matches on the same line be treated as different
412 | matches, like the g option to vimgrep.
413 | 
414 | *EasyGrepJumpToMatch*  [default=1]
415 | Specifies that jump to first match be activated, like the j option to vimgrep.
416 | 
417 | *EasyGrepSearchCurrentBufferDir*  [default=1]
418 | Setting this option causes EasyGrep to search not only the current directory,
419 | but also the directories for all buffers currently opened.
420 | 
421 | *EasyGrepInvertWholeWord*  [default=0]
422 | Specifies that the whole word search keys should be inverted from their
423 | default meaning.  For example, when this option is activated, <Leader>vv
424 | matches whole word, while <Leader>vV matches everything that includes the
425 | word.  Note that this affects both keymappings and commands.
426 | 
427 | *EasyGrepFileAssociationsInExplorer*  [default=0]
428 | Specifies whether to show the file associations list in the options explorer
429 | window.
430 | 
431 | *EasyGrepOptionPrefix*  [default=<leader>vy]
432 | Specifies the prefix that is used when building keymaps for setting options
433 | directly.  To specify that no option keymaps be created, set this to the empty
434 | string.
435 | 
436 | Default:
437 |     let g:EasyGrepOptionPrefix='<leader>vy'
438 | Custom:
439 |     let g:EasyGrepOptionPrefix=',oe'      (where ',oe' is your custom prefix)
440 | None:
441 |     let g:EasyGrepOptionPrefix=''         (this disables all mappings)
442 | 
443 | *EasyGrepReplaceWindowMode*  [default=0]
444 | Specifies the mode that the script will use when a buffer needs to be changed
445 | while performing a global replace.
446 | 0 - Open a new tab for each window
447 | 1 - Perform a split of the current window with the next window
448 | 2 - autowriteall; create no new windows
449 | 
450 | Note: Option 1 has the possibility of running out of vertical space to
451 | split more windows.  Actions are taken to make this a non-issue, but this
452 | option can often be more clunky than other options.
453 | Note: As a result of the limitation above, option 0 is the only mode that
454 | won't require saving the files during a replace.
455 | 
456 | *EasyGrepReplaceAllPerFile*  [default=0]
457 | Specifies that selecting 'a' (for all) will apply the replacements on a per
458 | file basis, as opposed to globally as is the default.
459 | 
460 | *EasyGrepExtraWarnings*  [default=1]
461 | Specifies that warnings be issued for conditions that may be valid but have
462 | the potential to confuse some users.
463 | 
464 | *EasyGrepDefaultUserPattern*  [default=""]
465 | Specifies the default pattern for 'User' mode. (see |EasyGrepMode| and
466 | |EasyGrep_OperationModes|).  This pattern must be defined and non-empty if
467 | |EasyGrepMode| is set to start in 'User' mode.
468 | 
469 | 
470 | ==============================================================================
471 |   6. Future                                                  *EasyGrep_Future*
472 | ==============================================================================
473 | 
474 | ------------------------------------------------------------------------------
475 | set file/directory inclusions.
476 | create capability to include paths other than the active directories in a
477 | search.  e.g.  ../../include, $INCLUDE, etc.
478 | ------------------------------------------------------------------------------
479 | set file/directory exclusions.
480 | This is currently supported with grepprg=grep or grepprg=ack but not with vimgrep.
481 | ------------------------------------------------------------------------------
482 | Provide recommendations on the best way to use the script
483 | ------------------------------------------------------------------------------
484 | Implement ResultListDo
485 | ------------------------------------------------------------------------------
486 | 
487 | ==============================================================================
488 |   7. Bugs                                                      *EasyGrep_Bugs*
489 | ==============================================================================
490 | 
491 | If you discover any bugs not listed here, please contact the |EasyGrep_Author|
492 | 
493 | ------------------------------------------------------------------------------
494 | Successive warning messages can hide a previous message
495 | ------------------------------------------------------------------------------
496 | ReplaceUndo opens a window even if it is already open?
497 | ------------------------------------------------------------------------------
498 | Report that a swap file can't be opened
499 | ------------------------------------------------------------------------------
500 | Patterns with backslashes in them require double-backslash to be searched from
501 | the command line.  This behaviour matches the builtin / command but it may be
502 | unintuitive.
503 | ------------------------------------------------------------------------------
504 | Support canceling a search and print a nice message
505 | ------------------------------------------------------------------------------
506 | 
507 | 
508 | 
509 | ==============================================================================
510 |   8. History                                                *EasyGrep_History*
511 | ==============================================================================
512 | 
513 |   1.1
514 |       Improved: much better support when grepprg is ack or grep. These tools
515 |           can search much more quickly than vimgrep and so may be preferable
516 |           to some users.
517 |       Feature: added a mapping to echo the command that EasyGrep will issue
518 |           (see 'v' in the options explorer)
519 |       Feature: Added keymap toggle for EasyGrepSearchCurrentBufferDir
520 |       Fixed: command line parsing of Grep command discarded spaces
521 |       Feature: added support for grep exclusions when grepprg is grep or ack
522 |       Feature: Added EasyGrepDefaultUserPattern option.
523 |           Thanks to Jesus Barcons for the suggestion.
524 |       Improved: Cleaned up the documentation
525 |       Improved: Cleaned up the internals of the script substantially
526 |       Improved: Formalized multi-select mode, which is when multiple file
527 |           extensions are selected from the options explorer
528 |       Improved: lots of misc fixes
529 |   1.0
530 |       Documentation: Added a help tag for each of the commands so that you can
531 |           look up more information on them.
532 |       Improved: Cleaned up the internals of the script substantially
533 |       Improved: Changed the name of FilterErrorList to ResultListFilter
534 |       Feature: Added ResultListOpen command to open all of the files in the
535 |           result list (aka error list)
536 |       Fixed: Added -- to signify the end of the command line options. Grepping
537 |           for patterns such as '->var' are now possible with ':Grep -- ->var'
538 |   0.98
539 |       Highlight: The Replace and ReplaceUndo commands were reimplemented.  The
540 |           granularity of matches inside of a Replace call were improved so that
541 |           you can now decide replacements individually per line.
542 |           Additionally, Complex operations such as replacing x[i][j][k] with
543 |           x(i,j,k) and following it up with a ReplaceUndo are now possible.
544 | 
545 |           e.g.
546 |           :Replace /x\[\([^]]\+\)\]\[\([^]]\+\)\]\[\([^]]\+\)\]/x(\1,\2,\3)/
547 |           :ReplaceUndo
548 | 
549 |           Please report any regressions with either of these functions.
550 | 
551 |       Feature: Added count command line option (-m 4 or -4)
552 |       Feature: Improved Grep options window keybindings; searching within the
553 |           options explorer window is now possible
554 |       Feature: Expanded searches to include all of the active buffers'
555 |           directories
556 |       Bugfix:  Fixed recursive operation and expanded search from reporting
557 |           duplicate results
558 |       Bugfix:  Fixed <C-e> and <C-y> in replace mode
559 |       Feature: Added EasyGrepWindowPosition for specifying where the error
560 |           list window will be opened
561 |       Feature: Added FilterErrorlist command for filtering the results within
562 |           the quickfix or location list windows
563 |       Feature: Improved printout when no matches are found
564 |       Feature: Improved searching when an entire line is selected
565 |   0.96
566 |       Feature: Expanded upon the list of file associations
567 |       Feature: Expanded searches to the current buffer's directory
568 |       in addition to the current working directory
569 |       Feature: Added command line arguments to :Grep and :Replace for
570 |       recursive searches and case sensitivity
571 |       Feature: Added toggle for window replace mode
572 |       Feature: Added toggle for showing file associations list in options
573 |       explorer
574 |       Bugfix: Case insensitivity would fail in replacing some patterns
575 |   0.95
576 |       Feature: Added search and replace on visual selections
577 |       Feature: Improved Grepping for items that can be interpreted as regular
578 |       expressions.  Selections are assumed to be literal, whereas explicit
579 |       commands are assumed to be regular expressions.
580 |       Feature: Removed option g:EasyGrepNoDirectMappings in favor of
581 |       g:EasyGrepOptionPrefix, which allows the option prefix to be changed.
582 |       Bugfix:  The tracked extension would sometimes fail to be updated when
583 |       switching between buffers
584 |       Documentation: Split the documentation into its own file; greatly
585 |       expanded upon its contents
586 |       Change: Activating a mode that is already activated will no longer
587 |       deactivate it
588 |       Change: GrepOptions no longer accepts an argument; use user mode instead
589 |       Change: Clarified mapping names; custom mappings will need to
590 |       be reset.
591 |   0.9
592 |       Feature: Added forward slash delineated pattern to the Replace command
593 |       e.g. :Replace /target/replacement/
594 |       that allows more complicated replacements; you can now work with
595 |       patterns that have spaces in them.
596 |       Bugfix: If cursorline is off at the start of a replace, now ensuring
597 |       that cursorline is turned off for all buffers, and not just the last one
598 |       Bugfix: fixed an issue with an extra tab being opened during a
599 |       replacement
600 |   0.8
601 |       Implemented case sensitivity that is independent of ignorecase, thanks
602 |       to Doro Wu for contributing to this functionality
603 |       Changed shortcut key for hidden files from 'i' to 'h'
604 |   0.7
605 |       Expanded search of EasyGrepFileAssociations list to every component of
606 |       'runtimepath'.  This solves a starting message for those who placed
607 |       EasyGrepFileAssociations in a location other than the first location in
608 |       'runtimepath'.
609 |   0.6
610 |       Fixed paths with spaces in them
611 |       Folds will now be disabled where replacements are to be made
612 |       Fixed an error with checking for extra warnings
613 |       Better highlighting while replacing
614 |       Recursive mode can no longer be activated when Buffers mode is activated
615 |   0.5
616 |       Fixed an issue with tracking the file extension where sometimes the
617 |       desired extension wouldn't be registered.
618 |       Better reporting when no files match.
619 |       Now warning when searching from a working directory that doesn't match
620 |       the current file's directory.
621 |       Added g:EasyGrepExtraWarnings option.
622 |   0.4
623 |       Improved Replace and ReplaceUndo
624 |       Added two configurable modes for how the windows operate when doing a
625 |       global replace.
626 |       Fixed an issue with linked filetypes.
627 |   0.3
628 |       Added experimental :Replace and :ReplaceUndo commands; keymapped
629 |       <leader>vr for :Replace
630 |       Improved response when no matches
631 |   0.2
632 |       Added option to toggle showing fewer or more options; showing fewer
633 |       options by default.
634 |       Added option '?' to print the current configuration and save it to a
635 |       register.
636 |       Now creating direct mappings by default; see g:EasyGrepNoDirectMappings
637 |       to turn this off.
638 |   0.1
639 |       Initial version
640 | 
641 | 
642 | ==============================================================================
643 |   9. License                                                *EasyGrep_License*
644 | ==============================================================================
645 | 
646 |                   Public domain, no restrictions whatsoever
647 | 
648 | When writing EasyGrep, I wanted it to be free in the broadest sense.  Of
649 | course, most (if not all) plugins for Vim are free, but I wanted mine to be
650 | freer still: I've released EasyGrep in the public domain.  It took a lot of
651 | time and learning to get EasyGrep to work, and I want anyone to take advantage
652 | of my contribution.  If you see some (or many) snippets of EasyGrep's code
653 | that you need, use it -- you don't need to ask me, think about any copyright,
654 | worry about violating a license, or even note that the code came from me; just
655 | use it.  My only request is that if you are thinking of forking EasyGrep (or
656 | enhancing, as some authors claim to do), please contact me to let me know
657 | what you feel is lacking in EasyGrep, and I promise I'll be receptive to
658 | correcting these issues.
659 | 
660 | 
661 | ==============================================================================
662 | vim:tw=78:ts=4:ft=help:norl:fdm=marker
663 | 


--------------------------------------------------------------------------------
/plugin/EasyGrep.vim:
--------------------------------------------------------------------------------
   1 | " Title:         EasyGrep
   2 | " Author:        Dan Price   vim@danprice.fastmail.net
   3 | "
   4 | " Goal:          To be an easy to use, powerful find and replace resource for
   5 | "                users of all skill levels.
   6 | " Usage:         This file should reside in the plugin directory and be
   7 | "                automatically sourced.
   8 | "
   9 | " License:       Public domain, no restrictions whatsoever
  10 | " Documentation: type ":help EasyGrep"
  11 | "
  12 | " Version:       1.1 -- Programs can inspect g:EasyGrepVersion
  13 | 
  14 | " Initialization {{{
  15 | if exists("g:EasyGrepVersion") || &cp || !has("quickfix")
  16 |     finish
  17 | endif
  18 | let g:EasyGrepVersion = "1.1"
  19 | " Check for Vim version 700 or greater {{{
  20 | if v:version < 700
  21 |     echo "Sorry, EasyGrep ".g:EasyGrepVersion." ONLY runs with Vim 7.0 and greater."
  22 |     finish
  23 | endif
  24 | " }}}
  25 | " }}}
  26 | 
  27 | " Internals {{{
  28 | " Helper Functions {{{
  29 | " countstr {{{
  30 | function! s:countstr(str, ele)
  31 |     let end = len(a:str)
  32 |     let c = 0
  33 |     let i = 0
  34 |     while i < end
  35 |         if a:str[i] == a:ele
  36 |             let c += 1
  37 |         endif
  38 |         let i += 1
  39 |     endwhile
  40 | 
  41 |     return c
  42 | endfunction
  43 | "}}}
  44 | " unique {{{
  45 | function! s:unique(lst)
  46 |     if empty(a:lst)
  47 |         return a:lst
  48 |     endif
  49 | 
  50 |     let lst = a:lst
  51 |     call sort(lst)
  52 | 
  53 |     let end = len(lst)
  54 |     let i = 1
  55 |     let lastSeen = lst[0]
  56 |     while i < end
  57 |         if lst[i] == lastSeen
  58 |             call remove(lst, i)
  59 |             let end -= 1
  60 |         else
  61 |             let i += 1
  62 |         endif
  63 |     endwhile
  64 | 
  65 |     return lst
  66 | endfunction
  67 | "}}}
  68 | " BackToForwardSlash {{{
  69 | function! s:BackToForwardSlash(arg)
  70 |     return substitute(a:arg, '\\', '/', 'g')
  71 | endfunction
  72 | "}}}
  73 | " ForwardToBackSlash {{{
  74 | function! s:ForwardToBackSlash(arg)
  75 |     return substitute(a:arg, '/', '\\', 'g')
  76 | endfunction
  77 | "}}}
  78 | " GetBuffersOutput {{{
  79 | function! s:GetBuffersOutput()
  80 |     redir => bufoutput
  81 |     silent! buffers
  82 |     " This echo clears a bug in printing that shows up when it is not present
  83 |     silent! echo ""
  84 |     redir END
  85 | 
  86 |     return bufoutput
  87 | endfunction
  88 | " }}}
  89 | " GetBufferIdList {{{
  90 | function! s:GetBufferIdList()
  91 |     let bufoutput = s:GetBuffersOutput()
  92 | 
  93 |     let bufids = []
  94 |     for i in split(bufoutput, "\n")
  95 |         let s1 = 0
  96 |         while i[s1] == ' '
  97 |             let s1 += 1
  98 |         endwhile
  99 | 
 100 |         let s2 = stridx(i, ' ', s1) - 1
 101 |         let id = str2nr(i[s1 : s2])
 102 | 
 103 |         call add(bufids, id)
 104 |     endfor
 105 | 
 106 |     return bufids
 107 | endfunction
 108 | " }}}
 109 | " GetBufferNamesList {{{
 110 | function! s:GetBufferNamesList()
 111 |     let bufoutput = s:GetBuffersOutput()
 112 | 
 113 |     let bufNames = []
 114 |     for i in split(bufoutput, "\n")
 115 |         let s1 = stridx(i, '"') + 1
 116 |         let s2 = stridx(i, '"', s1) - 1
 117 |         let str = i[s1 : s2]
 118 | 
 119 |         if str[0] == '[' && str[len(str)-1] == ']'
 120 |             continue
 121 |         endif
 122 | 
 123 |         if str != "" && has("win32") && str[0] == "/"
 124 |             " Add the drive prefix
 125 |             let str = fnamemodify(str, ":p")
 126 |         endif
 127 | 
 128 |         call add(bufNames, str)
 129 |     endfor
 130 | 
 131 |     return bufNames
 132 | endfunction
 133 | " }}}
 134 | " GetBufferDirsList {{{
 135 | function! s:GetBufferDirsList()
 136 |     let dirs = {}
 137 |     let bufs = s:GetBufferNamesList()
 138 |     for buf in bufs
 139 |         let d = fnamemodify(expand(buf), ":.:h")
 140 |         if d == ""
 141 |             let d = getcwd()
 142 |         elseif has("win32") && d[0] == "/"
 143 |             " Add the drive prefix and remove the trailing slash
 144 |             let d = fnamemodify(d, ":p:s-/$--")
 145 |         endif
 146 |         if empty(d)
 147 |             continue
 148 |         endif
 149 |         let dirs[d]=1
 150 |     endfor
 151 |     return keys(dirs)
 152 | endfunction
 153 | " }}}
 154 | " GetVisibleBuffers {{{
 155 | function! s:GetVisibleBuffers()
 156 |     let tablist = []
 157 |     for i in range(tabpagenr('$'))
 158 |        call extend(tablist, tabpagebuflist(i + 1))
 159 |     endfor
 160 |     let tablist = s:unique(tablist)
 161 |     return tablist
 162 | endfunction
 163 | " }}}
 164 | " EscapeList {{{
 165 | function! s:FileEscape(item)
 166 |     return escape(a:item, ' \')
 167 | endfunction
 168 | function! s:ShellEscape(item)
 169 |     return shellescape(a:item, 1)
 170 | endfunction
 171 | function! s:DoEscapeList(lst, seperator, func)
 172 |     let escapedList = []
 173 |     for item in a:lst
 174 |         let e = a:func(item).a:seperator
 175 |         call add(escapedList, e)
 176 |     endfor
 177 |     return escapedList
 178 | endfunction
 179 | function! s:EscapeList(lst, seperator)
 180 |     return s:DoEscapeList(a:lst, a:seperator, function("s:FileEscape"))
 181 | endfunction
 182 | function! s:ShellEscapeList(lst, seperator)
 183 |     return s:DoEscapeList(a:lst, a:seperator, function("s:ShellEscape"))
 184 | endfunction
 185 | "}}}
 186 | " Escape{{{
 187 | function! s:Escape(str, lst)
 188 |     let str = a:str
 189 |     for i in a:lst
 190 |         let str = escape(str, i)
 191 |     endfor
 192 |     return str
 193 | endfunction
 194 | "}}}
 195 | " EscapeSpecial {{{
 196 | function! s:EscapeSpecial(str)
 197 |     let lst = [ '\', '/', '^', '$' ]
 198 |     if &magic
 199 |         let magicLst = [ '*', '.', '~', '[', ']' ]
 200 |         call extend(lst, magicLst)
 201 |     endif
 202 |     return s:Escape(a:str, lst)
 203 | endfunction
 204 | "}}}
 205 | " IsRecursivePattern {{{
 206 | function! s:IsRecursivePattern(pattern)
 207 |     return stridx(a:pattern, "\*\*\/") == 0 ? 1 : 0
 208 | endfunction
 209 | " }}}
 210 | " GetSavedName {{{
 211 | function! s:GetSavedName(var)
 212 |     let var = a:var
 213 |     if match(var, "g:") == 0
 214 |         let var = substitute(var, "g:", "g_", "")
 215 |     endif
 216 |     return "s:saved_".var
 217 | endfunction
 218 | " }}}
 219 | " SaveVariable {{{
 220 | function! s:SaveVariable(var)
 221 |     if empty(a:var)
 222 |         return
 223 |     endif
 224 |     let savedName = s:GetSavedName(a:var)
 225 |     if match(a:var, "g:") == 0
 226 |         execute "let ".savedName." = ".a:var
 227 |     else
 228 |         execute "let ".savedName." = &".a:var
 229 |     endif
 230 | endfunction
 231 | " }}}
 232 | " RestoreVariable {{{
 233 | " if a second variable is present, indicate no unlet
 234 | function! s:RestoreVariable(var, ...)
 235 |     let doUnlet = a:0 == 1
 236 |     let savedName = s:GetSavedName(a:var)
 237 |     if exists(savedName)
 238 |         if match(a:var, "g:") == 0
 239 |             execute "let ".a:var." = ".savedName
 240 |         else
 241 |             execute "let &".a:var." = ".savedName
 242 |         endif
 243 |         if doUnlet
 244 |             unlet savedName
 245 |         endif
 246 |     endif
 247 | endfunction
 248 | " }}}
 249 | " OnOrOff {{{
 250 | function! s:OnOrOff(num)
 251 |     return a:num == 0 ? 'off' : 'on'
 252 | endfunction
 253 | "}}}
 254 | " Trim {{{
 255 | function! s:Trim(s)
 256 |     let len = strlen(a:s)
 257 | 
 258 |     let beg = 0
 259 |     while beg < len
 260 |         if a:s[beg] != " " && a:s[beg] != "\t"
 261 |             break
 262 |         endif
 263 |         let beg += 1
 264 |     endwhile
 265 | 
 266 |     let end = len - 1
 267 |     while end > beg
 268 |         if a:s[end] != " " && a:s[end] != "\t"
 269 |             break
 270 |         endif
 271 |         let end -= 1
 272 |     endwhile
 273 | 
 274 |     return strpart(a:s, beg, end-beg+1)
 275 | endfunction
 276 | "}}}
 277 | " ClearNewline {{{
 278 | function! s:ClearNewline(s)
 279 |     if empty(a:s)
 280 |         return a:s
 281 |     endif
 282 | 
 283 |     let lastchar = strlen(a:s)-1
 284 |     if char2nr(a:s[lastchar]) == 10
 285 |         return strpart(a:s, 0, lastchar)
 286 |     endif
 287 | 
 288 |     return a:s
 289 | endfunction
 290 | "}}}
 291 | " Warning/Error {{{
 292 | function! s:Info(message)
 293 |     echohl Normal | echomsg "[EasyGrep] Info: ".a:message | echohl None
 294 | endfunction
 295 | function! s:Warning(message)
 296 |     echohl WarningMsg | echomsg "[EasyGrep] Warning: ".a:message | echohl None
 297 | endfunction
 298 | function! s:Error(message)
 299 |     echohl ErrorMsg | echomsg "[EasyGrep] Error: ".a:message | echohl None
 300 | endfunction
 301 | function! s:InternalFailure(message)
 302 |     echoerr a:message
 303 |     call s:Info("Please record the error message above and contact EasyGrep's author for help in resolving this issue")
 304 | endfunction
 305 | "}}}
 306 | " }}}
 307 | " Script Variables {{{
 308 | let s:EasyGrepModeAll=0
 309 | let s:EasyGrepModeBuffers=1
 310 | let s:EasyGrepModeTracked=2
 311 | let s:EasyGrepModeUser=3
 312 | let s:EasyGrepNumModes = 4
 313 | 
 314 | " This is a special mode
 315 | let s:EasyGrepModeMultipleChoice=4
 316 | let s:EasyGrepNumModesWithSpecial = 5
 317 | 
 318 | let s:NumReplaceModeOptions = 3
 319 | 
 320 | let s:OptionsExplorerOpen = 0
 321 | 
 322 | let s:FilesToGrep = "*"
 323 | let s:TrackedExt  = "*"
 324 | 
 325 | function! s:GetReplaceWindowModeString(mode)
 326 |     if(a:mode < 0 || a:mode >= s:NumReplaceModeOptions)
 327 |         return "invalid"
 328 |     endif
 329 |     let ReplaceWindowModeStrings = [ "New Tab", "Split Windows", "autowriteall" ]
 330 |     return ReplaceWindowModeStrings[a:mode]
 331 | endfunction
 332 | let s:SortOptions = [ "Name", "Name Reversed", "Extension", "Extension Reversed" ]
 333 | let s:SortFunctions = [ "SortName", "SortNameReversed", "SortExtension", "SortExtensionReversed" ]
 334 | let s:SortChoice = 0
 335 | 
 336 | let s:Commands = [ "vimgrep", "grep" ]
 337 | let s:CommandChoice = 0
 338 | let s:LastSeenGrepprg = &grepprg
 339 | function! s:InitializeCommandChoice()
 340 |     let s:CommandChoice = g:EasyGrepCommand < len(s:Commands) ? g:EasyGrepCommand : 0
 341 | endfunction
 342 | let s:CurrentFileCurrentDirChecked = 0
 343 | let s:SanitizeLock = 0
 344 | 
 345 | " SetGatewayVariables {{{
 346 | function! s:SetGatewayVariables()
 347 |     echo
 348 |     call s:SaveVariable("lazyredraw")
 349 |     set lazyredraw
 350 | endfunction
 351 | " }}}
 352 | " ClearGatewayVariables {{{
 353 | function! s:ClearGatewayVariables()
 354 |     let s:CurrentFileCurrentDirChecked = 0
 355 |     call s:RestoreVariable("lazyredraw")
 356 | endfunction
 357 | " }}}
 358 | 
 359 | " }}}
 360 | " Common {{{
 361 | " Echo {{{
 362 | function! <sid>Echo(message)
 363 |     let str = ""
 364 |     if !s:OptionsExplorerOpen
 365 |         let str .= "[EasyGrep] "
 366 |     endif
 367 |     let str .= a:message
 368 |     echo str
 369 | endfunction
 370 | "}}}
 371 | " GetPatternList {{{
 372 | function! s:GetPatternList(sp, addAdditionalLocations)
 373 |     let sp = a:sp
 374 |     let addAdditionalLocations = a:addAdditionalLocations
 375 |     if s:IsModeBuffers()
 376 |         let str = join(s:EscapeList(s:GetBufferNamesList(), " "), sp)
 377 |         let addAdditionalLocations = 0
 378 |     elseif s:IsModeTracked()
 379 | 
 380 |         let str = s:TrackedExt
 381 |         let i = s:FindByPattern(s:TrackedExt)
 382 |         if i != -1
 383 |             let keyList = [ i ]
 384 |             let str = s:BreakDown(keyList)
 385 |         endif
 386 |     else
 387 |         let i = 0
 388 |         let numItems = len(s:Dict)
 389 |         let keyList = []
 390 |         while i < numItems
 391 |             if s:Dict[i][2] == 1
 392 |                 call add(keyList, i)
 393 |             endif
 394 |             let i += 1
 395 |         endwhile
 396 | 
 397 |         if !empty(keyList)
 398 |             let str = s:BreakDown(keyList)
 399 |         else
 400 |             call s:InternalFailure("Keylist should not be empty")
 401 |             let str = "*"
 402 |         endif
 403 |     endif
 404 | 
 405 |     if addAdditionalLocations
 406 |         let filesToGrep = s:AddAdditionalLocationsToList(str, sp)
 407 |     else
 408 |         let filesToGrep = str
 409 |     endif
 410 | 
 411 |     let filesToGrep = s:Trim(filesToGrep)
 412 |     return filesToGrep
 413 | endfunction
 414 | " }}}
 415 | " BuildListOfFilesToGrep {{{
 416 | function! s:BuildListOfFilesToGrep(...)
 417 |     if a:0 > 0
 418 |         let sp = a:1
 419 |     else
 420 |         let sp = " "
 421 |     endif
 422 |     let s:FilesToGrep = s:GetPatternList(sp, 1)
 423 |     return s:FilesToGrep
 424 | endfunction
 425 | " }}}
 426 | " AddAdditionalLocationsToList {{{
 427 | function! s:AddAdditionalLocationsToList(str, sp)
 428 |     if empty(a:str)
 429 |         return a:str
 430 |     endif
 431 | 
 432 |     let str = a:str
 433 |     let sp = a:sp
 434 |     if !s:IsModeBuffers() && g:EasyGrepSearchCurrentBufferDir
 435 |         let str = s:AddBufferDirsToPatternList(str,sp)
 436 |     endif
 437 |     let patternList = split(str)
 438 | 
 439 |     if g:EasyGrepHidden
 440 |         let i = 0
 441 |         let size = len(patternList)
 442 |         while i < size
 443 |             let item = patternList[i]
 444 |             let lastpiece = strridx(item, '/')
 445 |             if lastpiece == -1 && item[0] == '.'
 446 |                 " skip this item, it's already hidden
 447 |             elseif lastpiece != -1 && item[lastpiece+1] == '.'
 448 |                 " skip this item, it's already hidden
 449 |             else
 450 |                 if lastpiece == -1
 451 |                     let newItem = '.'.item
 452 |                 else
 453 |                     let newItem  = strpart(item, 0, lastpiece+1)
 454 |                     let newItem .= "."
 455 |                     let newItem .= strpart(item, lastpiece+1)
 456 |                 endif
 457 |                 let i += 1
 458 |                 let size += 1
 459 |                 call insert(patternList, newItem, i)
 460 |             endif
 461 |             let i += 1
 462 |         endwhile
 463 |     endif
 464 | 
 465 |     let str = ""
 466 |     for item in patternList
 467 |         if g:EasyGrepRecursive && s:IsCommandVimgrep()
 468 |             let str .= "**/"
 469 |         endif
 470 |         let str .= item.sp
 471 |     endfor
 472 | 
 473 |     return str
 474 | endfunction
 475 | "}}}
 476 | " AddBufferDirsToPatternList {{{
 477 | function! s:AddBufferDirsToPatternList(str,sp)
 478 |     let str = a:str
 479 |     let sp = a:sp
 480 | 
 481 |     " Build a list of the directories in buffers
 482 |     let dirs = sort(s:GetBufferDirsList())
 483 | 
 484 |     let patternList = split(str, sp)
 485 | 
 486 |     let currDir = getcwd()
 487 |     let accepteddirs = [ currDir ]
 488 |     for key in dirs
 489 |         let newDir = key
 490 |         let addToList = 1
 491 |         if newDir == currDir || newDir == '.'
 492 |             let addToList = 0
 493 |         elseif g:EasyGrepRecursive
 494 |             for d in accepteddirs
 495 |                 if s:IsRecursivelyReachable(d, newDir)
 496 |                     let addToList = 0
 497 |                     break
 498 |                 endif
 499 |             endfor
 500 |         endif
 501 |         if addToList
 502 |             call add(accepteddirs, newDir)
 503 |             for p in patternList
 504 |                 let str = str.sp.newDir."/".p
 505 |             endfor
 506 |         endif
 507 |     endfor
 508 |     return str
 509 | endfunction
 510 | "}}}
 511 | " FindByPattern {{{
 512 | function! s:FindByPattern(pattern)
 513 |     let pattern = a:pattern
 514 |     let i = 0
 515 |     let numItems = len(s:Dict)
 516 |     while i < numItems
 517 |         if i != s:EasyGrepModeTracked
 518 |             let patterns = split(s:Dict[i][1])
 519 |             for p in patterns
 520 |                 if pattern ==# p
 521 |                     return i
 522 |                 endif
 523 |             endfor
 524 |         endif
 525 |         let i += 1
 526 |     endwhile
 527 |     return -1
 528 | endfunction
 529 | " }}}
 530 | " IsRecursivelyReachable {{{
 531 | function! s:IsRecursivelyReachable(fromthisdir, target)
 532 |     let directoryTarget = fnamemodify(a:target, ":p:h")
 533 | 
 534 |     if match(directoryTarget, a:fromthisdir) != 0
 535 |         return 0
 536 |     endif
 537 | 
 538 |     return 1
 539 | endfunction
 540 | " }}}
 541 | " GetRecursiveMinimalSetList {{{
 542 | function! s:GetRecursiveMinimalSetList()
 543 | 
 544 |     let currDir = getcwd()
 545 |     let bufferdirs = sort(s:GetBufferDirsList())
 546 |     let bufferSetList = [ currDir ]
 547 | 
 548 |     for dir in bufferdirs
 549 |         let addToList = 1
 550 |         if dir == currDir || dir == '.'
 551 |             let addToList = 0
 552 |         else
 553 |             for d in bufferSetList
 554 |                 if s:IsRecursivelyReachable(d, dir)
 555 |                     let addToList = 0
 556 |                     break
 557 |                 endif
 558 |             endfor
 559 |         endif
 560 |         if addToList
 561 |             call add(bufferSetList, dir)
 562 |         endif
 563 |     endfor
 564 | 
 565 |     return bufferSetList
 566 | endfunction
 567 | " }}}
 568 | " GetDirectorySearchList {{{
 569 | function! s:GetDirectorySearchList()
 570 |     if g:EasyGrepSearchCurrentBufferDir
 571 |         if g:EasyGrepRecursive
 572 |             return s:GetRecursiveMinimalSetList()
 573 |         else
 574 |             return extend([getcwd()], s:GetBufferDirsList())
 575 |         endif
 576 |     else
 577 |         return [ getcwd() ]
 578 |     endif
 579 | endfunction
 580 | " }}}
 581 | " CheckIfCurrentFileIsSearched {{{
 582 | function! s:CheckIfCurrentFileIsSearched()
 583 |     if !g:EasyGrepExtraWarnings || s:CurrentFileCurrentDirChecked || g:EasyGrepSearchCurrentBufferDir
 584 |         return 1
 585 |     endif
 586 |     let s:CurrentFileCurrentDirChecked = 1
 587 |     if !empty(&buftype) " don't check for quickfix and others
 588 |         return 1
 589 |     endif
 590 |     if !s:IsModeBuffers()
 591 |         let currFile = bufname("%")
 592 |         if empty(currFile) && &modified
 593 |             call s:Warning("cannot search the current buffer because it is unnamed")
 594 |             return 0
 595 |         endif
 596 |         let fileDir = fnamemodify(currFile, ":p:h")
 597 |         if !empty(fileDir) && !g:EasyGrepSearchCurrentBufferDir
 598 |             let cwd = getcwd()
 599 |             let willmatch = 1
 600 |             if g:EasyGrepRecursive
 601 |                 if match(fileDir, cwd) != 0
 602 |                     let willmatch = 0
 603 |                 endif
 604 |             else
 605 |                 if fileDir != cwd
 606 |                     let willmatch = 0
 607 |                 endif
 608 |             endif
 609 |             if !willmatch
 610 |                 call s:Warning("current file not searched, its directory [".fileDir."] doesn't match the working directory [".cwd."]")
 611 |                 return 0
 612 |             endif
 613 |         endif
 614 |     endif
 615 |     return 1
 616 | endfunction
 617 | " }}}
 618 | " }}}
 619 | " OptionsExplorer {{{
 620 | " OpenOptionsExplorer {{{
 621 | function! s:OpenOptionsExplorer()
 622 |     let s:OptionsExplorerOpen = 1
 623 | 
 624 |     call s:CreateOptionsString()
 625 | 
 626 |     let windowLines = len(s:Options) + 1
 627 |     if g:EasyGrepFileAssociationsInExplorer
 628 |         let windowLines += len(s:Dict)
 629 |     else
 630 |         let windowLines += s:EasyGrepNumModes
 631 |     endif
 632 | 
 633 |     " split the window; fit exactly right
 634 |     exe "keepjumps botright ".windowLines."new"
 635 | 
 636 |     setlocal bufhidden=delete
 637 |     setlocal buftype=nofile
 638 |     setlocal nobuflisted
 639 |     setlocal noswapfile
 640 |     setlocal cursorline
 641 | 
 642 |     syn match Help    /^".*/
 643 |     highlight def link Help Special
 644 | 
 645 |     syn match Activated    /^>\w.*/
 646 |     highlight def link Activated Type
 647 | 
 648 |     syn match Selection    /^\ \w.*/
 649 |     highlight def link Selection String
 650 | 
 651 |     call s:MapOptionsKeys()
 652 | 
 653 |     call s:BuildListOfFilesToGrep()
 654 |     call s:FillWindow()
 655 | endfunction
 656 | " }}}
 657 | " Mapped Functions {{{
 658 | " EchoFilesSearched {{{
 659 | function! <sid>EchoFilesSearched()
 660 |     let filesToGrep = s:BuildListOfFilesToGrep("\n")
 661 | 
 662 |     if s:IsModeBuffers()
 663 |         let str = filesToGrep
 664 |     else
 665 |         let str = ""
 666 |         let patternList = split(filesToGrep)
 667 |         for p in patternList
 668 |             let s = glob(p)
 669 |             if !empty(s)
 670 |                 let fileList = split(s, "\n")
 671 |                 for f in fileList
 672 |                     if filereadable(f)
 673 |                         let str .= f."\n"
 674 |                     endif
 675 |                 endfor
 676 |             endif
 677 |         endfor
 678 |     endif
 679 | 
 680 |     if !empty(str)
 681 |         call s:Echo("Files that will be searched")
 682 |         echo str
 683 |     else
 684 |         call s:Echo("No files match the current options")
 685 |     endif
 686 |     call s:BuildListOfFilesToGrep()
 687 | endfunction
 688 | "}}}
 689 | " SetFilesToExclude {{{
 690 | function! <sid>SetFilesToExclude()
 691 |     let filesToExclude = input("Enter patterns to exclude, seperated by a comma: ", g:EasyGrepFilesToExclude)
 692 |     let g:EasyGrepFilesToExclude = s:Trim(filesToExclude)
 693 | 
 694 |     call s:BuildListOfFilesToGrep()
 695 |     call s:RefreshAllOptions()
 696 | 
 697 |     if !empty(g:EasyGrepFilesToExclude)
 698 |         call s:Echo("Set patterns to exclude to (".g:EasyGrepFilesToExclude.")")
 699 |         if !s:CommandSupportsExclusions()
 700 |             call s:Echo("But note that your command, ".s:GetGrepCommandName().", does not support them. See the docs for supported programs.")
 701 |         endif
 702 |     else
 703 |         call s:Echo("Clearing patterns to exclude")
 704 |     endif
 705 | endfunction
 706 | "}}}
 707 | " EchoGrepCommand {{{
 708 | function! <sid>EchoGrepCommand()
 709 |     if !s:IsCommandVimgrep() && !s:ValidateGrepCommand()
 710 |         return 0
 711 |     endif
 712 | 
 713 |     let placeholder = "<pattern>"
 714 |     let dirAnnotation = "Current Directory:     "
 715 |     let grepCommand = s:GetGrepCommandLine(placeholder, "", 0, "", 1)
 716 |     if g:EasyGrepSearchCurrentBufferDir
 717 |         let dirs = s:GetDirectorySearchList()
 718 |         for d in dirs
 719 |             call s:Echo(dirAnnotation.d)
 720 |             let dirAnnotation = "Additional Directory:  "
 721 |         endfor
 722 |     else
 723 |         call s:Echo(dirAnnotation.getcwd())
 724 |     endif
 725 |     call s:Echo("VIM command:           ".grepCommand)
 726 |     if s:GetGrepCommandName() == "grep"
 727 |         let shellCommand = substitute(grepCommand, "grep", &grepprg, "")
 728 |         call s:Echo("Shell command:         ".shellCommand)
 729 |     endif
 730 | endfunction
 731 | "}}}
 732 | " EchoOptionsSet {{{
 733 | function! <sid>EchoOptionsSet()
 734 | 
 735 |     let optList = [
 736 |             \ "g:EasyGrepFileAssociations",
 737 |             \ "g:EasyGrepMode",
 738 |             \ "g:EasyGrepCommand",
 739 |             \ "g:EasyGrepRecursive",
 740 |             \ "g:EasyGrepSearchCurrentBufferDir",
 741 |             \ "g:EasyGrepIgnoreCase",
 742 |             \ "g:EasyGrepHidden",
 743 |             \ "g:EasyGrepFilesToExclude",
 744 |             \ "g:EasyGrepAllOptionsInExplorer",
 745 |             \ "g:EasyGrepWindow",
 746 |             \ "g:EasyGrepReplaceWindowMode",
 747 |             \ "g:EasyGrepOpenWindowOnMatch",
 748 |             \ "g:EasyGrepEveryMatch",
 749 |             \ "g:EasyGrepJumpToMatch",
 750 |             \ "g:EasyGrepInvertWholeWord",
 751 |             \ "g:EasyGrepFileAssociationsInExplorer",
 752 |             \ "g:EasyGrepExtraWarnings",
 753 |             \ "g:EasyGrepOptionPrefix",
 754 |             \ "g:EasyGrepReplaceAllPerFile"
 755 |             \ ]
 756 | 
 757 |     let str = ""
 758 |     for item in optList
 759 |         let q = type(eval(item))==1 ? "'" : ""
 760 |         let str .= "let ".item."=".q.eval(item).q."\n"
 761 |     endfor
 762 | 
 763 |     call s:Warning("The following options will be saved in the e register; type \"ep to paste into your .vimrc")
 764 |     redir @e
 765 |     echo str
 766 |     redir END
 767 | 
 768 | endfunction
 769 | "}}}
 770 | " SelectOptionExplorerLine {{{
 771 | function! <sid>SelectOptionExplorerLine()
 772 |     let pos = getpos(".")
 773 |     let line = pos[1]
 774 |     let choice = line - s:firstPatternLine
 775 | 
 776 |     call s:ActivateChoice(choice)
 777 | endfunction
 778 | " }}}
 779 | " ActivateAll {{{
 780 | function! <sid>ActivateAll()
 781 |     call s:ActivateChoice(s:EasyGrepModeAll)
 782 | endfunction
 783 | "}}}
 784 | " ActivateBuffers {{{
 785 | function! <sid>ActivateBuffers()
 786 |     call s:ActivateChoice(s:EasyGrepModeBuffers)
 787 | endfunction
 788 | "}}}
 789 | " ActivateTracked {{{
 790 | function! <sid>ActivateTracked()
 791 |     call s:ActivateChoice(s:EasyGrepModeTracked)
 792 | endfunction
 793 | "}}}
 794 | " ActivateUser {{{
 795 | function! <sid>ActivateUser()
 796 |     call s:ActivateChoice(s:EasyGrepModeUser)
 797 | endfunction
 798 | "}}}
 799 | " ActivateChoice {{{
 800 | function! s:ActivateChoice(choice)
 801 |     let choice = a:choice
 802 | 
 803 |     if choice < 0 || choice == s:EasyGrepNumModes
 804 |         return
 805 |     endif
 806 | 
 807 |     if choice < s:EasyGrepNumModes
 808 |         let selectedMode = choice
 809 |     else
 810 |         let selectedMode = s:EasyGrepModeMultipleChoice
 811 |     endif
 812 | 
 813 |     if s:IsCommandAck()
 814 |         if selectedMode != s:EasyGrepModeAll && selectedMode != s:EasyGrepModeBuffers
 815 |             call s:Error("Cannot activate '".s:GetModeName(selectedMode)."' mode when ".s:GetGrepProgramPair().", as this grepprg implements its own filtering")
 816 |             return
 817 |         endif
 818 |     endif
 819 | 
 820 |     " handles the space in between the default modes and file association list
 821 |     let choice -= choice >= s:EasyGrepNumModes ? 1 : 0
 822 | 
 823 |     let choicesThatAreModes = [ s:EasyGrepModeAll, s:EasyGrepModeBuffers, s:EasyGrepModeTracked, s:EasyGrepModeUser ]
 824 | 
 825 |     let wasActivatedBeforeChoice = (s:Dict[choice][2] == 1)
 826 |     let shouldBecomeActivated = (s:Dict[choice][2] == 0)
 827 | 
 828 |     let userStr = ""
 829 |     if choice == s:EasyGrepModeUser
 830 |         let userStr = input("Enter Grep Pattern: ", s:Dict[choice][1])
 831 |         if empty(userStr)
 832 |             let s:Dict[choice][1] = ""
 833 |             if !wasActivatedBeforeChoice
 834 |                 return
 835 |             endif
 836 |         else
 837 |             " If the user's choice matches a pattern from the file association's
 838 |             " list, this gives the user the option of choosing that pattern instead
 839 |             let choice = s:GrepSetManual(userStr)
 840 |             if choice == -1
 841 |                 return
 842 |             elseif choice == s:EasyGrepModeUser
 843 |                 let s:Dict[choice][1] = userStr
 844 |             else "Activate the preset pattern
 845 |                 let shouldBecomeActivated = 1
 846 |                 let selectedMode = s:EasyGrepModeMultipleChoice
 847 |                 let s:Dict[s:EasyGrepModeUser][1] = ""
 848 |                 call s:ClearActivatedItems()
 849 |                 call s:UpdateAllSelections()
 850 |             endif
 851 |         endif
 852 |     endif
 853 | 
 854 |     let additionalmessage = ""
 855 |     let allBecomesActivated = 0
 856 |     if shouldBecomeActivated
 857 |         " Handle any incompatible modes
 858 |         if choice == s:EasyGrepModeBuffers && g:EasyGrepRecursive == 1
 859 |             let additionalmessage = "And setting g:EasyGrepRecursive to 'Off', as only buffers are searched"
 860 |             let g:EasyGrepRecursive = 0
 861 |         elseif s:IsCommandAck() && !g:EasyGrepRecursive
 862 |             let additionalmessage = "And setting g:EasyGrepRecusive to 'On', as ".s:GetGrepProgramPair()." is inherently recursive"
 863 |             let g:EasyGrepRecursive = 1
 864 |         endif
 865 | 
 866 |         if count(choicesThatAreModes, choice) > 0
 867 |             call s:ClearActivatedItems()
 868 |             call s:UpdateAllSelections()
 869 |         else
 870 |             for c in choicesThatAreModes
 871 |                 if s:Dict[c][2] == 1
 872 |                     let s:Dict[c][2] = 0
 873 |                     call s:UpdateSelectionLine(c)
 874 |                 endif
 875 |             endfor
 876 |         endif
 877 | 
 878 |         let s:Dict[choice][2] = 1
 879 |     else
 880 |         if choice == s:EasyGrepModeAll || choice == s:EasyGrepModeBuffers || choice == s:EasyGrepModeTracked || (choice == s:EasyGrepModeUser && !empty(userStr))
 881 |             let shouldBecomeActivated = 1
 882 |         else
 883 |             let s:Dict[choice][2] = 0
 884 |             let shouldBecomeActivated = 0
 885 |             if s:HasActivatedItem() == 0
 886 |                 let allBecomesActivated = 1
 887 |                 let s:Dict[s:EasyGrepModeAll][2] = 1
 888 |                 call s:UpdateSelectionLine(s:EasyGrepModeAll)
 889 |             endif
 890 |         endif
 891 |     endif
 892 | 
 893 |     call s:SetGrepMode(selectedMode)
 894 | 
 895 |     call s:UpdateSelectionLine(choice)
 896 |     call s:BuildListOfFilesToGrep()
 897 |     call s:RefreshAllOptions()
 898 | 
 899 |     let str = ""
 900 |     if choice == s:EasyGrepModeAll
 901 |         let str = "Activated (All)"
 902 |     else
 903 |         let e = shouldBecomeActivated ? "Activated" : "Deactivated"
 904 | 
 905 |         let keyName = s:Dict[choice][0]
 906 |         let str = e." (".keyName.")"
 907 |         if allBecomesActivated
 908 |             let str .= " -> Activated (All)"
 909 |         endif
 910 |     endif
 911 | 
 912 |     call s:Echo(str)
 913 |     if !empty(additionalmessage)
 914 |         call s:Echo(additionalmessage)
 915 |     endif
 916 | endfunction
 917 | "}}}
 918 | " Sort {{{
 919 | function! <sid>Sort()
 920 |     let s:SortChoice += 1
 921 |     if s:SortChoice == len(s:SortOptions)
 922 |         let s:SortChoice = 0
 923 |     endif
 924 | 
 925 |     let beg = s:EasyGrepNumModes
 926 |     let dictCopy = s:Dict[beg :]
 927 |     call sort(dictCopy, s:SortFunctions[s:SortChoice])
 928 |     let s:Dict[beg :] = dictCopy
 929 | 
 930 |     call s:RefreshAllOptions()
 931 |     call s:UpdateAllSelections()
 932 | 
 933 |     call s:Echo("Set sort to (".s:SortOptions[s:SortChoice].")")
 934 | endfunction
 935 | " }}}
 936 | " Sort Functions {{{
 937 | function! SortName(lhs, rhs)
 938 |     return a:lhs[0] == a:rhs[0] ? 0 : a:lhs[0] > a:rhs[0] ? 1 : -1
 939 | endfunction
 940 | 
 941 | function! SortNameReversed(lhs, rhs)
 942 |     let r = SortName(a:lhs, a:rhs)
 943 |     return r == 0 ? 0 : r == -1 ? 1 : -1
 944 | endfunction
 945 | 
 946 | function! SortExtension(lhs, rhs)
 947 |     return a:lhs[1] == a:rhs[1] ? 0 : a:lhs[1] > a:rhs[1] ? 1 : -1
 948 | endfunction
 949 | 
 950 | function! SortExtensionReversed(lhs, rhs)
 951 |     let r = SortExtension(a:lhs, a:rhs)
 952 |     return r == 0 ? 0 : r == -1 ? 1 : -1
 953 | endfunction
 954 | " }}}
 955 | " GetGrepCommandName {{{
 956 | function! s:GetGrepCommandName()
 957 |     return s:Commands[s:CommandChoice]
 958 | endfunction
 959 | " }}}
 960 | " GetGrepCommandNameWithOptions {{{
 961 | function! s:GetGrepCommandNameWithOptions()
 962 |     let name = s:GetGrepCommandName()
 963 |     if name == "grep"
 964 |         let name .= "='".&grepprg."'"
 965 |     endif
 966 |     return name
 967 | endfunction
 968 | " }}}
 969 | " GetGrepProgramName {{{
 970 | function! s:GetGrepProgramName()
 971 |     return substitute(&grepprg, "\\s.*", "", "")
 972 | endfunction
 973 | " }}}
 974 | " GetGrepProgramPair {{{
 975 | function! s:GetGrepProgramPair()
 976 |     return "(grepprg='".&grepprg."')"
 977 | endfunction
 978 | " }}}
 979 | " ToggleCommand {{{
 980 | function! <sid>ToggleCommand()
 981 |     let s:CommandChoice += 1
 982 |     if s:CommandChoice == len(s:Commands)
 983 |         let s:CommandChoice = 0
 984 |     endif
 985 |     let g:EasyGrepCommand = s:CommandChoice
 986 | 
 987 |     call s:BuildListOfFilesToGrep()
 988 |     call s:RefreshAllOptions()
 989 | 
 990 |     call s:Echo("Set command to (".s:GetGrepCommandNameWithOptions().")")
 991 |     if s:IsCommandAck()
 992 |         if s:IsModeTracked()
 993 |             call s:Echo("And setting g:EasyGrepMode to 'All', as ".s:GetGrepProgramPair()." implements its own filtering")
 994 |             call s:ForceGrepMode(s:EasyGrepModeAll)
 995 |         endif
 996 |         if !s:IsModeBuffers() && !g:EasyGrepRecursive
 997 |             call s:Echo("And setting g:EasyGrepRecusive to 'On', as ".s:GetGrepProgramPair()." is inherently recursive")
 998 |             let g:EasyGrepRecursive=1
 999 |         endif
1000 |     endif
1001 | endfunction
1002 | " }}}
1003 | " ToggleRecursion {{{
1004 | function! <sid>ToggleRecursion()
1005 |     if s:IsModeBuffers()
1006 |         call s:Warning("Recursive mode cant' be set when *Buffers* is activated")
1007 |         return
1008 |     endif
1009 | 
1010 |     let g:EasyGrepRecursive = !g:EasyGrepRecursive
1011 | 
1012 |     call s:BuildListOfFilesToGrep()
1013 |     call s:RefreshAllOptions()
1014 | 
1015 |     call s:Echo("Set recursive mode to (".s:OnOrOff(g:EasyGrepRecursive).")")
1016 | endfunction
1017 | " }}}
1018 | " ToggleIgnoreCase {{{
1019 | function! <sid>ToggleIgnoreCase()
1020 |     let g:EasyGrepIgnoreCase = !g:EasyGrepIgnoreCase
1021 |     call s:RefreshAllOptions()
1022 |     call s:Echo("Set ignore case to (".s:OnOrOff(g:EasyGrepIgnoreCase).")")
1023 | endfunction
1024 | " }}}
1025 | " ToggleHidden {{{
1026 | function! <sid>ToggleHidden()
1027 |     let g:EasyGrepHidden = !g:EasyGrepHidden
1028 | 
1029 |     call s:BuildListOfFilesToGrep()
1030 |     call s:RefreshAllOptions()
1031 | 
1032 |     call s:Echo("Set hidden files included to (".s:OnOrOff(g:EasyGrepHidden).")")
1033 | endfunction
1034 | " }}}
1035 | " ToggleBufferDirectories {{{
1036 | function! <sid>ToggleBufferDirectories()
1037 |     let g:EasyGrepSearchCurrentBufferDir = !g:EasyGrepSearchCurrentBufferDir
1038 | 
1039 |     call s:BuildListOfFilesToGrep()
1040 |     call s:RefreshAllOptions()
1041 | 
1042 |     call s:Echo("Set additional directories included to (".s:OnOrOff(g:EasyGrepSearchCurrentBufferDir).")")
1043 | endfunction
1044 | " }}}
1045 | " ToggleWindow {{{
1046 | function! <sid>ToggleWindow()
1047 |     let g:EasyGrepWindow = !g:EasyGrepWindow
1048 |     call s:RefreshAllOptions()
1049 | 
1050 |     call s:Echo("Set window to (".s:GetErrorListName().")")
1051 | endfunction
1052 | "}}}
1053 | " ToggleOpenWindow {{{
1054 | function! <sid>ToggleOpenWindow()
1055 |     let g:EasyGrepOpenWindowOnMatch = !g:EasyGrepOpenWindowOnMatch
1056 |     call s:RefreshAllOptions()
1057 | 
1058 |     call s:Echo("Set open window on match to (".s:OnOrOff(g:EasyGrepOpenWindowOnMatch).")")
1059 | endfunction
1060 | "}}}
1061 | " ToggleEveryMatch {{{
1062 | function! <sid>ToggleEveryMatch()
1063 |     let g:EasyGrepEveryMatch = !g:EasyGrepEveryMatch
1064 |     call s:RefreshAllOptions()
1065 | 
1066 |     call s:Echo("Set separate multiple matches to (".s:OnOrOff(g:EasyGrepEveryMatch).")")
1067 | endfunction
1068 | "}}}
1069 | " ToggleJumpToMatch {{{
1070 | function! <sid>ToggleJumpToMatch()
1071 |     let g:EasyGrepJumpToMatch = !g:EasyGrepJumpToMatch
1072 |     call s:RefreshAllOptions()
1073 | 
1074 |     call s:Echo("Set jump to match to (".s:OnOrOff(g:EasyGrepJumpToMatch).")")
1075 | endfunction
1076 | "}}}
1077 | " ToggleWholeWord {{{
1078 | function! <sid>ToggleWholeWord()
1079 |     let g:EasyGrepInvertWholeWord = !g:EasyGrepInvertWholeWord
1080 |     call s:RefreshAllOptions()
1081 | 
1082 |     call s:Echo("Set invert the meaning of whole word to (".s:OnOrOff(g:EasyGrepInvertWholeWord).")")
1083 | endfunction
1084 | "}}}
1085 | " ToggleReplaceWindowMode {{{
1086 | function! <sid>ToggleReplaceWindowMode()
1087 |     let g:EasyGrepReplaceWindowMode += 1
1088 |     if g:EasyGrepReplaceWindowMode == s:NumReplaceModeOptions
1089 |         let g:EasyGrepReplaceWindowMode = 0
1090 |     endif
1091 | 
1092 |     call s:RefreshAllOptions()
1093 | 
1094 |     call s:Echo("Set replace window mode to (".s:GetReplaceWindowModeString(g:EasyGrepReplaceWindowMode).")")
1095 | endfunction
1096 | " }}}
1097 | " ToggleOptionsDisplay {{{
1098 | function! <sid>ToggleOptionsDisplay()
1099 |     let g:EasyGrepAllOptionsInExplorer = !g:EasyGrepAllOptionsInExplorer
1100 | 
1101 |     if s:OptionsExplorerOpen
1102 |         let oldWindowLines = len(s:Options) + 1
1103 |         call s:FillWindow()
1104 |         let newWindowLines = len(s:Options) + 1
1105 | 
1106 |         let linesDiff = newWindowLines-oldWindowLines
1107 |         if linesDiff > 0
1108 |             let linesDiff = "+".linesDiff
1109 |         endif
1110 | 
1111 |         execute "resize ".linesDiff
1112 |         normal zb
1113 |     endif
1114 | 
1115 |     call s:Echo("Showing ". (g:EasyGrepAllOptionsInExplorer ? "more" : "fewer")." options")
1116 | endfunction
1117 | "}}}
1118 | " ToggleFileAssociationsInExplorer {{{
1119 | function! <sid>ToggleFileAssociationsInExplorer()
1120 |     let g:EasyGrepFileAssociationsInExplorer = !g:EasyGrepFileAssociationsInExplorer
1121 | 
1122 |     call s:FillWindow()
1123 |     call s:RefreshAllOptions()
1124 | 
1125 |     if g:EasyGrepFileAssociationsInExplorer
1126 |         execute "resize +".len(s:Dict)
1127 |     else
1128 |         let newSize = len(s:Options) + s:EasyGrepNumModes + 1
1129 |         execute "resize ".newSize
1130 |     endif
1131 |     normal zb
1132 | 
1133 |     call s:Echo("Set file associations in explorer to (".s:OnOrOff(g:EasyGrepFileAssociationsInExplorer).")")
1134 | endfunction
1135 | "}}}
1136 | " Quit {{{
1137 | function! <sid>Quit()
1138 |     let s:OptionsExplorerOpen = 0
1139 |     echo ""
1140 |     quit
1141 | endfunction
1142 | " }}}
1143 | "}}}
1144 | " ClearActivatedItems {{{
1145 | function! s:ClearActivatedItems()
1146 |     let i = 0
1147 |     let numItems = len(s:Dict)
1148 |     while i < numItems
1149 |         let s:Dict[i][2] = 0
1150 |         let i += 1
1151 |     endwhile
1152 | endfunction
1153 | " }}}
1154 | " HasActivatedItem {{{
1155 | function! s:HasActivatedItem()
1156 |     let i = 0
1157 |     let numItems = len(s:Dict)
1158 |     while i < numItems
1159 |         if s:Dict[i][2] == 1
1160 |             return 1
1161 |         endif
1162 |         let i += 1
1163 |     endwhile
1164 |     return 0
1165 | endfunction
1166 | " }}}
1167 | " RefreshAllOptions {{{
1168 | function! s:RefreshAllOptions()
1169 |     if !s:OptionsExplorerOpen
1170 |         return
1171 |     endif
1172 | 
1173 |     call s:CreateOptionsString()
1174 | 
1175 |     setlocal modifiable
1176 | 
1177 |     let lastLine = len(s:Options)
1178 |     let line = 0
1179 |     while line < lastLine
1180 |         call setline(line+1, s:Options[line])
1181 |         let line += 1
1182 |     endwhile
1183 | 
1184 |     setlocal nomodifiable
1185 | endfunction
1186 | " }}}
1187 | " UpdateAllSelections {{{
1188 | function! s:UpdateAllSelections()
1189 |     if !s:OptionsExplorerOpen
1190 |         return
1191 |     endif
1192 | 
1193 |     if g:EasyGrepFileAssociationsInExplorer
1194 |         let numItems = len(s:Dict)
1195 |     else
1196 |         let numItems = s:EasyGrepNumModes
1197 |     endif
1198 |     call s:UpdateSelectionRange(0, numItems)
1199 | endfunction
1200 | " }}}
1201 | " UpdateSelectionLine {{{
1202 | function! s:UpdateSelectionLine(choice)
1203 |     call s:UpdateSelectionRange(a:choice, a:choice+1)
1204 | endfunction
1205 | " }}}
1206 | " UpdateSelectionRange {{{
1207 | function! s:UpdateSelectionRange(first, last)
1208 |     if !s:OptionsExplorerOpen
1209 |         return
1210 |     endif
1211 | 
1212 |     setlocal modifiable
1213 |     let i = a:first
1214 |     while i < a:last
1215 |         let indicator = s:Dict[i][2] == 1 ? '>' : ' '
1216 |         let str = indicator. s:Dict[i][0] . ': ' . s:Dict[i][1]
1217 |         let lineOffset = i >= s:EasyGrepNumModes ? 1 : 0
1218 |         call setline(s:firstPatternLine+i+lineOffset, str)
1219 |         let i += 1
1220 |     endwhile
1221 | 
1222 |     setlocal nomodifiable
1223 | endfunction
1224 | " }}}
1225 | " FillWindow {{{
1226 | function! s:FillWindow()
1227 | 
1228 |     setlocal modifiable
1229 | 
1230 |     " Clear the entire window
1231 |     execute "silent %delete"
1232 | 
1233 |     call s:CreateOptionsString()
1234 |     call append(0, s:Options)
1235 |     let s:firstPatternLine = len(s:Options) + 1
1236 |     call s:RefreshAllOptions()
1237 | 
1238 |     setlocal modifiable
1239 | 
1240 |     if g:EasyGrepFileAssociationsInExplorer
1241 |         let numItems = len(s:Dict)
1242 |     else
1243 |         let numItems = s:EasyGrepNumModes
1244 |     endif
1245 | 
1246 |     let i = 0
1247 |     while i < numItems
1248 |         call append(s:firstPatternLine, "")
1249 |         let i += 1
1250 |     endwhile
1251 |     call s:UpdateAllSelections()
1252 |     setlocal nomodifiable
1253 | 
1254 |     " place the cursor at the start of the special options
1255 |     execute "".len(s:Options)+1
1256 | endfunction
1257 | " }}}
1258 | " CreateOptionMappings {{{
1259 | function! s:CreateOptionMappings()
1260 |     if empty(g:EasyGrepOptionPrefix)
1261 |         return
1262 |     endif
1263 | 
1264 |     let p = g:EasyGrepOptionPrefix
1265 | 
1266 |     exe "nmap <silent> ".p."a  :call <sid>ActivateAll()<cr>"
1267 |     exe "nmap <silent> ".p."b  :call <sid>ActivateBuffers()<cr>"
1268 |     exe "nmap <silent> ".p."t  :call <sid>ActivateTracked()<cr>"
1269 |     exe "nmap <silent> ".p."u  :call <sid>ActivateUser()<cr>"
1270 | 
1271 |     exe "nmap <silent> ".p."x  :call <sid>SetFilesToExclude()<cr>"
1272 |     exe "nmap <silent> ".p."c  :call <sid>ToggleCommand()<cr>"
1273 |     exe "nmap <silent> ".p."r  :call <sid>ToggleRecursion()<cr>"
1274 |     exe "nmap <silent> ".p."d  :call <sid>ToggleBufferDirectories()<cr>"
1275 |     exe "nmap <silent> ".p."i  :call <sid>ToggleIgnoreCase()<cr>"
1276 |     exe "nmap <silent> ".p."h  :call <sid>ToggleHidden()<cr>"
1277 |     exe "nmap <silent> ".p."w  :call <sid>ToggleWindow()<cr>"
1278 |     exe "nmap <silent> ".p."o  :call <sid>ToggleOpenWindow()<cr>"
1279 |     exe "nmap <silent> ".p."g  :call <sid>ToggleEveryMatch()<cr>"
1280 |     exe "nmap <silent> ".p."p  :call <sid>ToggleJumpToMatch()<cr>"
1281 |     exe "nmap <silent> ".p."!  :call <sid>ToggleWholeWord()<cr>"
1282 |     exe "nmap <silent> ".p."e  :call <sid>EchoFilesSearched()<cr>"
1283 |     exe "nmap <silent> ".p."s  :call <sid>Sort()<cr>"
1284 |     exe "nmap <silent> ".p."m  :call <sid>ToggleReplaceWindowMode()<cr>"
1285 |     exe "nmap <silent> ".p."?  :call <sid>ToggleOptionsDisplay()<cr>"
1286 |     exe "nmap <silent> ".p."v  :call <sid>EchoGrepCommand()<cr>"
1287 |     exe "nmap <silent> ".p."\\|  :call <sid>EchoOptionsSet()<cr>"
1288 |     exe "nmap <silent> ".p."*  :call <sid>ToggleFileAssociationsInExplorer()<cr>"
1289 | endfunction
1290 | "}}}
1291 | " GrepOptions {{{
1292 | function! <sid>GrepOptions()
1293 |     call s:SetGatewayVariables()
1294 |     call s:CreateDict()
1295 |     call s:OpenOptionsExplorer()
1296 |     return s:ClearGatewayVariables()
1297 | endfunction
1298 | " }}}
1299 | " CreateOptionsString {{{
1300 | function! s:CreateOptionsString()
1301 | 
1302 |     let s:Options = []
1303 | 
1304 |     call add(s:Options, "\"q: quit")
1305 |     call add(s:Options, "\"r: recursive mode (".s:OnOrOff(g:EasyGrepRecursive).")")
1306 |     call add(s:Options, "\"d: additional directories included (".s:OnOrOff(g:EasyGrepSearchCurrentBufferDir).")")
1307 |     call add(s:Options, "\"i: ignore case (".s:OnOrOff(g:EasyGrepIgnoreCase).")")
1308 |     call add(s:Options, "\"h: hidden files included (".s:OnOrOff(g:EasyGrepHidden).")")
1309 |     call add(s:Options, "\"e: echo files that would be searched")
1310 |     if g:EasyGrepAllOptionsInExplorer
1311 |         call add(s:Options, "\"x: set files to exclude")
1312 |         call add(s:Options, "\"c: change grep command (".s:GetGrepCommandNameWithOptions().")")
1313 |         call add(s:Options, "\"w: window to use (".s:GetErrorListName().")")
1314 |         call add(s:Options, "\"m: replace window mode (".s:GetReplaceWindowModeString(g:EasyGrepReplaceWindowMode).")")
1315 |         call add(s:Options, "\"o: open window on match (".s:OnOrOff(g:EasyGrepOpenWindowOnMatch).")")
1316 |         call add(s:Options, "\"g: separate multiple matches (".s:OnOrOff(g:EasyGrepEveryMatch).")")
1317 |         call add(s:Options, "\"p: jump to match (".s:OnOrOff(g:EasyGrepJumpToMatch).")")
1318 |         call add(s:Options, "\"!: invert the meaning of whole word (".s:OnOrOff(g:EasyGrepInvertWholeWord).")")
1319 |         call add(s:Options, "\"*: show file associations list (".s:OnOrOff(g:EasyGrepFileAssociationsInExplorer).")")
1320 |         if g:EasyGrepFileAssociationsInExplorer
1321 |             call add(s:Options, "\"s: change file associations list sorting (".s:SortOptions[s:SortChoice].")")
1322 |         endif
1323 |         call add(s:Options, "")
1324 |         call add(s:Options, "\"a: activate 'All' mode")
1325 |         call add(s:Options, "\"b: activate 'Buffers' mode")
1326 |         call add(s:Options, "\"t: activate 'TrackExt' mode")
1327 |         call add(s:Options, "\"u: activate 'User' mode")
1328 |         call add(s:Options, "")
1329 |         call add(s:Options, "\"v: echo the grep command")
1330 |         call add(s:Options, "\"|: echo options that are set")
1331 |     endif
1332 |     call add(s:Options, "\"?: show ". (g:EasyGrepAllOptionsInExplorer ? "fewer" : "more")." options")
1333 |     call add(s:Options, "")
1334 |     call add(s:Options, "\"Current Directory: ".getcwd())
1335 |     call add(s:Options, "\"Grep Targets: ".s:FilesToGrep)
1336 |     call add(s:Options, "\"Exclusions: ".(!empty(g:EasyGrepFilesToExclude) ? g:EasyGrepFilesToExclude : "none").(empty(g:EasyGrepFilesToExclude) || s:CommandSupportsExclusions() ? "" : " (only supported with grepprg of 'ack' or 'grep')"))
1337 |     call add(s:Options, "")
1338 | 
1339 | endfunction
1340 | "}}}
1341 | " MapOptionsKeys {{{
1342 | function! s:MapOptionsKeys()
1343 | 
1344 |     nnoremap <buffer> <silent> <cr> :call <sid>SelectOptionExplorerLine()<cr>
1345 |     nnoremap <buffer> <silent> :    :call <sid>Echo("Type q to quit")<cr>
1346 |     nnoremap <buffer> <silent> l    <Nop>
1347 | 
1348 |     nnoremap <buffer> <silent> q    :call <sid>Quit()<cr>
1349 |     nnoremap <buffer> <silent> r    :call <sid>ToggleRecursion()<cr>
1350 |     nnoremap <buffer> <silent> d    :call <sid>ToggleBufferDirectories()<cr>
1351 |     nnoremap <buffer> <silent> i    :call <sid>ToggleIgnoreCase()<cr>
1352 |     nnoremap <buffer> <silent> h    :call <sid>ToggleHidden()<cr>
1353 |     nnoremap <buffer> <silent> e    :call <sid>EchoFilesSearched()<cr>
1354 | 
1355 |     nnoremap <buffer> <silent> x    :call <sid>SetFilesToExclude()<cr>
1356 |     nnoremap <buffer> <silent> c    :call <sid>ToggleCommand()<cr>
1357 |     nnoremap <buffer> <silent> w    :call <sid>ToggleWindow()<cr>
1358 |     nnoremap <buffer> <silent> m    :call <sid>ToggleReplaceWindowMode()<cr>
1359 |     nnoremap <buffer> <silent> o    :call <sid>ToggleOpenWindow()<cr>
1360 |     nnoremap <buffer> <silent> g    :call <sid>ToggleEveryMatch()<cr>
1361 |     nnoremap <buffer> <silent> p    :call <sid>ToggleJumpToMatch()<cr>
1362 |     nnoremap <buffer> <silent> !    :call <sid>ToggleWholeWord()<cr>
1363 |     nnoremap <buffer> <silent> *    :call <sid>ToggleFileAssociationsInExplorer()<cr>
1364 |     nnoremap <buffer> <silent> s    :call <sid>Sort()<cr>
1365 | 
1366 |     nnoremap <buffer> <silent> a    :call <sid>ActivateAll()<cr>
1367 |     nnoremap <buffer> <silent> b    :call <sid>ActivateBuffers()<cr>
1368 |     nnoremap <buffer> <silent> t    :call <sid>ActivateTracked()<cr>
1369 |     nnoremap <buffer> <silent> u    :call <sid>ActivateUser()<cr>
1370 | 
1371 |     nnoremap <buffer> <silent> v    :call <sid>EchoGrepCommand()<cr>
1372 |     nnoremap <buffer> <silent> \|   :call <sid>EchoOptionsSet()<cr>
1373 |     nnoremap <buffer> <silent> ?    :call <sid>ToggleOptionsDisplay()<cr>
1374 | 
1375 | endfunction
1376 | "}}}
1377 | " GrepSetManual {{{
1378 | function! s:GrepSetManual(str)
1379 |     call s:SetGatewayVariables()
1380 |     let str = a:str
1381 |     if s:IsRecursivePattern(str)
1382 |         call s:Error("User specified grep pattern may not have a recursive specifier")
1383 |         call s:ClearGatewayVariables()
1384 |         return -1
1385 |     endif
1386 |     let pos = s:EasyGrepModeUser
1387 | 
1388 |     call s:CreateDict()
1389 |     let i = s:FindByPattern(str)
1390 |     if i != -1
1391 |         let s2 = s:Dict[i][1]
1392 |         if str == s2
1393 |             let pos = i
1394 |         else
1395 |             let msg = "Pattern '".s:Dict[i][0]."=".s:Dict[i][1]."' matches your input, use this?"
1396 |             let response = confirm(msg, "&Yes\n&No")
1397 |             if response == 1
1398 |                 let pos = i
1399 |             endif
1400 |         endif
1401 |     endif
1402 | 
1403 |     call s:ClearGatewayVariables()
1404 |     return pos
1405 | endfunction
1406 | "}}}
1407 | " }}}
1408 | " EasyGrepFileAssociations {{{
1409 | " CreateDict {{{
1410 | function! s:CreateDict()
1411 |     if exists("s:Dict")
1412 |         return
1413 |     endif
1414 | 
1415 |     let s:Dict = [ ]
1416 |     call add(s:Dict, [ "All" , "*", g:EasyGrepMode==s:EasyGrepModeAll ? 1 : 0 ] )
1417 |     call add(s:Dict, [ "Buffers" , "*Buffers*", g:EasyGrepMode==s:EasyGrepModeBuffers ? 1 : 0  ] )
1418 |     call add(s:Dict, [ "TrackExt" , "*", g:EasyGrepMode==s:EasyGrepModeTracked ? 1 : 0  ] )
1419 |     call add(s:Dict, [ "User" , "", g:EasyGrepMode==s:EasyGrepModeUser ? 1 : 0  ] )
1420 | 
1421 |     if len(s:Dict) != s:EasyGrepNumModes
1422 |         call s:InternalFailure("EasyGrep's default settings are not internally consistent; please reinstall")
1423 |     endif
1424 | 
1425 |     call s:ParseFileAssociationList()
1426 |     let s:NumFileAssociations = len(s:Dict) - s:EasyGrepNumModes
1427 | 
1428 | endfunction
1429 | " }}}
1430 | " BreakDown {{{
1431 | function! s:BreakDown(keyList)
1432 | 
1433 |     " Indicates which keys have already been parsed to avoid multiple entries
1434 |     " and infinite recursion
1435 |     let s:traversed = repeat([0], len(s:Dict))
1436 | 
1437 |     let str = ""
1438 |     for k in a:keyList
1439 |         let str .= s:DoBreakDown(k)." "
1440 |     endfor
1441 |     unlet s:traversed
1442 |     let str = s:Trim(str)
1443 | 
1444 |     return str
1445 | endfunction
1446 | "}}}
1447 | " DoBreakDown {{{
1448 | function! s:DoBreakDown(key)
1449 |     if s:traversed[a:key] == 1
1450 |         return ""
1451 |     endif
1452 |     let s:traversed[a:key] = 1
1453 | 
1454 |     let str = ""
1455 |     let patternList = split(s:Dict[a:key][1])
1456 |     for p in patternList
1457 |         if s:IsLink(p)
1458 |             let k = s:FindByKey(s:GetKeyFromLink(p))
1459 |             if k != -1
1460 |                 let str .= s:DoBreakDown(k)
1461 |             endif
1462 |         else
1463 |             let str .= p
1464 |         endif
1465 |         let str .= ' '
1466 |     endfor
1467 |     return str
1468 | endfunction
1469 | "}}}
1470 | " CheckLinks {{{
1471 | function! s:CheckLinks()
1472 |     let i = s:EasyGrepNumModes
1473 |     let end = len(s:Dict)
1474 |     while i < end
1475 |         let patterns = split(s:Dict[i][1])
1476 |         let j = 0
1477 |         for p in patterns
1478 |             if s:IsLink(p) && s:FindByKey(s:GetKeyFromLink(p)) == -1
1479 |                 call s:Warning("Key(".p.") links to a nonexistent key")
1480 |                 call remove(patterns, j)
1481 |                 let j -= 1
1482 |             endif
1483 |             let j += 1
1484 |         endfor
1485 | 
1486 |         if empty(patterns)
1487 |             call s:Warning("Key(".s:Dict[i][0].") has no valid patterns or links")
1488 |             call remove(s:Dict, i)
1489 |         else
1490 |             let s:Dict[i][1] = join(patterns)
1491 |         endif
1492 |         let i += 1
1493 |     endwhile
1494 | endfunction
1495 | "}}}
1496 | " FindByKey {{{
1497 | function! s:FindByKey(key)
1498 |     let i = 0
1499 |     let numItems = len(s:Dict)
1500 |     while i < numItems
1501 |         if s:Dict[i][0] ==# a:key
1502 |             return i
1503 |         endif
1504 |         let i += 1
1505 |     endwhile
1506 |     return -1
1507 | endfunction
1508 | " }}}
1509 | " IsInDict {{{
1510 | function! s:IsInDict(pat)
1511 |     let i = 0
1512 |     let numItems = len(s:Dict)
1513 |     while i < numItems
1514 |         if s:Dict[i][0] == a:pat
1515 |             return 1
1516 |         endif
1517 |         let i += 1
1518 |     endwhile
1519 |     return 0
1520 | endfunction
1521 | " }}}
1522 | " GetKeyFromLink {{{
1523 | function! s:GetKeyFromLink(str)
1524 |     return strpart(a:str, 1, len(a:str)-2)
1525 | endfunction
1526 | "}}}
1527 | " IsLink {{{
1528 | function! s:IsLink(str)
1529 |     return a:str[0] == '<' && a:str[len(a:str)-1] == '>'
1530 | endfunction
1531 | " }}}
1532 | " ParseFileAssociationList {{{
1533 | function! s:ParseFileAssociationList()
1534 |     let lst = s:GetFileAssociationList()
1535 | 
1536 |     if empty(lst)
1537 |         return
1538 |     endif
1539 | 
1540 |     if !filereadable(lst)
1541 |         call s:Error("Grep Pattern file list can't be read")
1542 |         return
1543 |     endif
1544 | 
1545 |     let fileList = readfile(lst)
1546 |     if empty(fileList)
1547 |         call s:Error("Grep Pattern file list is empty")
1548 |         return
1549 |     endif
1550 | 
1551 |     let lineCounter = 0
1552 |     for line in fileList
1553 |         let lineCounter += 1
1554 |         let line = s:Trim(line)
1555 |         if empty(line) || line[0] == "\""
1556 |             continue
1557 |         endif
1558 | 
1559 |         let keys = split(line, "=")
1560 |         if len(keys) != 2
1561 |             call s:Warning("Invalid line: ".line)
1562 |             continue
1563 |         endif
1564 | 
1565 |         let keys[0] = s:Trim(keys[0])
1566 |         let keys[1] = s:Trim(keys[1])
1567 | 
1568 |         if empty(keys[0]) || empty(keys[1])
1569 |             call s:Warning("Invalid line: ".line)
1570 |             continue
1571 |         endif
1572 | 
1573 |         " No real need to check that keys[0] is well-formed; just about any key
1574 |         " is acceptable
1575 | 
1576 |         if s:IsInDict(keys[0])
1577 |             call s:Warning("Key already added: ".keys[0])
1578 |             continue
1579 |         endif
1580 | 
1581 |         let pList = split(keys[1])
1582 |         for p in pList
1583 | 
1584 |             " check for invalid filesystem characters.
1585 |             if match(p, "[/\\,;']") != -1
1586 |                 call s:Warning("Invalid pattern (".p.") in line(".lineCounter.")")
1587 |                 continue
1588 |             endif
1589 | 
1590 |             if match(p, '[<>]') != -1
1591 |                 if    s:countstr(p, '<') > 1
1592 |                 \  || s:countstr(p, '>') > 1
1593 |                 \  || p[0] != '<'
1594 |                 \  || p[len(p)-1] != '>'
1595 |                     call s:Warning("Invalid link (".p.") in line(".lineCounter.")")
1596 |                     continue
1597 |                 endif
1598 |             endif
1599 |         endfor
1600 | 
1601 |         call add(s:Dict, [ keys[0], keys[1], 0 ] )
1602 |     endfor
1603 |     call s:CheckLinks()
1604 | endfunction
1605 | "}}}
1606 | " }}}
1607 | " Modes {{{
1608 | " IsModeAll {{{
1609 | function! s:IsModeAll()
1610 |     call s:SanitizeMode()
1611 |     return g:EasyGrepMode == s:EasyGrepModeAll
1612 | endfunction
1613 | " }}}
1614 | " IsModeBuffers {{{
1615 | function! s:IsModeBuffers()
1616 |     call s:SanitizeMode()
1617 |     return g:EasyGrepMode == s:EasyGrepModeBuffers
1618 | endfunction
1619 | " }}}
1620 | " IsModeTracked {{{
1621 | function! s:IsModeTracked()
1622 |     call s:SanitizeMode()
1623 |     return g:EasyGrepMode == s:EasyGrepModeTracked
1624 | endfunction
1625 | " }}}
1626 | " IsModeUser {{{
1627 | function! s:IsModeUser()
1628 |     call s:SanitizeMode()
1629 |     return g:EasyGrepMode == s:EasyGrepModeUser
1630 | endfunction
1631 | " }}}
1632 | " IsModeMultipleChoice {{{
1633 | function! s:IsModeMultipleChoice()
1634 |     call s:SanitizeMode()
1635 |     return g:EasyGrepMode == s:EasyGrepModeMultipleChoice
1636 | endfunction
1637 | " }}}
1638 | " GetModeName {{{
1639 | function! s:GetModeName(mode)
1640 |     if a:mode == s:EasyGrepModeAll
1641 |         return "All"
1642 |     elseif a:mode == s:EasyGrepModeBuffers
1643 |         return "Buffers"
1644 |     elseif a:mode == s:EasyGrepModeTracked
1645 |         return "TrackExt"
1646 |     elseif a:mode == s:EasyGrepModeUser
1647 |         return "User"
1648 |     else
1649 |         return "MultiSelect"
1650 |     endif
1651 | endfunction
1652 | " }}}
1653 | " SetGrepMode {{{
1654 | function! s:SetGrepMode(mode)
1655 |     let g:EasyGrepMode = a:mode
1656 | endfunction
1657 | " }}}
1658 | " ForceGrepMode {{{
1659 | function! s:ForceGrepMode(mode)
1660 |     call s:ClearActivatedItems()
1661 |     call s:SetGrepMode(a:mode)
1662 |     let s:Dict[a:mode][2] = 1
1663 | endfunction
1664 | " }}}
1665 | " SanitizeMode {{{
1666 | function! s:SanitizeMode()
1667 |     if s:SanitizeLock
1668 |         return
1669 |     endif
1670 |     let s:SanitizeLock = 1
1671 | 
1672 |     " First check the grep command
1673 |     if !s:CheckGrepCommandForChanges()
1674 |         let s:SanitizeLock = 0
1675 |         return
1676 |     endif
1677 | 
1678 |     " Next ensure that our mode is sensible
1679 |     if g:EasyGrepMode < 0 || g:EasyGrepMode >= s:EasyGrepNumModesWithSpecial
1680 |         call s:Error("Invalid value for g:EasyGrepMode; reverting to 'All' mode.")
1681 |         call s:ForceGrepMode(s:EasyGrepModeAll)
1682 |     elseif g:EasyGrepMode == s:EasyGrepModeMultipleChoice
1683 |         " This is OK
1684 |     elseif s:Dict[g:EasyGrepMode][2] != 1
1685 |         " The user switched the mode by explicitly setting the g:EasyGrepMode
1686 |         " global variable; make sure to sync up with it
1687 |         call s:ForceGrepMode(g:EasyGrepMode)
1688 |     endif
1689 | 
1690 |     let s:SanitizeLock = 0
1691 | endfunction
1692 | " }}}
1693 | " ValidateGrepCommand {{{
1694 | function! s:ValidateGrepCommand()
1695 |     if empty(&grepprg)
1696 |         call s:Error("Cannot proceed; the 'grepprg' setting is empty while EasyGrep is configured to use the grep command")
1697 |         call s:Info("If you are unsure what to do, revert grepprg to it's default with 'set grepprg&'")
1698 |         return 0
1699 |     endif
1700 |     return 1
1701 | endfunction
1702 | " }}}
1703 | " CheckGrepCommandForChanges {{{
1704 | function! s:CheckGrepCommandForChanges()
1705 |     if &grepprg != s:LastSeenGrepprg
1706 |         if s:IsCommandAck()
1707 |             if !s:IsModeAll() && !s:IsModeBuffers()
1708 |                 call s:Info("==================================================================================")
1709 |                 call s:Info("The 'grepprg' has changed to '".s:GetGrepCommandName()."' since last inspected")
1710 |                 call s:Info("Switching to 'All' mode as the '".s:GetModeName(g:EasyGrepMode)."' mode is incompatible with this program")
1711 |                 if !g:EasyGrepRecursive
1712 |                     call s:Info("And setting g:EasyGrepRecusive to 'On', as ".s:GetGrepProgramPair()." is inherently recursive")
1713 |                     let g:EasyGrepRecursive = 1
1714 |                 endif
1715 |                 call s:Info("==================================================================================")
1716 |                 call s:ForceGrepMode(s:EasyGrepModeAll)
1717 |             endif
1718 |         endif
1719 |         let s:LastSeenGrepprg = &grepprg
1720 |         return 0
1721 |     endif
1722 |     return 1
1723 | endfunction
1724 | " }}}
1725 | " Extension Tracking {{{
1726 | " SetCurrentExtension {{{
1727 | function! s:SetCurrentExtension()
1728 |     call s:CreateDict()
1729 |     if !empty(&buftype)
1730 |         return
1731 |     endif
1732 |     let fname = bufname("%")
1733 |     if empty(fname)
1734 |         return
1735 |     endif
1736 |     let ext = fnamemodify(fname, ":e")
1737 |     if !empty(ext)
1738 |         let ext = "*.".ext
1739 |     else
1740 |         let ext = fnamemodify(fname, ":p:t")
1741 |         if(empty(ext))
1742 |             return
1743 |         endif
1744 |     endif
1745 |     if !s:IsModeTracked()
1746 |         " Always save the extension when not in tracked mode
1747 |         let s:TrackedExt = ext
1748 | 
1749 |         " Note: this has a very, very, very, small issue (is it even an
1750 |         " issue?) where if you're working with C++ files, and you switch to
1751 |         " buffers mode, and then edit a file of another type, like .c (which
1752 |         " should be in the C++ list), and then switch back to tracked mode,
1753 |         " you will lose the C++ association and have to go back to a C++
1754 |         " file before being able to search them.
1755 |         " This is so small of an issue that it's almost a non-issue, so I'm
1756 |         " not going to bother fixing it
1757 |     else
1758 |         let tempList = split(s:FilesToGrep)
1759 | 
1760 |         " When in tracked mode, change the tracked extension if it isn't
1761 |         " already in the list of files to be grepped
1762 |         if index(tempList, ext) == -1
1763 |             let s:TrackedExt = ext
1764 |             let s:Dict[s:EasyGrepModeTracked][1] = ext
1765 |         endif
1766 |     endif
1767 | endfunction
1768 | "}}}
1769 | " SetWatchExtension {{{
1770 | function! s:SetWatchExtension()
1771 |     augroup EasyGrepAutocommands
1772 |         au!
1773 |         autocmd BufEnter * call s:SetCurrentExtension()
1774 |     augroup END
1775 | endfunction
1776 | "}}}
1777 | " }}}
1778 | " }}}
1779 | " Selection Functions {{{
1780 | " GrepSelection {{{
1781 | function! <sid>GrepSelection(add, whole)
1782 |     call s:SetGatewayVariables()
1783 |     let currSelection=s:GetCurrentSelection()
1784 |     if empty(currSelection)
1785 |         call s:Warning("No current selection")
1786 |         return s:ClearGatewayVariables()
1787 |     endif
1788 |     call s:DoGrep(currSelection, a:add, a:whole, "", 1)
1789 |     return s:ClearGatewayVariables()
1790 | endfunction
1791 | " }}}
1792 | " GrepCurrentWord {{{
1793 | function! <sid>GrepCurrentWord(add, whole)
1794 |     call s:SetGatewayVariables()
1795 |     let currWord=s:GetCurrentWord()
1796 |     if empty(currWord)
1797 |         call s:Warning("No current word")
1798 |         return s:ClearGatewayVariables()
1799 |     endif
1800 | 
1801 |     call s:CheckIfCurrentFileIsSearched()
1802 |     let r = s:DoGrep(currWord, a:add, a:whole, "", 1)
1803 |     return s:ClearGatewayVariables()
1804 | endfunction
1805 | " }}}
1806 | " ReplaceSelection {{{
1807 | function! <sid>ReplaceSelection(whole)
1808 |     call s:SetGatewayVariables()
1809 |     let currSelection=s:GetCurrentSelection()
1810 |     if empty(currSelection)
1811 |         call s:Warning("No current selection")
1812 |         return s:ClearGatewayVariables()
1813 |     endif
1814 | 
1815 |     call s:ReplaceString(currSelection, a:whole, 1)
1816 |     return s:ClearGatewayVariables()
1817 | endfunction
1818 | "}}}
1819 | " GetCurrentWord {{{
1820 | function! s:GetCurrentWord()
1821 |     return expand("<cword>")
1822 | endfunction
1823 | " }}}
1824 | " GetCurrentSelection {{{
1825 | function! s:GetCurrentSelection()
1826 |     return s:ClearNewline(@")
1827 | endfunction
1828 | " }}}
1829 | " ReplaceCurrentWord {{{
1830 | function! <sid>ReplaceCurrentWord(whole)
1831 |     call s:SetGatewayVariables()
1832 |     let currWord=s:GetCurrentWord()
1833 |     if empty(currWord)
1834 |         call s:Warning("No current word")
1835 |         return s:ClearGatewayVariables()
1836 |     endif
1837 | 
1838 |     call s:ReplaceString(currWord, a:whole, 1)
1839 |     return s:ClearGatewayVariables()
1840 | endfunction
1841 | "}}}
1842 | " }}}
1843 | " Command Line Functions {{{
1844 | " GrepCommandLine {{{
1845 | function! s:GrepCommandLine(argv, add, bang)
1846 |     call s:SetGatewayVariables()
1847 |     let opts = s:ParseCommandLine(a:argv)
1848 |     if !empty(opts["failedparse"])
1849 |         let errorstring="Invalid command: ".opts["failedparse"]
1850 |         echo errorstring
1851 |     else
1852 |         call s:SetCommandLineOptions(opts)
1853 |         call s:DoGrep(opts["pattern"], a:add, a:bang == "!" ? 1 : 0, opts["count"]>0 ? opts["count"] : "", 0)
1854 |         call s:RestoreCommandLineOptions(opts)
1855 |     endif
1856 |     return s:ClearGatewayVariables()
1857 | endfunction
1858 | " }}}
1859 | " ParseCommandLine {{{
1860 | function! s:ParseCommandLine(argv)
1861 |     let opts = {}
1862 |     let opts["recursive"] = 0
1863 |     let opts["case-insensitive"] = g:EasyGrepIgnoreCase
1864 |     let opts["case-sensitive"] = 0
1865 |     let opts["count"] = 0
1866 |     let opts["pattern"] = ""
1867 |     let opts["failedparse"] = ""
1868 |     let parseopts = 1
1869 | 
1870 |     if empty(a:argv)
1871 |         return opts
1872 |     endif
1873 | 
1874 |     let nextiscount = 0
1875 |     let tokens = split(a:argv, ' \zs')
1876 |     let numtokens = len(tokens)
1877 |     let j = 0
1878 |     while j < numtokens
1879 |         let tok = tokens[j]
1880 |         let tok = s:Trim(tok)
1881 |         if tok == "--"
1882 |             let parseopts = 0
1883 |             let j += 1
1884 |             continue
1885 |         endif
1886 |         if tok[0] == '-' && parseopts
1887 |             let tok = s:Trim(tok)
1888 |             if tok =~ '-[0-9]\+'
1889 |                 let opts["count"] = tok[1:]
1890 |             else
1891 |                 let i = 1
1892 |                 let end = len(tok)
1893 |                 while i < end
1894 |                     let c = tok[i]
1895 |                     if c == '-'
1896 |                         " ignore
1897 |                     elseif c ==# 'R' || c==# 'r'
1898 |                         let opts["recursive"] = 1
1899 |                     elseif c ==# 'i'
1900 |                         let opts["case-insensitive"] = 1
1901 |                     elseif c ==# 'I'
1902 |                         let opts["case-sensitive"] = 1
1903 |                     elseif c ==# 'm'
1904 |                         let j += 1
1905 |                         if j < numtokens
1906 |                             let tok = tokens[j]
1907 |                             let opts["count"] = tok
1908 |                         else
1909 |                             let opts["failedparse"] = "Missing argument to -m"
1910 |                         endif
1911 |                     else
1912 |                         let opts["failedparse"] = "Invalid option (".c.")"
1913 |                     endif
1914 |                     let i += 1
1915 |                 endwhile
1916 |             endif
1917 |         else
1918 |             if opts["pattern"] != ""
1919 |                 let opts["pattern"] .= " "
1920 |             endif
1921 |             let opts["pattern"] .= tok
1922 |         endif
1923 |         let j += 1
1924 |     endwhile
1925 | 
1926 |     if !empty(opts["failedparse"])
1927 |         return opts
1928 |     endif
1929 | 
1930 |     if empty(opts["pattern"])
1931 |         let opts["failedparse"] = "missing pattern"
1932 |     endif
1933 | 
1934 |     return opts
1935 | endfunction
1936 | " }}}
1937 | " SetCommandLineOptions {{{
1938 | function! s:SetCommandLineOptions(opts)
1939 |     let opts = a:opts
1940 |     call s:SaveVariable("g:EasyGrepRecursive")
1941 |     let g:EasyGrepRecursive = g:EasyGrepRecursive || opts["recursive"]
1942 | 
1943 |     call s:SaveVariable("g:EasyGrepIgnoreCase")
1944 |     let g:EasyGrepIgnoreCase = (g:EasyGrepIgnoreCase || opts["case-insensitive"]) && !opts["case-sensitive"]
1945 | endfunction
1946 | " }}}
1947 | " RestoreCommandLineOptions {{{
1948 | function! s:RestoreCommandLineOptions(opts)
1949 |     let opts = a:opts
1950 |     call s:RestoreVariable("g:EasyGrepRecursive")
1951 |     call s:RestoreVariable("g:EasyGrepIgnoreCase")
1952 | endfunction
1953 | " }}}
1954 | " Replace {{{
1955 | function! s:Replace(whole, argv)
1956 |     call s:SetGatewayVariables()
1957 | 
1958 |     let l = len(a:argv)
1959 |     let invalid = 0
1960 | 
1961 |     if l == 0
1962 |         let invalid = 1
1963 |     elseif l > 3 && a:argv[0] == '/'
1964 |         let ph = tempname()
1965 |         let ph = substitute(ph, '/', '_', 'g')
1966 |         let temp = substitute(a:argv, '\\/', ph, "g")
1967 |         let l = len(temp)
1968 |         if temp[l-1] != '/'
1969 |             call s:Error("Missing trailing /")
1970 |             let invalid = 1
1971 |         elseif stridx(temp, '/', 1) == l-1
1972 |             call s:Error("Missing middle /")
1973 |             let invalid = 1
1974 |         elseif s:countstr(temp, '/') > 3
1975 |             call s:Error("Too many /'s, escape these if necessary")
1976 |             let invalid = 1
1977 |         else
1978 |             let argv = split(temp, '/')
1979 |             let i = 0
1980 |             while i < len(argv)
1981 |                 let argv[i] = substitute(argv[i], ph, '\\/', 'g')
1982 |                 let i += 1
1983 |             endwhile
1984 |         endif
1985 |     else
1986 |         let argv = split(a:argv)
1987 |         if len(argv) != 2
1988 |             call s:Error("Too many arguments")
1989 |             let invalid = 1
1990 |         endif
1991 |     endif
1992 | 
1993 |     if invalid
1994 |         call s:Echo("usage: Replace /target/replacement/ --or-- Replace target replacement")
1995 |         return
1996 |     endif
1997 | 
1998 |     let target = argv[0]
1999 |     let replacement = argv[1]
2000 | 
2001 |     call s:DoReplace(target, replacement, a:whole, 0)
2002 |     return s:ClearGatewayVariables()
2003 | endfunction
2004 | "}}}
2005 | " ReplaceUndo {{{
2006 | function! s:ReplaceUndo(bang)
2007 |     call s:SetGatewayVariables()
2008 |     if !exists("s:actionList")
2009 |         call s:Error("No saved actions to undo")
2010 |         return s:ClearGatewayVariables()
2011 |     endif
2012 | 
2013 |     " If either of these variables exists, that means the last command was
2014 |     " interrupted; give it another shot
2015 |     if !exists(s:GetSavedName("switchbuf")) && !exists(s:GetSavedName("autowriteall"))
2016 | 
2017 |         call s:SaveVariable("switchbuf")
2018 |         set switchbuf=useopen
2019 |         if g:EasyGrepReplaceWindowMode == 2
2020 |             call s:SaveVariable("autowriteall")
2021 |             set autowriteall
2022 |         else
2023 |             if g:EasyGrepReplaceWindowMode == 0
2024 |                 set switchbuf+=usetab
2025 |             else
2026 |                 set switchbuf+=split
2027 |             endif
2028 |         endif
2029 |     endif
2030 | 
2031 |     call s:SetErrorList(s:LastErrorList)
2032 |     call s:GotoStartErrorList()
2033 | 
2034 |     let bufList = s:GetVisibleBuffers()
2035 | 
2036 |     let i = 0
2037 |     let numItems = len(s:actionList)
2038 |     let lastFile = -1
2039 | 
2040 |     let finished = 0
2041 |     while !finished
2042 |         try
2043 |             while i < numItems
2044 | 
2045 |                 let cc          = s:actionList[i][0]
2046 |                 let off         = s:actionList[i][1]
2047 |                 let target      = s:actionList[i][2]
2048 |                 let replacement = s:actionList[i][3]
2049 | 
2050 |                 if g:EasyGrepReplaceWindowMode == 0
2051 |                     let thisFile = s:LastErrorList[cc].bufnr
2052 |                     if thisFile != lastFile
2053 |                         " only open a new tab when this window isn't already
2054 |                         " open
2055 |                         if index(bufList, thisFile) == -1
2056 |                             if lastFile != -1
2057 |                                 tabnew
2058 |                             endif
2059 |                             if g:EasyGrepWindow == 0
2060 |                                 execute g:EasyGrepWindowPosition." copen"
2061 |                             else
2062 |                                 execute g:EasyGrepWindowPosition." lopen"
2063 |                             endif
2064 |                             setlocal nofoldenable
2065 |                         endif
2066 |                     endif
2067 |                     let lastFile = thisFile
2068 |                 endif
2069 | 
2070 |                 if g:EasyGrepWindow == 0
2071 |                     execute "cc ".(cc+1)
2072 |                 else
2073 |                     execute "ll ".(cc+1)
2074 |                 endif
2075 | 
2076 |                 " TODO: increase the granularity of the undo to be per-atom
2077 |                 " TODO: check that replacement is at off
2078 | 
2079 |                 let thisLine = getline(".")
2080 |                 let linebeg = strpart(thisLine, 0, off)
2081 |                 let lineend = strpart(thisLine, off)
2082 |                 let lineend = substitute(lineend, replacement, target, "")
2083 |                 let newLine = linebeg.lineend
2084 | 
2085 |                 call setline(".", newLine)
2086 | 
2087 |                 let i += 1
2088 |             endwhile
2089 |             let finished = 1
2090 |         catch /^Vim(\a\+):E36:/
2091 |             redraw
2092 |             call s:Warning("Ran out of room for more windows")
2093 |             let finished = confirm("Do you want to save all windows and continue?", "&Yes\n&No")-1
2094 |             if finished == 1
2095 |                 call s:Warning("To continue, save unsaved windows, make some room (try :only) and run ReplaceUndo again")
2096 |                 return
2097 |             else
2098 |                 wall
2099 |                 only
2100 |             endif
2101 |         catch /^Vim:Interrupt$/
2102 |             redraw
2103 |             call s:Warning("Undo interrupted by user; state is not guaranteed")
2104 |             let finished = confirm("Are you sure you want to stop the undo?", "&Yes\n&No")-1
2105 |             let finished = !finished
2106 |         catch
2107 |             redraw
2108 |             echo v:exception
2109 |             call s:Warning("Undo interrupted; state is not guaranteed")
2110 |             let finished = confirm("Do you want to continue undoing?", "&Yes\n&No")-1
2111 |         endtry
2112 |     endwhile
2113 | 
2114 |     call s:RestoreVariable("switchbuf")
2115 |     call s:RestoreVariable("autowriteall")
2116 | 
2117 |     unlet s:actionList
2118 |     unlet s:LastErrorList
2119 |     return s:ClearGatewayVariables()
2120 | endfunction
2121 | "}}}
2122 | " }}}
2123 | " Grep Implementation {{{
2124 | " SetGrepVariables{{{
2125 | function! s:SetGrepVariables(command)
2126 |     if s:IsCommandVimgrep()
2127 |         call s:SaveVariable("ignorecase")
2128 |         let &ignorecase = g:EasyGrepIgnoreCase
2129 |     endif
2130 | endfunction
2131 | "}}}
2132 | " RestoreGrepVariables{{{
2133 | function! s:RestoreGrepVariables()
2134 |     call s:RestoreVariable("ignorecase")
2135 | endfunction
2136 | "}}}
2137 | " CommandSupportsExclusions {{{
2138 | function! s:CommandSupportsExclusions()
2139 |     return s:IsCommandAck() || s:IsCommandGrep()
2140 | endfunction
2141 | "}}}
2142 | " IsCommandVimgrep {{{
2143 | function! s:IsCommandVimgrep()
2144 |     return (s:GetGrepCommandName() == "vimgrep")
2145 | endfunction
2146 | "}}}
2147 | " IsCommandAck {{{
2148 | function! s:IsCommandAck()
2149 |     return !s:IsCommandVimgrep() && (s:GetGrepProgramName() == "ack" || s:GetGrepProgramName() == "ack-grep")
2150 | endfunction
2151 | "}}}
2152 | " IsCommandFindstr {{{
2153 | function! s:IsCommandFindstr()
2154 |     return !s:IsCommandVimgrep() && (s:GetGrepProgramName() == "findstr")
2155 | endfunction
2156 | "}}}
2157 | " IsCommandGrep {{{
2158 | function! s:IsCommandGrep()
2159 |     return !s:IsCommandVimgrep() && (s:GetGrepProgramName() == "grep")
2160 | endfunction
2161 | "}}}
2162 | " GetGrepCommandLine{{{
2163 | function! s:GetGrepCommandLine(word, add, whole, count, escapeArgs)
2164 |     let com = s:GetGrepCommandName()
2165 | 
2166 |     let commandIsVimgrep = s:IsCommandVimgrep()
2167 |     let commandIsGrep = s:IsCommandGrep()
2168 |     let commandIsFindstr = s:IsCommandFindstr()
2169 |     let commandIsAck = s:IsCommandAck()
2170 | 
2171 |     let s1 = ""
2172 |     let s2 = ""
2173 |     if commandIsVimgrep
2174 |         let s1 = "/"
2175 |         let s2 = "/"
2176 | 
2177 |         if g:EasyGrepEveryMatch
2178 |             let s2 .= "g"
2179 |         endif
2180 | 
2181 |         if g:EasyGrepJumpToMatch
2182 |             let s2 .= "j"
2183 |         endif
2184 |     endif
2185 | 
2186 |     let opts = ""
2187 | 
2188 |     if g:EasyGrepInvertWholeWord
2189 |         let whole = !a:whole
2190 |     else
2191 |         let whole = a:whole
2192 |     endif
2193 | 
2194 |     let word = a:escapeArgs ? s:EscapeSpecial(a:word) : a:word
2195 |     if commandIsGrep || commandIsAck
2196 |         let word = "\"".word."\""
2197 |     endif
2198 | 
2199 |     if whole
2200 |         if commandIsVimgrep
2201 |             let word = "\\<".word."\\>"
2202 |         elseif commandIsGrep || commandIsAck
2203 |             let word = "-w ".word
2204 |         elseif commandIsFindstr
2205 |             let word = "\"\\<".word."\\>\""
2206 |         endif
2207 |     endif
2208 | 
2209 |     if g:EasyGrepRecursive
2210 |         if commandIsGrep
2211 |             let opts .= "-R "
2212 |         elseif commandIsFindstr
2213 |             let opts .= "/S "
2214 |         elseif commandIsAck
2215 |             " do nothing
2216 |         endif
2217 |     endif
2218 | 
2219 |     if g:EasyGrepIgnoreCase
2220 |         if commandIsGrep || commandIsAck
2221 |             let opts .= "-i "
2222 |         elseif commandIsFindstr
2223 |             let opts .= "/I "
2224 |         endif
2225 |     else
2226 |         if commandIsFindstr
2227 |             let opts .= "/i "
2228 |         endif
2229 |     endif
2230 | 
2231 |     if commandIsGrep && g:EasyGrepRecursive
2232 |         " TODO: clean this up. This is a temporary hack to prevent buffer
2233 |         " directories from being added to the filesToGrep string
2234 |         call s:SaveVariable("g:EasyGrepSearchCurrentBufferDir")
2235 |         let g:EasyGrepSearchCurrentBufferDir = 0
2236 |     endif
2237 | 
2238 |     let filesToGrep = s:BuildListOfFilesToGrep()
2239 |     let filesToExclude = g:EasyGrepFilesToExclude
2240 | 
2241 |     " Set extra inclusions and exclusions
2242 |     if commandIsGrep
2243 |         " Ignore errors
2244 |         let opts .= "-s"
2245 | 
2246 |         " Specific inclusions are only set in recursive mode
2247 |         if g:EasyGrepRecursive
2248 |             call s:RestoreVariable("g:EasyGrepSearchCurrentBufferDir")
2249 |             " The --include paths will contain the file patterns
2250 |             let opts .= " " . join(map(split(filesToGrep, ' '), '"--include=\"" .v:val."\""'), ' ')
2251 |             if g:EasyGrepSearchCurrentBufferDir
2252 |                 let dirs = s:GetRecursiveMinimalSetList()
2253 |             else
2254 |                 let dirs = [ getcwd() ]
2255 |             endif
2256 |             " the files we specify will be directories
2257 |             let filesToGrep = join(dirs, ' ')
2258 |         endif
2259 | 
2260 |         let opts .= " " . join(map(split(filesToExclude, ','), '"--exclude=\"".v:val."\""." --exclude-dir=\"".v:val."\""'), ' ')
2261 |     elseif commandIsAck
2262 |         " Patch up the command line in a way that ack understands
2263 |         " 1) Replace a leading star with the current directory
2264 |         let filesToGrep = substitute(filesToGrep, "^\*", getcwd(), "")
2265 |         " 2) Replace all trailing stars with a space
2266 |         let filesToGrep = substitute(filesToGrep, '/\*', "", "g")
2267 | 
2268 |         " Add exclusions
2269 |         let opts .= " " . join(map(split(filesToExclude, ','), '"--ignore-dir=\"".v:val."\""'), ' ')
2270 |     endif
2271 | 
2272 |     if commandIsAck || commandIsFindstr
2273 |         let filesToGrep = s:RemovePatternsWithNoFiles(filesToGrep, ' ')
2274 |     endif
2275 | 
2276 |     if commandIsFindstr
2277 |         let filesToGrep=s:ForwardToBackSlash(filesToGrep)
2278 |     endif
2279 | 
2280 |     let win = g:EasyGrepWindow != 0 ? "l" : ""
2281 |     let grepCommand = a:count.win.com.a:add." ".opts." ".s1.word.s2." ".filesToGrep
2282 | 
2283 |     return grepCommand
2284 | endfunction
2285 | "}}}
2286 | " HasTargetsThatMatch {{{
2287 | function! s:HasTargetsThatMatch(word)
2288 |     call s:CheckIfCurrentFileIsSearched()
2289 | 
2290 |     if s:IsModeBuffers() && empty(s:FilesToGrep)
2291 |         call s:Warning("No saved buffers to explore")
2292 |         return 0
2293 |     endif
2294 | 
2295 |     if g:EasyGrepExtraWarnings && !g:EasyGrepRecursive
2296 |         " Don't evaluate if in recursive mode, this will take too long
2297 |         if !s:HasFilesThatMatch()
2298 |             call s:WarnNoMatches(a:word)
2299 |             return 0
2300 |         endif
2301 |     endif
2302 | 
2303 |     return 1
2304 | endfunction
2305 | 
2306 | " }}}
2307 | " DoGrep {{{
2308 | function! s:DoGrep(word, add, whole, count, escapeArgs)
2309 |     call s:CreateDict()
2310 | 
2311 |     if s:OptionsExplorerOpen == 1
2312 |         call s:Error("Error: Can't Grep while options window is open")
2313 |         return 0
2314 |     endif
2315 | 
2316 |     call s:BuildListOfFilesToGrep()
2317 |     if !s:HasTargetsThatMatch(a:word)
2318 |         return 0
2319 |     endif
2320 | 
2321 |     let commandName = s:GetGrepCommandName()
2322 |     if !s:ValidateGrepCommand()
2323 |         return 0
2324 |     endif
2325 | 
2326 |     call s:SetGrepVariables(commandName)
2327 |     let grepCommand = s:GetGrepCommandLine(a:word, a:add, a:whole, a:count, a:escapeArgs)
2328 | 
2329 |     let failed = 0
2330 |     try
2331 |         if g:EasyGrepRecursive
2332 |             call s:Info("Running a recursive search, this may take a while")
2333 |         endif
2334 | 
2335 |         silent execute grepCommand
2336 |     catch
2337 |         if v:exception != 'E480'
2338 |             call s:WarnNoMatches(a:word)
2339 |             try
2340 |                 " go to the last error list on no matches
2341 |                 if g:EasyGrepWindow == 0
2342 |                     silent colder
2343 |                 else
2344 |                     silent lolder
2345 |                 endif
2346 |             catch
2347 |             endtry
2348 |         else
2349 |             call s:Error("FIXME: exception not caught ".v:exception)
2350 |         endif
2351 |         let failed = 1
2352 |     endtry
2353 | 
2354 |     call s:RestoreGrepVariables()
2355 |     if failed
2356 |         return 0
2357 |     endif
2358 | 
2359 |     if s:HasGrepResults()
2360 |         if g:EasyGrepOpenWindowOnMatch
2361 |             if g:EasyGrepWindow == 0
2362 |                 execute g:EasyGrepWindowPosition." copen"
2363 |             else
2364 |                 execute g:EasyGrepWindowPosition." lopen"
2365 |             endif
2366 |             setlocal nofoldenable
2367 |         endif
2368 |     else
2369 |         call s:WarnNoMatches(a:word)
2370 |         return 0
2371 |     endif
2372 | 
2373 |     return 1
2374 | endfunction
2375 | " }}}
2376 | " HasGrepResults{{{
2377 | function! s:HasGrepResults()
2378 |     return !empty(s:GetErrorList())
2379 | endfunction
2380 | "}}}
2381 | " HasFilesThatMatch{{{
2382 | function! s:HasFilesThatMatch()
2383 |     let saveFilesToGrep = s:FilesToGrep
2384 | 
2385 |     call s:BuildListOfFilesToGrep("\n")
2386 |     let patternList = split(s:FilesToGrep, "\n")
2387 |     for p in patternList
2388 |         let p = s:Trim(p)
2389 |         let fileList = split(glob(p), "\n")
2390 |         for f in fileList
2391 |             if filereadable(f)
2392 |                 let s:FilesToGrep = saveFilesToGrep
2393 |                 return 1
2394 |             endif
2395 |         endfor
2396 |     endfor
2397 | 
2398 |     let s:FilesToGrep = saveFilesToGrep
2399 |     return 0
2400 | endfunction
2401 | "}}}
2402 | " RemovePatternsWithNoFiles {{{
2403 | function! s:RemovePatternsWithNoFiles(files, sep)
2404 |     let files = a:files
2405 |     let newList = ""
2406 | 
2407 |     let patternList = split(files, a:sep)
2408 |     for p in patternList
2409 |         let p = s:Trim(p)
2410 |         let globbedList = glob(p)
2411 |         if globbedList != ""
2412 |             let newList = newList.a:sep.p
2413 |         endif
2414 |     endfor
2415 | 
2416 |     return newList
2417 | endfunction
2418 | "}}}
2419 | " WarnNoMatches {{{
2420 | function! s:WarnNoMatches(pattern)
2421 |     if s:IsModeBuffers()
2422 |         let fpat = "*Buffers*"
2423 |     elseif s:IsModeAll()
2424 |         let fpat = "*"
2425 |     else
2426 |         let fpat = s:GetPatternList(" ", 0)
2427 |     endif
2428 | 
2429 |     let r = g:EasyGrepRecursive ? " (+Recursive)" : ""
2430 |     let h = g:EasyGrepHidden    ? " (+Hidden)"    : ""
2431 | 
2432 |     redraw
2433 |     call s:Warning("No matches for '".a:pattern."'")
2434 |     call s:Warning("File Pattern: ".fpat.r.h)
2435 | 
2436 |     let dirs = s:GetDirectorySearchList()
2437 |     let s = "Directories:"
2438 |     for d in dirs
2439 |         call s:Warning(s." ".d)
2440 |         let s = "            "
2441 |     endfor
2442 |     if !empty(g:EasyGrepFilesToExclude) && s:CommandSupportsExclusions()
2443 |         call s:Warning("Exclusions:  ".g:EasyGrepFilesToExclude)
2444 |     endif
2445 | endfunction
2446 | " }}}
2447 | " }}}
2448 | " Replace Implementation {{{
2449 | " ReplaceString {{{
2450 | function! s:ReplaceString(str, whole, escapeArgs)
2451 |     call s:CheckIfCurrentFileIsSearched()
2452 |     let r = input("Replace '".a:str."' with: ", a:str)
2453 |     if empty(r)
2454 |         let confirmed = confirm("Proceed replacing '".a:str."' with an empty pattern, effectively deleting it?", "&Yes\n&No")-1
2455 |         if confirmed
2456 |             return
2457 |         endif
2458 |     endif
2459 |     if r == a:str
2460 |         call s:Echo("No change in pattern")
2461 |         return
2462 |     endif
2463 | 
2464 |     call s:DoReplace(a:str, r, a:whole, a:escapeArgs)
2465 | endfunction
2466 | "}}}
2467 | " DoReplace {{{
2468 | function! s:DoReplace(target, replacement, whole, escapeArgs)
2469 | 
2470 |     if !s:DoGrep(a:target, "", a:whole, "", a:escapeArgs)
2471 |         return
2472 |     endif
2473 | 
2474 |     let target = a:escapeArgs ? s:EscapeSpecial(a:target) : a:target
2475 |     let replacement = a:replacement
2476 | 
2477 |     let s:LastErrorList = deepcopy(s:GetErrorList())
2478 |     let numMatches = len(s:LastErrorList)
2479 | 
2480 |     let s:actionList = []
2481 | 
2482 |     call s:SaveVariable("switchbuf")
2483 |     set switchbuf=useopen
2484 |     if g:EasyGrepReplaceWindowMode == 2
2485 |         call s:SaveVariable("autowriteall")
2486 |         set autowriteall
2487 |     else
2488 |         if g:EasyGrepReplaceWindowMode == 0
2489 |             set switchbuf+=usetab
2490 |         else
2491 |             set switchbuf+=split
2492 |         endif
2493 |     endif
2494 | 
2495 |     let bufList = s:GetVisibleBuffers()
2496 | 
2497 |     call s:GotoStartErrorList()
2498 | 
2499 |     call s:SaveVariable("ignorecase")
2500 |     let &ignorecase = g:EasyGrepIgnoreCase
2501 | 
2502 |     call s:SaveVariable("cursorline")
2503 |     set cursorline
2504 |     call s:SaveVariable("hlsearch")
2505 |     set hlsearch
2506 | 
2507 |     if g:EasyGrepIgnoreCase
2508 |         let case = '\c'
2509 |     else
2510 |         let case = '\C'
2511 |     endif
2512 | 
2513 |     if g:EasyGrepInvertWholeWord
2514 |         let whole = !a:whole
2515 |     else
2516 |         let whole = a:whole
2517 |     endif
2518 | 
2519 |     if whole
2520 |         let target = "\\<".target."\\>"
2521 |     endif
2522 | 
2523 |     let finished = 0
2524 |     let lastFile = -1
2525 |     let doAll = 0
2526 |     let i = 0
2527 |     while i < numMatches && !finished
2528 |         try
2529 |             let pendingQuit = 0
2530 |             let doit = 1
2531 | 
2532 |             let thisFile = s:LastErrorList[i].bufnr
2533 |             if thisFile != lastFile
2534 |                 call s:RestoreVariable("cursorline", "no")
2535 |                 call s:RestoreVariable("hlsearch", "no")
2536 |                 if g:EasyGrepReplaceWindowMode == 0
2537 |                     " only open a new tab when the window doesn't already exist
2538 |                     if index(bufList, thisFile) == -1
2539 |                         if lastFile != -1
2540 |                             tabnew
2541 |                         endif
2542 |                         if g:EasyGrepWindow == 0
2543 |                             execute g:EasyGrepWindowPosition." copen"
2544 |                         else
2545 |                             execute g:EasyGrepWindowPosition." lopen"
2546 |                         endif
2547 |                         setlocal nofoldenable
2548 |                     endif
2549 |                 endif
2550 |                 if doAll && g:EasyGrepReplaceAllPerFile
2551 |                     let doAll = 0
2552 |                 endif
2553 |             endif
2554 | 
2555 |             if g:EasyGrepWindow == 0
2556 |                 execute "cc ".(i+1)
2557 |             else
2558 |                 execute "ll ".(i+1)
2559 |             endif
2560 | 
2561 |             if thisFile != lastFile
2562 |                 set cursorline
2563 |                 set hlsearch
2564 |             endif
2565 |             let lastFile = thisFile
2566 | 
2567 |             if foldclosed(".") != -1
2568 |                 foldopen!
2569 |             endif
2570 | 
2571 |             let thisLine = getline(".")
2572 |             let off = match(thisLine,case.target, 0)
2573 |             while off != -1
2574 | 
2575 |                 " this highlights the match; it seems to be a simpler solution
2576 |                 " than matchadd()
2577 |                 let linebeg = strpart(thisLine, 0, off)
2578 |                 let m = matchstr(thisLine,case.target, off)
2579 |                 let lineafterm = strpart(thisLine, off+strlen(m))
2580 | 
2581 |                 let linebeg = s:EscapeSpecial(linebeg)
2582 |                 let m = s:EscapeSpecial(m)
2583 |                 let lineafterm = s:EscapeSpecial(lineafterm)
2584 | 
2585 |                 silent exe "s/".linebeg."\\zs".case.m."\\ze".lineafterm."//ne"
2586 | 
2587 |                 if !doAll
2588 | 
2589 |                     redraw!
2590 |                     echohl Type | echo "replace with ".a:replacement." (y/n/a/q/l/^E/^Y)?"| echohl None
2591 |                     let ret = getchar()
2592 | 
2593 |                     if ret == 5
2594 |                         if winline() > &scrolloff+1
2595 |                             normal 
2596 |                         endif
2597 |                         continue
2598 |                     elseif ret == 25
2599 |                         if (winheight(0)-winline()) > &scrolloff
2600 |                             normal 
2601 |                         endif
2602 |                         continue
2603 |                     elseif ret == 27
2604 |                         let doit = 0
2605 |                         let pendingQuit = 1
2606 |                     else
2607 |                         let ret = nr2char(ret)
2608 | 
2609 |                         if ret == '<cr>'
2610 |                             continue
2611 |                         elseif ret == 'y'
2612 |                             let doit = 1
2613 |                         elseif ret == 'n'
2614 |                             let doit = 0
2615 |                         elseif ret == 'a'
2616 |                             let doit = 1
2617 |                             let doAll = 1
2618 |                         elseif ret == 'q'
2619 |                             let doit = 0
2620 |                             let pendingQuit = 1
2621 |                         elseif ret == 'l'
2622 |                             let doit = 1
2623 |                             let pendingQuit = 1
2624 |                         else
2625 |                             continue
2626 |                         endif
2627 |                     endif
2628 |                 endif
2629 | 
2630 |                 if doit
2631 |                     let linebeg = strpart(thisLine, 0, off)
2632 |                     let lineend = strpart(thisLine, off)
2633 |                     let newend = substitute(lineend, target, replacement, "")
2634 |                     let newLine = linebeg.newend
2635 |                     call setline(".", newLine)
2636 | 
2637 |                     let replacedText = matchstr(lineend, target)
2638 |                     let remainder = substitute(lineend, target, "", "")
2639 |                     let replacedWith = strpart(newend, 0, strridx(newend, remainder))
2640 | 
2641 |                     let action = [i, off, replacedText, replacedWith]
2642 |                     call add(s:actionList, action)
2643 |                 endif
2644 | 
2645 |                 if pendingQuit
2646 |                     break
2647 |                 endif
2648 | 
2649 |                 let thisLine = getline(".")
2650 |                 let m = matchstr(thisLine,target, off)
2651 |                 let off = match(thisLine,target,off+strlen(m))
2652 | 
2653 |                 " matching at the end of line should exit here to avoid infinite loops
2654 |                 if off == len(thisLine)
2655 |                     let off = -1
2656 |                 endif
2657 |             endwhile
2658 | 
2659 |             if pendingQuit
2660 |                 break
2661 |             endif
2662 | 
2663 |         catch /^Vim(\a\+):E36:/
2664 |             redraw
2665 |             call s:Warning("Ran out of room for more windows")
2666 |             let finished = confirm("Do you want to save all windows and continue?", "&Yes\n&No")-1
2667 |             if finished == 1
2668 |                 call s:Warning("To continue, save unsaved windows, make some room (try :only) and run Replace again")
2669 |             else
2670 |                 wall
2671 |                 only
2672 |             endif
2673 |         catch /^Vim:Interrupt$/
2674 |             redraw
2675 |             call s:Warning("Replace interrupted by user")
2676 |             let finished = confirm("Are you sure you want to stop the replace?", "&Yes\n&No")-1
2677 |             let finished = !finished
2678 |         catch
2679 |             redraw
2680 |             echo "Exception encountered: ".v:exception
2681 |             call s:Warning("Replace interrupted")
2682 |             let finished = confirm("Do you want to continue replace?", "&Yes\n&No")-1
2683 |         endtry
2684 | 
2685 |         let i += 1
2686 | 
2687 |     endwhile
2688 | 
2689 |     call s:RestoreVariable("switchbuf")
2690 |     call s:RestoreVariable("autowriteall")
2691 |     call s:RestoreVariable("cursorline")
2692 |     call s:RestoreVariable("hlsearch")
2693 |     call s:RestoreVariable("ignorecase")
2694 | endfunction
2695 | "}}}
2696 | " }}}
2697 | " ResultList Functions {{{
2698 | " GetErrorList {{{
2699 | function! s:GetErrorList()
2700 |     if g:EasyGrepWindow == 0
2701 |         return getqflist()
2702 |     else
2703 |         return getloclist(0)
2704 |     endif
2705 | endfunction
2706 | "}}}
2707 | " GetErrorListName {{{
2708 | function! s:GetErrorListName()
2709 |     if g:EasyGrepWindow == 0
2710 |         return 'quickfix'
2711 |     else
2712 |         return 'location list'
2713 |     endif
2714 | endfunction
2715 | "}}}
2716 | " SetErrorList {{{
2717 | function! s:SetErrorList(lst)
2718 |     if g:EasyGrepWindow == 0
2719 |         call setqflist(a:lst)
2720 |     else
2721 |         call setloclist(0,a:lst)
2722 |     endif
2723 | endfunction
2724 | "}}}
2725 | " GotoStartErrorList {{{
2726 | function! s:GotoStartErrorList()
2727 |     if g:EasyGrepWindow == 0
2728 |         cfirst
2729 |     else
2730 |         lfirst
2731 |     endif
2732 | endfunction
2733 | "}}}
2734 | " ResultListFilter {{{
2735 | function! s:ResultListFilter(...)
2736 |     let mode = 'g'
2737 | 
2738 |     let filterlist = []
2739 |     for s in a:000
2740 |         if s[0] == '-'
2741 |             if s == '-v'
2742 |                 let mode = 'v'
2743 |             elseif s == '-g'
2744 |                 if mode == 'v'
2745 |                     call s:Error("Multiple -v / -g arguments given")
2746 |                     return
2747 |                 endif
2748 |                 let mode = 'g'
2749 |             else
2750 |                 call s:Error("Invalid command line switch")
2751 |                 return
2752 |             endif
2753 |         else
2754 |             call add(filterlist, s)
2755 |         endif
2756 |     endfor
2757 | 
2758 |     if empty(filterlist)
2759 |         call s:Error("Missing pattern to filter")
2760 |         return
2761 |     endif
2762 | 
2763 |     let lst = s:GetErrorList()
2764 |     if empty(lst)
2765 |         call s:Error("Error list is empty")
2766 |         return
2767 |     endif
2768 | 
2769 |     let newlst = []
2770 |     for d in lst
2771 |         let matched = 0
2772 |         for f in filterlist
2773 |             let r = match(d.text, f)
2774 |             if mode == 'g'
2775 |                 let matched = (r != -1)
2776 |             else
2777 |                 let matched = (r == -1)
2778 |             endif
2779 |             if matched == 1
2780 |                 call add(newlst, d)
2781 |                 break
2782 |             endif
2783 |         endfor
2784 |     endfor
2785 | 
2786 |     call s:SetErrorList(newlst)
2787 | endfunction
2788 | "}}}
2789 | " ResultListOpen {{{
2790 | function! s:ResultListOpen(...)
2791 |     let lst = s:GetErrorList()
2792 | 
2793 |     if empty(lst)
2794 |         call s:Error("Error list is empty")
2795 |         return
2796 |     endif
2797 | 
2798 |     let lastbnum = -1
2799 |     for item in lst
2800 |         if item.bufnr != lastbnum
2801 |             exe "tabnew ".bufname(item.bufnr)
2802 |             let lastbnum = item.bufnr
2803 |         endif
2804 |     endfor
2805 | endfunction
2806 | "}}}
2807 | " ResultListDo {{{
2808 | function! s:ResultListDo(command)
2809 |     let lst = s:GetErrorList()
2810 |     if empty(lst)
2811 |         call s:Error("Error list is empty")
2812 |         return
2813 |     endif
2814 | 
2815 |     let numMatches = len(lst)
2816 | 
2817 |     call s:SaveVariable("switchbuf")
2818 |     set switchbuf=useopen
2819 |     if g:EasyGrepReplaceWindowMode == 2
2820 |         call s:SaveVariable("autowriteall")
2821 |         set autowriteall
2822 |     else
2823 |         if g:EasyGrepReplaceWindowMode == 0
2824 |             set switchbuf+=usetab
2825 |         else
2826 |             set switchbuf+=split
2827 |         endif
2828 |     endif
2829 | 
2830 |     let bufList = s:GetVisibleBuffers()
2831 | 
2832 |     call s:GotoStartErrorList()
2833 | 
2834 |     call s:SaveVariable("cursorline")
2835 |     set cursorline
2836 | 
2837 |     let finished = 0
2838 |     let lastFile = -1
2839 |     let doAll = 0
2840 |     let i = 0
2841 |     while i < numMatches && !finished
2842 |         try
2843 |             let pendingQuit = 0
2844 |             let doit = 1
2845 | 
2846 |             let thisFile = lst[i].bufnr
2847 |             if thisFile != lastFile
2848 |                 call s:RestoreVariable("cursorline", "no")
2849 |                 if g:EasyGrepReplaceWindowMode == 0
2850 |                     " only open a new tab when the window doesn't already exist
2851 |                     if index(bufList, thisFile) == -1
2852 |                         if lastFile != -1
2853 |                             tabnew
2854 |                         endif
2855 |                         if g:EasyGrepWindow == 0
2856 |                             execute g:EasyGrepWindowPosition." copen"
2857 |                         else
2858 |                             execute g:EasyGrepWindowPosition." lopen"
2859 |                         endif
2860 |                         setlocal nofoldenable
2861 |                     endif
2862 |                 endif
2863 |                 if doAll && g:EasyGrepReplaceAllPerFile
2864 |                     let doAll = 0
2865 |                 endif
2866 |             endif
2867 | 
2868 |             if g:EasyGrepWindow == 0
2869 |                 execute "cc ".(i+1)
2870 |             else
2871 |                 execute "ll ".(i+1)
2872 |             endif
2873 | 
2874 |             if thisFile != lastFile
2875 |                 set cursorline
2876 |             endif
2877 |             let lastFile = thisFile
2878 | 
2879 |             if foldclosed(".") != -1
2880 |                 foldopen!
2881 |             endif
2882 | 
2883 |             if !doAll
2884 | 
2885 |                 redraw!
2886 |                 echohl Type | echo "run ".a:command." (y/n/a/q/l/^E/^Y)?"| echohl None
2887 |                 let ret = getchar()
2888 | 
2889 |                 if ret == 5
2890 |                     if winline() > &scrolloff+1
2891 |                         normal 
2892 |                     endif
2893 |                     continue
2894 |                 elseif ret == 25
2895 |                     if (winheight(0)-winline()) > &scrolloff
2896 |                         normal 
2897 |                     endif
2898 |                     continue
2899 |                 elseif ret == 27
2900 |                     let doit = 0
2901 |                     let pendingQuit = 1
2902 |                 else
2903 |                     let ret = nr2char(ret)
2904 | 
2905 |                     if ret == '<cr>'
2906 |                         continue
2907 |                     elseif ret == 'y'
2908 |                         let doit = 1
2909 |                     elseif ret == 'n'
2910 |                         let doit = 0
2911 |                     elseif ret == 'a'
2912 |                         let doit = 1
2913 |                         let doAll = 1
2914 |                     elseif ret == 'q'
2915 |                         let doit = 0
2916 |                         let pendingQuit = 1
2917 |                     elseif ret == 'l'
2918 |                         let doit = 1
2919 |                         let pendingQuit = 1
2920 |                     else
2921 |                         continue
2922 |                     endif
2923 |                 endif
2924 |             endif
2925 | 
2926 |             if doit
2927 |                 exe .a:command
2928 |             endif
2929 | 
2930 |             if pendingQuit
2931 |                 break
2932 |             endif
2933 | 
2934 |         catch /^Vim(\a\+):E36:/
2935 |             redraw
2936 |             call s:Warning("Ran out of room for more windows")
2937 |             let finished = confirm("Do you want to save all windows and continue?", "&Yes\n&No")-1
2938 |             if finished == 1
2939 |                 call s:Warning("To continue, save unsaved windows, make some room (try :only) and run Replace again")
2940 |             else
2941 |                 wall
2942 |                 only
2943 |             endif
2944 |         catch /^Vim:Interrupt$/
2945 |             redraw
2946 |             call s:Warning("ResultListDo interrupted by user")
2947 |             let finished = confirm("Are you sure you want to stop the ResultListDo?", "&Yes\n&No")-1
2948 |             let finished = !finished
2949 |         catch
2950 |             redraw
2951 |             echo "Exception encountered: ".v:exception
2952 |             call s:Warning("ResultListDo interrupted")
2953 |             let finished = confirm("Do you want to continue ResultListDo?", "&Yes\n&No")-1
2954 |         endtry
2955 | 
2956 |         let i += 1
2957 | 
2958 |     endwhile
2959 | 
2960 |     call s:RestoreVariable("switchbuf")
2961 |     call s:RestoreVariable("autowriteall")
2962 |     call s:RestoreVariable("cursorline")
2963 | 
2964 | endfunction
2965 | "}}}
2966 | " }}}
2967 | " }}}
2968 | 
2969 | " Commands {{{
2970 | command! -bang -nargs=+ Grep :call s:GrepCommandLine( <q-args> , "", "<bang>")
2971 | command! -bang -nargs=+ GrepAdd :call s:GrepCommandLine( <q-args>, "add", "<bang>")
2972 | command! GrepOptions :call <sid>GrepOptions()
2973 | 
2974 | command! -bang -nargs=+ Replace :call s:Replace("<bang>", <q-args>)
2975 | command! -bang ReplaceUndo :call s:ReplaceUndo("<bang>")
2976 | 
2977 | command! -nargs=0 ResultListOpen :call s:ResultListOpen()
2978 | command! -nargs=+ ResultListFilter :call s:ResultListFilter(<f-args>)
2979 | command! -nargs=+ ResultListDo :call s:ResultListDo(<q-args>)
2980 | "}}}
2981 | " Keymaps {{{
2982 | if !hasmapto("<plug>EgMapGrepOptions")
2983 |     map <silent> <Leader>vo <plug>EgMapGrepOptions
2984 | endif
2985 | if !hasmapto("<plug>EgMapGrepCurrentWord_v")
2986 |     map <silent> <Leader>vv <plug>EgMapGrepCurrentWord_v
2987 | endif
2988 | if !hasmapto("<plug>EgMapGrepSelection_v")
2989 |     vmap <silent> <Leader>vv <plug>EgMapGrepSelection_v
2990 | endif
2991 | if !hasmapto("<plug>EgMapGrepCurrentWord_V")
2992 |     map <silent> <Leader>vV <plug>EgMapGrepCurrentWord_V
2993 | endif
2994 | if !hasmapto("<plug>EgMapGrepSelection_V")
2995 |     vmap <silent> <Leader>vV <plug>EgMapGrepSelection_V
2996 | endif
2997 | if !hasmapto("<plug>EgMapGrepCurrentWord_a")
2998 |     map <silent> <Leader>va <plug>EgMapGrepCurrentWord_a
2999 | endif
3000 | if !hasmapto("<plug>EgMapGrepSelection_a")
3001 |     vmap <silent> <Leader>va <plug>EgMapGrepSelection_a
3002 | endif
3003 | if !hasmapto("<plug>EgMapGrepCurrentWord_A")
3004 |     map <silent> <Leader>vA <plug>EgMapGrepCurrentWord_A
3005 | endif
3006 | if !hasmapto("<plug>EgMapGrepSelection_A")
3007 |     vmap <silent> <Leader>vA <plug>EgMapGrepSelection_A
3008 | endif
3009 | if !hasmapto("<plug>EgMapReplaceCurrentWord_r")
3010 |     map <silent> <Leader>vr <plug>EgMapReplaceCurrentWord_r
3011 | endif
3012 | if !hasmapto("<plug>EgMapReplaceSelection_r")
3013 |     vmap <silent> <Leader>vr <plug>EgMapReplaceSelection_r
3014 | endif
3015 | if !hasmapto("<plug>EgMapReplaceCurrentWord_R")
3016 |     map <silent> <Leader>vR <plug>EgMapReplaceCurrentWord_R
3017 | endif
3018 | if !hasmapto("<plug>EgMapReplaceSelection_R")
3019 |     vmap <silent> <Leader>vR <plug>EgMapReplaceSelection_R
3020 | endif
3021 | 
3022 | if !exists("g:EasyGrepMappingsSet")
3023 |     nmap <silent> <unique> <script> <plug>EgMapGrepOptions          :call <sid>GrepOptions()<CR>
3024 |     nmap <silent> <unique> <script> <plug>EgMapGrepCurrentWord_v    :call <sid>GrepCurrentWord("", 0)<CR>
3025 |     vmap <silent> <unique> <script> <plug>EgMapGrepSelection_v     y:call <sid>GrepSelection("", 0)<CR>
3026 |     nmap <silent> <unique> <script> <plug>EgMapGrepCurrentWord_V    :call <sid>GrepCurrentWord("", 1)<CR>
3027 |     vmap <silent> <unique> <script> <plug>EgMapGrepSelection_V     y:call <sid>GrepSelection("", 1)<CR>
3028 |     nmap <silent> <unique> <script> <plug>EgMapGrepCurrentWord_a    :call <sid>GrepCurrentWord("add", 0)<CR>
3029 |     vmap <silent> <unique> <script> <plug>EgMapGrepSelection_a     y:call <sid>GrepSelection("add", 0)<CR>
3030 |     nmap <silent> <unique> <script> <plug>EgMapGrepCurrentWord_A    :call <sid>GrepCurrentWord("add", 1)<CR>
3031 |     vmap <silent> <unique> <script> <plug>EgMapGrepSelection_A     y:call <sid>GrepSelection("add", 1)<CR>
3032 |     nmap <silent> <unique> <script> <plug>EgMapReplaceCurrentWord_r :call <sid>ReplaceCurrentWord(0)<CR>
3033 |     vmap <silent> <unique> <script> <plug>EgMapReplaceSelection_r  y:call <sid>ReplaceSelection(0)<CR>
3034 |     nmap <silent> <unique> <script> <plug>EgMapReplaceCurrentWord_R :call <sid>ReplaceCurrentWord(1)<CR>
3035 |     vmap <silent> <unique> <script> <plug>EgMapReplaceSelection_R  y:call <sid>ReplaceSelection(1)<CR>
3036 | 
3037 |     let g:EasyGrepMappingsSet = 1
3038 | endif
3039 | 
3040 | "}}}
3041 | " User Options {{{
3042 | function! s:InitializeMode()
3043 |     if !exists("g:EasyGrepMode")
3044 |         let g:EasyGrepMode=s:EasyGrepModeAll
3045 |         " 0 - All
3046 |         " 1 - Buffers
3047 |         " 2 - Track
3048 |         " 3 - User
3049 |     else
3050 |         if g:EasyGrepMode < 0 || g:EasyGrepMode >= s:EasyGrepNumModes
3051 |             call s:Error("Invalid value for g:EasyGrepMode; reverting to 'All' mode.")
3052 |             let g:EasyGrepMode = s:EasyGrepModeAll
3053 |         endif
3054 |     endif
3055 | endfunction
3056 | 
3057 | if !exists("g:EasyGrepCommand")
3058 |     let g:EasyGrepCommand=0
3059 | endif
3060 | 
3061 | if !exists("g:EasyGrepRecursive")
3062 |     let g:EasyGrepRecursive=0
3063 | endif
3064 | 
3065 | if !exists("g:EasyGrepIgnoreCase")
3066 |     let g:EasyGrepIgnoreCase=&ignorecase
3067 | endif
3068 | 
3069 | if !exists("g:EasyGrepHidden")
3070 |     let g:EasyGrepHidden=0
3071 | endif
3072 | 
3073 | if !exists("g:EasyGrepAllOptionsInExplorer")
3074 |     let g:EasyGrepAllOptionsInExplorer=0
3075 | endif
3076 | 
3077 | if !exists("g:EasyGrepWindow")
3078 |     let g:EasyGrepWindow=0
3079 | endif
3080 | 
3081 | if !exists("g:EasyGrepOpenWindowOnMatch")
3082 |     let g:EasyGrepOpenWindowOnMatch=1
3083 | endif
3084 | 
3085 | if !exists("g:EasyGrepEveryMatch")
3086 |     let g:EasyGrepEveryMatch=0
3087 | endif
3088 | 
3089 | if !exists("g:EasyGrepJumpToMatch")
3090 |     let g:EasyGrepJumpToMatch=1
3091 | endif
3092 | 
3093 | if !exists("g:EasyGrepSearchCurrentBufferDir")
3094 |     let g:EasyGrepSearchCurrentBufferDir=1
3095 | endif
3096 | 
3097 | if !exists("g:EasyGrepInvertWholeWord")
3098 |     let g:EasyGrepInvertWholeWord=0
3099 | endif
3100 | 
3101 | " EasyGrepFileAssociations {{{
3102 | function! s:GetFileAssociationList()
3103 |     if exists("g:EasyGrepFileAssociations")
3104 |         return g:EasyGrepFileAssociations
3105 |     endif
3106 | 
3107 |     let VimfilesDirs=split(&runtimepath, ',')
3108 |     for v in VimfilesDirs
3109 |         let f = s:BackToForwardSlash(v)."/plugin/EasyGrepFileAssociations"
3110 |         if filereadable(f)
3111 |             let g:EasyGrepFileAssociations=f
3112 |             return f
3113 |         endif
3114 |     endfor
3115 | 
3116 |     call s:Error("Grep Pattern file list can't be read")
3117 |     let g:EasyGrepFileAssociations=""
3118 |     return ""
3119 | endfunction
3120 | " }}}
3121 | 
3122 | if !exists("g:EasyGrepFileAssociationsInExplorer")
3123 |     let g:EasyGrepFileAssociationsInExplorer=0
3124 | endif
3125 | 
3126 | if !exists("g:EasyGrepOptionPrefix")
3127 |     let g:EasyGrepOptionPrefix='<leader>vy'
3128 |     " Note: I picked a default option prefix of vy because I find it easy to type.
3129 | endif
3130 | 
3131 | if !exists("g:EasyGrepReplaceWindowMode")
3132 |     let g:EasyGrepReplaceWindowMode=0
3133 | else
3134 |     if g:EasyGrepReplaceWindowMode >= s:NumReplaceModeOptions
3135 |         call s:Error("Invalid value for g:EasyGrepReplaceWindowMode")
3136 |         let g:EasyGrepReplaceWindowMode = 0
3137 |     endif
3138 | endif
3139 | 
3140 | if !exists("g:EasyGrepReplaceAllPerFile")
3141 |     let g:EasyGrepReplaceAllPerFile=0
3142 | endif
3143 | 
3144 | if !exists("g:EasyGrepExtraWarnings")
3145 |     let g:EasyGrepExtraWarnings=1
3146 | endif
3147 | 
3148 | if !exists("g:EasyGrepWindowPosition")
3149 |     let g:EasyGrepWindowPosition=""
3150 | else
3151 |     let w = g:EasyGrepWindowPosition
3152 |     if w != ""
3153 | \   && w != "vertical"
3154 | \   && w != "leftabove"
3155 | \   && w != "aboveleft"
3156 | \   && w != "rightbelow"
3157 | \   && w != "belowright"
3158 | \   && w != "topleft"
3159 | \   && w != "botright"
3160 |        call s:Error("Invalid position specified in g:EasyGrepWindowPosition")
3161 |        let g:EasyGrepWindowPosition=""
3162 |    endif
3163 | endif
3164 | 
3165 | if !exists("g:EasyGrepFilesToExclude")
3166 |     let g:EasyGrepFilesToExclude=""
3167 | endif
3168 | 
3169 | " EasyGrepDefaultUserPattern {{{
3170 | function! s:CheckDefaultUserPattern()
3171 |     call s:CreateDict()
3172 |     let error = ""
3173 |     let userModeAndEmpty = (g:EasyGrepMode == s:EasyGrepModeUser) && empty(s:Dict[s:EasyGrepModeUser][1])
3174 |     if exists("g:EasyGrepDefaultUserPattern")
3175 |         if empty(g:EasyGrepDefaultUserPattern) && userModeAndEmpty
3176 |             let error = "Cannot start in 'User' mode when g:EasyGrepDefaultUserPattern is empty"
3177 |             call s:ForceGrepMode(s:EasyGrepModeAll)
3178 |         elseif s:IsRecursivePattern(g:EasyGrepDefaultUserPattern)
3179 |             let error = "User specified grep pattern may not have a recursive specifier"
3180 |         else
3181 |             let s:Dict[s:EasyGrepModeUser][1] = g:EasyGrepDefaultUserPattern
3182 |         endif
3183 |     elseif userModeAndEmpty
3184 |         let error = "Cannot start in 'User' mode when g:EasyGrepDefaultUserPattern is undefined"
3185 |         call s:ForceGrepMode(s:EasyGrepModeAll)
3186 |     endif
3187 | 
3188 |     if !empty(error)
3189 |         let error = error."; switching to 'All' mode"
3190 |         call s:Error(error)
3191 |         call s:ForceGrepMode(s:EasyGrepModeAll)
3192 |     endif
3193 | endfunction
3194 | "}}}
3195 | 
3196 | "}}}
3197 | " Script Finalization {{{
3198 | call s:InitializeCommandChoice()
3199 | call s:InitializeMode()
3200 | call s:CreateOptionMappings()
3201 | call s:SetWatchExtension()
3202 | call s:CheckDefaultUserPattern()
3203 | "}}}
3204 | 
3205 | 


--------------------------------------------------------------------------------