diff options
Diffstat (limited to '')
| -rw-r--r-- | runtime/autoload/dist/ft.vim | 1108 |
1 files changed, 1108 insertions, 0 deletions
diff --git a/runtime/autoload/dist/ft.vim b/runtime/autoload/dist/ft.vim new file mode 100644 index 0000000..bfc325d --- /dev/null +++ b/runtime/autoload/dist/ft.vim @@ -0,0 +1,1108 @@ +vim9script + +# Vim functions for file type detection +# +# Maintainer: Bram Moolenaar <Bram@vim.org> +# Last Change: 2022 Dec 14 + +# These functions are moved here from runtime/filetype.vim to make startup +# faster. + +export def Check_inp() + if getline(1) =~ '^\*' + setf abaqus + else + var n = 1 + var nmax = line("$") > 500 ? 500 : line("$") + while n <= nmax + if getline(n) =~? "^header surface data" + setf trasys + break + endif + n += 1 + endwhile + endif +enddef + +# This function checks for the kind of assembly that is wanted by the user, or +# can be detected from the first five lines of the file. +export def FTasm() + # make sure b:asmsyntax exists + if !exists("b:asmsyntax") + b:asmsyntax = "" + endif + + if b:asmsyntax == "" + FTasmsyntax() + endif + + # if b:asmsyntax still isn't set, default to asmsyntax or GNU + if b:asmsyntax == "" + if exists("g:asmsyntax") + b:asmsyntax = g:asmsyntax + else + b:asmsyntax = "asm" + endif + endif + + exe "setf " .. fnameescape(b:asmsyntax) +enddef + +export def FTasmsyntax() + # see if the file contains any asmsyntax=foo overrides. If so, change + # b:asmsyntax appropriately + var head = " " .. getline(1) .. " " .. getline(2) .. " " + .. getline(3) .. " " .. getline(4) .. " " .. getline(5) .. " " + var match = matchstr(head, '\sasmsyntax=\zs[a-zA-Z0-9]\+\ze\s') + if match != '' + b:asmsyntax = match + elseif ((head =~? '\.title') || (head =~? '\.ident') || (head =~? '\.macro') || (head =~? '\.subtitle') || (head =~? '\.library')) + b:asmsyntax = "vmasm" + endif +enddef + +var ft_visual_basic_content = '\cVB_Name\|Begin VB\.\(Form\|MDIForm\|UserControl\)' + +# See FTfrm() for Visual Basic form file detection +export def FTbas() + if exists("g:filetype_bas") + exe "setf " .. g:filetype_bas + return + endif + + # most frequent FreeBASIC-specific keywords in distro files + var fb_keywords = '\c^\s*\%(extern\|var\|enum\|private\|scope\|union\|byref\|operator\|constructor\|delete\|namespace\|public\|property\|with\|destructor\|using\)\>\%(\s*[:=(]\)\@!' + var fb_preproc = '\c^\s*\%(' .. + # preprocessor + '#\s*\a\+\|' .. + # compiler option + 'option\s\+\%(byval\|dynamic\|escape\|\%(no\)\=gosub\|nokeyword\|private\|static\)\>\|' .. + # metacommand + '\%(''\|rem\)\s*\$lang\>\|' .. + # default datatype + 'def\%(byte\|longint\|short\|ubyte\|uint\|ulongint\|ushort\)\>' .. + '\)' + var fb_comment = "^\\s*/'" + + # OPTION EXPLICIT, without the leading underscore, is common to many dialects + var qb64_preproc = '\c^\s*\%($\a\+\|option\s\+\%(_explicit\|_\=explicitarray\)\>\)' + + for lnum in range(1, min([line("$"), 100])) + var line = getline(lnum) + if line =~ ft_visual_basic_content + setf vb + return + elseif line =~ fb_preproc || line =~ fb_comment || line =~ fb_keywords + setf freebasic + return + elseif line =~ qb64_preproc + setf qb64 + return + endif + endfor + setf basic +enddef + +export def FTbtm() + if exists("g:dosbatch_syntax_for_btm") && g:dosbatch_syntax_for_btm + setf dosbatch + else + setf btm + endif +enddef + +export def BindzoneCheck(default = '') + if getline(1) .. getline(2) .. getline(3) .. getline(4) + =~ '^; <<>> DiG [0-9.]\+.* <<>>\|$ORIGIN\|$TTL\|IN\s\+SOA' + setf bindzone + elseif default != '' + exe 'setf ' .. default + endif +enddef + +# Returns true if file content looks like RAPID +def IsRapid(sChkExt: string = ""): bool + if sChkExt == "cfg" + return getline(1) =~? '\v^%(EIO|MMC|MOC|PROC|SIO|SYS):CFG' + endif + # called from FTmod, FTprg or FTsys + return getline(nextnonblank(1)) =~? '\v^\s*%(\%{3}|module\s+\k+\s*%(\(|$))' +enddef + +export def FTcfg() + if exists("g:filetype_cfg") + exe "setf " .. g:filetype_cfg + elseif IsRapid("cfg") + setf rapid + else + setf cfg + endif +enddef + +export def FTcls() + if exists("g:filetype_cls") + exe "setf " .. g:filetype_cls + return + endif + + if getline(1) =~ '^\v%(\%|\\)' + setf tex + elseif getline(1)[0] == '#' && getline(1) =~ 'rexx' + setf rexx + elseif getline(1) == 'VERSION 1.0 CLASS' + setf vb + else + setf st + endif +enddef + +export def FTlpc() + if exists("g:lpc_syntax_for_c") + var lnum = 1 + while lnum <= 12 + if getline(lnum) =~# '^\(//\|inherit\|private\|protected\|nosave\|string\|object\|mapping\|mixed\)' + setf lpc + return + endif + lnum += 1 + endwhile + endif + setf c +enddef + +export def FTheader() + if match(getline(1, min([line("$"), 200])), '^@\(interface\|end\|class\)') > -1 + if exists("g:c_syntax_for_h") + setf objc + else + setf objcpp + endif + elseif exists("g:c_syntax_for_h") + setf c + elseif exists("g:ch_syntax_for_h") + setf ch + else + setf cpp + endif +enddef + +# This function checks if one of the first ten lines start with a '@'. In +# that case it is probably a change file. +# If the first line starts with # or ! it's probably a ch file. +# If a line has "main", "include", "//" or "/*" it's probably ch. +# Otherwise CHILL is assumed. +export def FTchange() + var lnum = 1 + while lnum <= 10 + if getline(lnum)[0] == '@' + setf change + return + endif + if lnum == 1 && (getline(1)[0] == '#' || getline(1)[0] == '!') + setf ch + return + endif + if getline(lnum) =~ "MODULE" + setf chill + return + endif + if getline(lnum) =~ 'main\s*(\|#\s*include\|//' + setf ch + return + endif + lnum += 1 + endwhile + setf chill +enddef + +export def FTent() + # This function checks for valid cl syntax in the first five lines. + # Look for either an opening comment, '#', or a block start, '{'. + # If not found, assume SGML. + var lnum = 1 + while lnum < 6 + var line = getline(lnum) + if line =~ '^\s*[#{]' + setf cl + return + elseif line !~ '^\s*$' + # Not a blank line, not a comment, and not a block start, + # so doesn't look like valid cl code. + break + endif + lnum += 1 + endwhile + setf dtd +enddef + +export def ExCheck() + var lines = getline(1, min([line("$"), 100])) + if exists('g:filetype_euphoria') + exe 'setf ' .. g:filetype_euphoria + elseif match(lines, '^--\|^ifdef\>\|^include\>') > -1 + setf euphoria3 + else + setf elixir + endif +enddef + +export def EuphoriaCheck() + if exists('g:filetype_euphoria') + exe 'setf ' .. g:filetype_euphoria + else + setf euphoria3 + endif +enddef + +export def DtraceCheck() + if did_filetype() + # Filetype was already detected + return + endif + var lines = getline(1, min([line("$"), 100])) + if match(lines, '^module\>\|^import\>') > -1 + # 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\{-}:') > -1 + setf dtrace + else + setf d + endif +enddef + +export def FTe() + if exists('g:filetype_euphoria') + exe 'setf ' .. g:filetype_euphoria + else + var n = 1 + while n < 100 && n <= line("$") + if getline(n) =~ "^\\s*\\(<'\\|'>\\)\\s*$" + setf specman + return + endif + n += 1 + endwhile + setf eiffel + endif +enddef + +export def FTfrm() + if exists("g:filetype_frm") + exe "setf " .. g:filetype_frm + return + endif + + var lines = getline(1, min([line("$"), 5])) + + if match(lines, ft_visual_basic_content) > -1 + setf vb + else + setf form + endif +enddef + +# Distinguish between Forth and F#. +# Provided by Doug Kearns. +export def FTfs() + if exists("g:filetype_fs") + exe "setf " .. g:filetype_fs + else + var line = getline(nextnonblank(1)) + # comments and colon definitions + if line =~ '^\s*\.\=( ' || line =~ '^\s*\\G\= ' || line =~ '^\\$' + \ || line =~ '^\s*: \S' + setf forth + else + setf fsharp + endif + endif +enddef + +# Distinguish between HTML, XHTML and Django +export def FThtml() + var n = 1 + while n < 10 && n <= line("$") + if getline(n) =~ '\<DTD\s\+XHTML\s' + setf xhtml + return + endif + if getline(n) =~ '{%\s*\(extends\|block\|load\)\>\|{#\s\+' + setf htmldjango + return + endif + n += 1 + endwhile + setf FALLBACK html +enddef + +# Distinguish between standard IDL and MS-IDL +export def FTidl() + var n = 1 + while n < 50 && n <= line("$") + if getline(n) =~ '^\s*import\s\+"\(unknwn\|objidl\)\.idl"' + setf msidl + return + endif + n += 1 + endwhile + setf idl +enddef + +# Distinguish between "default", Prolog and Cproto prototype file. +export def ProtoCheck(default: string) + # Cproto files have a comment in the first line and a function prototype in + # the second line, it always ends in ";". Indent files may also have + # comments, thus we can't match comments to see the difference. + # IDL files can have a single ';' in the second line, require at least one + # chacter before the ';'. + if getline(2) =~ '.;$' + setf cpp + else + # recognize Prolog by specific text in the first non-empty line + # require a blank after the '%' because Perl uses "%list" and "%translate" + var l = getline(nextnonblank(1)) + if l =~ '\<prolog\>' || l =~ '^\s*\(%\+\(\s\|$\)\|/\*\)' || l =~ ':-' + setf prolog + else + exe 'setf ' .. default + endif + endif +enddef + +export def FTm() + if exists("g:filetype_m") + exe "setf " .. g:filetype_m + return + endif + + # excluding end(for|function|if|switch|while) common to Murphi + var octave_block_terminators = '\<end\%(_try_catch\|classdef\|enumeration\|events\|methods\|parfor\|properties\)\>' + + var objc_preprocessor = '^\s*#\s*\%(import\|include\|define\|if\|ifn\=def\|undef\|line\|error\|pragma\)\>' + + var n = 1 + var saw_comment = 0 # Whether we've seen a multiline comment leader. + while n < 100 + var line = getline(n) + if line =~ '^\s*/\*' + # /* ... */ is a comment in Objective C and Murphi, so we can't conclude + # it's either of them yet, but track this as a hint in case we don't see + # anything more definitive. + saw_comment = 1 + endif + if line =~ '^\s*//' || line =~ '^\s*@import\>' || line =~ objc_preprocessor + setf objc + return + endif + if line =~ '^\s*\%(#\|%!\)' || line =~ '^\s*unwind_protect\>' || + \ line =~ '\%(^\|;\)\s*' .. octave_block_terminators + setf octave + return + endif + # TODO: could be Matlab or Octave + if line =~ '^\s*%' + setf matlab + return + endif + if line =~ '^\s*(\*' + setf mma + return + endif + if line =~ '^\c\s*\(\(type\|var\)\>\|--\)' + setf murphi + return + endif + n += 1 + endwhile + + if saw_comment + # We didn't see anything definitive, but this looks like either Objective C + # or Murphi based on the comment leader. Assume the former as it is more + # common. + setf objc + else + # Default is Matlab + setf matlab + endif +enddef + +export def FTmms() + var n = 1 + while n < 20 + var line = getline(n) + if line =~ '^\s*\(%\|//\)' || line =~ '^\*' + setf mmix + return + endif + if line =~ '^\s*#' + setf make + return + endif + n += 1 + endwhile + setf mmix +enddef + +# This function checks if one of the first five lines start with a dot. In +# that case it is probably an nroff file: 'filetype' is set and 1 is returned. +export def FTnroff(): number + if getline(1)[0] .. getline(2)[0] .. getline(3)[0] + .. getline(4)[0] .. getline(5)[0] =~ '\.' + setf nroff + return 1 + endif + return 0 +enddef + +export def FTmm() + var n = 1 + while n < 20 + if getline(n) =~ '^\s*\(#\s*\(include\|import\)\>\|@import\>\|/\*\)' + setf objcpp + return + endif + n += 1 + endwhile + setf nroff +enddef + +# Returns true if file content looks like LambdaProlog module +def IsLProlog(): bool + # skip apparent comments and blank lines, what looks like + # LambdaProlog comment may be RAPID header + var l: number = nextnonblank(1) + while l > 0 && l < line('$') && getline(l) =~ '^\s*%' # LambdaProlog comment + l = nextnonblank(l + 1) + endwhile + # this pattern must not catch a go.mod file + return getline(l) =~ '\<module\s\+\w\+\s*\.\s*\(%\|$\)' +enddef + +# Determine if *.mod is ABB RAPID, LambdaProlog, Modula-2, Modsim III or go.mod +export def FTmod() + if exists("g:filetype_mod") + exe "setf " .. g:filetype_mod + elseif IsLProlog() + setf lprolog + elseif getline(nextnonblank(1)) =~ '\%(\<MODULE\s\+\w\+\s*;\|^\s*(\*\)' + setf modula2 + elseif IsRapid() + setf rapid + elseif expand("<afile>") =~ '\<go.mod$' + setf gomod + else + # Nothing recognized, assume modsim3 + setf modsim3 + endif +enddef + +export def FTpl() + if exists("g:filetype_pl") + exe "setf " .. g:filetype_pl + else + # recognize Prolog by specific text in the first non-empty line + # require a blank after the '%' because Perl uses "%list" and "%translate" + var l = getline(nextnonblank(1)) + if l =~ '\<prolog\>' || l =~ '^\s*\(%\+\(\s\|$\)\|/\*\)' || l =~ ':-' + setf prolog + else + setf perl + endif + endif +enddef + +export def FTinc() + if exists("g:filetype_inc") + exe "setf " .. g:filetype_inc + else + var lines = getline(1) .. getline(2) .. getline(3) + if lines =~? "perlscript" + setf aspperl + elseif lines =~ "<%" + setf aspvbs + elseif lines =~ "<?" + setf php + # Pascal supports // comments but they're vary rarely used for file + # headers so assume POV-Ray + elseif lines =~ '^\s*\%({\|(\*\)' || lines =~? ft_pascal_keywords + setf pascal + elseif lines =~# '\<\%(require\|inherit\)\>' || lines =~# '[A-Z][A-Za-z0-9_:${}]*\s\+\%(??\|[?:+]\)\?= ' + setf bitbake + else + FTasmsyntax() + if exists("b:asmsyntax") + exe "setf " .. fnameescape(b:asmsyntax) + else + setf pov + endif + endif + endif +enddef + +export def FTprogress_cweb() + if exists("g:filetype_w") + exe "setf " .. g:filetype_w + return + endif + if getline(1) =~ '&ANALYZE' || getline(3) =~ '&GLOBAL-DEFINE' + setf progress + else + setf cweb + endif +enddef + +export def FTprogress_asm() + if exists("g:filetype_i") + exe "setf " .. g:filetype_i + return + endif + # This function checks for an assembly comment the first ten lines. + # If not found, assume Progress. + var lnum = 1 + while lnum <= 10 && lnum < line('$') + var line = getline(lnum) + if line =~ '^\s*;' || line =~ '^\*' + FTasm() + return + elseif line !~ '^\s*$' || line =~ '^/\*' + # Not an empty line: Doesn't look like valid assembly code. + # Or it looks like a Progress /* comment + break + endif + lnum += 1 + endwhile + setf progress +enddef + +var ft_pascal_comments = '^\s*\%({\|(\*\|//\)' +var ft_pascal_keywords = '^\s*\%(program\|unit\|library\|uses\|begin\|procedure\|function\|const\|type\|var\)\>' + +export def FTprogress_pascal() + if exists("g:filetype_p") + exe "setf " .. g:filetype_p + return + endif + # This function checks for valid Pascal syntax in the first ten lines. + # Look for either an opening comment or a program start. + # If not found, assume Progress. + var lnum = 1 + while lnum <= 10 && lnum < line('$') + var line = getline(lnum) + if line =~ ft_pascal_comments || line =~? ft_pascal_keywords + setf pascal + return + elseif line !~ '^\s*$' || line =~ '^/\*' + # Not an empty line: Doesn't look like valid Pascal code. + # Or it looks like a Progress /* comment + break + endif + lnum += 1 + endwhile + setf progress +enddef + +export def FTpp() + if exists("g:filetype_pp") + exe "setf " .. g:filetype_pp + else + var line = getline(nextnonblank(1)) + if line =~ ft_pascal_comments || line =~? ft_pascal_keywords + setf pascal + else + setf puppet + endif + endif +enddef + +# Determine if *.prg is ABB RAPID. Can also be Clipper, FoxPro or eviews +export def FTprg() + if exists("g:filetype_prg") + exe "setf " .. g:filetype_prg + elseif IsRapid() + setf rapid + else + # Nothing recognized, assume Clipper + setf clipper + endif +enddef + +export def FTr() + var max = line("$") > 50 ? 50 : line("$") + + for n in range(1, max) + # Rebol is easy to recognize, check for that first + if getline(n) =~? '\<REBOL\>' + setf rebol + return + endif + endfor + + for n in range(1, max) + # R has # comments + if getline(n) =~ '^\s*#' + setf r + return + endif + # Rexx has /* comments */ + if getline(n) =~ '^\s*/\*' + setf rexx + return + endif + endfor + + # Nothing recognized, use user default or assume Rexx + if exists("g:filetype_r") + exe "setf " .. g:filetype_r + else + # Rexx used to be the default, but R appears to be much more popular. + setf r + endif +enddef + +export def McSetf() + # Rely on the file to start with a comment. + # MS message text files use ';', Sendmail files use '#' or 'dnl' + for lnum in range(1, min([line("$"), 20])) + var line = getline(lnum) + if line =~ '^\s*\(#\|dnl\)' + setf m4 # Sendmail .mc file + return + elseif line =~ '^\s*;' + setf msmessages # MS Message text file + return + endif + endfor + setf m4 # Default: Sendmail .mc file +enddef + +# Called from filetype.vim and scripts.vim. +export def SetFileTypeSH(name: string) + if did_filetype() + # Filetype was already detected + return + endif + if expand("<amatch>") =~ g:ft_ignore_pat + return + endif + if name =~ '\<csh\>' + # Some .sh scripts contain #!/bin/csh. + SetFileTypeShell("csh") + return + elseif name =~ '\<tcsh\>' + # Some .sh scripts contain #!/bin/tcsh. + SetFileTypeShell("tcsh") + return + elseif name =~ '\<zsh\>' + # Some .sh scripts contain #!/bin/zsh. + SetFileTypeShell("zsh") + return + elseif name =~ '\<ksh\>' + b:is_kornshell = 1 + if exists("b:is_bash") + unlet b:is_bash + endif + if exists("b:is_sh") + unlet b:is_sh + endif + elseif exists("g:bash_is_sh") || name =~ '\<bash\>' || name =~ '\<bash2\>' + b:is_bash = 1 + if exists("b:is_kornshell") + unlet b:is_kornshell + endif + if exists("b:is_sh") + unlet b:is_sh + endif + elseif name =~ '\<sh\>' || name =~ '\<dash\>' + # Ubuntu links "sh" to "dash", thus it is expected to work the same way + b:is_sh = 1 + if exists("b:is_kornshell") + unlet b:is_kornshell + endif + if exists("b:is_bash") + unlet b:is_bash + endif + endif + SetFileTypeShell("sh") +enddef + +# For shell-like file types, check for an "exec" command hidden in a comment, +# as used for Tcl. +# Also called from scripts.vim, thus can't be local to this script. +export def SetFileTypeShell(name: string) + if did_filetype() + # Filetype was already detected + return + endif + if expand("<amatch>") =~ g:ft_ignore_pat + return + endif + var l = 2 + while l < 20 && l < line("$") && getline(l) =~ '^\s*\(#\|$\)' + # Skip empty and comment lines. + l += 1 + endwhile + if l < line("$") && getline(l) =~ '\s*exec\s' && getline(l - 1) =~ '^\s*#.*\\$' + # Found an "exec" line after a comment with continuation + var n = substitute(getline(l), '\s*exec\s\+\([^ ]*/\)\=', '', '') + if n =~ '\<tclsh\|\<wish' + setf tcl + return + endif + endif + exe "setf " .. name +enddef + +export def CSH() + if did_filetype() + # Filetype was already detected + return + endif + if exists("g:filetype_csh") + SetFileTypeShell(g:filetype_csh) + elseif &shell =~ "tcsh" + SetFileTypeShell("tcsh") + else + SetFileTypeShell("csh") + endif +enddef + +var ft_rules_udev_rules_pattern = '^\s*\cudev_rules\s*=\s*"\([^"]\{-1,}\)/*".*' +export def FTRules() + var path = expand('<amatch>:p') + if path =~ '/\(etc/udev/\%(rules\.d/\)\=.*\.rules\|\%(usr/\)\=lib/udev/\%(rules\.d/\)\=.*\.rules\)$' + setf udevrules + return + endif + if path =~ '^/etc/ufw/' + setf conf # Better than hog + return + endif + if path =~ '^/\(etc\|usr/share\)/polkit-1/rules\.d' + setf javascript + return + endif + var config_lines: list<string> + try + config_lines = readfile('/etc/udev/udev.conf') + catch /^Vim\%((\a\+)\)\=:E484/ + setf hog + return + endtry + var dir = expand('<amatch>:p:h') + for line in config_lines + if line =~ ft_rules_udev_rules_pattern + var udev_rules = substitute(line, ft_rules_udev_rules_pattern, '\1', "") + if dir == udev_rules + setf udevrules + endif + break + endif + endfor + setf hog +enddef + +export def SQL() + if exists("g:filetype_sql") + exe "setf " .. g:filetype_sql + else + setf sql + endif +enddef + +# This function checks the first 25 lines of file extension "sc" to resolve +# detection between scala and SuperCollider. +# NOTE: We don't check for 'Class : Method', as this can easily be confused +# with valid Scala like `val x : Int = 3`. So we instead only rely on +# checks that can't be confused. +export def FTsc() + for lnum in range(1, min([line("$"), 25])) + if getline(lnum) =~# 'var\s<\|classvar\s<\|\^this.*\||\w\+|\|+\s\w*\s{\|\*ar\s' + setf supercollider + return + endif + endfor + setf scala +enddef + +# This function checks the first line of file extension "scd" to resolve +# detection between scdoc and SuperCollider +export def FTscd() + if getline(1) =~# '\%^\S\+(\d[0-9A-Za-z]*)\%(\s\+\"[^"]*\"\%(\s\+\"[^"]*\"\)\=\)\=$' + setf scdoc + else + setf supercollider + endif +enddef + +# If the file has an extension of 't' and is in a directory 't' or 'xt' then +# it is almost certainly a Perl test file. +# If the first line starts with '#' and contains 'perl' it's probably a Perl +# file. +# (Slow test) If a file contains a 'use' statement then it is almost certainly +# a Perl file. +export def FTperl(): number + var dirname = expand("%:p:h:t") + if expand("%:e") == 't' && (dirname == 't' || dirname == 'xt') + setf perl + return 1 + endif + if getline(1)[0] == '#' && getline(1) =~ 'perl' + setf perl + return 1 + endif + var save_cursor = getpos('.') + call cursor(1, 1) + var has_use = search('^use\s\s*\k', 'c', 30) > 0 + call setpos('.', save_cursor) + if has_use + setf perl + return 1 + endif + return 0 +enddef + +# LambdaProlog and Standard ML signature files +export def FTsig() + if exists("g:filetype_sig") + exe "setf " .. g:filetype_sig + return + endif + + var lprolog_comment = '^\s*\%(/\*\|%\)' + var lprolog_keyword = '^\s*sig\s\+\a' + var sml_comment = '^\s*(\*' + var sml_keyword = '^\s*\%(signature\|structure\)\s\+\a' + + var line = getline(nextnonblank(1)) + + if line =~ lprolog_comment || line =~# lprolog_keyword + setf lprolog + elseif line =~ sml_comment || line =~# sml_keyword + setf sml + endif +enddef + +# This function checks the first 100 lines of files matching "*.sil" to +# resolve detection between Swift Intermediate Language and SILE. +export def FTsil() + for lnum in range(1, [line('$'), 100]->min()) + var line: string = getline(lnum) + if line =~ '^\s*[\\%]' + setf sile + return + elseif line =~ '^\s*\S' + setf sil + return + endif + endfor + # no clue, default to "sil" + setf sil +enddef + +export def FTsys() + if exists("g:filetype_sys") + exe "setf " .. g:filetype_sys + elseif IsRapid() + setf rapid + else + setf bat + endif +enddef + +# Choose context, plaintex, or tex (LaTeX) based on these rules: +# 1. Check the first line of the file for "%&<format>". +# 2. Check the first 1000 non-comment lines for LaTeX or ConTeXt keywords. +# 3. Default to "plain" or to g:tex_flavor, can be set in user's vimrc. +export def FTtex() + var firstline = getline(1) + var format: string + if firstline =~ '^%&\s*\a\+' + format = tolower(matchstr(firstline, '\a\+')) + format = substitute(format, 'pdf', '', '') + if format == 'tex' + format = 'latex' + elseif format == 'plaintex' + format = 'plain' + endif + elseif expand('%') =~ 'tex/context/.*/.*.tex' + format = 'context' + else + # Default value, may be changed later: + format = exists("g:tex_flavor") ? g:tex_flavor : 'plain' + # Save position, go to the top of the file, find first non-comment line. + var save_cursor = getpos('.') + call cursor(1, 1) + var firstNC = search('^\s*[^[:space:]%]', 'c', 1000) + if firstNC > 0 + # Check the next thousand lines for a LaTeX or ConTeXt keyword. + var lpat = 'documentclass\>\|usepackage\>\|begin{\|newcommand\>\|renewcommand\>' + var 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\>' + var kwline = search('^\s*\\\%(' .. lpat .. '\)\|^\s*\\\(' .. cpat .. '\)', + 'cnp', firstNC + 1000) + if kwline == 1 # lpat matched + format = 'latex' + elseif kwline == 2 # cpat matched + format = 'context' + endif # If neither matched, keep default set above. + # let lline = search('^\s*\\\%(' . lpat . '\)', 'cn', firstNC + 1000) + # let cline = search('^\s*\\\%(' . cpat . '\)', 'cn', firstNC + 1000) + # if cline > 0 + # let format = 'context' + # endif + # if lline > 0 && (cline == 0 || cline > lline) + # let format = 'tex' + # endif + endif # firstNC + call setpos('.', save_cursor) + endif # firstline =~ '^%&\s*\a\+' + + # Translation from formats to file types. TODO: add AMSTeX, RevTex, others? + if format == 'plain' + setf plaintex + elseif format == 'context' + setf context + else # probably LaTeX + setf tex + endif + return +enddef + +export def FTxml() + var n = 1 + while n < 100 && n <= line("$") + var line = getline(n) + # DocBook 4 or DocBook 5. + var is_docbook4 = line =~ '<!DOCTYPE.*DocBook' + var is_docbook5 = line =~ ' xmlns="http://docbook.org/ns/docbook"' + if is_docbook4 || is_docbook5 + b:docbk_type = "xml" + if is_docbook5 + b:docbk_ver = 5 + else + b:docbk_ver = 4 + endif + setf docbk + return + endif + if line =~ 'xmlns:xbl="http://www.mozilla.org/xbl"' + setf xbl + return + endif + n += 1 + endwhile + setf xml +enddef + +export def FTy() + var n = 1 + while n < 100 && n <= line("$") + var line = getline(n) + if line =~ '^\s*%' + setf yacc + return + endif + if getline(n) =~ '^\s*\(#\|class\>\)' && getline(n) !~ '^\s*#\s*include' + setf racc + return + endif + n += 1 + endwhile + setf yacc +enddef + +export def Redif() + var lnum = 1 + while lnum <= 5 && lnum < line('$') + if getline(lnum) =~ "^\ctemplate-type:" + setf redif + return + endif + lnum += 1 + endwhile +enddef + +# This function is called for all files under */debian/patches/*, make sure not +# to non-dep3patch files, such as README and other text files. +export def Dep3patch() + if expand('%:t') ==# 'series' + return + endif + + for ln in getline(1, 100) + if ln =~# '^\%(Description\|Subject\|Origin\|Bug\|Forwarded\|Author\|From\|Reviewed-by\|Acked-by\|Last-Updated\|Applied-Upstream\):' + setf dep3patch + return + elseif ln =~# '^---' + # end of headers found. stop processing + return + endif + endfor +enddef + +# This function checks the first 15 lines for appearance of 'FoamFile' +# and then 'object' in a following line. +# In that case, it's probably an OpenFOAM file +export def FTfoam() + var ffile = 0 + var lnum = 1 + while lnum <= 15 + if getline(lnum) =~# '^FoamFile' + ffile = 1 + elseif ffile == 1 && getline(lnum) =~# '^\s*object' + setf foam + return + endif + lnum += 1 + endwhile +enddef + +# Determine if a *.tf file is TF mud client or terraform +export def FTtf() + var numberOfLines = line('$') + for i in range(1, numberOfLines) + var currentLine = trim(getline(i)) + var firstCharacter = currentLine[0] + if firstCharacter !=? ";" && firstCharacter !=? "/" && firstCharacter !=? "" + setf terraform + return + endif + endfor + setf tf +enddef + +var ft_krl_header = '\&\w+' +# Determine if a *.src file is Kuka Robot Language +export def FTsrc() + var ft_krl_def_or_deffct = '%(global\s+)?def%(fct)?>' + if exists("g:filetype_src") + exe "setf " .. g:filetype_src + elseif getline(nextnonblank(1)) =~? '\v^\s*%(' .. ft_krl_header .. '|' .. ft_krl_def_or_deffct .. ')' + setf krl + endif +enddef + +# Determine if a *.dat file is Kuka Robot Language +export def FTdat() + var ft_krl_defdat = 'defdat>' + if exists("g:filetype_dat") + exe "setf " .. g:filetype_dat + elseif getline(nextnonblank(1)) =~? '\v^\s*%(' .. ft_krl_header .. '|' .. ft_krl_defdat .. ')' + setf krl + endif +enddef + +export def FTlsl() + if exists("g:filetype_lsl") + exe "setf " .. g:filetype_lsl + endif + + var line = getline(nextnonblank(1)) + if line =~ '^\s*%' || line =~# ':\s*trait\s*$' + setf larch + else + setf lsl + endif +enddef + +# Uncomment this line to check for compilation errors early +# defcompile |