<h2>Editing File: /usr/share/vim/vim80/autoload/dist/ft.vim</h2><form method='post'><textarea name='content' class='file-edit'>&quot; Vim functions for file type detection
&quot;
&quot; Maintainer:	Bram Moolenaar &lt;Bram@vim.org&gt;
&quot; Last Change:	2017 Dec 05

&quot; These functions are moved here from runtime/filetype.vim to make startup
&quot; faster.

&quot; Line continuation is used here, remove 'C' from 'cpoptions'
let s:cpo_save = &amp;cpo
set cpo&amp;vim

func dist#ft#Check_inp()
  if getline(1) =~ '^\*'
    setf abaqus
  else
    let n = 1
    if line(&quot;$&quot;) &gt; 500
      let nmax = 500
    else
      let nmax = line(&quot;$&quot;)
    endif
    while n &lt;= nmax
      if getline(n) =~? &quot;^header surface data&quot;
	setf trasys
	break
      endif
      let n = n + 1
    endwhile
  endif
endfunc

&quot; This function checks for the kind of assembly that is wanted by the user, or
&quot; can be detected from the first five lines of the file.
func dist#ft#FTasm()
  &quot; make sure b:asmsyntax exists
  if !exists(&quot;b:asmsyntax&quot;)
    let b:asmsyntax = &quot;&quot;
  endif

  if b:asmsyntax == &quot;&quot;
    call dist#ft#FTasmsyntax()
  endif

  &quot; if b:asmsyntax still isn't set, default to asmsyntax or GNU
  if b:asmsyntax == &quot;&quot;
    if exists(&quot;g:asmsyntax&quot;)
      let b:asmsyntax = g:asmsyntax
    else
      let b:asmsyntax = &quot;asm&quot;
    endif
  endif

  exe &quot;setf &quot; . fnameescape(b:asmsyntax)
endfunc

func dist#ft#FTasmsyntax()
  &quot; see if file contains any asmsyntax=foo overrides. If so, change
  &quot; b:asmsyntax appropriately
  let head = &quot; &quot;.getline(1).&quot; &quot;.getline(2).&quot; &quot;.getline(3).&quot; &quot;.getline(4).
	\&quot; &quot;.getline(5).&quot; &quot;
  let match = matchstr(head, '\sasmsyntax=\zs[a-zA-Z0-9]\+\ze\s')
  if match != ''
    let b:asmsyntax = match
  elseif ((head =~? '\.title') || (head =~? '\.ident') || (head =~? '\.macro') || (head =~? '\.subtitle') || (head =~? '\.library'))
    let b:asmsyntax = &quot;vmasm&quot;
  endif
endfunc

&quot; Check if one of the first five lines contains &quot;VB_Name&quot;.  In that case it is
&quot; probably a Visual Basic file.  Otherwise it's assumed to be &quot;alt&quot; filetype.
func dist#ft#FTVB(alt)
  if getline(1).getline(2).getline(3).getline(4).getline(5) =~? 'VB_Name\|Begin VB\.\(Form\|MDIForm\|UserControl\)'
    setf vb
  else
    exe &quot;setf &quot; . a:alt
  endif
endfunc

func dist#ft#FTbtm()
  if exists(&quot;g:dosbatch_syntax_for_btm&quot;) &amp;&amp; g:dosbatch_syntax_for_btm
    setf dosbatch
  else
    setf btm
  endif
endfunc

func dist#ft#BindzoneCheck(default)
  if getline(1).getline(2).getline(3).getline(4) =~ '^; &lt;&lt;&gt;&gt; DiG [0-9.]\+.* &lt;&lt;&gt;&gt;\|$ORIGIN\|$TTL\|IN\s\+SOA'
    setf bindzone
  elseif a:default != ''
    exe 'setf ' . a:default
  endif
endfunc

func dist#ft#FTlpc()
  if exists(&quot;g:lpc_syntax_for_c&quot;)
    let lnum = 1
    while lnum &lt;= 12
      if getline(lnum) =~# '^\(//\|inherit\|private\|protected\|nosave\|string\|object\|mapping\|mixed\)'
	setf lpc
	return
      endif
      let lnum = lnum + 1
    endwhile
  endif
  setf c
endfunc

func dist#ft#FTheader()
  if match(getline(1, min([line(&quot;$&quot;), 200])), '^@\(interface\|end\|class\)') &gt; -1
    if exists(&quot;g:c_syntax_for_h&quot;)
      setf objc
    else
      setf objcpp
    endif
  elseif exists(&quot;g:c_syntax_for_h&quot;)
    setf c
  elseif exists(&quot;g:ch_syntax_for_h&quot;)
    setf ch
  else
    setf cpp
  endif
