if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'latex') == -1
" vimtex - LaTeX plugin for Vim
"
" Maintainer: Karl Yngve Lervåg
" Email: karl.yngve@gmail.com
"
function! vimtex#state#init_buffer() abort " {{{1
command! -buffer VimtexToggleMain call vimtex#state#toggle_main()
command! -buffer VimtexReloadState call vimtex#state#reload()
nnoremap <buffer> <plug>(vimtex-toggle-main) :VimtexToggleMain<cr>
nnoremap <buffer> <plug>(vimtex-reload-state) :VimtexReloadState<cr>
endfunction
" }}}1
function! vimtex#state#init() abort " {{{1
let [l:main, l:main_type] = s:get_main()
let l:id = s:get_main_id(l:main)
if l:id >= 0
let b:vimtex_id = l:id
let b:vimtex = s:vimtex_states[l:id]
else
let b:vimtex_id = s:vimtex_next_id
let b:vimtex = s:vimtex.new(l:main, l:main_type, 0)
let s:vimtex_next_id += 1
let s:vimtex_states[b:vimtex_id] = b:vimtex
endif
endfunction
" }}}1
function! vimtex#state#init_local() abort " {{{1
let l:filename = expand('%:p')
let l:preserve_root = get(s:, 'subfile_preserve_root')
unlet! s:subfile_preserve_root
if b:vimtex.tex ==# l:filename | return | endif
let l:vimtex_id = s:get_main_id(l:filename)
if l:vimtex_id < 0
let l:vimtex_id = s:vimtex_next_id
let l:vimtex = s:vimtex.new(l:filename, 'local file', l:preserve_root)
let s:vimtex_next_id += 1
let s:vimtex_states[l:vimtex_id] = l:vimtex
if !has_key(b:vimtex, 'subids')
let b:vimtex.subids = []
endif
call add(b:vimtex.subids, l:vimtex_id)
let l:vimtex.main_id = b:vimtex_id
endif
let b:vimtex_local = {
\ 'active' : 0,
\ 'main_id' : b:vimtex_id,
\ 'sub_id' : l:vimtex_id,
\}
endfunction
" }}}1
function! vimtex#state#reload() abort " {{{1
let l:id = s:get_main_id(expand('%:p'))
if has_key(s:vimtex_states, l:id)
let l:vimtex = remove(s:vimtex_states, l:id)
call l:vimtex.cleanup()
endif
if has_key(s:vimtex_states, get(b:, 'vimtex_id', -1))
let l:vimtex = remove(s:vimtex_states, b:vimtex_id)
call l:vimtex.cleanup()
endif
call vimtex#state#init()
call vimtex#state#init_local()
endfunction
" }}}1
function! vimtex#state#toggle_main() abort " {{{1
if exists('b:vimtex_local')
let b:vimtex_local.active = !b:vimtex_local.active
let b:vimtex_id = b:vimtex_local.active
\ ? b:vimtex_local.sub_id
\ : b:vimtex_local.main_id
let b:vimtex = vimtex#state#get(b:vimtex_id)
call vimtex#log#info('Changed to `' . b:vimtex.base . "' "
\ . (b:vimtex_local.active ? '[local]' : '[main]'))
endif
endfunction
" }}}1
function! vimtex#state#list_all() abort " {{{1
return values(s:vimtex_states)
endfunction
" }}}1
function! vimtex#state#exists(id) abort " {{{1
return has_key(s:vimtex_states, a:id)
endfunction
" }}}1
function! vimtex#state#get(id) abort " {{{1
return s:vimtex_states[a:id]
endfunction
" }}}1
function! vimtex#state#get_all() abort " {{{1
return s:vimtex_states
endfunction
" }}}1
function! vimtex#state#cleanup(id) abort " {{{1
if !vimtex#state#exists(a:id) | return | endif
"
" Count the number of open buffers for the given blob
"
let l:buffers = filter(range(1, bufnr('$')), 'buflisted(v:val)')
let l:ids = map(l:buffers, 'getbufvar(v:val, ''vimtex_id'', -1)')
let l:count = count(l:ids, a:id)
"
" Don't clean up if there are more than one buffer connected to the current
" blob
"
if l:count > 1 | return | endif
let l:vimtex = vimtex#state#get(a:id)
"
" Handle possible subfiles properly
"
if has_key(l:vimtex, 'subids')
let l:subcount = 0
for l:sub_id in get(l:vimtex, 'subids', [])
let l:subcount += count(l:ids, l:sub_id)
endfor
if l:count + l:subcount > 1 | return | endif
for l:sub_id in get(l:vimtex, 'subids', [])
call remove(s:vimtex_states, l:sub_id).cleanup()
endfor
call remove(s:vimtex_states, a:id).cleanup()
else
call remove(s:vimtex_states, a:id).cleanup()
if has_key(l:vimtex, 'main_id')
let l:main = vimtex#state#get(l:vimtex.main_id)
let l:count_main = count(l:ids, l:vimtex.main_id)
for l:sub_id in get(l:main, 'subids', [])
let l:count_main += count(l:ids, l:sub_id)
endfor
if l:count_main + l:count <= 1
call remove(s:vimtex_states, l:vimtex.main_id).cleanup()
endif
endif
endif
endfunction
" }}}1
function! s:get_main_id(main) abort " {{{1
for [l:id, l:state] in items(s:vimtex_states)
if l:state.tex == a:main
return str2nr(l:id)
endif
endfor
return -1
endfunction
function! s:get_main() abort " {{{1
if exists('s:disabled_modules')
unlet s:disabled_modules
endif
"
" Use buffer variable if it exists
"
if exists('b:vimtex_main') && filereadable(b:vimtex_main)
return [fnamemodify(b:vimtex_main, ':p'), 'buffer variable']
endif
"
" Search for TEX root specifier at the beginning of file. This is used by
" several other plugins and editors.
"
let l:candidate = s:get_main_from_texroot()
if !empty(l:candidate)
return [l:candidate, 'texroot specifier']
endif
"
" Check if the current file is a main file
"
if s:file_is_main(expand('%:p'))
return [expand('%:p'), 'current file verified']
endif
"
" Support for subfiles package
"
let l:candidate = s:get_main_from_subfile()
if !empty(l:candidate)
return [l:candidate, 'subfiles']
endif
"
" Search for .latexmain-specifier
"
let l:candidate = s:get_main_latexmain(expand('%:p'))
if !empty(l:candidate)
return [l:candidate, 'latexmain specifier']
endif
"
" Search for .latexmkrc @default_files specifier
"
let l:candidate = s:get_main_latexmk()
if !empty(l:candidate)
return [l:candidate, 'latexmkrc @default_files']
endif
"
" Check if we are class or style file
"
if index(['cls', 'sty'], expand('%:e')) >= 0
let l:id = getbufvar('#', 'vimtex_id', -1)
if l:id >= 0 && has_key(s:vimtex_states, l:id)
return [s:vimtex_states[l:id].tex, 'cls/sty file (inherit from alternate)']
else
let s:disabled_modules = ['latexmk', 'view', 'toc']
return [expand('%:p'), 'cls/sty file']
endif
endif
"
" Search for main file recursively through include specifiers
"
if !get(g:, 'vimtex_disable_recursive_main_file_detection', 0)
let l:candidate = s:get_main_choose(s:get_main_recurse())
if !empty(l:candidate)
return [l:candidate, 'recursive search']
endif
endif
"
" Use fallback candidate or the current file
"
let l:candidate = get(s:, 'cand_fallback', expand('%:p'))
if exists('s:cand_fallback')
unlet s:cand_fallback
return [l:candidate, 'fallback']
else
return [l:candidate, 'current file']
endif
endfunction
" }}}1
function! s:get_main_from_texroot() abort " {{{1
for l:line in getline(1, 5)
let l:file_pattern = matchstr(l:line, g:vimtex#re#tex_input_root)
if empty(l:file_pattern) | continue | endif
if !vimtex#paths#is_abs(l:file_pattern)
let l:file_pattern = simplify(expand('%:p:h') . '/' . l:file_pattern)
endif
let l:candidates = glob(l:file_pattern, 0, 1)
if len(l:candidates) > 1
return s:get_main_choose(l:candidates)
elseif len(l:candidates) == 1
return l:candidates[0]
endif
endfor
return ''
endfunction
" }}}1
function! s:get_main_from_subfile() abort " {{{1
for l:line in getline(1, 5)
let l:filename = matchstr(l:line,
\ '^\C\s*\\documentclass\[\zs.*\ze\]{subfiles}')
if len(l:filename) > 0
if l:filename !~# '\.tex$'
let l:filename .= '.tex'
endif
if vimtex#paths#is_abs(l:filename)
" Specified path is absolute
if filereadable(l:filename) | return l:filename | endif
else
" Try specified path as relative to current file path
let l:candidate = simplify(expand('%:p:h') . '/' . l:filename)
if filereadable(l:candidate) | return l:candidate | endif
" Try specified path as relative to the project main file. This is
" difficult, since the main file is the one we are looking for. We
" therefore assume that the main file lives somewhere upwards in the
" directory tree.
let l:candidate = fnamemodify(findfile(l:filename, '.;'), ':p')
if filereadable(l:candidate)
\ && s:file_reaches_current(l:candidate)
let s:subfile_preserve_root = 1
return fnamemodify(candidate, ':p')
endif
" Check the alternate buffer. This seems sensible e.g. in cases where one
" enters an "outer" subfile through a 'gf' motion from the main file.
let l:vimtex = getbufvar('#', 'vimtex', {})
for l:file in get(l:vimtex, 'sources', [])
if expand('%:p') ==# simplify(l:vimtex.root . '/' . l:file)
let s:subfile_preserve_root = 1
return l:vimtex.tex
endif
endfor
endif
endif
endfor
return ''
endfunction
" }}}1
function! s:get_main_latexmain(file) abort " {{{1
for l:cand in s:findfiles_recursive('*.latexmain', expand('%:p:h'))
let l:cand = fnamemodify(l:cand, ':p:r')
if s:file_reaches_current(l:cand)
return l:cand
else
let s:cand_fallback = l:cand
endif
endfor
return ''
endfunction
function! s:get_main_latexmk() abort " {{{1
let l:root = expand('%:p:h')
let l:results = vimtex#compiler#latexmk#get_rc_opt(
\ l:root, 'default_files', 2, [])
if l:results[1] < 1 | return '' | endif
for l:candidate in l:results[0]
let l:file = l:root . '/' . l:candidate
if filereadable(l:file)
return l:file
endif
endfor
return ''
endfunction
function! s:get_main_recurse(...) abort " {{{1
" Either start the search from the original file, or check if the supplied
" file is a main file (or invalid)
if a:0 == 0
let l:file = expand('%:p')
let l:tried = {}
else
let l:file = a:1
let l:tried = a:2
if s:file_is_main(l:file)
return [l:file]
elseif !filereadable(l:file)
return []
endif
endif
" Create list of candidates that was already tried for the current file
if !has_key(l:tried, l:file)
let l:tried[l:file] = [l:file]
endif
" Apply filters successively (minor optimization)
let l:re_filter1 = fnamemodify(l:file, ':t:r')
let l:re_filter2 = g:vimtex#re#tex_input . '\s*\f*' . l:re_filter1
" Search through candidates found recursively upwards in the directory tree
let l:results = []
for l:cand in s:findfiles_recursive('*.tex', fnamemodify(l:file, ':p:h'))
if index(l:tried[l:file], l:cand) >= 0 | continue | endif
call add(l:tried[l:file], l:cand)
if len(filter(filter(readfile(l:cand),
\ 'v:val =~# l:re_filter1'),
\ 'v:val =~# l:re_filter2')) > 0
let l:results += s:get_main_recurse(fnamemodify(l:cand, ':p'), l:tried)
endif
endfor
return l:results
endfunction
" }}}1
function! s:get_main_choose(list) abort " {{{1
let l:list = vimtex#util#uniq_unsorted(a:list)
if empty(l:list) | return '' | endif
if len(l:list) == 1 | return l:list[0] | endif
let l:all = map(copy(l:list), '[s:get_main_id(v:val), v:val]')
let l:new = map(filter(copy(l:all), 'v:val[0] < 0'), 'v:val[1]')
let l:existing = {}
for [l:key, l:val] in filter(copy(l:all), 'v:val[0] >= 0')
let l:existing[l:key] = l:val
endfor
let l:alternate_id = getbufvar('#', 'vimtex_id', -1)
if len(l:existing) == 1
return values(l:existing)[0]
elseif len(l:existing) > 1 && has_key(l:existing, l:alternate_id)
return l:existing[l:alternate_id]
elseif len(l:existing) < 1 && len(l:new) == 1
return l:new[0]
else
let l:choices = {}
for l:tex in l:list
let l:choices[l:tex] = vimtex#paths#relative(l:tex, getcwd())
endfor
return vimtex#echo#choose(l:choices,
\ 'Please select an appropriate main file:')
endif
endfunction
" }}}1
function! s:file_is_main(file) abort " {{{1
if !filereadable(a:file) | return 0 | endif
"
" Check if a:file is a main file by looking for the \documentclass command,
" but ignore the following:
"
" \documentclass[...]{subfiles}
" \documentclass[...]{standalone}
"
let l:lines = readfile(a:file, 0, 50)
call filter(l:lines, 'v:val =~# ''\C\\documentclass\_\s*[\[{]''')
call filter(l:lines, 'v:val !~# ''{subfiles}''')
call filter(l:lines, 'v:val !~# ''{standalone}''')
if len(l:lines) == 0 | return 0 | endif
" A main file contains `\begin{document}`
let l:lines = vimtex#parser#preamble(a:file, {
\ 'inclusive' : 1,
\ 'root' : fnamemodify(a:file, ':p:h'),
\})
call filter(l:lines, 'v:val =~# ''\\begin\s*{document}''')
return len(l:lines) > 0
endfunction
" }}}1
function! s:file_reaches_current(file) abort " {{{1
" Note: This function assumes that the input a:file is an absolute path
if !filereadable(a:file) | return 0 | endif
for l:line in filter(readfile(a:file), 'v:val =~# g:vimtex#re#tex_input')
let l:file = matchstr(l:line, g:vimtex#re#tex_input . '\zs\f+')
if empty(l:file) | continue | endif
if !vimtex#paths#is_abs(l:file)
let l:file = fnamemodify(a:file, ':h') . '/' . l:file
endif
if l:file !~# '\.tex$'
let l:file .= '.tex'
endif
if expand('%:p') ==# l:file
\ || s:file_reaches_current(l:file)
return 1
endif
endfor
return 0
endfunction
" }}}1
function! s:findfiles_recursive(expr, path) abort " {{{1
let l:path = a:path
let l:dirs = l:path
while l:path != fnamemodify(l:path, ':h')
let l:path = fnamemodify(l:path, ':h')
let l:dirs .= ',' . l:path
endwhile
return split(globpath(fnameescape(l:dirs), a:expr), '\n')
endfunction
" }}}1
let s:vimtex = {}
function! s:vimtex.new(main, main_parser, preserve_root) abort dict " {{{1
let l:new = deepcopy(self)
let l:new.tex = a:main
let l:new.root = fnamemodify(l:new.tex, ':h')
let l:new.base = fnamemodify(l:new.tex, ':t')
let l:new.name = fnamemodify(l:new.tex, ':t:r')
let l:new.main_parser = a:main_parser
if a:preserve_root && exists('b:vimtex')
let l:new.root = b:vimtex.root
let l:new.base = vimtex#paths#relative(a:main, l:new.root)
endif
if exists('s:disabled_modules')
let l:new.disabled_modules = s:disabled_modules
endif
"
" The preamble content is used to parse for the engine directive, the
" documentclass and the package list; we store it as a temporary shared
" object variable
"
let l:new.preamble = vimtex#parser#preamble(l:new.tex, {
\ 'root' : l:new.root,
\})
call l:new.parse_tex_program()
call l:new.parse_documentclass()
call l:new.parse_graphicspath()
call l:new.gather_sources()
call vimtex#view#init_state(l:new)
call vimtex#compiler#init_state(l:new)
call vimtex#qf#init_state(l:new)
call vimtex#toc#init_state(l:new)
call vimtex#fold#init_state(l:new)
" Parsing packages might depend on the compiler setting for build_dir
call l:new.parse_packages()
unlet l:new.preamble
unlet l:new.new
return l:new
endfunction
" }}}1
function! s:vimtex.cleanup() abort dict " {{{1
if exists('self.compiler.cleanup')
call self.compiler.cleanup()
endif
if exists('#User#VimtexEventQuit')
if exists('b:vimtex')
let b:vimtex_tmp = b:vimtex
endif
let b:vimtex = self
doautocmd <nomodeline> User VimtexEventQuit
if exists('b:vimtex_tmp')
let b:vimtex = b:vimtex_tmp
unlet b:vimtex_tmp
else
unlet b:vimtex
endif
endif
" Close quickfix window
silent! cclose
endfunction
" }}}1
function! s:vimtex.parse_tex_program() abort dict " {{{1
let l:lines = copy(self.preamble[:20])
let l:tex_program_re =
\ '\v^\c\s*\%\s*\!?\s*tex\s+%(TS-)?program\s*\=\s*\zs.*\ze\s*$'
call map(l:lines, 'matchstr(v:val, l:tex_program_re)')
call filter(l:lines, '!empty(v:val)')
let self.tex_program = tolower(get(l:lines, -1, '_'))
endfunction
" }}}1
function! s:vimtex.parse_documentclass() abort dict " {{{1
let self.documentclass = ''
for l:line in self.preamble
let l:class = matchstr(l:line, '^\s*\\documentclass.*{\zs\w*\ze}')
if !empty(l:class)
let self.documentclass = l:class
break
endif
endfor
endfunction
" }}}1
function! s:vimtex.parse_graphicspath() abort dict " {{{1
" Combine the preamble as one long string of commands
let l:preamble = join(map(copy(self.preamble),
\ 'substitute(v:val, ''\\\@<!%.*'', '''', '''')'))
" Extract the graphicspath command from this string
let l:graphicspath = matchstr(l:preamble,
\ g:vimtex#re#not_bslash
\ . '\\graphicspath\s*\{\s*\{\s*\zs.{-}\ze\s*\}\s*\}'
\)
" Add all parsed graphicspaths
let self.graphicspath = []
for l:path in split(l:graphicspath, '\s*}\s*{\s*')
let l:path = substitute(l:path, '\/\s*$', '', '')
call add(self.graphicspath, vimtex#paths#is_abs(l:path)
\ ? l:path
\ : simplify(self.root . '/' . l:path))
endfor
endfunction
" }}}1
function! s:vimtex.parse_packages() abort dict " {{{1
let self.packages = get(self, 'packages', {})
" Try to parse .fls file if present, as it is usually more complete. That is,
" it contains a generated list of all the packages that are used.
for l:line in vimtex#parser#fls(self.fls())
let l:package = matchstr(l:line, '^INPUT \zs.\+\ze\.sty$')
let l:package = fnamemodify(l:package, ':t')
if !empty(l:package)
let self.packages[l:package] = {}
endif
endfor
" Now parse preamble as well for usepackage and RequirePackage
if !has_key(self, 'preamble') | return | endif
let l:usepackages = filter(copy(self.preamble), 'v:val =~# ''\v%(usep|RequireP)ackage''')
let l:pat = g:vimtex#re#not_comment . g:vimtex#re#not_bslash
\ . '\v\\%(usep|RequireP)ackage\s*%(\[[^[\]]*\])?\s*\{\s*\zs%([^{}]+)\ze\s*\}'
call map(l:usepackages, 'matchstr(v:val, l:pat)')
call map(l:usepackages, 'split(v:val, ''\s*,\s*'')')
for l:packages in l:usepackages
for l:package in l:packages
let self.packages[l:package] = {}
endfor
endfor
endfunction
" }}}1
function! s:vimtex.gather_sources() abort dict " {{{1
let self.sources = vimtex#parser#tex#parse_files(
\ self.tex, {'root' : self.root})
call map(self.sources, 'vimtex#paths#relative(v:val, self.root)')
endfunction
" }}}1
function! s:vimtex.pprint_items() abort dict " {{{1
let l:items = [
\ ['name', self.name],
\ ['base', self.base],
\ ['root', self.root],
\ ['tex', self.tex],
\ ['out', self.out()],
\ ['log', self.log()],
\ ['aux', self.aux()],
\ ['fls', self.fls()],
\ ['main parser', self.main_parser],
\]
if self.tex_program !=# '_'
call add(l:items, ['tex program', self.tex_program])
endif
if len(self.sources) >= 2
call add(l:items, ['source files', self.sources])
endif
call add(l:items, ['compiler', get(self, 'compiler', {})])
call add(l:items, ['viewer', get(self, 'viewer', {})])
call add(l:items, ['qf', get(self, 'qf', {})])
if exists('self.documentclass')
call add(l:items, ['document class', self.documentclass])
endif
if !empty(self.packages)
call add(l:items, ['packages', sort(keys(self.packages))])
endif
return [['vimtex project', l:items]]
endfunction
" }}}1
function! s:vimtex.log() abort dict " {{{1
return self.ext('log')
endfunction
" }}}1
function! s:vimtex.aux() abort dict " {{{1
return self.ext('aux')
endfunction
" }}}1
function! s:vimtex.fls() abort dict " {{{1
return self.ext('fls')
endfunction
" }}}1
function! s:vimtex.out(...) abort dict " {{{1
return call(self.ext, ['pdf'] + a:000, self)
endfunction
" }}}1
function! s:vimtex.ext(ext, ...) abort dict " {{{1
" First check build dir (latexmk -output_directory option)
if !empty(get(get(self, 'compiler', {}), 'build_dir', ''))
let cand = self.compiler.build_dir . '/' . self.name . '.' . a:ext
if !vimtex#paths#is_abs(self.compiler.build_dir)
let cand = self.root . '/' . cand
endif
if a:0 > 0 || filereadable(cand)
return fnamemodify(cand, ':p')
endif
endif
" Next check for file in project root folder
let cand = self.root . '/' . self.name . '.' . a:ext
if a:0 > 0 || filereadable(cand)
return fnamemodify(cand, ':p')
endif
" Finally return empty string if no entry is found
return ''
endfunction
" }}}1
function! s:vimtex.getftime() abort dict " {{{1
return max(map(copy(self.sources), 'getftime(self.root . ''/'' . v:val)'))
endfunction
" }}}1
" Initialize module
let s:vimtex_states = {}
let s:vimtex_next_id = 0
endif
