Mercurial > vim
annotate runtime/doc/if_cscop.txt @ 33566:e1e3805fcd96 v9.0.2028
patch 9.0.2028: confusing build dependencies
Commit: https://github.com/vim/vim/commit/5d03525cdef5db1b1cedfa26c6f8a21aaa207ec0
Author: Yee Cheng Chin <ychin.git@gmail.com>
Date: Sun Oct 15 09:50:53 2023 +0200
patch 9.0.2028: confusing build dependencies
Problem: confusing build dependencies
Solution: clean them up, make them parallelizable
Separate vim binary and unittest dependencies, make them parallelizable
Clean up make dependencies so Vim and unit test binaries only depend on
the object files they need. This fixes an existing issue where after
running unit tests, the Vim binary would be invalidated, which results
in it having to be linked again when running script tests, even though
Vim was already previously built.
Make link.sh (script we use to link those binaries) generate namespaced
temporary files for each app to avoid them colliding with each other.
This allows `unittesttargets` to be built in parallel.
These fixes are useful when using link-time-optimization as the link
phase could now take minutes rather than a few seconds.
closes: #13344
Signed-off-by: Christian Brabandt <cb@256bit.org>
Co-authored-by: Yee Cheng Chin <ychin.git@gmail.com>
| author | Christian Brabandt <cb@256bit.org> |
|---|---|
| date | Sun, 15 Oct 2023 10:00:03 +0200 |
| parents | f8116058ca76 |
| children | 4635e43f2c6f |
| rev | line source |
|---|---|
| 29314 | 1 *if_cscop.txt* For Vim version 9.0. Last change: 2022 Jan 08 |
| 7 | 2 |
| 3 | |
| 4 VIM REFERENCE MANUAL by Andy Kahn | |
| 5 | |
| 6 *cscope* *Cscope* | |
| 7 This document explains how to use Vim's cscope interface. | |
| 8 | |
| 9 Cscope is a tool like ctags, but think of it as ctags on steroids since it | |
| 10 does a lot more than what ctags provides. In Vim, jumping to a result from | |
| 11 a cscope query is just like jumping to any tag; it is saved on the tag stack | |
| 12 so that with the right keyboard mappings, you can jump back and forth between | |
| 13 functions as you normally would with |tags|. | |
| 14 | |
| 15 1. Cscope introduction |cscope-intro| | |
| 16 2. Cscope related commands |cscope-commands| | |
| 17 3. Cscope options |cscope-options| | |
| 18 4. How to use cscope in Vim |cscope-howtouse| | |
| 19 5. Limitations |cscope-limitations| | |
| 20 6. Suggested usage |cscope-suggestions| | |
| 21 7. Availability & Information |cscope-info| | |
| 22 | |
| 23 This is currently for Unix and Win32 only. | |
| 24 | |
| 25 ============================================================================== | |
| 26 1. Cscope introduction *cscope-intro* | |
| 27 | |
| 28 The following text is taken from a version of the cscope man page: | |
| 29 | |
| 30 ----- | |
| 31 | |
| 32 Cscope is an interactive screen-oriented tool that helps you: | |
| 33 | |
| 34 Learn how a C program works without endless flipping through a thick | |
| 35 listing. | |
| 36 | |
| 37 Locate the section of code to change to fix a bug without having to | |
| 38 learn the entire program. | |
| 39 | |
| 40 Examine the effect of a proposed change such as adding a value to an | |
| 41 enum variable. | |
| 42 | |
| 43 Verify that a change has been made in all source files such as adding | |
| 44 an argument to an existing function. | |
| 45 | |
| 46 Rename a global variable in all source files. | |
| 47 | |
| 48 Change a constant to a preprocessor symbol in selected lines of files. | |
| 49 | |
| 50 It is designed to answer questions like: | |
| 51 Where is this symbol used? | |
| 52 Where is it defined? | |
| 53 Where did this variable get its value? | |
| 54 What is this global symbol's definition? | |
| 55 Where is this function in the source files? | |
| 56 What functions call this function? | |
| 57 What functions are called by this function? | |
| 58 Where does the message "out of space" come from? | |
| 59 Where is this source file in the directory structure? | |
| 60 What files include this header file? | |
| 61 | |
| 62 Cscope answers these questions from a symbol database that it builds the | |
| 63 first time it is used on the source files. On a subsequent call, cscope | |
| 64 rebuilds the database only if a source file has changed or the list of | |
| 65 source files is different. When the database is rebuilt the data for the | |
| 66 unchanged files is copied from the old database, which makes rebuilding | |
| 67 much faster than the initial build. | |
| 68 | |
| 69 ----- | |
| 70 | |
| 71 When cscope is normally invoked, you will get a full-screen selection | |
| 72 screen allowing you to make a query for one of the above questions. | |
| 73 However, once a match is found to your query and you have entered your | |
| 74 text editor to edit the source file containing match, you cannot simply | |
| 75 jump from tag to tag as you normally would with vi's Ctrl-] or :tag | |
| 76 command. | |
| 77 | |
| 78 Vim's cscope interface is done by invoking cscope with its line-oriented | |
| 79 interface, and then parsing the output returned from a query. The end | |
| 80 result is that cscope query results become just like regular tags, so | |
| 81 you can jump to them just like you do with normal tags (Ctrl-] or :tag) | |
| 82 and then go back by popping off the tagstack with Ctrl-T. (Please note | |
| 83 however, that you don't actually jump to a cscope tag simply by doing | |
| 84 Ctrl-] or :tag without remapping these commands or setting an option. | |
| 85 See the remaining sections on how the cscope interface works and for | |
| 86 suggested use.) | |
| 87 | |
| 88 | |
| 89 ============================================================================== | |
| 90 2. Cscope related commands *cscope-commands* | |
| 91 | |
| 27036 | 92 *:cscope* *:cs* *:scs* *:scscope* *E259* *E262* *E560* *E561* |
|
11659
49c12c93abf3
Updated runtime files and translations.
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
93 All cscope commands are accessed through suboptions to the cscope commands. |
|
49c12c93abf3
Updated runtime files and translations.
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
94 `:cscope` or `:cs` is the main command |
|
49c12c93abf3
Updated runtime files and translations.
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
95 `:scscope` or `:scs` does the same and splits the window |
|
49c12c93abf3
Updated runtime files and translations.
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
96 `:lcscope` or `:lcs` uses the location list, see |:lcscope| |
| 7 | 97 |
| 98 The available subcommands are: | |
| 99 | |
|
8951
0bdeaf7092bc
commit https://github.com/vim/vim/commit/aa3b15dbebf333282503d6031e2f9ba6ee4398ed
Christian Brabandt <cb@256bit.org>
parents:
5294
diff
changeset
|
100 *E563* *E564* *E566* *E568* *E622* *E623* *E625* |
|
0bdeaf7092bc
commit https://github.com/vim/vim/commit/aa3b15dbebf333282503d6031e2f9ba6ee4398ed
Christian Brabandt <cb@256bit.org>
parents:
5294
diff
changeset
|
101 *E626* *E609* |
| 7 | 102 add : Add a new cscope database/connection. |
| 103 | |
| 104 USAGE :cs add {file|dir} [pre-path] [flags] | |
| 105 | |
| 106 [pre-path] is the pathname used with the -P command to cscope. | |
| 107 | |
| 108 [flags] are any additional flags you want to pass to cscope. | |
| 109 | |
| 110 EXAMPLES > | |
| 111 :cscope add /usr/local/cdb/cscope.out | |
| 112 :cscope add /projects/vim/cscope.out /usr/local/vim | |
| 113 :cscope add cscope.out /usr/local/vim -C | |
| 114 < | |
| 2596 | 115 *cscope-find* *cs-find* *E567* |
| 7 | 116 find : Query cscope. All cscope query options are available |
| 117 except option #5 ("Change this grep pattern"). | |
| 118 | |
| 119 USAGE :cs find {querytype} {name} | |
| 120 | |
| 121 {querytype} corresponds to the actual cscope line | |
| 122 interface numbers as well as default nvi commands: | |
| 123 | |
| 124 0 or s: Find this C symbol | |
| 125 1 or g: Find this definition | |
| 126 2 or d: Find functions called by this function | |
| 127 3 or c: Find functions calling this function | |
| 128 4 or t: Find this text string | |
| 129 6 or e: Find this egrep pattern | |
| 130 7 or f: Find this file | |
| 131 8 or i: Find files #including this file | |
|
9344
33c1b85d408c
commit https://github.com/vim/vim/commit/802a0d902fca423acb15f835d7b09183883d79a0
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
132 9 or a: Find places where this symbol is assigned a value |
| 7 | 133 |
| 1847 | 134 For all types, except 4 and 6, leading white space for {name} is |
| 135 removed. For 4 and 6 there is exactly one space between {querytype} | |
| 136 and {name}. Further white space is included in {name}. | |
| 137 | |
| 7 | 138 EXAMPLES > |
| 139 :cscope find c vim_free | |
| 1847 | 140 :cscope find 3 vim_free |
| 7 | 141 < |
| 1847 | 142 These two examples perform the same query: functions calling |
| 143 "vim_free". > | |
| 144 | |
| 145 :cscope find t initOnce | |
| 146 :cscope find t initOnce | |
| 147 < | |
| 148 The first one searches for the text "initOnce", the second one for | |
| 149 " initOnce". > | |
| 7 | 150 |
| 151 :cscope find 0 DEFAULT_TERM | |
| 152 < | |
| 153 Executing this example on the source code for Vim 5.1 produces the | |
| 154 following output: | |
| 155 | |
| 156 Cscope tag: DEFAULT_TERM | |
| 157 # line filename / context / line | |
| 158 1 1009 vim-5.1-gtk/src/term.c <<GLOBAL>> | |
| 159 #define DEFAULT_TERM (char_u *)"amiga" | |
| 160 2 1013 vim-5.1-gtk/src/term.c <<GLOBAL>> | |
| 161 #define DEFAULT_TERM (char_u *)"win32" | |
| 162 3 1017 vim-5.1-gtk/src/term.c <<GLOBAL>> | |
| 163 #define DEFAULT_TERM (char_u *)"pcterm" | |
| 164 4 1021 vim-5.1-gtk/src/term.c <<GLOBAL>> | |
| 165 #define DEFAULT_TERM (char_u *)"ansi" | |
| 166 5 1025 vim-5.1-gtk/src/term.c <<GLOBAL>> | |
| 167 #define DEFAULT_TERM (char_u *)"vt52" | |
| 168 6 1029 vim-5.1-gtk/src/term.c <<GLOBAL>> | |
| 169 #define DEFAULT_TERM (char_u *)"os2ansi" | |
| 170 7 1033 vim-5.1-gtk/src/term.c <<GLOBAL>> | |
| 171 #define DEFAULT_TERM (char_u *)"ansi" | |
| 172 8 1037 vim-5.1-gtk/src/term.c <<GLOBAL>> | |
| 173 # undef DEFAULT_TERM | |
| 174 9 1038 vim-5.1-gtk/src/term.c <<GLOBAL>> | |
| 175 #define DEFAULT_TERM (char_u *)"beos-ansi" | |
| 176 10 1042 vim-5.1-gtk/src/term.c <<GLOBAL>> | |
| 177 #define DEFAULT_TERM (char_u *)"mac-ansi" | |
| 178 11 1335 vim-5.1-gtk/src/term.c <<set_termname>> | |
| 179 term = DEFAULT_TERM; | |
| 180 12 1459 vim-5.1-gtk/src/term.c <<set_termname>> | |
| 181 if (STRCMP(term, DEFAULT_TERM)) | |
| 182 13 1826 vim-5.1-gtk/src/term.c <<termcapinit>> | |
| 183 term = DEFAULT_TERM; | |
| 184 14 1833 vim-5.1-gtk/src/term.c <<termcapinit>> | |
| 185 term = DEFAULT_TERM; | |
| 186 15 3635 vim-5.1-gtk/src/term.c <<update_tcap>> | |
| 187 p = find_builtin_term(DEFAULT_TERM); | |
| 188 Enter nr of choice (<CR> to abort): | |
| 189 | |
| 190 The output shows several pieces of information: | |
| 191 1. The tag number (there are 15 in this example). | |
| 192 2. The line number where the tag occurs. | |
| 193 3. The filename where the tag occurs. | |
| 194 4. The context of the tag (e.g., global, or the function name). | |
| 195 5. The line from the file itself. | |
| 196 | |
| 197 help : Show a brief synopsis. | |
| 198 | |
| 199 USAGE :cs help | |
| 200 | |
| 2596 | 201 *E261* |
| 7 | 202 kill : Kill a cscope connection (or kill all cscope connections). |
| 203 | |
| 204 USAGE :cs kill {num|partial_name} | |
| 205 | |
| 206 To kill a cscope connection, the connection number or a partial | |
| 207 name must be specified. The partial name is simply any part of | |
| 208 the pathname of the cscope database. Kill a cscope connection | |
| 209 using the partial name with caution! | |
| 210 | |
| 211 If the specified connection number is -1, then _ALL_ cscope | |
| 212 connections will be killed. | |
| 213 | |
| 214 reset : Reinit all cscope connections. | |
| 215 | |
| 216 USAGE :cs reset | |
| 217 | |
| 218 show : Show cscope connections. | |
| 219 | |
| 220 USAGE :cs show | |
| 221 | |
| 665 | 222 *:lcscope* *:lcs* |
| 223 This command is same as the ":cscope" command, except when the | |
| 224 'cscopequickfix' option is set, the location list for the current window is | |
| 225 used instead of the quickfix list to show the cscope results. | |
| 226 | |
| 7 | 227 *:cstag* *E257* *E562* |
| 228 If you use cscope as well as ctags, |:cstag| allows you to search one or | |
| 229 the other before making a jump. For example, you can choose to first | |
| 230 search your cscope database(s) for a match, and if one is not found, then | |
| 231 your tags file(s) will be searched. The order in which this happens | |
| 232 is determined by the value of |csto|. See |cscope-options| for more | |
| 233 details. | |
| 234 | |
| 235 |:cstag| performs the equivalent of ":cs find g" on the identifier when | |
| 236 searching through the cscope database(s). | |
| 237 | |
| 238 |:cstag| performs the equivalent of |:tjump| on the identifier when searching | |
| 239 through your tags file(s). | |
| 240 | |
| 241 | |
| 242 ============================================================================== | |
| 243 3. Cscope options *cscope-options* | |
| 244 | |
| 245 Use the |:set| command to set all cscope options. Ideally, you would do | |
| 246 this in one of your startup files (e.g., .vimrc). Some cscope related | |
| 247 variables are only valid within |.vimrc|. Setting them after vim has | |
| 248 started will have no effect! | |
| 249 | |
| 250 *cscopeprg* *csprg* | |
| 251 'cscopeprg' specifies the command to execute cscope. The default is | |
| 252 "cscope". For example: > | |
| 253 :set csprg=/usr/local/bin/cscope | |
| 254 < | |
| 255 *cscopequickfix* *csqf* *E469* | |
| 256 {not available when compiled without the |+quickfix| feature} | |
| 257 'cscopequickfix' specifies whether to use quickfix window to show cscope | |
| 236 | 258 results. This is a list of comma-separated values. Each item consists of |
|
9344
33c1b85d408c
commit https://github.com/vim/vim/commit/802a0d902fca423acb15f835d7b09183883d79a0
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
259 |cscope-find| command (s, g, d, c, t, e, f, i or a) and flag (+, - or 0). |
| 7 | 260 '+' indicates that results must be appended to quickfix window, |
| 261 '-' implies previous results clearance, '0' or command absence - don't use | |
| 236 | 262 quickfix. Search is performed from start until first command occurrence. |
| 263 The default value is "" (don't use quickfix anyway). The following value | |
| 33 | 264 seems to be useful: > |
|
9344
33c1b85d408c
commit https://github.com/vim/vim/commit/802a0d902fca423acb15f835d7b09183883d79a0
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
265 :set cscopequickfix=s-,c-,d-,i-,t-,e-,a- |
| 33 | 266 < |
| 7 | 267 *cscopetag* *cst* |
| 2908 | 268 If 'cscopetag' is set, the commands ":tag" and CTRL-] as well as "vim -t" |
| 269 will always use |:cstag| instead of the default :tag behavior. Effectively, | |
| 270 by setting 'cst', you will always search your cscope databases as well as | |
| 271 your tag files. The default is off. Examples: > | |
| 7 | 272 :set cst |
| 273 :set nocst | |
| 274 < | |
| 2873 | 275 *cscoperelative* *csre* |
| 2908 | 276 If 'cscoperelative' is set, then in absence of a prefix given to cscope |
| 277 (prefix is the argument of -P option of cscope), basename of cscope.out | |
| 278 location (usually the project root directory) will be used as the prefix | |
| 279 to construct an absolute path. The default is off. Note: This option is | |
| 280 only effective when cscope (cscopeprg) is initialized without a prefix | |
| 281 path (-P). Examples: > | |
| 2873 | 282 :set csre |
| 283 :set nocsre | |
| 284 < | |
| 7 | 285 *cscopetagorder* *csto* |
| 286 The value of 'csto' determines the order in which |:cstag| performs a search. | |
| 287 If 'csto' is set to zero, cscope database(s) are searched first, followed | |
| 288 by tag file(s) if cscope did not return any matches. If 'csto' is set to | |
| 289 one, tag file(s) are searched before cscope database(s). The default is zero. | |
| 290 Examples: > | |
| 291 :set csto=0 | |
| 292 :set csto=1 | |
| 293 < | |
| 294 *cscopeverbose* *csverb* | |
| 295 If 'cscopeverbose' is not set (the default), messages will not be printed | |
| 296 indicating success or failure when adding a cscope database. Ideally, you | |
| 297 should reset this option in your |.vimrc| before adding any cscope databases, | |
| 298 and after adding them, set it. From then on, when you add more databases | |
| 299 within Vim, you will get a (hopefully) useful message should the database fail | |
| 300 to be added. Examples: > | |
| 301 :set csverb | |
| 302 :set nocsverb | |
| 303 < | |
| 304 *cscopepathcomp* *cspc* | |
| 305 The value of 'cspc' determines how many components of a file's path to | |
| 306 display. With the default value of zero the entire path will be displayed. | |
| 307 The value one will display only the filename with no path. Other values | |
| 308 display that many components. For example: > | |
| 309 :set cspc=3 | |
| 310 will display the last 3 components of the file's path, including the file | |
| 311 name itself. | |
| 312 | |
| 313 ============================================================================== | |
| 314 4. How to use cscope in Vim *cscope-howtouse* | |
| 315 | |
| 316 The first thing you need to do is to build a cscope database for your | |
| 317 source files. For the most basic case, simply do "cscope -b". Please | |
| 318 refer to the cscope man page for more details. | |
| 319 | |
| 320 Assuming you have a cscope database, you need to "add" the database to Vim. | |
| 321 This establishes a cscope "connection" and makes it available for Vim to use. | |
| 322 You can do this in your .vimrc file, or you can do it manually after starting | |
| 323 vim. For example, to add the cscope database "cscope.out", you would do: | |
| 324 | |
| 325 :cs add cscope.out | |
| 326 | |
| 327 You can double-check the result of this by executing ":cs show". This will | |
| 328 produce output which looks like this: | |
| 329 | |
| 330 # pid database name prepend path | |
| 331 0 28806 cscope.out <none> | |
| 332 | |
| 333 Note: | |
| 334 Because of the Microsoft RTL limitations, Win32 version shows 0 instead | |
| 335 of the real pid. | |
| 336 | |
| 337 Once a cscope connection is established, you can make queries to cscope and | |
| 338 the results will be printed to you. Queries are made using the command | |
| 339 ":cs find". For example: | |
| 340 | |
| 341 :cs find g ALIGN_SIZE | |
| 342 | |
| 343 This can get a little cumbersome since one ends up doing a significant | |
| 344 amount of typing. Fortunately, there are ways around this by mapping | |
| 345 shortcut keys. See |cscope-suggestions| for suggested usage. | |
| 346 | |
| 347 If the results return only one match, you will automatically be taken to it. | |
| 348 If there is more than one match, you will be given a selection screen to pick | |
| 349 the match you want to go to. After you have jumped to the new location, | |
| 350 simply hit Ctrl-T to get back to the previous one. | |
| 351 | |
| 352 | |
| 353 ============================================================================== | |
| 354 5. Limitations *cscope-limitations* | |
| 355 | |
| 356 Cscope support for Vim is only available on systems that support these four | |
| 357 system calls: fork(), pipe(), execl(), waitpid(). This means it is mostly | |
| 358 limited to Unix systems. | |
| 359 | |
| 360 Additionally Cscope support works for Win32. For more information and a | |
| 361 cscope version for Win32 see: | |
| 362 | |
| 363 http://iamphet.nm.ru/cscope/index.html | |
| 364 | |
| 20 | 365 The DJGPP-built version from http://cscope.sourceforge.net is known to not |
| 366 work with Vim. | |
| 367 | |
| 1931 | 368 Hard-coded limitation: doing a |:tjump| when |:cstag| searches the tag files |
| 369 is not configurable (e.g., you can't do a tselect instead). | |
| 7 | 370 |
| 371 ============================================================================== | |
| 372 6. Suggested usage *cscope-suggestions* | |
| 373 | |
| 374 Put these entries in your .vimrc (adjust the pathname accordingly to your | |
| 375 setup): > | |
| 376 | |
| 377 if has("cscope") | |
| 378 set csprg=/usr/local/bin/cscope | |
| 379 set csto=0 | |
| 380 set cst | |
| 381 set nocsverb | |
| 382 " add any database in current directory | |
| 383 if filereadable("cscope.out") | |
| 384 cs add cscope.out | |
| 385 " else add database pointed to by environment | |
| 386 elseif $CSCOPE_DB != "" | |
| 387 cs add $CSCOPE_DB | |
| 388 endif | |
| 389 set csverb | |
| 390 endif | |
| 391 | |
| 392 By setting 'cscopetag', we have effectively replaced all instances of the :tag | |
| 393 command with :cstag. This includes :tag, Ctrl-], and "vim -t". In doing | |
| 394 this, the regular tag command not only searches your ctags generated tag | |
| 395 files, but your cscope databases as well. | |
| 396 | |
| 397 Some users may want to keep the regular tag behavior and have a different | |
| 398 shortcut to access :cstag. For example, one could map Ctrl-_ (underscore) | |
| 399 to :cstag with the following command: > | |
| 400 | |
| 401 map <C-_> :cstag <C-R>=expand("<cword>")<CR><CR> | |
| 402 | |
| 403 A couple of very commonly used cscope queries (using ":cs find") is to | |
| 404 find all functions calling a certain function and to find all occurrences | |
| 405 of a particular C symbol. To do this, you can use these mappings as an | |
| 406 example: > | |
| 407 | |
| 408 map g<C-]> :cs find 3 <C-R>=expand("<cword>")<CR><CR> | |
| 409 map g<C-\> :cs find 0 <C-R>=expand("<cword>")<CR><CR> | |
| 410 | |
| 411 These mappings for Ctrl-] (right bracket) and Ctrl-\ (backslash) allow you to | |
| 412 place your cursor over the function name or C symbol and quickly query cscope | |
| 413 for any matches. | |
| 414 | |
| 415 Or you may use the following scheme, inspired by Vim/Cscope tutorial from | |
| 416 Cscope Home Page (http://cscope.sourceforge.net/): > | |
| 417 | |
| 418 nmap <C-_>s :cs find s <C-R>=expand("<cword>")<CR><CR> | |
| 419 nmap <C-_>g :cs find g <C-R>=expand("<cword>")<CR><CR> | |
| 420 nmap <C-_>c :cs find c <C-R>=expand("<cword>")<CR><CR> | |
| 421 nmap <C-_>t :cs find t <C-R>=expand("<cword>")<CR><CR> | |
| 422 nmap <C-_>e :cs find e <C-R>=expand("<cword>")<CR><CR> | |
| 423 nmap <C-_>f :cs find f <C-R>=expand("<cfile>")<CR><CR> | |
| 424 nmap <C-_>i :cs find i ^<C-R>=expand("<cfile>")<CR>$<CR> | |
| 425 nmap <C-_>d :cs find d <C-R>=expand("<cword>")<CR><CR> | |
|
9344
33c1b85d408c
commit https://github.com/vim/vim/commit/802a0d902fca423acb15f835d7b09183883d79a0
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
426 nmap <C-_>a :cs find a <C-R>=expand("<cword>")<CR><CR> |
| 7 | 427 |
| 428 " Using 'CTRL-spacebar' then a search type makes the vim window | |
| 429 " split horizontally, with search result displayed in | |
| 430 " the new window. | |
| 431 | |
| 432 nmap <C-Space>s :scs find s <C-R>=expand("<cword>")<CR><CR> | |
| 433 nmap <C-Space>g :scs find g <C-R>=expand("<cword>")<CR><CR> | |
| 434 nmap <C-Space>c :scs find c <C-R>=expand("<cword>")<CR><CR> | |
| 435 nmap <C-Space>t :scs find t <C-R>=expand("<cword>")<CR><CR> | |
| 436 nmap <C-Space>e :scs find e <C-R>=expand("<cword>")<CR><CR> | |
| 437 nmap <C-Space>f :scs find f <C-R>=expand("<cfile>")<CR><CR> | |
| 438 nmap <C-Space>i :scs find i ^<C-R>=expand("<cfile>")<CR>$<CR> | |
| 439 nmap <C-Space>d :scs find d <C-R>=expand("<cword>")<CR><CR> | |
|
9344
33c1b85d408c
commit https://github.com/vim/vim/commit/802a0d902fca423acb15f835d7b09183883d79a0
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
440 nmap <C-Space>a :scs find a <C-R>=expand("<cword>")<CR><CR> |
| 7 | 441 |
| 442 " Hitting CTRL-space *twice* before the search type does a vertical | |
| 443 " split instead of a horizontal one | |
| 444 | |
| 445 nmap <C-Space><C-Space>s | |
| 446 \:vert scs find s <C-R>=expand("<cword>")<CR><CR> | |
| 447 nmap <C-Space><C-Space>g | |
| 448 \:vert scs find g <C-R>=expand("<cword>")<CR><CR> | |
| 449 nmap <C-Space><C-Space>c | |
| 450 \:vert scs find c <C-R>=expand("<cword>")<CR><CR> | |
| 451 nmap <C-Space><C-Space>t | |
| 452 \:vert scs find t <C-R>=expand("<cword>")<CR><CR> | |
| 453 nmap <C-Space><C-Space>e | |
| 454 \:vert scs find e <C-R>=expand("<cword>")<CR><CR> | |
| 455 nmap <C-Space><C-Space>i | |
| 456 \:vert scs find i ^<C-R>=expand("<cfile>")<CR>$<CR> | |
| 457 nmap <C-Space><C-Space>d | |
| 458 \:vert scs find d <C-R>=expand("<cword>")<CR><CR> | |
|
9344
33c1b85d408c
commit https://github.com/vim/vim/commit/802a0d902fca423acb15f835d7b09183883d79a0
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
459 nmap <C-Space><C-Space>a |
|
33c1b85d408c
commit https://github.com/vim/vim/commit/802a0d902fca423acb15f835d7b09183883d79a0
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
460 \:vert scs find a <C-R>=expand("<cword>")<CR><CR> |
| 7 | 461 |
| 462 ============================================================================== | |
| 463 7. Cscope availability and information *cscope-info* | |
| 464 | |
| 465 If you do not already have cscope (it did not come with your compiler | |
| 466 license or OS distribution), then you can download it for free from: | |
| 467 http://cscope.sourceforge.net/ | |
| 468 This is released by SCO under the BSD license. | |
| 469 | |
| 470 In Solaris 2.x, if you have the C compiler license, you will also have | |
| 471 cscope. Both are usually located under /opt/SUNWspro/bin | |
| 472 | |
| 473 There is source to an older version of a cscope clone (called "cs") available | |
| 474 on the net. Due to various reasons, this is not supported with Vim. | |
| 475 | |
| 476 The cscope interface/support for Vim was originally written by | |
| 477 Andy Kahn <ackahn@netapp.com>. The original structure (as well as a tiny | |
| 12968 | 478 bit of code) was adapted from the cscope interface in nvi. |
| 7 | 479 *cscope-win32* |
| 13125 | 480 For a cscope version for Win32 see (seems abandoned): |
| 12968 | 481 https://code.google.com/archive/p/cscope-win32/ |
| 7 | 482 |
| 236 | 483 Win32 support was added by Sergey Khorev <sergey.khorev@gmail.com>. Contact |
| 147 | 484 him if you have Win32-specific issues. |
| 7 | 485 |
| 14421 | 486 vim:tw=78:ts=8:noet:ft=help:norl: |