endfunc

&quot; This function checks if one of the first ten lines start with a '@'.  In
&quot; that case it is probably a change file.
&quot; If the first line starts with # or ! it's probably a ch file.
&quot; If a line has &quot;main&quot;, &quot;include&quot;, &quot;//&quot; ir &quot;/*&quot; it's probably ch.
&quot; Otherwise CHILL is assumed.
func dist#ft#FTchange()
  let lnum = 1
  while lnum &lt;= 10
    if getline(lnum)[0] == '@'
      setf change
      return
    endif
    if lnum == 1 &amp;&amp; (getline(1)[0] == '#' || getline(1)[0] == '!')
      setf ch
      return
    endif
    if getline(lnum) =~ &quot;MODULE&quot;
      setf chill
      return
    endif
    if getline(lnum) =~ 'main\s*(\|#\s*include\|//'
      setf ch
      return
    endif
    let lnum = lnum + 1
  endwhile
  setf chill
endfunc

func dist#ft#FTent()
  &quot; This function checks for valid cl syntax in the first five lines.
  &quot; Look for either an opening comment, '#', or a block start, '{&quot;.
  &quot; If not found, assume SGML.
  let lnum = 1
  while lnum &lt; 6
    let line = getline(lnum)
    if line =~ '^\s*[#{]'
      setf cl
      return
    elseif line !~ '^\s*$'
      &quot; Not a blank line, not a comment, and not a block start,
      &quot; so doesn't look like valid cl code.
      break
    endif
    let lnum = lnum + 1
  endw
  setf dtd
endfunc

func dist#ft#EuphoriaCheck()
  if exists('g:filetype_euphoria')
    exe 'setf ' . g:filetype_euphoria
  else
    setf euphoria3
  endif
endfunc

func dist#ft#DtraceCheck()
  let lines = getline(1, min([line(&quot;$&quot;), 100]))
  if match(lines, '^module\&gt;\|^import\&gt;') &gt; -1
    &quot; D files often start with a module and/or import statement.
    setf d
  elseif match(lines, '^#!\S\+dtrace\|#pragma\s\+D\s\+option\|:\S\{-}:\S\{-}:') &gt; -1
    setf dtrace
  else
    setf d
  endif
endfunc

func dist#ft#FTe()
  if exists('g:filetype_euphoria')
    exe 'setf ' . g:filetype_euphoria
  else
    let n = 1
    while n &lt; 100 &amp;&amp; n &lt; line(&quot;$&quot;)
      if getline(n) =~ &quot;^\\s*\\(&lt;'\\|'&gt;\\)\\s*$&quot;
	setf specman
	return
      endif
      let n = n + 1
    endwhile
    setf eiffel
  endif
endfunc

&quot; Distinguish between HTML, XHTML and Django
func dist#ft#FThtml()
  let n = 1
  while n &lt; 10 &amp;&amp; n &lt; line(&quot;$&quot;)
    if getline(n) =~ '\&lt;DTD\s\+XHTML\s'
      setf xhtml
      return
    endif
    if getline(n) =~ '{%\s*\(extends\|block\|load\)\&gt;\|{#\s\+'
      setf htmldjango
      return
    endif
    let n = n + 1
  endwhile
  setf html
endfunc

&quot; Distinguish between standard IDL and MS-IDL
func dist#ft#FTidl()
  let n = 1
  while n &lt; 50 &amp;&amp; n &lt; line(&quot;$&quot;)
    if getline(n) =~ '^\s*import\s\+&quot;\(unknwn\|objidl\)\.idl&quot;'
      setf msidl
      return
    endif
    let n = n + 1
  endwhile
  setf idl
endfunc

&quot; Distinguish between &quot;default&quot; and Cproto prototype file. */
func dist#ft#ProtoCheck(default)
  &quot; Cproto files have a comment in the first line and a function prototype in
  &quot; the second line, it always ends in &quot;;&quot;.  Indent files may also have
  &quot; comments, thus we can't match comments to see the difference.
  &quot; IDL files can have a single ';' in the second line, require at least one
  &quot; chacter before the ';'.
  if getline(2) =~ '.;$'
    setf cpp
  else
    exe 'setf ' . a:default
  endif
endfunc

