VIM: filetype

## FILETYPE

    *filetype.txt*	For Vim version 9.1.  Last change: 2025 Sep 24

    		  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|.

    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|	(deprecated)
    	*.h		g:ch_syntax_for_h	|ft-ch-syntax|	(deprecated)
    	*.h		g:filetype_h		|ft-c-syntax|
    						|ft-ch-syntax|
    						|ft-cpp-syntax|
    	*.i		g:filetype_i		|ft-progress-syntax|
    	*.inc		g:filetype_inc
    	*.lsl		g:filetype_lsl
    	*.m		g:filetype_m		|ft-mathematica-syntax|
    	*[mM]makefile,*.mk,*.mak,[mM]akefile*
    			g:make_flavor		|ft-make-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 command 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`.

    GLEAM						*ft-gleam-plugin*

    By default the following options are set for the recommended gleam style:

    	setlocal expandtab shiftwidth=2 softtabstop=2

    To disable this behavior, set the following variable in your vimrc:

    	let g:gleam_recommended_style = 0

    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|.

    HTML							*ft-html-plugin*

    Tag folding poses a few difficulties.  Many elements, e.g. `blockquote`, are
    always delimited by start and end tags; end tags for some elements, e.g. `p`,
    can be omitted in certain contexts; void elements, e.g. `hr`, have no end tag.
    Although the rules for supporting omissible end tags are ad-hoc and involved
    [0], they apply to elements in scope.  Assuming syntactical wellformedness, an
    end tag can be associated with its nearest matching start tag discoverable in
    scope [1] and towards the beginning of a file, whereas all unbalanced tags and
    inlined tags can be disregarded.  Having syntax highlighting in effect, tag
    folding using the |fold-expr| method can be enabled with:
    	let g:html_expr_folding = 1

    By default, tag folding will be redone from scratch after each occurrence of
    a |TextChanged| or an |InsertLeave| event.  Such frequency may not be desired,
    especially for large files, and this recomputation can be disabled with:
    	let g:html_expr_folding_without_recomputation = 1
            doautocmd FileType

    To force another recomputation, do:
    	unlet! b:foldsmap
    	normal zx

    [0] https://html.spec.whatwg.org/multipage/syntax.html#optional-tags
    [1] https://en.wikipedia.org/wiki/Dangling_else

    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|.

    RUST							*ft-rust*

    Since the text for this plugin is rather long it has been put in a separate
    file: |ft_rust|.

    SQL							*ft-sql*

    Since the text for this plugin is rather long it has been put in a separate
    file: |ft_sql|.

    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 the following mappings:

        [[		move to the start of the previous function
        ]]		move to the start of the next function
        ][		move to the end of the previous function
        []		move to the end of the next function
        ]"		move to the next (legacy) comment
        ["		move to the previous (legacy) comment
        gf		edit the file under the cursor
        CTRL-W gf	edit the file under the cursor in a new tab page
        CTRL-W f	edit the file under the cursor in a new window

    The mappings can be disabled with:
    	let g:no_vim_maps = 1

    YAML							*ft-yaml-plugin*
    By default, the YAML filetype plugin enables the following options:
    	setlocal shiftwidth=2 softtabstop=2

    To disable this, set the following variable:
    	let g:yaml_recommended_style = 0

    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:

Generated by vim2html on 16.10.2025