mirror of
https://github.com/vim/vim
synced 2025-03-14 22:07:51 +01:00
Some checks are pending
GitHub CI / linux (arm64, gcc, [nogui], tiny) (push) Waiting to run
GitHub CI / linux (arm64, gcc, true, [unittests], huge) (push) Waiting to run
GitHub CI / linux (clang, [asan], huge, 5.1) (push) Waiting to run
GitHub CI / linux (clang, [nogui], tiny) (push) Waiting to run
GitHub CI / linux (gcc, [nogui], tiny) (push) Waiting to run
GitHub CI / linux (gcc, [vimtags], normal) (push) Waiting to run
GitHub CI / linux (gcc, true, [uchar testgui], huge, dynamic) (push) Waiting to run
GitHub CI / linux (gcc, true, [unittests], huge) (push) Waiting to run
GitHub CI / linux (i386, gcc, normal, ./src/shadow) (push) Waiting to run
GitHub CI / linux (native, clang, [], normal) (push) Waiting to run
GitHub CI / linux (native, clang, [], tiny) (push) Waiting to run
GitHub CI / linux (native, clang, true, [], huge, dynamic, stable-abi) (push) Waiting to run
GitHub CI / linux (native, gcc, [], normal) (push) Waiting to run
GitHub CI / linux (native, gcc, [], tiny) (push) Waiting to run
GitHub CI / linux (native, gcc, true, [], huge) (push) Waiting to run
GitHub CI / macos (huge, macos-13) (push) Waiting to run
GitHub CI / macos (huge, macos-15) (push) Waiting to run
GitHub CI / macos (normal, macos-13) (push) Waiting to run
GitHub CI / macos (normal, macos-15) (push) Waiting to run
GitHub CI / macos (tiny, macos-13) (push) Waiting to run
GitHub CI / macos (tiny, macos-15) (push) Waiting to run
GitHub CI / windows (no, no, x64, HUGE, stable, msvc) (push) Waiting to run
GitHub CI / windows (no, no, x86, TINY, mingw) (push) Waiting to run
GitHub CI / windows (no, yes, x64, yes, HUGE, mingw) (push) Waiting to run
GitHub CI / windows (no, yes, x86, NORMAL, msvc) (push) Waiting to run
GitHub CI / windows (yes, no, x64, NORMAL, mingw) (push) Waiting to run
GitHub CI / windows (yes, no, x86, HUGE, msvc) (push) Waiting to run
GitHub CI / windows (yes, yes, x64, TINY, msvc) (push) Waiting to run
GitHub CI / windows (yes, yes, x86, yes, HUGE, stable, mingw) (push) Waiting to run
CodeQL / Analyze (push) Waiting to run
Signed-off-by: Christian Brabandt <cb@256bit.org>
1066 lines
37 KiB
Text
1066 lines
37 KiB
Text
*filetype.txt* For Vim version 9.1. Last change: 2025 Mar 14
|
|
|
|
|
|
VIM REFERENCE MANUAL by Bram Moolenaar
|
|
|
|
|
|
Filetypes *filetype* *file-type*
|
|
|
|
1. Filetypes |filetypes|
|
|
2. Filetype plugin |filetype-plugins|
|
|
3. Docs for the default filetype plugins. |ftplugin-docs|
|
|
|
|
Also see |autocmd.txt|.
|
|
|
|
|
|
==============================================================================
|
|
1. Filetypes *filetypes* *file-types*
|
|
|
|
Vim can detect the type of file that is edited. This is done by checking the
|
|
file name and sometimes by inspecting the contents of the file for specific
|
|
text.
|
|
|
|
*:filetype* *:filet*
|
|
To enable file type detection, use this command in your vimrc: >
|
|
:filetype on
|
|
Each time a new or existing file is edited, Vim will try to recognize the type
|
|
of the file and set the 'filetype' option. This will trigger the FileType
|
|
event, which can be used to set the syntax highlighting, set options, etc.
|
|
|
|
NOTE: Filetypes and 'compatible' don't work together well, since being Vi
|
|
compatible means options are global. Resetting 'compatible' is recommended,
|
|
if you didn't do that already.
|
|
|
|
Detail: The ":filetype on" command will load one of these files:
|
|
Amiga $VIMRUNTIME/filetype.vim
|
|
Mac $VIMRUNTIME:filetype.vim
|
|
MS-Windows $VIMRUNTIME\filetype.vim
|
|
Unix $VIMRUNTIME/filetype.vim
|
|
VMS $VIMRUNTIME/filetype.vim
|
|
This file is a Vim script that defines autocommands for the
|
|
BufNewFile and BufRead events. If the file type is not found by the
|
|
name, the file $VIMRUNTIME/scripts.vim is used to detect it from the
|
|
contents of the file.
|
|
When the GUI is running or will start soon, the |menu.vim| script is
|
|
also sourced. See |'go-M'| about avoiding that.
|
|
|
|
To add your own file types, see |new-filetype| below. To search for help on a
|
|
filetype prepend "ft-" and optionally append "-syntax", "-indent" or
|
|
"-plugin". For example: >
|
|
:help ft-vim-indent
|
|
:help ft-vim-syntax
|
|
:help ft-man-plugin
|
|
|
|
If the file type is not detected automatically, or it finds the wrong type,
|
|
you can either set the 'filetype' option manually, or add a modeline to your
|
|
file. Example, for an IDL file use the command: >
|
|
:set filetype=idl
|
|
|
|
or add this |modeline| to the file:
|
|
/* vim: set filetype=idl : */ ~
|
|
|
|
*:filetype-plugin-on*
|
|
You can enable loading the plugin files for specific file types with: >
|
|
:filetype plugin on
|
|
If filetype detection was not switched on yet, it will be as well.
|
|
This actually loads the file "ftplugin.vim" in 'runtimepath'.
|
|
The result is that when a file is edited its plugin file is loaded (if there
|
|
is one for the detected filetype). |filetype-plugin|
|
|
|
|
*:filetype-plugin-off*
|
|
You can disable it again with: >
|
|
:filetype plugin off
|
|
The filetype detection is not switched off then. But if you do switch off
|
|
filetype detection, the plugins will not be loaded either.
|
|
This actually loads the file "ftplugof.vim" in 'runtimepath'.
|
|
|
|
*:filetype-indent-on*
|
|
You can enable loading the indent file for specific file types with: >
|
|
:filetype indent on
|
|
If filetype detection was not switched on yet, it will be as well.
|
|
This actually loads the file "indent.vim" in 'runtimepath'.
|
|
The result is that when a file is edited its indent file is loaded (if there
|
|
is one for the detected filetype). |indent-expression|
|
|
|
|
*:filetype-indent-off*
|
|
You can disable it again with: >
|
|
:filetype indent off
|
|
The filetype detection is not switched off then. But if you do switch off
|
|
filetype detection, the indent files will not be loaded either.
|
|
This actually loads the file "indoff.vim" in 'runtimepath'.
|
|
This disables auto-indenting for files you will open. It will keep working in
|
|
already opened files. Reset 'autoindent', 'cindent', 'smartindent' and/or
|
|
'indentexpr' to disable indenting in an opened file.
|
|
|
|
*:filetype-off*
|
|
To disable file type detection, use this command: >
|
|
:filetype off
|
|
This will keep the flags for "plugin" and "indent", but since no file types
|
|
are being detected, they won't work until the next ":filetype on".
|
|
|
|
|
|
Overview: *:filetype-overview*
|
|
|
|
command detection plugin indent ~
|
|
:filetype on on unchanged unchanged
|
|
:filetype off off unchanged unchanged
|
|
:filetype plugin on on on unchanged
|
|
:filetype plugin off unchanged off unchanged
|
|
:filetype indent on on unchanged on
|
|
:filetype indent off unchanged unchanged off
|
|
:filetype plugin indent on on on on
|
|
:filetype plugin indent off unchanged off off
|
|
|
|
To see the current status, type: >
|
|
:filetype
|
|
The output looks something like this: >
|
|
filetype detection:ON plugin:ON indent:OFF
|
|
|
|
The file types are also used for syntax highlighting. If the ":syntax on"
|
|
command is used, the file type detection is installed too. There is no need
|
|
to do ":filetype on" after ":syntax on".
|
|
|
|
To disable one of the file types, add a line in your filetype file, see
|
|
|remove-filetype|.
|
|
|
|
*filetype-detect*
|
|
To detect the file type again: >
|
|
:filetype detect
|
|
Use this if you started with an empty file and typed text that makes it
|
|
possible to detect the file type. For example, when you entered this in a
|
|
shell script: "#!/bin/csh".
|
|
When filetype detection was off, it will be enabled first, like the "on"
|
|
argument was used.
|
|
|
|
*filetype-overrule*
|
|
When the same extension is used for multiple filetypes, Vim tries to guess
|
|
what kind of file it is. This doesn't always work. A number of global
|
|
variables can be used to overrule the filetype used for certain extensions:
|
|
|
|
file name variable ~
|
|
*.asa g:filetype_asa |ft-aspperl-syntax|
|
|
|ft-aspvbs-syntax|
|
|
*.asm g:asmsyntax |ft-asm-syntax|
|
|
*.asp g:filetype_asp |ft-aspperl-syntax|
|
|
|ft-aspvbs-syntax|
|
|
*.bas g:filetype_bas |ft-basic-syntax|
|
|
*.cfg g:filetype_cfg
|
|
*.cls g:filetype_cls
|
|
*.csh g:filetype_csh |ft-csh-syntax|
|
|
*.dat g:filetype_dat
|
|
*.def g:filetype_def
|
|
*.dsp g:filetype_dsp
|
|
*.f g:filetype_f |ft-forth-syntax|
|
|
*.frm g:filetype_frm |ft-form-syntax|
|
|
*.fs g:filetype_fs |ft-forth-syntax|
|
|
*.h g:c_syntax_for_h |ft-c-syntax|
|
|
*.i g:filetype_i |ft-progress-syntax|
|
|
*.inc g:filetype_inc
|
|
*.lsl g:filetype_lsl
|
|
*.m g:filetype_m |ft-mathematica-syntax|
|
|
*.markdown,*.mdown,*.mkd,*.mkdn,*.mdwn,*.md
|
|
g:filetype_md |ft-pandoc-syntax|
|
|
*.mod g:filetype_mod
|
|
*.p g:filetype_p |ft-pascal-syntax|
|
|
*.pl g:filetype_pl
|
|
*.pp g:filetype_pp |ft-pascal-syntax|
|
|
*.prg g:filetype_prg
|
|
*.r g:filetype_r
|
|
*.sig g:filetype_sig
|
|
*.sql g:filetype_sql |ft-sql-syntax|
|
|
*.src g:filetype_src
|
|
*.sys g:filetype_sys
|
|
*.sh g:bash_is_sh |ft-sh-syntax|
|
|
*.tex g:tex_flavor |ft-tex-plugin|
|
|
*.typ g:filetype_typ
|
|
*.v g:filetype_v
|
|
*.w g:filetype_w |ft-cweb-syntax|
|
|
|
|
For a few filetypes the global variable is used only when the filetype could
|
|
not be detected:
|
|
*.r g:filetype_r |ft-rexx-syntax|
|
|
|
|
*filetype-ignore*
|
|
To avoid that certain files are being inspected, the g:ft_ignore_pat variable
|
|
is used. The default value is set like this: >
|
|
:let g:ft_ignore_pat = '\.\(Z\|gz\|bz2\|zip\|tgz\)$'
|
|
This means that the contents of compressed files are not inspected.
|
|
|
|
*new-filetype*
|
|
If a file type that you want to use is not detected yet, there are four ways
|
|
to add it. In any way, it's better not to modify the $VIMRUNTIME/filetype.vim
|
|
file. It will be overwritten when installing a new version of Vim.
|
|
|
|
A. If you want to overrule all default file type checks.
|
|
This works by writing one file for each filetype. The disadvantage is that
|
|
there can be many files. The advantage is that you can simply drop this
|
|
file in the right directory to make it work.
|
|
*ftdetect*
|
|
1. Create your user runtime directory. You would normally use the first
|
|
item of the 'runtimepath' option. Then create the directory "ftdetect"
|
|
inside it. Example for Unix: >
|
|
:!mkdir ~/.vim
|
|
:!mkdir ~/.vim/ftdetect
|
|
<
|
|
2. Create a file that contains an autocommand to detect the file type.
|
|
Example: >
|
|
au BufRead,BufNewFile *.mine set filetype=mine
|
|
< Note that there is no "augroup" command, this has already been done
|
|
when sourcing your file. You could also use the pattern "*" and then
|
|
check the contents of the file to recognize it.
|
|
Write this file as "mine.vim" in the "ftdetect" directory in your user
|
|
runtime directory. For example, for Unix: >
|
|
:w ~/.vim/ftdetect/mine.vim
|
|
|
|
< 3. To use the new filetype detection you must restart Vim.
|
|
|
|
The files in the "ftdetect" directory are used after all the default
|
|
checks, thus they can overrule a previously detected file type. But you
|
|
can also use |:setfiletype| to keep a previously detected filetype.
|
|
|
|
B. If you want to detect your file after the default file type checks.
|
|
|
|
This works like A above, but instead of setting 'filetype' unconditionally
|
|
use ":setfiletype". This will only set 'filetype' if no file type was
|
|
detected yet. Example: >
|
|
au BufRead,BufNewFile *.txt setfiletype text
|
|
<
|
|
You can also use the already detected file type in your command. For
|
|
example, to use the file type "mypascal" when "pascal" has been detected: >
|
|
au BufRead,BufNewFile * if &ft == 'pascal' | set ft=mypascal
|
|
| endif
|
|
|
|
C. If your file type can be detected by the file name.
|
|
1. Create your user runtime directory. You would normally use the first
|
|
item of the 'runtimepath' option. Example for Unix: >
|
|
:!mkdir ~/.vim
|
|
<
|
|
2. Create a file that contains autocommands to detect the file type.
|
|
Example: >
|
|
" my filetype file
|
|
if exists("did_load_filetypes")
|
|
finish
|
|
endif
|
|
augroup filetypedetect
|
|
au! BufRead,BufNewFile *.mine setfiletype mine
|
|
au! BufRead,BufNewFile *.xyz setfiletype drawing
|
|
augroup END
|
|
< Write this file as "filetype.vim" in your user runtime directory. For
|
|
example, for Unix: >
|
|
:w ~/.vim/filetype.vim
|
|
|
|
< 3. To use the new filetype detection you must restart Vim.
|
|
|
|
Your filetype.vim will be sourced before the default FileType autocommands
|
|
have been installed. Your autocommands will match first, and the
|
|
":setfiletype" command will make sure that no other autocommands will set
|
|
'filetype' after this.
|
|
*new-filetype-scripts*
|
|
D. If your filetype can only be detected by inspecting the contents of the
|
|
file.
|
|
|
|
1. Create your user runtime directory. You would normally use the first
|
|
item of the 'runtimepath' option. Example for Unix: >
|
|
:!mkdir ~/.vim
|
|
<
|
|
2. Create a vim script file for doing this. Example: >
|
|
if did_filetype() " filetype already set..
|
|
finish " ..don't do these checks
|
|
endif
|
|
if getline(1) =~ '^#!.*\<mine\>'
|
|
setfiletype mine
|
|
elseif getline(1) =~? '\<drawing\>'
|
|
setfiletype drawing
|
|
endif
|
|
< See $VIMRUNTIME/scripts.vim for more examples.
|
|
Write this file as "scripts.vim" in your user runtime directory. For
|
|
example, for Unix: >
|
|
:w ~/.vim/scripts.vim
|
|
<
|
|
3. The detection will work right away, no need to restart Vim.
|
|
|
|
Your scripts.vim is loaded before the default checks for file types, which
|
|
means that your rules override the default rules in
|
|
$VIMRUNTIME/scripts.vim.
|
|
|
|
*remove-filetype*
|
|
If a file type is detected that is wrong for you, install a filetype.vim or
|
|
scripts.vim to catch it (see above). You can set 'filetype' to a non-existing
|
|
name to avoid that it will be set later anyway: >
|
|
:set filetype=ignored
|
|
|
|
If you are setting up a system with many users, and you don't want each user
|
|
to add/remove the same filetypes, consider writing the filetype.vim and
|
|
scripts.vim files in a runtime directory that is used for everybody. Check
|
|
the 'runtimepath' for a directory to use. If there isn't one, set
|
|
'runtimepath' in the |system-vimrc|. Be careful to keep the default
|
|
directories!
|
|
|
|
|
|
*autocmd-osfiletypes*
|
|
NOTE: this code is currently disabled, as the RISC OS implementation was
|
|
removed. In the future this will use the 'filetype' option.
|
|
|
|
On operating systems which support storing a file type with the file, you can
|
|
specify that an autocommand should only be executed if the file is of a
|
|
certain type.
|
|
|
|
The actual type checking depends on which platform you are running Vim
|
|
on; see your system's documentation for details.
|
|
|
|
To use osfiletype checking in an autocommand you should put a list of types to
|
|
match in angle brackets in place of a pattern, like this: >
|
|
|
|
:au BufRead *.html,<&faf;HTML> runtime! syntax/html.vim
|
|
|
|
This will match:
|
|
|
|
- Any file whose name ends in ".html"
|
|
- Any file whose type is "&faf" or "HTML", where the meaning of these types
|
|
depends on which version of Vim you are using.
|
|
Unknown types are considered NOT to match.
|
|
|
|
You can also specify a type and a pattern at the same time (in which case they
|
|
must both match): >
|
|
|
|
:au BufRead <&fff>diff*
|
|
|
|
This will match files of type "&fff" whose names start with "diff".
|
|
|
|
|
|
*plugin-details*
|
|
The "plugin" directory can be in any of the directories in the 'runtimepath'
|
|
option. All of these directories will be searched for plugins and they are
|
|
all loaded. For example, if this command: >
|
|
|
|
set runtimepath
|
|
|
|
produces this output:
|
|
|
|
runtimepath=/etc/vim,~/.vim,/usr/local/share/vim/vim82 ~
|
|
|
|
then Vim will load all plugins in these directories and below:
|
|
|
|
/etc/vim/plugin/ ~
|
|
~/.vim/plugin/ ~
|
|
/usr/local/share/vim/vim82/plugin/ ~
|
|
|
|
Note that the last one is the value of $VIMRUNTIME which has been expanded.
|
|
|
|
Note that when using a plugin manager or |packages| many directories will be
|
|
added to 'runtimepath'. These plugins each require their own directory, don't
|
|
put them directly in ~/.vim/plugin.
|
|
|
|
What if it looks like your plugin is not being loaded? You can find out what
|
|
happens when Vim starts up by using the |-V| argument: >
|
|
|
|
vim -V2
|
|
|
|
You will see a lot of messages, in between them is a remark about loading the
|
|
plugins. It starts with:
|
|
|
|
Searching for "plugin/**/*.vim" in ~
|
|
|
|
There you can see where Vim looks for your plugin scripts.
|
|
|
|
==============================================================================
|
|
2. Filetype plugin *filetype-plugins*
|
|
|
|
When loading filetype plugins has been enabled |:filetype-plugin-on|, options
|
|
will be set and mappings defined. These are all local to the buffer, they
|
|
will not be used for other files.
|
|
|
|
Defining mappings for a filetype may get in the way of the mappings you
|
|
define yourself. There are a few ways to avoid this:
|
|
1. Set the "maplocalleader" variable to the key sequence you want the mappings
|
|
to start with. Example: >
|
|
:let maplocalleader = ","
|
|
< All mappings will then start with a comma instead of the default, which
|
|
is a backslash. Also see |<LocalLeader>|.
|
|
|
|
2. Define your own mapping. Example: >
|
|
:map ,p <Plug>MailQuote
|
|
< You need to check the description of the plugin file below for the
|
|
functionality it offers and the string to map to.
|
|
You need to define your own mapping before the plugin is loaded (before
|
|
editing a file of that type). The plugin will then skip installing the
|
|
default mapping.
|
|
*no_mail_maps* *g:no_mail_maps*
|
|
3. Disable defining mappings for a specific filetype by setting a variable,
|
|
which contains the name of the filetype. For the "mail" filetype this
|
|
would be: >
|
|
:let no_mail_maps = 1
|
|
< *no_plugin_maps* *g:no_plugin_maps*
|
|
4. Disable defining mappings for all filetypes by setting a variable: >
|
|
:let no_plugin_maps = 1
|
|
<
|
|
|
|
*ftplugin-overrule*
|
|
If a global filetype plugin does not do exactly what you want, there are three
|
|
ways to change this:
|
|
|
|
1. Add a few settings.
|
|
You must create a new filetype plugin in a directory early in
|
|
'runtimepath'. For Unix, for example you could use this file: >
|
|
vim ~/.vim/ftplugin/fortran.vim
|
|
< You can set those settings and mappings that you would like to add. Note
|
|
that the global plugin will be loaded after this, it may overrule the
|
|
settings that you do here. If this is the case, you need to use one of the
|
|
following two methods.
|
|
|
|
2. Make a copy of the plugin and change it.
|
|
You must put the copy in a directory early in 'runtimepath'. For Unix, for
|
|
example, you could do this: >
|
|
cp $VIMRUNTIME/ftplugin/fortran.vim ~/.vim/ftplugin/fortran.vim
|
|
< Then you can edit the copied file to your liking. Since the b:did_ftplugin
|
|
variable will be set, the global plugin will not be loaded.
|
|
A disadvantage of this method is that when the distributed plugin gets
|
|
improved, you will have to copy and modify it again.
|
|
|
|
3. Overrule the settings after loading the global plugin.
|
|
You must create a new filetype plugin in a directory from the end of
|
|
'runtimepath'. For Unix, for example, you could use this file: >
|
|
vim ~/.vim/after/ftplugin/fortran.vim
|
|
< In this file you can change just those settings that you want to change.
|
|
|
|
==============================================================================
|
|
3. Docs for the default filetype plugins. *ftplugin-docs*
|
|
|
|
|
|
*plugin_exec* *g:plugin_exec*
|
|
Enable executing of external commands. This was done historically for e.g.
|
|
the perl filetype plugin (and a few others) to set the search path.
|
|
Disabled by default for security reasons: >
|
|
:let g:plugin_exec = 1
|
|
It is also possible to enable this only for certain filetypes: >
|
|
:let g:<filetype>_exec = 1
|
|
So to enable this only for ruby, set the following variable: >
|
|
:let g:ruby_exec = 1
|
|
|
|
If both, the global `plugin_exec` and the `<filetype>_exec` specific variable
|
|
are set, the filetype specific variable should have precedent.
|
|
|
|
|
|
ASCIIDOC *ft-asciidoc-plugin*
|
|
|
|
To enable |folding| use this: >
|
|
let g:asciidoc_folding = 1
|
|
|
|
To disable nesting of folded headers use this: >
|
|
let g:asciidoc_foldnested = 0
|
|
|
|
To disable folding everything under the title use this: >
|
|
let asciidoc_fold_under_title = 0
|
|
|
|
|
|
ARDUINO *ft-arduino-plugin*
|
|
|
|
By default the following options are set, in accordance with the default
|
|
settings of Arduino IDE: >
|
|
|
|
setlocal expandtab tabstop=2 softtabstop=2 shiftwidth=2
|
|
|
|
To disable this behavior, set the following variable in your vimrc: >
|
|
|
|
let g:arduino_recommended_style = 0
|
|
|
|
|
|
AWK *ft-awk-plugin*
|
|
|
|
Support for features specific to GNU Awk, like @include, can be enabled by
|
|
setting: >
|
|
:let g:awk_is_gawk = 1
|
|
|
|
|
|
CHANGELOG *ft-changelog-plugin*
|
|
|
|
Allows for easy entrance of Changelog entries in Changelog files. There are
|
|
some commands, mappings, and variables worth exploring:
|
|
|
|
Options:
|
|
'comments' is made empty to not mess up formatting.
|
|
'textwidth' is set to 78, which is standard.
|
|
'formatoptions' the 't' flag is added to wrap when inserting text.
|
|
|
|
Commands:
|
|
NewChangelogEntry Adds a new Changelog entry in an intelligent fashion
|
|
(see below).
|
|
|
|
Local mappings:
|
|
<Leader>o Starts a new Changelog entry in an equally intelligent
|
|
fashion (see below).
|
|
|
|
Global mappings:
|
|
NOTE: The global mappings are accessed by sourcing the
|
|
ftplugin/changelog.vim file first, e.g. with >
|
|
runtime ftplugin/changelog.vim
|
|
< in your |.vimrc|.
|
|
<Leader>o Switches to the ChangeLog buffer opened for the
|
|
current directory, or opens it in a new buffer if it
|
|
exists in the current directory. Then it does the
|
|
same as the local <Leader>o described above.
|
|
|
|
Variables:
|
|
g:changelog_timeformat Deprecated; use g:changelog_dateformat instead.
|
|
g:changelog_dateformat The date (and time) format used in ChangeLog entries.
|
|
The format accepted is the same as for the
|
|
|strftime()| function.
|
|
The default is "%Y-%m-%d" which is the standard format
|
|
for many ChangeLog layouts.
|
|
g:changelog_username The name and email address of the user.
|
|
The default is deduced from environment variables and
|
|
system files. It searches /etc/passwd for the comment
|
|
part of the current user, which informally contains
|
|
the real name of the user up to the first separating
|
|
comma. then it checks the $NAME environment variable
|
|
and finally runs `whoami` and `hostname` to build an
|
|
email address. The final form is >
|
|
Full Name <user@host>
|
|
<
|
|
g:changelog_new_date_format
|
|
The format to use when creating a new date-entry.
|
|
The following table describes special tokens in the
|
|
string:
|
|
%% insert a single '%' character
|
|
%d insert the date from above
|
|
%u insert the user from above
|
|
%p insert result of b:changelog_entry_prefix
|
|
%c where to position cursor when done
|
|
The default is "%d %u\n\n\t* %p%c\n\n", which produces
|
|
something like (| is where cursor will be, unless at
|
|
the start of the line where it denotes the beginning
|
|
of the line) >
|
|
|2003-01-14 Full Name <user@host>
|
|
|
|
|
| * prefix|
|
|
<
|
|
g:changelog_new_entry_format
|
|
The format used when creating a new entry.
|
|
The following table describes special tokens in the
|
|
string:
|
|
%p insert result of b:changelog_entry_prefix
|
|
%c where to position cursor when done
|
|
The default is "\t*%c", which produces something
|
|
similar to >
|
|
| * prefix|
|
|
<
|
|
g:changelog_date_entry_search
|
|
The search pattern to use when searching for a
|
|
date-entry.
|
|
The same tokens that can be used for
|
|
g:changelog_new_date_format can be used here as well.
|
|
The default is '^\s*%d\_s*%u' which finds lines
|
|
matching the form >
|
|
|2003-01-14 Full Name <user@host>
|
|
< and some similar formats.
|
|
|
|
g:changelog_date_end_entry_search
|
|
The search pattern to use when searching for the end
|
|
of a date-entry.
|
|
The same tokens that can be used for
|
|
g:changelog_new_date_format can be used here as well.
|
|
The default is '^\s*$' which finds lines that contain
|
|
only whitespace or are completely empty.
|
|
|
|
b:changelog_name *b:changelog_name*
|
|
Name of the ChangeLog file to look for.
|
|
The default is 'ChangeLog'.
|
|
|
|
b:changelog_path
|
|
Path of the ChangeLog to use for the current buffer.
|
|
The default is empty, thus looking for a file named
|
|
|b:changelog_name| in the same directory as the
|
|
current buffer. If not found, the parent directory of
|
|
the current buffer is searched. This continues
|
|
recursively until a file is found or there are no more
|
|
parent directories to search.
|
|
|
|
b:changelog_entry_prefix
|
|
Name of a function to call to generate a prefix to a
|
|
new entry. This function takes no arguments and
|
|
should return a string containing the prefix.
|
|
Returning an empty prefix is fine.
|
|
The default generates the shortest path between the
|
|
ChangeLog's pathname and the current buffers pathname.
|
|
In the future, it will also be possible to use other
|
|
variable contexts for this variable, for example, g:.
|
|
|
|
The Changelog entries are inserted where they add the least amount of text.
|
|
After figuring out the current date and user, the file is searched for an
|
|
entry beginning with the current date and user and if found adds another item
|
|
under it. If not found, a new entry and item is prepended to the beginning of
|
|
the Changelog.
|
|
|
|
|
|
FORTRAN *ft-fortran-plugin*
|
|
|
|
Options:
|
|
'expandtab' is switched on to avoid tabs as required by the Fortran
|
|
standards unless the user has set fortran_have_tabs in .vimrc.
|
|
'textwidth' is set to 80 for fixed source format whereas it is set to 132
|
|
for free source format. Setting the fortran_extended_line_length
|
|
variable increases the width to 132 for fixed source format.
|
|
'formatoptions' is set to break code and comment lines and to preserve long
|
|
lines. You can format comments with |gq|.
|
|
For further discussion of fortran_have_tabs and the method used for the
|
|
detection of source format see |ft-fortran-syntax|.
|
|
|
|
|
|
FREEBASIC *ft-freebasic-plugin*
|
|
|
|
This plugin aims to treat the four FreeBASIC dialects, "fb", "qb", "fblite"
|
|
and "deprecated", as distinct languages.
|
|
|
|
The dialect will be set to the first name found in g:freebasic_forcelang, any
|
|
#lang directive or $lang metacommand in the file being edited, or finally
|
|
g:freebasic_lang. These global variables conceptually map to the fbc options
|
|
-forcelang and -lang. If no dialect is explicitly specified "fb" will be
|
|
used.
|
|
|
|
For example, to set the dialect to a default of "fblite" but still allow for
|
|
any #lang directive overrides, use the following command: >
|
|
|
|
let g:freebasic_lang = "fblite"
|
|
|
|
|
|
GDSCRIPT *ft-gdscript-plugin*
|
|
|
|
By default the following options are set, based on Godot official docs: >
|
|
|
|
setlocal noexpandtab softtabstop=0 shiftwidth=0
|
|
|
|
To disable this behavior, set the following variable in your vimrc: >
|
|
|
|
let g:gdscript_recommended_style = 0
|
|
|
|
|
|
GIT COMMIT *ft-gitcommit-plugin*
|
|
|
|
One command, :DiffGitCached, is provided to show a diff of the current commit
|
|
in the preview window. It is equivalent to calling "git diff --cached" plus
|
|
any arguments given to the command.
|
|
|
|
GIT REBASE *ft-gitrebase-plugin*
|
|
|
|
The gitrebase filetype defines the following buffer-local commands, to help
|
|
with interactive `git rebase`: >
|
|
|
|
:Drop " to discard this commit
|
|
:Edit " to stop for editing this commit
|
|
:Fixup " to squash (but discard the message) into the previous one
|
|
:Pick " to pick this commit (the cursor is on)
|
|
:Reword " to pick this commit, but change the commit message
|
|
:Squash " to squash this commit into the previous one
|
|
|
|
In addition, the following comamnd can be used to cycle between the different
|
|
possibilities: >
|
|
|
|
:Cycle " to cycle between the previous commands
|
|
<
|
|
The `:Cycle` command is also mapped to the CTRL-A and CTRL-X keys.
|
|
For details, see `git-rebase --help`.
|
|
|
|
GO *ft-go-plugin*
|
|
|
|
By default the following options are set, based on Golang official docs: >
|
|
|
|
setlocal noexpandtab softtabstop=0 shiftwidth=0
|
|
|
|
To disable this behavior, set the following variable in your vimrc: >
|
|
|
|
let g:go_recommended_style = 0
|
|
|
|
|
|
GPROF *ft-gprof-plugin*
|
|
|
|
The gprof filetype plugin defines a mapping <C-]> to jump from a function
|
|
entry in the gprof flat profile or from a function entry in the call graph
|
|
to the details of that function in the call graph.
|
|
|
|
The mapping can be disabled with: >
|
|
let g:no_gprof_maps = 1
|
|
|
|
|
|
HARE *ft-hare*
|
|
|
|
Since the text for this plugin is rather long it has been put in a separate
|
|
file: |ft_hare.txt|.
|
|
|
|
IDRIS2 *ft-idris2-plugin*
|
|
|
|
By default the following options are set: >
|
|
|
|
setlocal shiftwidth=2 tabstop=2 expandtab
|
|
setlocal comments=s1:{-,mb:-,ex:-},:\|\|\|,:--
|
|
setlocal commentstring=--\ %s
|
|
setlocal wildignore+=*.ibc
|
|
|
|
To use tabs instead of spaces for indentation, set the following variable
|
|
in your vimrc: >
|
|
|
|
let g:idris2#allow_tabchar = 1
|
|
|
|
JAVA *ft-java-plugin*
|
|
|
|
Whenever the variable "g:ftplugin_java_source_path" is defined and its value
|
|
is a filename whose extension is either ".jar" or ".zip", e.g.: >
|
|
let g:ftplugin_java_source_path = '/path/to/src.jar'
|
|
let g:ftplugin_java_source_path = '/path/to/src.zip'
|
|
<
|
|
and the |zip| plugin has already been sourced, the |gf| command can be used to
|
|
open the archive and the |n| command can be used to look for the selected type
|
|
and the <Return> key can be used to load a listed file.
|
|
|
|
Note that the effect of using the "gf" command WITHIN a buffer loaded with the
|
|
Zip plugin depends on the version of the Zip plugin. For the Zip plugin
|
|
versions that do not support Jar type archives, consider creating symbolic
|
|
links with the ".zip" extension for each Jar archive of interest and assigning
|
|
any such file to the variable from now on.
|
|
|
|
Otherwise, for the defined variable "g:ftplugin_java_source_path", the local
|
|
value of the 'path' option will be further modified by prefixing the value of
|
|
the variable, e.g.: >
|
|
let g:ftplugin_java_source_path = $JDK_SRC_PATH
|
|
let &l:path = g:ftplugin_java_source_path . ',' . &l:path
|
|
<
|
|
and the "gf" command can be used on a fully-qualified type to look for a file
|
|
in the "path" and to try to load it.
|
|
|
|
Remember to manually trigger the |FileType| event from a buffer with a Java
|
|
file loaded in it each time after assigning a new value to the variable: >
|
|
doautocmd FileType
|
|
<
|
|
Markdown documentation comments may contain common runs of vertical leading
|
|
whitespace following the comment marks (`///`) for aesthetic reasons; however,
|
|
some horizontal runs of leading whitespace are significant in Markdown because
|
|
they denote code blocks etc. For convenience, a 'formatexpr' function is
|
|
provided for the |gq| operator. As long as neither "g:java_ignore_javadoc"
|
|
nor "g:java_ignore_markdown" is defined, the reformatting of Markdown comments
|
|
can be enabled on demand with: >
|
|
setlocal formatexpr=g:javaformat#RemoveCommonMarkdownWhitespace()
|
|
<
|
|
Or for Vim versions less than `7.4.265`, with: >
|
|
setlocal formatexpr=javaformat#RemoveCommonMarkdownWhitespace()
|
|
<
|
|
This function accepts a range of lines, removes a common run of vertical
|
|
leading whitespace, and rewrites the lines of the range. Depending on the
|
|
author's layout style and the comment contents, which lines to select for
|
|
reformatting can vary from the whole comment to only some portion of it.
|
|
|
|
To enable the recognition of Markdown comments each time after removing
|
|
"g:java_ignore_markdown" or "g:java_ignore_javadoc", remember to manually
|
|
re-source "javaformat.vim" for Vim versions greater than `8.2.1397`: >
|
|
runtime autoload/javaformat.vim
|
|
<
|
|
JSON-FORMAT *ft-json-plugin*
|
|
|
|
JSON filetype can be extended to use 'formatexpr' and "json.FormatExpr()"
|
|
function for json formatting (using |gq|).
|
|
|
|
Add following lines to $HOME/.vim/ftplugin/json.vim: >
|
|
|
|
vim9script
|
|
import autoload 'dist/json.vim'
|
|
setl formatexpr=json.FormatExpr()
|
|
|
|
LUA *ft-lua-plugin* *g:lua_folding*
|
|
|
|
You can enable folding of Lua functions using |fold-expr| by: >
|
|
|
|
let g:lua_folding = 1
|
|
< *g:lua_version* *g:lua_subversion*
|
|
Lua filetype's 'includeexpr' and |ft-lua-syntax| highlighting use the global
|
|
variables "g:lua_version" and "g:lua_subversion" to determine the version of
|
|
Lua to use (5.3 is the default)
|
|
|
|
For example, to use Lua 5.1, set the variables like this: >
|
|
|
|
let g:lua_version = 5
|
|
let g:lua_subversion = 1
|
|
<
|
|
MAIL *ft-mail-plugin*
|
|
|
|
Options:
|
|
'modeline' is switched off to avoid the danger of trojan horses, and to
|
|
avoid that a Subject line with "Vim:" in it will cause an
|
|
error message.
|
|
'textwidth' is set to 72. This is often recommended for e-mail.
|
|
'formatoptions' is set to break text lines and to repeat the comment leader
|
|
in new lines, so that a leading ">" for quotes is repeated.
|
|
You can also format quoted text with |gq|.
|
|
|
|
Local mappings:
|
|
<LocalLeader>q or \MailQuote
|
|
Quotes the text selected in Visual mode, or from the cursor position
|
|
to the end of the file in Normal mode. This means "> " is inserted in
|
|
each line.
|
|
|
|
MAN *ft-man-plugin* *:Man* *:ManReload* *man.vim*
|
|
|
|
This plugin displays a manual page in a nice way. See |find-manpage| in the
|
|
user manual for more information.
|
|
|
|
To start using the |:Man| command before any manual page has been loaded,
|
|
source this script from your startup |vimrc| file: >
|
|
runtime ftplugin/man.vim
|
|
|
|
Options:
|
|
'iskeyword' The '.' character is added to support the use of CTRL-] on the
|
|
manual page name.
|
|
|
|
Commands:
|
|
Man {name} Display the manual page for {name} in a window.
|
|
Man {number} {name}
|
|
Display the manual page for {name} in a section {number}.
|
|
ManReload Reload the cache of available man pages used for |:Man| argument
|
|
completion.
|
|
|
|
Global mapping:
|
|
<Leader>K Displays the manual page for the word under the cursor.
|
|
<Plug>ManPreGetPage
|
|
idem, allows for using a mapping: >
|
|
nmap <F1> <Plug>ManPreGetPage
|
|
|
|
Local mappings:
|
|
<Plug>ManBS
|
|
<LocalLeader>h Clear backspace <BS> characters from the buffer.
|
|
CTRL-] Jump to the manual page for the word under the cursor.
|
|
CTRL-T Jump back to the previous manual page.
|
|
|
|
The mappings can be disabled with: >
|
|
let g:no_man_maps = 1
|
|
|
|
To use a vertical split instead of horizontal: >
|
|
let g:ft_man_open_mode = 'vert'
|
|
To use a new tab: >
|
|
let g:ft_man_open_mode = 'tab'
|
|
|
|
To enable |folding|, use this: >
|
|
let g:ft_man_folding_enable = 1
|
|
If you do not like the default folding, use an |autocommand| to add your
|
|
desired folding style instead. For example: >
|
|
autocmd FileType man setlocal foldmethod=indent foldenable
|
|
|
|
If you would like :Man {number} {name} to behave like man {number} {name} by
|
|
not running man {name} if no page is found, then use this: >
|
|
let g:ft_man_no_sect_fallback = 1
|
|
<
|
|
*g:ft_man_implementation*
|
|
The completion for the :Man command tries to guess which implementation of man
|
|
the system has. If it guesses wrong, you can set g:ft_man_implementation to
|
|
one of these values:
|
|
'man-db' https://man-db.nongnu.org/
|
|
'' Unknown, fall back to completing shell commands
|
|
instead of man pages.
|
|
|
|
You may also want to set 'keywordprg' to make the |K| command open a manual
|
|
page in a Vim window: >
|
|
set keywordprg=:Man
|
|
|
|
|
|
MANPAGER *manpager.vim*
|
|
|
|
The |:Man| command allows you to turn Vim into a manpager (that syntax
|
|
highlights manpages and follows linked manpages on hitting CTRL-]).
|
|
|
|
For bash,zsh,ksh or dash, add to the config file (.bashrc,.zshrc, ...)
|
|
|
|
export MANPAGER="vim +MANPAGER --not-a-term -"
|
|
|
|
For (t)csh, add to the config file
|
|
|
|
setenv MANPAGER "vim +MANPAGER --not-a-term -"
|
|
|
|
For fish, add to the config file
|
|
|
|
set -x MANPAGER "vim +MANPAGER --not-a-term -"
|
|
|
|
|
|
MARKDOWN *ft-markdown-plugin*
|
|
|
|
To enable folding use this: >
|
|
let g:markdown_folding = 1
|
|
|
|
'expandtab' will be set by default. If you do not want that use this: >
|
|
let g:markdown_recommended_style = 0
|
|
|
|
|
|
ORG *ft-org-plugin*
|
|
|
|
To enable folding use this: >
|
|
let g:org_folding = 1
|
|
<
|
|
|
|
PDF *ft-pdf-plugin*
|
|
|
|
Two maps, <C-]> and <C-T>, are provided to simulate a tag stack for navigating
|
|
the PDF. The following are treated as tags:
|
|
|
|
- The byte offset after "startxref" to the xref table
|
|
- The byte offset after the /Prev key in the trailer to an earlier xref table
|
|
- A line of the form "0123456789 00000 n" in the xref table
|
|
- An object reference like "1 0 R" anywhere in the PDF
|
|
|
|
These maps can be disabled with >
|
|
:let g:no_pdf_maps = 1
|
|
|
|
PLSQL *ft-plsql-plugin*
|
|
|
|
To enable syntax folding in PL/SQL filetypes, set the following variable: >
|
|
|
|
:let g:plsql_fold = 1
|
|
<
|
|
|
|
PYTHON *ft-python-plugin* *PEP8*
|
|
|
|
By default the following options are set, in accordance with PEP8: >
|
|
|
|
setlocal expandtab shiftwidth=4 softtabstop=4 tabstop=8
|
|
|
|
To disable this behavior, set the following variable in your vimrc: >
|
|
|
|
let g:python_recommended_style = 0
|
|
|
|
|
|
QF QUICKFIX *qf.vim* *ft-qf-plugin*
|
|
|
|
The "qf" filetype is used for the quickfix window, see |quickfix-window|.
|
|
|
|
The quickfix filetype plugin includes configuration for displaying the command
|
|
that produced the quickfix list in the |status-line|. To disable this setting,
|
|
configure as follows: >
|
|
:let g:qf_disable_statusline = 1
|
|
|
|
|
|
R MARKDOWN *ft-rmd-plugin*
|
|
|
|
By default ftplugin/html.vim is not sourced. If you want it sourced, add to
|
|
your |vimrc|: >
|
|
let rmd_include_html = 1
|
|
|
|
The 'formatexpr' option is set dynamically with different values for R code
|
|
and for Markdown code. If you prefer that 'formatexpr' is not set, add to your
|
|
|vimrc|: >
|
|
let rmd_dynamic_comments = 0
|
|
|
|
|
|
R RESTRUCTURED TEXT *ft-rrst-plugin*
|
|
|
|
The 'formatexpr' option is set dynamically with different values for R code
|
|
and for ReStructured text. If you prefer that 'formatexpr' is not set, add to
|
|
your |vimrc|: >
|
|
let rrst_dynamic_comments = 0
|
|
|
|
|
|
RESTRUCTUREDTEXT *ft-rst-plugin*
|
|
|
|
The following formatting setting are optionally available: >
|
|
setlocal expandtab shiftwidth=3 softtabstop=3 tabstop=8
|
|
|
|
To enable this behavior, set the following variable in your vimrc: >
|
|
let g:rst_style = 1
|
|
|
|
|
|
RNOWEB *ft-rnoweb-plugin*
|
|
|
|
The 'formatexpr' option is set dynamically with different values for R code
|
|
and for LaTeX code. If you prefer that 'formatexpr' is not set, add to your
|
|
|vimrc|: >
|
|
let rnw_dynamic_comments = 0
|
|
|
|
|
|
RPM SPEC *ft-spec-plugin*
|
|
|
|
Since the text for this plugin is rather long it has been put in a separate
|
|
file: |pi_spec.txt|.
|
|
|
|
|
|
RUST *ft-rust*
|
|
|
|
Since the text for this plugin is rather long it has been put in a separate
|
|
file: |ft_rust.txt|.
|
|
|
|
|
|
SQL *ft-sql*
|
|
|
|
Since the text for this plugin is rather long it has been put in a separate
|
|
file: |ft_sql.txt|.
|
|
|
|
|
|
TEX *ft-tex-plugin* *g:tex_flavor*
|
|
|
|
If the first line of a *.tex file has the form >
|
|
%&<format>
|
|
then this determined the file type: plaintex (for plain TeX), context (for
|
|
ConTeXt), or tex (for LaTeX). Otherwise, the file is searched for keywords to
|
|
choose context or tex. If no keywords are found, it defaults to plaintex.
|
|
You can change the default by defining the variable g:tex_flavor to the format
|
|
(not the file type) you use most. Use one of these: >
|
|
let g:tex_flavor = "plain"
|
|
let g:tex_flavor = "context"
|
|
let g:tex_flavor = "latex"
|
|
Currently no other formats are recognized.
|
|
|
|
TYPST *ft-typst-plugin*
|
|
|
|
*g:typst_conceal*
|
|
When |TRUE| the Typst filetype plugin will set the 'conceallevel' option to 2.
|
|
|
|
*g:typst_folding*
|
|
When |TRUE| the Typst filetype plugin will fold headings. (default: |FALSE|)
|
|
|
|
To enable: >
|
|
let g:typst_folding = 1
|
|
<
|
|
*g:typst_foldnested*
|
|
When |TRUE| the Typst filetype plugin will fold nested heading under their
|
|
parents. (default: |TRUE|)
|
|
|
|
To disable: >
|
|
let g:typst_foldnested = 0
|
|
<
|
|
VIM *ft-vim-plugin*
|
|
|
|
The Vim filetype plugin defines mappings to move to the start and end of
|
|
functions with [[ and ]]. Move around comments with ]" and [".
|
|
|
|
The mappings can be disabled with: >
|
|
let g:no_vim_maps = 1
|
|
|
|
|
|
ZIG *ft-zig-plugin*
|
|
|
|
*g:zig_recommended_style*
|
|
By default the following indentation options are set, in accordance with Zig's
|
|
recommended style (https://ziglang.org/documentation/master/): >
|
|
|
|
setlocal expandtab shiftwidth=4 softtabstop=4 tabstop=8
|
|
<
|
|
To disable this behavior, set |g:zig_recommended_style| to 0: >
|
|
|
|
let g:zig_recommended_style = 0
|
|
<
|
|
*g:zig_std_dir*
|
|
The path to the Zig standard library. The Zig |ftplugin| reads |g:zig_std_dir|
|
|
and appends it to the 'path' for Zig files. Where the Zig standard library
|
|
is located is system and installation method dependent.
|
|
|
|
One can automatically set |g:zig_std_dir| using `zig env`: >
|
|
|
|
let g:zig_std_dir = json_decode(system('zig env'))['std_dir']
|
|
<
|
|
This can, for example, be put in a FileType |:autocmd| or user |ftplugin| to
|
|
only load when a Zig file is opened.
|
|
|
|
|
|
ZIMBU *ft-zimbu-plugin*
|
|
|
|
The Zimbu filetype plugin defines mappings to move to the start and end of
|
|
functions with [[ and ]].
|
|
|
|
The mappings can be disabled with: >
|
|
let g:no_zimbu_maps = 1
|
|
<
|
|
|
|
|
|
vim:tw=78:ts=8:noet:ft=help:norl:
|