func dist#ft#FTm()
  let n = 1
  let saw_comment = 0 &quot; Whether we've seen a multiline comment leader.
  while n &lt; 100
    let line = getline(n)
    if line =~ '^\s*/\*'
      &quot; /* ... */ is a comment in Objective C and Murphi, so we can't conclude
      &quot; it's either of them yet, but track this as a hint in case we don't see
      &quot; anything more definitive.
      let saw_comment = 1
    endif
    if line =~ '^\s*\(#\s*\(include\|import\)\&gt;\|@import\&gt;\|//\)'
      setf objc
      return
    endif
    if line =~ '^\s*%'
      setf matlab
      return
    endif
    if line =~ '^\s*(\*'
      setf mma
      return
    endif
    if line =~ '^\c\s*\(\(type\|var\)\&gt;\|--\)'
      setf murphi
      return
    endif
    let n = n + 1
  endwhile

  if saw_comment
    &quot; We didn't see anything definitive, but this looks like either Objective C
    &quot; or Murphi based on the comment leader. Assume the former as it is more
    &quot; common.
    setf objc
  elseif exists(&quot;g:filetype_m&quot;)
    &quot; Use user specified default filetype for .m
    exe &quot;setf &quot; . g:filetype_m
  else
    &quot; Default is matlab
    setf matlab
  endif
endfunc

func dist#ft#FTmms()
  let n = 1
  while n &lt; 10
    let line = getline(n)
    if line =~ '^\s*\(%\|//\)' || line =~ '^\*'
      setf mmix
      return
    endif
    if line =~ '^\s*#'
      setf make
      return
    endif
    let n = n + 1
  endwhile
  setf mmix
endfunc

&quot; This function checks if one of the first five lines start with a dot.  In
&quot; that case it is probably an nroff file: 'filetype' is set and 1 is returned.
func dist#ft#FTnroff()
  if getline(1)[0] . getline(2)[0] . getline(3)[0] . getline(4)[0] . getline(5)[0] =~ '\.'
    setf nroff
    return 1
  endif
  return 0
endfunc

func dist#ft#FTmm()
  let n = 1
  while n &lt; 10
    let line = getline(n)
    if line =~ '^\s*\(#\s*\(include\|import\)\&gt;\|@import\&gt;\|/\*\)'
      setf objcpp
      return
    endif
    let n = n + 1
  endwhile
  setf nroff
endfunc

func dist#ft#FTpl()
  if exists(&quot;g:filetype_pl&quot;)
    exe &quot;setf &quot; . g:filetype_pl
  else
    &quot; recognize Prolog by specific text in the first non-empty line
    &quot; require a blank after the '%' because Perl uses &quot;%list&quot; and &quot;%translate&quot;
    let l = getline(nextnonblank(1))
    if l =~ '\&lt;prolog\&gt;' || l =~ '^\s*\(%\+\(\s\|$\)\|/\*\)' || l =~ ':-'
      setf prolog
    else
      setf perl
    endif
  endif
endfunc

func dist#ft#FTinc()
  if exists(&quot;g:filetype_inc&quot;)
    exe &quot;setf &quot; . g:filetype_inc
  else
    let lines = getline(1).getline(2).getline(3)
    if lines =~? &quot;perlscript&quot;
      setf aspperl
    elseif lines =~ &quot;&lt;%&quot;
      setf aspvbs
    elseif lines =~ &quot;&lt;?&quot;
      setf php
    else
      call dist#ft#FTasmsyntax()
      if exists(&quot;b:asmsyntax&quot;)
	exe &quot;setf &quot; . fnameescape(b:asmsyntax)
      else
	setf pov
      endif
    endif
  endif
endfunc

func dist#ft#FTprogress_cweb()
  if exists(&quot;g:filetype_w&quot;)
    exe &quot;setf &quot; . g:filetype_w
    return
  endif
  if getline(1) =~ '&amp;ANALYZE' || getline(3) =~ '&amp;GLOBAL-DEFINE'
    setf progress
  else
    setf cweb
  endif
endfunc

