Welcome to my Vim Page. Herein you'll find a number of scripts, some source
code (needs compiling, but I do have pre-compiled executables for you PC
types), and Vim syntax files. If you'd like to know more about Vim, check out
Vim Online. For more about vi, click on the vi lovers home page. The
syntax files below are often snapshots of my working copies, so sometimes they
may be works-in-progress. Usually such files will say ASTRO-ONLY
somewhere in the top four lines of the file. In any case, the scripts here
will be more up-to-date than the versions, if any, that I put on vim.sf.net.
Nearly all scripts herein will be using the new vimball archive format (*.vba
files) available with vim 7.0 -- it provides for better installation and
automatic helptag generation. If there's a "vba" suffix, you'll need vim 7.0
or later! Vim 7.0 users, however, do need to get a new version of
(vimball);
vim 7.1 users already have a sufficiently up-to-date version of vimball.
This approach allows your cinoptions to be effective, so you get the
indentation style you prefer (abbreviations prevent this). So,
if you use my stubs file, you probably should set the cino option. That way
the stub will be indented in your style. I've included a copy of my cinoptions below;
feel free to incorporate them (my style is the best, of course!) and change them as
you will (aw, shucks).
Intro: Flist
is a program which does a
number of things with C/C++ source files' functions: use it to generate
listings of functions, prototypes, calling trees, tags, and more (see
flist)! You may find the maps in
flistmaps a help in using flist with the
current file in Vim.
Hints: Flist's -h option makes <hints> files.
After you've used flist to generate your hints file, just source it into
your editing session or put the following code into your
<.vimrc> for automatic sourcing of hints:
if filereadable(expand("hints"))
au BufNewFile,BufReadPost *.c,*.C,*.cpp,*.CPP,*.cxx so hints<CR>
endif
The result? Every time you type a function name, a prototype for it will
appear on the information line. In order to see it, you should set your
cmdheight to 2 or more (:set ch=2) and possibly have showmode off (:set nosmd).
Maps: Along with flist itself I've
provided a small set of maps which use flist. The maps take the form
\[px][pxgs]: prototype or extern, and prototype, extern, global, and static.
The map invokes flist against the current file and inserts a list of
(global/static/both) prototypes or extern-style function declarations. The \pc
map inserts a list of prototypes suitable for inclusion in a comment.
Source Trees: Flist's -Tg option builds a tree-like graph of function use.
Coupled with the Flist-based Tree plugin for vim 6.0 or later,
one can browse the calling tree on the left hand side of the screen,
select a function to edit by putting the cursor on its line, and hitting
return. Put <FlistTree.vim> into your plugin directory; you may then use the
command :Flist [filename(s)] to begin graph-tree editing. See the
usage notes in <FlistTree.vim> for more commands! Click for a
screenshot if you'd
like to see it first.
Dummy Functions: Flist includes a -D option, which generates "dummy" function
definitions. In order to make trees, flist makes a pass over all the source
files to determine what functions are present, and then a second pass to
determine what functions are called by what functions. Thus common functions
(such as printf) are ignored, and the structure of your program is usually
better revealed. However, if you want to know where such functions are called,
or functions that were defined in your own personal library, you may wish
to set up a file containing a list of such functions with no
body (or even arguments). That way flist will process the dummy file
quickly. The -D option allows one to generate such a dummy file easily
from real ones.
| Calling Options | Explanation |
| flist *.c | list functions in files |
| flist -d *.c | generate a <ctags> file |
| flist -e *.c | generate an <etags> file |
| flist -h *.c | generate a <hints> file |
| flist -p *.c | list prototypes |
| flist -t *.c | list of functions for inclusion in a comment |
| flist -x *.c | list functions as externs |
| flist -Ta *.c | list calling tree, all roots |
| flist -Tg *.c | "graphical" calling tree |
| flist -Tf *.c | functions found report |
| flist -Tu *.c | functions used/called-by report |
| flist "?" | help |
Color Scheme
I've included Vim-script which implements my choice for syntax
highlighting. Please check out my page on DrChip's colorscheme
for the colorscheme I use. I like keeping the same colorscheme for both
gui (gvim) and console (vim); the latter restricts the number of colors available, so such dual-use
colorschemes must needs be designed for the limitations of the console.
Columnizing
Ever wished to convert a list of words into a multi-column list
(such as ls produces)? Mcol will do that for you (see Links below),
and check out some of my mcol-using scripts in mcol.vim.
+---------+------------------------------------------------------+
|Original | Using ma on "one", moving to "six", and typing \mn3|
|List | map \mn3 0!'amcol -n3<CR> |
+---------+------------------------------------------------------+
|one | |
|two | |
|three | one three five |
|four | two four six |
|five | |
|six | |
+---------+------------------------------------------------------+
DrChip's Online Tips and Scripts
| Script | aftersyntax: allows multiple after/syntax/[lang]/files.vim |
| Script | Align: alignment by multiple separators |
| Script | AnsiEsc: highlighting by ansi escape sequences plus concealment |
| Script | AsNeeded: loading vim scripts on demand |
| Script | astronaut: same syntax highlighting for console and gui |
| Script | AutoAlign: auto-alignment of = := etc as one types |
| Script | blockhl: highlighting of {} level for C/C++ |
| Script | cecscope : command and menu driven cscope interface |
| Script | cecutil : some utilities used by other of my scripts |
| Script | CVSconflict : CVS conflict resolution using vimdiff |
| Script | Decho: supports script debugging |
| Script | DrawIt!: ascii line drawing (lines, ellipses, fills, etc) |
| Script | drcstubs.tar.gz: ftplugins to support quick and easy language constructs |
| Script | drc_indent.tar.gz: various indent files |
| Script | EasyAccents: making accents easy |
| Script | engspchk: spelling checker |
| Script | ephtml: extended perl html syntax highlighting |
| Script | foldcol: inline fold a visual block (column) |
| Script | GetLatestVimScripts.vim: how to keep your scripts from vim.sf.net up-to-date |
| Script | gvcolors: displays X colornames in their own colors |
| Script | HelpExtractor: vim+help bundling |
| Script | hicolors: display current highlighting scheme colors + colorscheme editor |
| Script | HiCurLine: Highlights the current line |
| Script | HiMtchBrkt: Highlights the current line |
| Script | hints_man2.vim: Hints for C Library Functions (man2 based) |
| Script | hints_man3.vim: Hints for C Library Functions (man3 based) |
| Script | LargeFile: Edit large files quickly |
| Script | LogiPat: Boolean Logic Patterns |
| Script | Manpageview : vim-based manpage viewing |
| Script | maplesyrup : indenting, autoalign, and matchit support for Maple V |
| Script | Mines: a game |
| Script | mrswin: a toggling version of mswin.vim |
| Script | netrw: Network Oriented Reading and Writing |
| Script | pluginkiller: helps plugin writers find troublesome options |
| Script | vimball: vim-based archiver builder and extractor |
| Script | vis: VisualCommands, Substitutes, and Searches |
| Script | visincr: visual-block based incremented lists |
| Script | SeeTab : makes tabs visible as alternating bars |
| Script | WhereFrom :helps one locate where maps, scripts, and functions are defined |
| Script | ZoomWin : zoom into a window, zoom out to all windows |
| Tip | A map for swapping words |
| Tip | Alignment: =, LaTeX tables, declarations, etc |
| Tip | Applying substitutes to a visual block |
| Tip | Bouncing Parentheses (during insertion) |
| Tip | Deleting a buffer without changing your window layout |
| Tip | Generating a column of increasing numbers |
| Tip | Getting the official distribution's latest: syntax highlighting, runtime, docs, plugins, etc |
| Tip | Highlight matching brackets as one moves in normal mode |
| Tip | How do I get rid of that bold stuff with my xterm? |
| Tip | How to initialize plugins |
| Tip | How to overwrite a visual-block of text with another such block |
| Tip | How to sort using visual blocks |
| Tip | How to tell what syntax highlighting group *that* is! |
| Tip | How to toggle between all vertical and all horizontal window layout |
| Tip | How to write a plugin |
| Tip | Maps, Commands, and Functions - some examples of their interplay |
| Tip | Opening gvim atop a console window |
| Tip | Repeating a substitute from current cursor position |
| Tip | Restore cursor to file position in previous editing session |
| Tip | Spelling checkers: Dutch, English, German, Hungarian, and Yiddish |
| Tip | Using vim as a man-page viewer under Unix |
Patches
- getfsize patch
This patch extends getfsize({fname}) to getfsize({fname}[,unitsize]).
The optional second argument specifies the units that getfsize()
will return the file size in. It's useful for handling file
sizes that are over 2GB.
PC: Pre-Compiled Executables
I've included some pre-compiled executables for the PC for which I used a Borland
C/C++ compiler (under Miscellaneous in the Links).
As a bonus, I've thrown in my calculator program, too. You should
still get the source code distributions; if you have ansi escape sequences enabled
for your MS-DOS windows, and have <rdcolor.dat>, prompts and help will come
up in color. The copyright notices associated with the source distributions also
still apply to the executables.
Short Vim Command List
If you've gotten here, I'm sure you realize that Vim has a large
number of commands -- that is, commands that one can do while
in normal mode. That's not counting the command mode commands!
Check out the Real Short Vim Normal-Mode List of Commands.
Spelling Checker
The English spelling checker
(under Scripts in the Links)
uses Vim's native syntax highlighting ability to make
misspelled (English) words show up as an "Error" (usually white on a red
background). The Vim-based English spell checker also supports entering words
that the cursor is on into a temporary or permanent dictionary and allows one
to skip to the previous or subsequent spelling error (if any). It co-exists
quite well with TeX, LaTeX, Html, and other such specialized text, and can
be used to check the spelling inside comments in various programming languages.
Getting Started:
The English spelling checker now comes as a "tarball":
gunzip the file <engspchk.tar.gz> and
tar -oxvf engspchk.tar in the .vim or _vimfiles
directory.
The English spelling checker is a plugin; it
does a quick load and makes a map for \ec (actually the \
is <Leader> which can be changed; see :he mapleader).
The dictionary isn't loaded until one types \ec.
It also creates a menu item to load the spelling checker for gvim
(the gui).
The custom user dictionary and optional Webster's 1913 dictionary
is stored using the path specified by the vim variable g:cvimsyn,
settable in the <.vimrc>.
If that variable isn't set, then the CVIMSYN environment
variable, if it exists, is used.
If you want to use the environment variable approach:
| sh | CVIMSYN="path";export CVIMSYN |
| csh | setenv CVIMSYN "path" |
| ksh | export CVIMSYN="path" |
| Windows 95,98 | in <autoexec.bat>: |
| | set CVIMSYN=..path.. |
| Windows 2000,NT,etc | Right click on <My Computer> |
| | Choose <Properties> |
| | Click <System Properties> |
| | Click <Advanced> tab |
Moving:
For Vim versions 5.04 and later, the <engspchk.vim>
file additionally provides two maps (\en and \ep) to move to the next and preceding
spelling error, if any. I suggest you upgrade if you haven't already, because
Vim's functions are powerful!
Custom Dictionary:
Engspchk allows the user to temporarily save (\et) or to
permanently save (\es) words the user uses but somehow isn't in
Engspchk's dictionary. A temporary save only affects the current
vim editing session; a permanent save writes the word to a custom user dictionary
which is automatically loaded in the future.
Alternatives:
For Vim version 6.0 and later, <engspchk.vim>
provides the (\ea) map which brings up a one-line alternatives window for the
word under the cursor. Move left and right with the full power of Vim, and
when the cursor lies on the desired substitute word, a simple carriage return
will cause replacement. You'll also need to have the
agrep
program to do this (there's a pre-compiled for Windows version available using
this link). The first use of (\ea)
takes longer than subsequent use because the script that gets invoked constructs
a plain list of words from the engspchk file.
No Flashing:
With Vim version 6.0y and later and starting with version 2.04 of
engspchk no longer will Error highlighting flash on and off while you're
typing. Thanks go to Chase Tingley (with emendations by Bram Moolenaar) who
wrote the changes to Vim to make this possible.
More Words: Previously the
<wb1913_engspchk.vim> file was provided separately, but it is
now provided in the <engsphck.tar.gz> tarball. still optional if you'd
rather not load it. Webster has provided an electronic copy of the words from
its 1913 edition; those words that appear in that dictionary that don't appear
in <engspchk.vim>'s dictionary itself are provided in the
<wb1913_engsphck.vim> file. If the file appears in the directory
specified by the g:cvimsyn variable (or by the CVIMSYN environment variable)
then it is loaded automatically.
Other Languages: There are now variants of
<engspchk.vim> for Dutch, German, Hungarian, Polish, and Yiddish. Engspchk
has been improved so that mostly all that's needed are the dictionaries themselves.
I'd appreciate it if you could let me know where on the Web to find it so I can make a link on
this page to it!
Thomas Köhler has made his create script which
uses the Bourne shell; it merges a dictionary with engspchk.vim to
create a spelling checker for another language.
Since vim 7.0 and later now includes embedded spell checking, I've removed
most of the spelling dictionaries. If someone is still interested, please
send me an email (NdrOchip@ScampbellPfamily.AbizM - NOSPAM) and I'll send
you a copy. Unfortunately, I'm limited on my webspace, and I needed the
space! I have dictionaries for Dutch, French, German, Hungarian, Italian,
Polish, Russian, and Spanish.
To see a screenshot, please click on this.
Tag Generation
I have written my own tag generating program (see Links);
although Exuberant Ctags is good, I know how to modify hdrtag
to suit me. It contains tagging generation for c/c++, c/c++ header files,
lex, yacc, TeX (cites and labels), vim scripts (functions and syntax), and Maple V.
Exuberant Ctags will no longer be distributed with vim as of v6.0i. I've provided
a link to its homesite in the source code-related links below.
Text Alignment
The alignment scripts (<Align.vim> and <AlignMaps.vim>) now supplant
the older external filter approach. The new scripts, which include help and
plentiful examples, provide:
- cyclic left, right, and centering justification of fields
- cyclic or equivalent regular-expression separators
- cyclic left, right, and centering of multi-length separators
- improved initial white space control: retain, eliminate, re-use first
- specifiable separator padding
- visual range specified alignment, including via visual-block
- multiple maps in <AlignMaps.vim> which tackle complex
alignment problems, such as aligning C/C++ declarations,
function argument lists, etc.
See my DrChip's Alignment Tool for Vim page for links and examples.
An alternative aligner is available from
Gergely Kontra
(Johannes Zellner used to have one available, but apparently his site has disappeared).
Useful Maps
- Date maps (year-month-day, month-day-year, etc)
imap <Leader>ymd <C-R>=strftime("%y%m%d")<CR>
imap <Leader>mdy <C-R>=strftime("%m/%d/%y")<CR>
imap <Leader>ndy <C-R>=strftime("%b %d, %Y")<CR>
imap <Leader>hms <C-R>=strftime("%T")<CR>
imap <Leader>ynd <C-R>=strftime("%Y %b %d")<CR>
com! YMD :norm! i<C-R>=strftime("%y%m%d")<CR>
com! MDY :norm! i<C-R>=strftime("%m/%d/%y")<CR>
com! NDY :norm! i<C-R>=strftime("%b %d, %Y")<CR>
com! HMS :norm! i<C-R>=strftime("%T")<CR>
- Determining the highlight group that the word under the cursor belongs to
nmap <silent> <F10> :echo "hi<" . synIDattr(synID(line("."),col("."),1),"name") . '> trans<' . synIDattr(synID(line("."),col("."),0),"name") . "> lo<" . synIDattr(synIDtrans(synID(line("."),col("."),1)),"name") . ">"<CR>
- Mirrors and Reversals:
nno <silent> <Leader>fr :set lz<cr>'aO<esc>ma'':'a+1,.g/^/m 'a<cr>kdd:set lz!<cr>
vno <silent> <Leader>fr :<c-u>set lz<CR>O<esc>V'>:g/^/m '<<cr>'<dd:set lz!<cr>
nmap <silent> <Leader>fR V'a\fR
vno <silent> <Leader>fR c<C-O>:set ri lz<cr><C-R>"<esc>:norm! dd`<<cr>:set ri! lz!<cr>
- Insertion mode Completion Function Key Maps (press while in insert mode to see list)
" <F1> <c-x><c-L> completion: whole line
" <F2> <c-x><c-N> completion: keywords using current file
" <F3> <c-x><c-K> completion: keywords using dictionary
" <F4> <c-x><c-T> completion: keywords using thesaurus
" <F5> <c-x><c-I> completion: keywords in current and included files
" <F6> <c-x><c-]> completion: tags
" <F7> <c-x><c-F> completion: file names
" <F8> <c-x><c-D> completion: definitions or macros
" <F9> <c-x><c-V> completion: vim command line
" <F10> <c-x><c-O> completion: omni completion
ino <silent> <F1> <c-x><c-L>
ino <silent> <F2> <c-x><c-N>
ino <silent> <F3> <c-x><c-K>
ino <silent> <F4> <c-x><c-T>
ino <silent> <F5> <c-x><c-I>
ino <silent> <F6> <c-x><c-]>
ino <silent> <F7> <c-x><c-F>
ino <silent> <F8> <c-x><c-D>
ino <silent> <F9> <c-x><c-V>
ino <silent> <F10> <c-x><c-O>
ino <silent> <F11> <C-O>ma<C-O>yiw<C-O>:ptag <C-R>"<CR><C-O>`a
ino <silent> <s-left> <c-x><c-p>
ino <silent> <s-right> <c-x><c-n>
ino <silent> <F12> <c-o>:echo 'completes[ F1:line F2:keywrd F3:dict F4:thes - F5:fromfile F6:tags F7:fname F8:defns - F9:vimcmd F10:omni ] F11:ptag-iw F12:funkey help'<CR>
- Moving up/down by function, unfolding current function but folding all else
noremap [[ [[zMzvz.
noremap ]] ]]zMzvz.
- Some typical settings for viminfo that I use:
set viminfo=!,'10,\"100,:20,%,nc:\\cec\\_viminfo
set viminfo=!,'25,\"100,:20,%,n~/.viminfo
- Transferring blocks of text between vim sessions
nmap <Leader>xr :r $HOME/.vimxfer<CR>
nmap <Leader>xw :'a,.w! $HOME/.vimxfer<CR>
vmap <Leader>xw :w! $HOME/.vimxfer<CR>
nmap <Leader>xa :'a,.w>> $HOME/.vimxfer<CR>
vmap <Leader>xa :w>> $HOME/.vimxfer<CR>
nmap <Leader>xS :so $HOME/.vimxfer<CR>
nmap <Leader>xy :'a,.y *<CR>
vmap <Leader>xy :y *<CR>
Vim Functions, Plugs, and Stubs
VIM 7.0 USERS: BE SURE TO GET THE LATEST VIMBALL PLUGIN BEFORE ATTEMPTING TO USE SCRIPTS UPLOADED ON OR AFTER AUG 1, 2006
Various functions, plug-ins, and quick-insertion stubs follow alphabetically. There are several
plugins that I post both here and at vim.sf.net.
Scripts here are my most up-to-date ones and may be considered as alpha/beta releases;
I tend to put the ones I'm updating/fixing here. After a bit of feedback, and a variable length
of time (ie. whenever I get around to it), I will also post the scripts on
vim.sf.net.
I use three release states with my plugins:
- NOT RELEASED -- my latest version (labelled v[0-9]*[a-z], ex. v3b).
May be handed out to individuals while I'm attempting
to debug some problem they're having. The version
number will remain fixed while the plugin is in this
state. These versions of my plugins shouldn't get
generally released, but accidents happen.
- ASTRO-ONLY -- a somewhat experimental version of my plugins, also
labelled with v[0-9]*[a-z] (ex. v3b). These versions
have their trailing letter changed as they get
updated. These versions appear on this website.
- (nothing) -- the plugin has been released on vim.sf.net
and concurrently on my own website. These versions drop the trailing
letters, having the format v[0-9]* (ex. v3). Those plugins
which Bram has picked up for vim releases have also been
forwarded to Bram.
In other words, I use the ASTRO-ONLY stage as a beta release, and NOT RELEASED
as an alpha. Helps get the bugs out before its released to potentially
thousands.
If you have some feedback (problems or kudos!), please send an email to NdrOchip@ScampbellPfamily.AbizM
(less the embedded NOSPAM therein).
-
| Updated Apr 07, 2005 (v2a) |
Several directories, such as .vim/after/syntax, allows multiple files
therein but does not look into sudirectories therein. By copying this
file to such a directory, and renaming it using the subdirectory name + ".vim",
the subdirectory name will be scanned for any and all *.vim files and such
files will be loaded.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
Also available at vim.sf.net where you may rank it.
- DrChip's Astronaut Colorscheme
| Updated Aug 10, 2006 (v8c) |
The astronaut.vim colorscheme
(see DrChip's colorscheme for more about it)
provides a constant colorscheme for both gvim and vim.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Alignment
| Updated Mar 06, 2008 (v33) |
Aligns text based on patterns (see page for more!).
NOTICE: The latest version of Align and AlignMaps given here need vim 7.0aa.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
Also available at vim.sf.net where you may rank it.
- Alignment Maps
| Updated Mar 21, 2008 (v40c) |
Provides numerous maps to facilitate text alignment(see page for more!)
Also available at vim.sf.net where you may rank it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Ansi Highlighting
| Updated May 12, 2008 (v9a) |
Source this in and ansi escape coloring sequences,
generally of the forms ^[[3#m or ^[[3#;4#m, will be
colored appropriately. The escape sequence itself
takes space but will itself use "Ignore" highlighting. Ideally
the escape sequences would be folded out but that capability
isn't in vim 6.0 yet (folding is line-based).
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
Also available at vim.sf.net
where you may rank it.
- AsNeeded
| Updated Feb 28, 2008 (v16i) |
Supports automatic sourcing (loading) of functions as needed. AsNeeded.vim is a plugin
that sources other scripts in the .vim/AsNeeded directory when a function is called
that is needed. One may use :AsNeeded command or :AN command. AsNeeded actually
supports as-needed sourcing for functions, maps, and commands.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- AutoAlign suite
| Updated Sep 20, 2007 (v14c) |
Uses the Align.vba.gz
package to facilitate aligning equations, etc, as you type them.
Also available at vim.sf.net
where you may rank it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Blockhl: Nesting Level Based Highlighting For C
| Updated Feb 01, 2007 (v4) |
Blockhl controls the highlighting of leading tabs based on the nesting level of {}s
for the C and C++ languages by providing a sequence of graylevels.
The file should be put into the .../after/syntax/c directory.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Cecmatrix: Matrix Handling
| Updated Jan 04, 2008 (v1b) |
This plugin provides:
- The MatInit command -- use visual block mode to define a Matrix
- MatAdd, MatSub, MatMult, and MatTpose commands (and functions) to add, subtract,
multiply, and transpose matrices
- The MatWrite command -- to write one or more matrices into your text
Uses the Align and cecutil plugins.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Stubs
| Updated Nov 21, 2007 (v3c) |
Supports quick entry of language constructs for C, sh/ksh/bash, LaTeX, and vim.
Ie. while in insert mode and using C, a if` will result in
a if(){} construct entered into your code with the
cursor appropriately positioned for further insertion. When done with entering
the test expression, hitting <esc&rt; will place your cursor (in insert mode)
after the "{". (also see Abbreviations for C)
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- C Function Menu Generator
Marcel van der Laan wrote a function
:call C_ListFuncs() which uses flist to
generate a menu of functions in the current file.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- C Compiler Commands
| Updated Jan 05, 2006 (v1) |
The compiling.vim plugin
provides error format files for several C compilers, plus
a :Chk command to show one window with source with lines with errors and warnings
given Error highlighting and a quickfix window showing the associated messages.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- CVS Conflict File Handler
| Updated Apr 08, 2008 (v2c) |
When one does "cvs update", one may get files marked with "C" for
conflict. Cvs was unable to automatically merge one's local
version with the repository, and merging requires human intervention.
The :CVSconflict command takes the current conflict file,
splits it into two separate files, and enables vimdiff-style
editing and viewing.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Calendar Utilities
| Updated Oct 19, 2007 (v3a) |
Used by visincr.vim (which is described
below), <calutil.vim> provides three calendar-related functions:
DayOfWeek(y,m,d), Cal2Jul(y,m,d), and Jul2Cal(julday). DayOfWeek() converts a date
to a day of week name, and the other two convert between dates and the Julian day.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Cscope Interface
| Updated May 13, 2008 (v4b) |
(vim v7.0 only) Cscope interface to find functions which call functions,
are called by functions, etc. Put in your .vim/plugin directory, and
try :CSh for help. There's optional local quickfix windows, vertical
or horizontal window with cscope output, menus, etc.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- DrC's Utilities contains various functions and some maps:
| Updated Sep 04, 2007 (v17) |
Marks: SaveMark(markname) RestoreMark(markname) DestroyMark(markname)
Pos'n: SaveWinPosn() RestoreWinPosn() \swp \rwp (actually uses )
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Decho: DrC's Vim Debugger
| Updated Feb 13, 2008 (v20f) |
The Decho.vim plugin provides debugging messages in a separate window.
One puts
Decho "some message here"
-or-
call Decho("another message")
and Decho will split the screen with a five line debugging window on the
bottom of the display where the messages will appear. Allows one to
inspect multiple error messages with the usual vim editing commands!
More help and commands are available with Decho's help.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- DotFill
| Updated Apr 11, 2006 (v1a) |
Facilitates setting up aligned columns with user-specified fill-characters. Often used with contents
pages. Example of usage: :[range]DotFill . (to fill with dots)
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- DrawIt.vba.gz
| Updated Oct 10, 2007 (v9) |
A plugin for drawing vertical, horizontal, and slanted lines using text.
With DrawIt, one may use the number pad to leave a trail of dashes,
bars, etc behind. Furthermore, it also supports using visual-block specified regions
to draw boxes, ellipses, arrowheads, lines, and to specify floods.
Also available at vim.sf.net
where you may rank it. The version here requires vim 7.0!!!
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- DrC's Indent Files
| Updated May 03, 2005 (v1) |
The drc_indent.vim package of indent files
provides DrC's indent files and customizations for sh, tex, vim, and maple.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- EasyAccents.vim
| Updated Feb 04, 2008 (v9a) |
A plug-in that makes using accented characters easier
Also available at vim.sf.net
where you may rank it. (Version 8)
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Engspchk (spelling checker)
| Updated Feb 28, 2008 (v65b) |
A multiple-human-language spell checking tool!
Supports on-the-fly spell-checking, spelling suggestions,
the mouse (when available), and menus (gvim).
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- FlistTree
| Updated Jan 02, 2008 (v9b) |
Shows a graphical function-usage tree. See FlistTree.vim itself for instructions.
(uses flist, a program)
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- foldcol.vim
| Updated Dec 21, 2004 (v3a) |
Coupled with Vince Negri's conceal/ownsyntax patch, foldcol
makes it possible to fold columns of text from view.
Also available at vim.sf.net where you may rank it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- funcsrch.vim
| Updated Jan 25, 2006 (v2a) |
Permits searches to be taken only within a function, as
defined by [[ (for start of function) and ][ (for end of function). These normal
commands may, of course, be defined as maps in the ftplugin directory to customize
them for specific languages.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- getscript.vba.gz
| Updated Jan 08, 2008 (v29) |
This plugin's :GetLatestVimScripts command (or :GLVS for short)
will automate grabbing the latest version of the plugins and scripts that you
express an interest in by putting a line into the GetScript/GetScript.dat
file. With cooperating plugins, GetScript can build the data file itself, too.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball.
Unfortunately, there was a bug that makes the getscript.vim version that was distributed with vim v7.0
cause difficulties with a vimball-installation of a new getscript.vim. So, you'll need to remove
the older version of getscript.vim:
- Change directory to the directory holding the vim 7.0 distribution's plugin/ and autoload/ directories.
- /bin/rm plugin/getscript*.vim autoload/getscript*.vim doc/pi_getscript.txt
- gvcolors
| Updated Oct 10, 2007 (v6) |
Gvim colors -- displays a list of named colors that gvim has available
with X; each color shows up in its own color! One can toggle between dark and bright backgrounds
by using a rightmouse click. A leftmouse click on a color brings it to the
top line of the display. The colors at the top of the display have their
red-green-blue values, in decimal, on the bottom of the screen.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Hdrtag List
| Updated Dec 04, 2006 (v1d) |
Display tags, tagtypes, in a left-hand window with the :Hdrtag command.
Intended to support the hdrtag program by providing
a taglist-like interface for it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- More Help Syntax Highlighting
| Updated Apr 07, 2007 (v1c) |
This script will add extra highlighting and syntax-based folding to the vim help pages.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- HelpExtractor
| Updated May 25, 2005 (v3) |
This script can be used to make .vim scripts automatically install help.
Also available at vim.sf.net
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Highlight Colors Help and Editor
| Updated Sep 11, 2007 (v9e) |
Shows highlighting colors in their own colors, plus a colorscheme editor!
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Highlight Current Line
| Updated Mar 01, 2006 (v7k) |
With this plugin the current line will be highlighted
Also available at vim.sf.net where you may rank it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Highlight Marks
| Updated Mar 20, 2008 (v2c) |
Highlights marks by using the signs feature (your vim needs to be compiled for big/huge).
Required: Kruize and Gedde's ShowMarks.vim plugin, which does most of the work. Its at
vim.sf.net .
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Hints for Library Functions (man2 based)
| Updated Mar 13, 2007 (v1) |
Shows prototype hints as one types a function (man page 2 based)
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Hints for Library Functions (man3 based)
| Updated Mar 13, 2007 (v1) |
Shows prototype hints as one types a function (man page 3 based)
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- HiLinkTrace
| Updated Feb 28, 2008 (v4f) |
A plugin which traces the highlighting linkages; ie. just what highlighting
groups associated with the word under the cursor? (hilinks.vim, implements a map "\hlt")
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Highlighting Matching Brackets
| Updated Apr 28, 2006 (v23c) |
A Vim 6.0 plugin that highlights a matching bracket
when the cursor moves on it. Uses HelpExtractor to set up its help.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- LaTeX Maps
| Updated Jan 14, 2008 (v2c) |
Supports quick entry of LaTeX constructs (ie. ".." becomes
``..'', enum` gets expanded to \begin{enumerate}, etc).
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- LargeFile
| Updated Apr 11, 2008 (v4d) |
Allows much quicker editing of large files (default: 100MB+ are "large"), at the price of turning
off events, undo, syntax highlighting, etc.
Also available at vim.sf.net
where you may rank it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Library Viewer
| Updated Oct 17, 2007 (v1a) |
This plugin uses the "nm" utility to present an overview of the contents of archive and object files.
Its based on autocmds, and so to use it all one needs do is to open an archive (*.a), an object (*.o) file,
or a shared library (*.so) by attempting to edit it. (formerly known as the archive/object visualizer)
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- LogiPat
| Updated Sep 25, 2006 (v3b) |
Provides a :LogiPat {boolean-logic pattern} and forms a search.
Also available at vim.sf.net
where you may rank it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Maintainer
| Updated Mar 27, 2006 (v2a) |
Use ":echo Maintainer" to find
out who the maintainer is of the syntax file you're
currently using; ":echo Maintainer("language")"
to determine the Maintainer of a specific language (ie. c, vim, tex, jsp, etc).
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Man Page Viewer
| Updated May 09, 2008 (v18d) |
A plugin which facilitates the viewing of man pages under Unix systems;
supports :Man topic, :Man topic booknumber, :Man booknumber topic, and
:Man topic(booknumber). While in a man page the K key will invoke manpaging
on the word under the cursor.
Also available at vim.sf.net
where you may rank it. Supports perl (*.pl, *.upl) and info (*.i), too.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Maple Syrup
| Updated Jan 25, 2006 (v3b) |
This tarball contains multiple files to support MapleSoft's Maple programming
language for symbolic algebra. Included: indent, auto-align, and matchit support.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Mines
| Updated Apr 08, 2008 (v17a) |
A game for vim implementing the world famous game of Mines!
Also available at vim.sf.net
where you may rank it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Multi-Column Listing
| Updated Feb 07, 2006 (v1a) |
The mcol.vim plugin
converts a list of words into a multi-column listing, much as "ls" does with a list of files.
It uses the mcol program; see mcol to get a copy of the source.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Network Oriented Reading, Writing, and Browsing
| Updated May 09, 2008 (v125m) |
Supports network-oriented editing with urls. One may read and write files
using one of several supported protocols (ex: ftp, scp) and browse
directories, both remotely and locally. This version requires vim 7.0.
Be sure to remove any older versions of netrw before attempting to install this version.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball.
Unfortunately, there was a bug that makes the netrw version that was distributed with vim v7.0
cause difficulties with a vimball-installation of a new netrw. So, for vim v7.0, you'll need to remove
the older version of netrw:
- Change directory to the directory holding the vim 7.0 distribution's plugin/ and autoload/ directories.
- /bin/rm plugin/netrw*.vim autoload/netrw*.vim doc/pi_netrw.txt
Beginning with v108b of netrw: sourcing remote files is supported.
Here's a list of some netrw options that I myself use:
let g:netrw_altv = 1
let g:netrw_fastbrowse = 2
let g:netrw_keepdir = 0
let g:netrw_liststyle = 2
let g:netrw_retmap = 1
let g:netrw_silent = 1
let g:netrw_special_syntax= 1
- Netrw Clean
| Updated Sep 05, 2007 (v1a) |
The netrwclean.vim plugin will attempt to remove the netrw plugin: with :NetrwClean, only the personal directory copy
will be cleaned. With :NetrwClean!, this plugin will attempt to remove netrw from both your personal directory
and the system directory. You need permission to remove such files, of course. This plugin may be helpful
for those who've previously gotten an up-to-date version of netrw but then update their vim later via ftp, cvs, etc
with an even more recent version of netrw (in that case, use :NetrwClean).
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- pluginkiller.vba.gz
| Updated Oct 10, 2007 (v3a) |
Plugin writers! Have you ever wished you could find what option settings
will interfere with your plugin before your users do? The pluginkiller
helps automate finding such troublesome settings.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Rainbow Brackets
| Updated Apr 05, 2005 (v1) |
This plugin provides a rainbow of colors for matching brackets ( [] () {} ) depending
on their nesting level ; it is intended to support the C and C++ languages. The syntax file
distributed with Vim for Lisp already supports rainbow highlighting of ()s; bring up vim and
type ":help ft-lisp-syntax".
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Rndm
| Updated Feb 20, 2007 (v4e) |
Returns random variates
- Rndm() returns uniformly distributed variates on [0, 100,000,000)
- Urndm(a,b) returns uniformly distributed variates on [a,b])
- Dice(qty,sides) rolls qty of sides-sided dice and adds them up
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- RunView