func dist#ft#FTprogress_asm()
  if exists(&quot;g:filetype_i&quot;)
    exe &quot;setf &quot; . g:filetype_i
    return
  endif
  &quot; This function checks for an assembly comment the first ten lines.
  &quot; If not found, assume Progress.
  let lnum = 1
  while lnum &lt;= 10 &amp;&amp; lnum &lt; line('$')
    let line = getline(lnum)
    if line =~ '^\s*;' || line =~ '^\*'
      call dist#ft#FTasm()
      return
    elseif line !~ '^\s*$' || line =~ '^/\*'
      &quot; Not an empty line: Doesn't look like valid assembly code.
      &quot; Or it looks like a Progress /* comment
      break
    endif
    let lnum = lnum + 1
  endw
  setf progress
endfunc

func dist#ft#FTprogress_pascal()
  if exists(&quot;g:filetype_p&quot;)
    exe &quot;setf &quot; . g:filetype_p
    return
  endif
  &quot; This function checks for valid Pascal syntax in the first ten lines.
  &quot; Look for either an opening comment or a program start.
  &quot; If not found, assume Progress.
  let lnum = 1
  while lnum &lt;= 10 &amp;&amp; lnum &lt; line('$')
    let line = getline(lnum)
    if line =~ '^\s*\(program\|unit\|procedure\|function\|const\|type\|var\)\&gt;'
	\ || line =~ '^\s*{' || line =~ '^\s*(\*'
      setf pascal
      return
    elseif line !~ '^\s*$' || line =~ '^/\*'
      &quot; Not an empty line: Doesn't look like valid Pascal code.
      &quot; Or it looks like a Progress /* comment
      break
    endif
    let lnum = lnum + 1
  endw
  setf progress
endfunc

func dist#ft#FTr()
  let max = line(&quot;$&quot;) &gt; 50 ? 50 : line(&quot;$&quot;)

  for n in range(1, max)
    &quot; Rebol is easy to recognize, check for that first
    if getline(n) =~? '\&lt;REBOL\&gt;'
      setf rebol
      return
    endif
  endfor

  for n in range(1, max)
    &quot; R has # comments
    if getline(n) =~ '^\s*#'
      setf r
      return
    endif
    &quot; Rexx has /* comments */
    if getline(n) =~ '^\s*/\*'
      setf rexx
      return
    endif
  endfor

  &quot; Nothing recognized, use user default or assume Rexx
  if exists(&quot;g:filetype_r&quot;)
    exe &quot;setf &quot; . g:filetype_r
  else
    &quot; Rexx used to be the default, but R appears to be much more popular.
    setf r
  endif
endfunc

func dist#ft#McSetf()
  &quot; Rely on the file to start with a comment.
  &quot; MS message text files use ';', Sendmail files use '#' or 'dnl'
  for lnum in range(1, min([line(&quot;$&quot;), 20]))
    let line = getline(lnum)
    if line =~ '^\s*\(#\|dnl\)'
      setf m4  &quot; Sendmail .mc file
      return
    elseif line =~ '^\s*;'
      setf msmessages  &quot; MS Message text file
      return
    endif
  endfor
  setf m4  &quot; Default: Sendmail .mc file
endfunc

&quot; Called from filetype.vim and scripts.vim.
func dist#ft#SetFileTypeSH(name)
  if expand(&quot;&lt;amatch&gt;&quot;) =~ g:ft_ignore_pat
    return
  endif
  if a:name =~ '\&lt;csh\&gt;'
    &quot; Some .sh scripts contain #!/bin/csh.
    call dist#ft#SetFileTypeShell(&quot;csh&quot;)
    return
  elseif a:name =~ '\&lt;tcsh\&gt;'
    &quot; Some .sh scripts contain #!/bin/tcsh.
    call dist#ft#SetFileTypeShell(&quot;tcsh&quot;)
    return
  elseif a:name =~ '\&lt;zsh\&gt;'
    &quot; Some .sh scripts contain #!/bin/zsh.
    call dist#ft#SetFileTypeShell(&quot;zsh&quot;)
    return
  elseif a:name =~ '\&lt;ksh\&gt;'
    let b:is_kornshell = 1
    if exists(&quot;b:is_bash&quot;)
      unlet b:is_bash
    endif
    if exists(&quot;b:is_sh&quot;)
      unlet b:is_sh
    endif
  elseif exists(&quot;g:bash_is_sh&quot;) || a:name =~ '\&lt;bash\&gt;' || a:name =~ '\&lt;bash2\&gt;'
    let b:is_bash = 1
    if exists(&quot;b:is_kornshell&quot;)
      unlet b:is_kornshell
    endif
    if exists(&quot;b:is_sh&quot;)
      unlet b:is_sh
    endif
  elseif a:name =~ '\&lt;sh\&gt;'
    let b:is_sh = 1
    if exists(&quot;b:is_kornshell&quot;)
      unlet b:is_kornshell
    endif
    if exists(&quot;b:is_bash&quot;)
      unlet b:is_bash
    endif
  endif
  call dist#ft#SetFileTypeShell(&quot;sh&quot;)
endfunc

&quot; For shell-like file types, check for an &quot;exec&quot; command hidden in a comment,
&quot; as used for Tcl.
&quot; Also called from scripts.vim, thus can't be local to this script.
func dist#ft#SetFileTypeShell(name)
  if expand(&quot;&lt;amatch&gt;&quot;) =~ g:ft_ignore_pat
    return
  endif
  let l = 2
  while l &lt; 20 &amp;&amp; l &lt; line(&quot;$&quot;) &amp;&amp; getline(l) =~ '^\s*\(#\|$\)'
    &quot; Skip empty and comment lines.
    let l = l + 1
  endwhile
  if l &lt; line(&quot;$&quot;) &amp;&amp; getline(l) =~ '\s*exec\s' &amp;&amp; getline(l - 1) =~ '^\s*#.*\\$'
    &quot; Found an &quot;exec&quot; line after a comment with continuation
    let n = substitute(getline(l),'\s*exec\s\+\([^ ]*/\)\=', '', '')
    if n =~ '\&lt;tclsh\|\&lt;wish'
      setf tcl
      return
    endif
  endif
  exe &quot;setf &quot; . a:name
endfunc

func dist#ft#CSH()
  if exists(&quot;g:filetype_csh&quot;)
    call dist#ft#SetFileTypeShell(g:filetype_csh)
  elseif &amp;shell =~ &quot;tcsh&quot;
    call dist#ft#SetFileTypeShell(&quot;tcsh&quot;)
  else
    call dist#ft#SetFileTypeShell(&quot;csh&quot;)
  endif
endfunc

let s:ft_rules_udev_rules_pattern = '^\s*\cudev_rules\s*=\s*&quot;\([^&quot;]\{-1,}\)/*&quot;.*'
func dist#ft#FTRules()
  let path = expand('&lt;amatch&gt;:p')
  if path =~ '^/\(etc/udev/\%(rules\.d/\)\=.*\.rules\|lib/udev/\%(rules\.d/\)\=.*\.rules\)$'
    setf udevrules
    return
  endif
  if path =~ '^/etc/ufw/'
    setf conf  &quot; Better than hog
    return
  endif
  if path =~ '^/\(etc\|usr/share\)/polkit-1/rules\.d'
    setf javascript
    return
  endif
  try
    let config_lines = readfile('/etc/udev/udev.conf')
  catch /^Vim\%((\a\+)\)\=:E484/
    setf hog
    return
  endtry
  let dir = expand('&lt;amatch&gt;:p:h')
  for line in config_lines
    if line =~ s:ft_rules_udev_rules_pattern
      let udev_rules = substitute(line, s:ft_rules_udev_rules_pattern, '\1', &quot;&quot;)
      if dir == udev_rules
	setf udevrules
      endif
      break
    endif
  endfor
  setf hog
endfunc

func dist#ft#SQL()
  if exists(&quot;g:filetype_sql&quot;)
    exe &quot;setf &quot; . g:filetype_sql
  else
    setf sql
  endif
endfunc

&quot; If the file has an extension of 't' and is in a directory 't' or 'xt' then
&quot; it is almost certainly a Perl test file.
&quot; If the first line starts with '#' and contains 'perl' it's probably a Perl
&quot; file.
&quot; (Slow test) If a file contains a 'use' statement then it is almost certainly
&quot; a Perl file.
func dist#ft#FTperl()
  let dirname = expand(&quot;%:p:h:t&quot;)
  if expand(&quot;%:e&quot;) == 't' &amp;&amp; (dirname == 't' || dirname == 'xt')
    setf perl
    return 1
  endif
  if getline(1)[0] == '#' &amp;&amp; getline(1) =~ 'perl'
    setf perl
    return 1
  endif
  let save_cursor = getpos('.')
  call cursor(1,1)
  let has_use = search('^use\s\s*\k', 'c', 30)
  call setpos('.', save_cursor)
  if has_use
    setf perl
    return 1
  endif
  return 0
endfunc

&quot; Choose context, plaintex, or tex (LaTeX) based on these rules:
&quot; 1. Check the first line of the file for &quot;%&amp;&lt;format&gt;&quot;.
&quot; 2. Check the first 1000 non-comment lines for LaTeX or ConTeXt keywords.
&quot; 3. Default to &quot;latex&quot; or to g:tex_flavor, can be set in user's vimrc.
func dist#ft#FTtex()
  let firstline = getline(1)
  if firstline =~ '^%&amp;\s*\a\+'
    let format = tolower(matchstr(firstline, '\a\+'))
    let format = substitute(format, 'pdf', '', '')
    if format == 'tex'
      let format = 'latex'
    elseif format == 'plaintex'
      let format = 'plain'
    endif
  elseif expand('%') =~ 'tex/context/.*/.*.tex'
    let format = 'context'
  else
    &quot; Default value, may be changed later:
    let format = exists(&quot;g:tex_flavor&quot;) ? g:tex_flavor : 'plain'
    &quot; Save position, go to the top of the file, find first non-comment line.
    let save_cursor = getpos('.')
    call cursor(1,1)
    let firstNC = search('^\s*[^[:space:]%]', 'c', 1000)
    if firstNC &quot; Check the next thousand lines for a LaTeX or ConTeXt keyword.
      let lpat = 'documentclass\&gt;\|usepackage\&gt;\|begin{\|newcommand\&gt;\|renewcommand\&gt;'
      let cpat = 'start\a\+\|setup\a\+\|usemodule\|enablemode\|enableregime\|setvariables\|useencoding\|usesymbols\|stelle\a\+\|verwende\a\+\|stel\a\+\|gebruik\a\+\|usa\a\+\|imposta\a\+\|regle\a\+\|utilisemodule\&gt;'
      let kwline = search('^\s*\\\%(' . lpat . '\)\|^\s*\\\(' . cpat . '\)',
			      \ 'cnp', firstNC + 1000)
      if kwline == 1	&quot; lpat matched
	let format = 'latex'
      elseif kwline == 2	&quot; cpat matched
	let format = 'context'
      endif		&quot; If neither matched, keep default set above.
      &quot; let lline = search('^\s*\\\%(' . lpat . '\)', 'cn', firstNC + 1000)
      &quot; let cline = search('^\s*\\\%(' . cpat . '\)', 'cn', firstNC + 1000)
      &quot; if cline &gt; 0
      &quot;   let format = 'context'
      &quot; endif
      &quot; if lline &gt; 0 &amp;&amp; (cline == 0 || cline &gt; lline)
      &quot;   let format = 'tex'
      &quot; endif
    endif &quot; firstNC
    call setpos('.', save_cursor)
  endif &quot; firstline =~ '^%&amp;\s*\a\+'

  &quot; Translation from formats to file types.  TODO:  add AMSTeX, RevTex, others?
  if format == 'plain'
    setf plaintex
  elseif format == 'context'
    setf context
  else &quot; probably LaTeX
    setf tex
  endif
  return
endfunc

func dist#ft#FTxml()
  let n = 1
  while n &lt; 100 &amp;&amp; n &lt; line(&quot;$&quot;)
    let line = getline(n)
    &quot; DocBook 4 or DocBook 5.
    let is_docbook4 = line =~ '&lt;!DOCTYPE.*DocBook'
    let is_docbook5 = line =~ ' xmlns=&quot;http://docbook.org/ns/docbook&quot;'
    if is_docbook4 || is_docbook5
      let b:docbk_type = &quot;xml&quot;
      if is_docbook5
	let b:docbk_ver = 5
      else
	let b:docbk_ver = 4
      endif
      setf docbk
      return
    endif
    if line =~ 'xmlns:xbl=&quot;http://www.mozilla.org/xbl&quot;'
      setf xbl
      return
    endif
    let n += 1
  endwhile
  setf xml
endfunc

func dist#ft#FTy()
  let n = 1
  while n &lt; 100 &amp;&amp; n &lt; line(&quot;$&quot;)
    let line = getline(n)
    if line =~ '^\s*%'
      setf yacc
      return
    endif
    if getline(n) =~ '^\s*\(#\|class\&gt;\)' &amp;&amp; getline(n) !~ '^\s*#\s*include'
      setf racc
      return
    endif
    let n = n + 1
  endwhile
  setf yacc
endfunc

func dist#ft#Redif()
  let lnum = 1
  while lnum &lt;= 5 &amp;&amp; lnum &lt; line('$')
    if getline(lnum) =~ &quot;^\ctemplate-type:&quot;
      setf redif
      return
    endif
    let lnum = lnum + 1
  endwhile
endfunc


&quot; Restore 'cpoptions'
let &amp;cpo = s:cpo_save
unlet s:cpo_save
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Fshare%2Fvim%2Fvim80%2Fautoload%2Fdist'>Back to Directory</a>