Remove latex, fixes #484

1 files changed, 0 insertions, 700 deletions

diff --git a/autoload/vimtex/compiler/latexmk.vim b/autoload/vimtex/compiler/latexmk.vim
deleted file mode 100644
index d7a36708..00000000
--- a/autoload/vimtex/compiler/latexmk.vim
+++ /dev/null
@@ -1,700 +0,0 @@
-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#compiler#latexmk#init(options) abort " {{{1
-  let l:compiler = deepcopy(s:compiler)
-
-  call l:compiler.init(extend(a:options,
-        \ get(g:, 'vimtex_compiler_latexmk', {}), 'keep'))
-
-  return l:compiler
-endfunction
-
-" }}}1
-function! vimtex#compiler#latexmk#wrap_option(name, value) abort " {{{1
-  return has('win32')
-        \ ? ' -e "$' . a:name . ' = ''' . a:value . '''"'
-        \ : ' -e ''$' . a:name . ' = "' . a:value . '"'''
-endfunction
-
-"}}}1
-
-function! vimtex#compiler#latexmk#get_rc_opt(root, opt, type, default) abort " {{{1
-  "
-  " Parse option from .latexmkrc.
-  "
-  " Arguments:
-  "   root         Root of LaTeX project
-  "   opt          Name of options
-  "   type         0 if string, 1 if integer, 2 if list
-  "   default      Value to return if option not found in latexmkrc file
-  "
-  " Output:
-  "   [value, location]
-  "
-  "   value        Option value (integer or string)
-  "   location     An integer that indicates where option was found
-  "                 -1: not found (default value returned)
-  "                  0: global latexmkrc file
-  "                  1: local latexmkrc file
-  "
-
-  if a:type == 0
-    let l:pattern = '^\s*\$' . a:opt . '\s*=\s*[''"]\(.\+\)[''"]'
-  elseif a:type == 1
-    let l:pattern = '^\s*\$' . a:opt . '\s*=\s*\(\d\+\)'
-  elseif a:type == 2
-    let l:pattern = '^\s*@' . a:opt . '\s*=\s*(\(.*\))'
-  else
-    throw 'vimtex: argument error'
-  endif
-
-  " Candidate files
-  " - each element is a pair [path_to_file, is_local_rc_file].
-  let l:files = [
-        \ [a:root . '/latexmkrc', 1],
-        \ [a:root . '/.latexmkrc', 1],
-        \ [fnamemodify('~/.latexmkrc', ':p'), 0],
-        \]
-  if !empty($XDG_CONFIG_HOME)
-    call add(l:files, [$XDG_CONFIG_HOME . '/latexmk/latexmkrc', 0])
-  endif
-
-  let l:result = [a:default, -1]
-
-  for [l:file, l:is_local] in l:files
-    if filereadable(l:file)
-      let l:match = matchlist(readfile(l:file), l:pattern)
-      if len(l:match) > 1
-        let l:result = [l:match[1], l:is_local]
-        break
-      end
-    endif
-  endfor
-
-  " Parse the list
-  if a:type == 2 && l:result[1] > -1
-    let l:array = split(l:result[0], ',')
-    let l:result[0] = []
-    for l:x in l:array
-      let l:x = substitute(l:x, "^'", '', '')
-      let l:x = substitute(l:x, "'$", '', '')
-      let l:result[0] += [l:x]
-    endfor
-  endif
-
-  return l:result
-endfunction
-
-" }}}1
-
-let s:compiler = {
-      \ 'name' : 'latexmk',
-      \ 'executable' : 'latexmk',
-      \ 'backend' : has('nvim') ? 'nvim'
-      \                         : v:version >= 800 ? 'jobs' : 'process',
-      \ 'root' : '',
-      \ 'target' : '',
-      \ 'target_path' : '',
-      \ 'background' : 1,
-      \ 'build_dir' : '',
-      \ 'callback' : 1,
-      \ 'continuous' : 1,
-      \ 'output' : tempname(),
-      \ 'options' : [
-      \   '-verbose',
-      \   '-file-line-error',
-      \   '-synctex=1',
-      \   '-interaction=nonstopmode',
-      \ ],
-      \ 'hooks' : [],
-      \ 'shell' : fnamemodify(&shell, ':t'),
-      \}
-
-function! s:compiler.init(options) abort dict " {{{1
-  call extend(self, a:options)
-
-  call self.init_check_requirements()
-  call self.init_build_dir_option()
-  call self.init_pdf_mode_option()
-
-  call extend(self, deepcopy(s:compiler_{self.backend}))
-
-  " Continuous processes can't run in foreground, neither can processes run
-  " with the new jobs api
-  if self.continuous || self.backend !=# 'process'
-    let self.background = 1
-  endif
-
-  if self.backend !=# 'process'
-    let self.shell = 'sh'
-  endif
-endfunction
-
-" }}}1
-function! s:compiler.init_build_dir_option() abort dict " {{{1
-  "
-  " Check if .latexmkrc sets the build_dir - if so this should be respected
-  "
-  let l:out_dir =
-        \ vimtex#compiler#latexmk#get_rc_opt(self.root, 'out_dir', 0, '')[0]
-
-  if !empty(l:out_dir)
-    if !empty(self.build_dir) && (self.build_dir !=# l:out_dir)
-      call vimtex#log#warning(
-            \ 'Setting out_dir from latexmkrc overrides build_dir!',
-            \ 'Changed build_dir from: ' . self.build_dir,
-            \ 'Changed build_dir to: ' . l:out_dir)
-    endif
-    let self.build_dir = l:out_dir
-  endif
-endfunction
-
-" }}}1
-function! s:compiler.init_pdf_mode_option() abort dict " {{{1
-  " If the TeX program directive was not set, and if the pdf_mode is set in
-  " a .latexmkrc file, then deduce the compiler engine from the value of
-  " pdf_mode.
-
-  " Parse the pdf_mode option. If not found, it is set to -1.
-  let [l:pdf_mode, l:is_local] =
-        \ vimtex#compiler#latexmk#get_rc_opt(self.root, 'pdf_mode', 1, -1)
-
-  " If pdf_mode has a supported value (1: pdflatex, 4: lualatex, 5: xelatex),
-  " override the value of self.tex_program.
-  if l:pdf_mode == 1
-    let l:tex_program = 'pdflatex'
-  elseif l:pdf_mode == 3
-    let l:tex_program = 'pdfdvi'
-  elseif l:pdf_mode == 4
-    let l:tex_program = 'lualatex'
-  elseif l:pdf_mode == 5
-    let l:tex_program = 'xelatex'
-  else
-    return
-  endif
-
-  if self.tex_program ==# '_'
-    " The TeX program directive was not specified
-    let self.tex_program = l:tex_program
-  elseif l:is_local && self.tex_program !=# l:tex_program
-    call vimtex#log#warning(
-          \ 'Value of pdf_mode from latexmkrc is inconsistent with ' .
-          \ 'TeX program directive!',
-          \ 'TeX program: ' . self.tex_program,
-          \ 'pdf_mode:    ' . l:tex_program,
-          \ 'The value of pdf_mode will be ignored.')
-  endif
-endfunction
-
-" }}}1
-function! s:compiler.init_check_requirements() abort dict " {{{1
-  " Check option validity
-  if self.callback
-    if !(has('clientserver') || has('nvim') || has('job'))
-      let self.callback = 0
-      call vimtex#log#warning(
-            \ 'Can''t use callbacks without +job, +nvim, or +clientserver',
-            \ 'Callback option has been disabled.')
-    endif
-  endif
-
-  " Check for required executables
-  let l:required = [self.executable]
-  if self.continuous && !(has('win32') || has('win32unix'))
-    let l:required += ['pgrep']
-  endif
-  let l:missing = filter(l:required, '!executable(v:val)')
-
-  " Disable latexmk if required programs are missing
-  if len(l:missing) > 0
-    for l:cmd in l:missing
-      call vimtex#log#warning(l:cmd . ' is not executable')
-    endfor
-    throw 'vimtex: Requirements not met'
-  endif
-endfunction
-
-" }}}1
-
-function! s:compiler.build_cmd() abort dict " {{{1
-  if has('win32')
-    let l:cmd = 'set max_print_line=2000 & ' . self.executable
-  else
-    if self.shell ==# 'fish'
-      let l:cmd = 'set max_print_line 2000; and ' . self.executable
-    else
-      let l:cmd = 'max_print_line=2000 ' . self.executable
-    endif
-  endif
-
-  for l:opt in self.options
-    let l:cmd .= ' ' . l:opt
-  endfor
-
-  let l:cmd .= ' ' . self.get_engine()
-
-  if !empty(self.build_dir)
-    let l:cmd .= ' -outdir=' . fnameescape(self.build_dir)
-  endif
-
-  if self.continuous
-    let l:cmd .= ' -pvc'
-
-    " Set viewer options
-    if !get(g:, 'vimtex_view_automatic', 1)
-          \ || get(get(b:vimtex, 'viewer', {}), 'xwin_id') > 0
-          \ || get(s:, 'silence_next_callback', 0)
-      let l:cmd .= ' -view=none'
-    elseif g:vimtex_view_enabled
-          \ && has_key(b:vimtex.viewer, 'latexmk_append_argument')
-      let l:cmd .= b:vimtex.viewer.latexmk_append_argument()
-    endif
-
-    if self.callback
-      if has('job') || has('nvim')
-        for [l:opt, l:val] in items({
-              \ 'success_cmd' : 'vimtex_compiler_callback_success',
-              \ 'failure_cmd' : 'vimtex_compiler_callback_failure',
-              \})
-          let l:func = 'echo ' . l:val
-          let l:cmd .= vimtex#compiler#latexmk#wrap_option(l:opt, l:func)
-        endfor
-      elseif empty(v:servername)
-        call vimtex#log#warning('Can''t use callbacks with empty v:servername')
-      else
-        " Some notes:
-        " - We excape the v:servername because this seems necessary on Windows
-        "   for neovim, see e.g. Github Issue #877
-        for [l:opt, l:val] in items({'success_cmd' : 1, 'failure_cmd' : 0})
-          let l:callback = has('win32')
-                \   ? '"vimtex#compiler#callback(' . l:val . ')"'
-                \   : '\"vimtex\#compiler\#callback(' . l:val . ')\"'
-          let l:func = vimtex#util#shellescape('""')
-                \ . g:vimtex_compiler_progname
-                \ . vimtex#util#shellescape('""')
-                \ . ' --servername ' . vimtex#util#shellescape(v:servername)
-                \ . ' --remote-expr ' . l:callback
-          let l:cmd .= vimtex#compiler#latexmk#wrap_option(l:opt, l:func)
-        endfor
-      endif
-    endif
-  endif
-
-  return l:cmd . ' ' . vimtex#util#shellescape(self.target)
-endfunction
-
-" }}}1
-function! s:compiler.get_engine() abort dict " {{{1
-  return get(extend(g:vimtex_compiler_latexmk_engines,
-        \ {
-        \  'pdfdvi'           : '-pdfdvi',
-        \  'pdflatex'         : '-pdf',
-        \  'luatex'           : '-lualatex',
-        \  'lualatex'         : '-lualatex',
-        \  'xelatex'          : '-xelatex',
-        \  'context (pdftex)' : '-pdf -pdflatex=texexec',
-        \  'context (luatex)' : '-pdf -pdflatex=context',
-        \  'context (xetex)'  : '-pdf -pdflatex=''texexec --xtx''',
-        \ }, 'keep'), self.tex_program, '-pdf')
-endfunction
-
-" }}}1
-function! s:compiler.cleanup() abort dict " {{{1
-  if self.is_running()
-    call self.kill()
-  endif
-endfunction
-
-" }}}1
-function! s:compiler.pprint_items() abort dict " {{{1
-  let l:configuration = [
-        \ ['continuous', self.continuous],
-        \ ['callback', self.callback],
-        \]
-
-  if self.backend ==# 'process' && !self.continuous
-    call add(l:configuration, ['background', self.background])
-  endif
-
-  if !empty(self.build_dir)
-    call add(l:configuration, ['build_dir', self.build_dir])
-  endif
-  call add(l:configuration, ['latexmk options', self.options])
-  call add(l:configuration, ['latexmk engine', self.get_engine()])
-
-  let l:list = []
-  call add(l:list, ['backend', self.backend])
-  if self.executable !=# s:compiler.executable
-    call add(l:list, ['latexmk executable', self.executable])
-  endif
-  if self.background
-    call add(l:list, ['output', self.output])
-  endif
-
-  if self.target_path !=# b:vimtex.tex
-    call add(l:list, ['root', self.root])
-    call add(l:list, ['target', self.target_path])
-  endif
-
-  call add(l:list, ['configuration', l:configuration])
-
-  if has_key(self, 'process')
-    call add(l:list, ['process', self.process])
-  endif
-
-  if has_key(self, 'job')
-    if self.continuous
-      if self.backend ==# 'jobs'
-        call add(l:list, ['job', self.job])
-      else
-        call add(l:list, ['pid', self.get_pid()])
-      endif
-    endif
-    call add(l:list, ['cmd', self.cmd])
-  endif
-
-  return l:list
-endfunction
-
-" }}}1
-
-function! s:compiler.clean(full) abort dict " {{{1
-  let l:restart = self.is_running()
-  if l:restart
-    call self.stop()
-  endif
-
-  " Define and run the latexmk clean cmd
-  let l:cmd = (has('win32')
-        \   ? 'cd /D "' . self.root . '" & '
-        \   : 'cd ' . vimtex#util#shellescape(self.root) . '; ')
-        \ . self.executable . ' ' . (a:full ? '-C ' : '-c ')
-  if !empty(self.build_dir)
-    let l:cmd .= printf(' -outdir=%s ', fnameescape(self.build_dir))
-  endif
-  let l:cmd .= vimtex#util#shellescape(self.target)
-  call vimtex#process#run(l:cmd)
-
-  call vimtex#log#info('Compiler clean finished' . (a:full ? ' (full)' : ''))
-
-  if l:restart
-    let self.silent_next_callback = 1
-    silent call self.start()
-  endif
-endfunction
-
-" }}}1
-function! s:compiler.start(...) abort dict " {{{1
-  if self.is_running()
-    call vimtex#log#warning(
-          \ 'Compiler is already running for `' . self.target . "'")
-    return
-  endif
-
-  "
-  " Create build dir if it does not exist
-  "
-  if !empty(self.build_dir)
-    let l:dirs = split(glob(self.root . '/**/*.tex'), '\n')
-    call map(l:dirs, 'fnamemodify(v:val, '':h'')')
-    call map(l:dirs, 'strpart(v:val, strlen(self.root) + 1)')
-    call vimtex#util#uniq(sort(filter(l:dirs, "v:val !=# ''")))
-    call map(l:dirs,
-          \ (vimtex#paths#is_abs(self.build_dir) ? '' : "self.root . '/' . ")
-          \ . "self.build_dir . '/' . v:val")
-    call filter(l:dirs, '!isdirectory(v:val)')
-
-    " Create the non-existing directories
-    for l:dir in l:dirs
-      call mkdir(l:dir, 'p')
-    endfor
-  endif
-
-  call self.exec()
-
-  if self.continuous
-    call vimtex#log#info('Compiler started in continuous mode'
-          \ . (a:0 > 0 ? ' (single shot)' : ''))
-    if exists('#User#VimtexEventCompileStarted')
-      doautocmd <nomodeline> User VimtexEventCompileStarted
-    endif
-  else
-    if self.background
-      call vimtex#log#info('Compiler started in background!')
-    else
-      call vimtex#compiler#callback(!vimtex#qf#inquire(self.target))
-    endif
-  endif
-endfunction
-
-" }}}1
-function! s:compiler.stop() abort dict " {{{1
-  if self.is_running()
-    call self.kill()
-    call vimtex#log#info('Compiler stopped (' . self.target . ')')
-    if exists('#User#VimtexEventCompileStopped')
-      doautocmd <nomodeline> User VimtexEventCompileStopped
-    endif
-  else
-    call vimtex#log#warning(
-          \ 'There is no process to stop (' . self.target . ')')
-  endif
-endfunction
-
-" }}}1
-
-let s:compiler_process = {}
-function! s:compiler_process.exec() abort dict " {{{1
-  let l:process = vimtex#process#new()
-  let l:process.name = 'latexmk'
-  let l:process.continuous = self.continuous
-  let l:process.background = self.background
-  let l:process.workdir = self.root
-  let l:process.output = self.output
-  let l:process.cmd = self.build_cmd()
-
-  if l:process.continuous
-    if (has('win32') || has('win32unix'))
-      " Not implemented
-    else
-      for l:pid in split(system(
-            \ 'pgrep -f "^[^ ]*perl.*latexmk.*' . self.target . '"'), "\n")
-        let l:path = resolve('/proc/' . l:pid . '/cwd') . '/' . self.target
-        if l:path ==# self.target_path
-          let l:process.pid = str2nr(l:pid)
-          break
-        endif
-      endfor
-    endif
-  endif
-
-  function! l:process.set_pid() abort dict " {{{2
-    if (has('win32') || has('win32unix'))
-      let pidcmd = 'tasklist /fi "imagename eq latexmk.exe"'
-      let pidinfo = vimtex#process#capture(pidcmd)[-1]
-      let self.pid = str2nr(split(pidinfo,'\s\+')[1])
-    else
-      let self.pid = str2nr(system('pgrep -nf "^[^ ]*perl.*latexmk"')[:-2])
-    endif
-
-    return self.pid
-  endfunction
-
-  " }}}2
-
-  let self.process = l:process
-  call self.process.run()
-endfunction
-
-" }}}1
-function! s:compiler_process.start_single() abort dict " {{{1
-  let l:continuous = self.continuous
-  let self.continuous = self.background && self.callback && !empty(v:servername)
-
-  if self.continuous
-    let g:vimtex_compiler_callback_hooks += ['VimtexSSCallback']
-    function! VimtexSSCallback(status) abort
-      silent call vimtex#compiler#stop()
-      call remove(g:vimtex_compiler_callback_hooks, 'VimtexSSCallback')
-    endfunction
-  endif
-
-  call self.start(1)
-  let self.continuous = l:continuous
-endfunction
-
-" }}}1
-function! s:compiler_process.is_running() abort dict " {{{1
-  return exists('self.process.pid') && self.process.pid > 0
-endfunction
-
-" }}}1
-function! s:compiler_process.kill() abort dict " {{{1
-  call self.process.stop()
-endfunction
-
-" }}}1
-function! s:compiler_process.get_pid() abort dict " {{{1
-  return has_key(self, 'process') ? self.process.pid : 0
-endfunction
-
-" }}}1
-
-let s:compiler_jobs = {}
-function! s:compiler_jobs.exec() abort dict " {{{1
-  let self.cmd = self.build_cmd()
-  let l:cmd = has('win32')
-        \ ? 'cmd /s /c "' . self.cmd . '"'
-        \ : ['sh', '-c', self.cmd]
-
-  let l:options = {
-        \ 'out_io' : 'file',
-        \ 'err_io' : 'file',
-        \ 'out_name' : self.output,
-        \ 'err_name' : self.output,
-        \}
-  if self.continuous
-    let l:options.out_io = 'pipe'
-    let l:options.err_io = 'pipe'
-    let l:options.out_cb = function('s:callback_continuous_output')
-    let l:options.err_cb = function('s:callback_continuous_output')
-    call writefile([], self.output, 'a')
-  else
-    let s:cb_target = self.target_path !=# b:vimtex.tex
-          \ ? self.target_path : ''
-    let l:options.exit_cb = function('s:callback')
-  endif
-
-  call vimtex#paths#pushd(self.root)
-  let self.job = job_start(l:cmd, l:options)
-  call vimtex#paths#popd()
-endfunction
-
-" }}}1
-function! s:compiler_jobs.start_single() abort dict " {{{1
-  let l:continuous = self.continuous
-  let self.continuous = 0
-  call self.start()
-  let self.continuous = l:continuous
-endfunction
-
-" }}}1
-function! s:compiler_jobs.kill() abort dict " {{{1
-  call job_stop(self.job)
-endfunction
-
-" }}}1
-function! s:compiler_jobs.is_running() abort dict " {{{1
-  return has_key(self, 'job') && job_status(self.job) ==# 'run'
-endfunction
-
-" }}}1
-function! s:compiler_jobs.get_pid() abort dict " {{{1
-  return has_key(self, 'job')
-        \ ? get(job_info(self.job), 'process') : 0
-endfunction
-
-" }}}1
-function! s:callback(ch, msg) abort " {{{1
-  call vimtex#compiler#callback(!vimtex#qf#inquire(s:cb_target))
-endfunction
-
-" }}}1
-function! s:callback_continuous_output(channel, msg) abort " {{{1
-  if exists('b:vimtex') && filewritable(b:vimtex.compiler.output)
-    call writefile([a:msg], b:vimtex.compiler.output, 'a')
-  endif
-
-  if a:msg ==# 'vimtex_compiler_callback_success'
-    call vimtex#compiler#callback(1)
-  elseif a:msg ==# 'vimtex_compiler_callback_failure'
-    call vimtex#compiler#callback(0)
-  endif
-
-  try
-    for l:Hook in get(get(get(b:, 'vimtex', {}), 'compiler', {}), 'hooks', [])
-      call l:Hook(a:msg)
-    endfor
-  catch /E716/
-  endtry
-endfunction
-
-" }}}1
-
-let s:compiler_nvim = {}
-function! s:compiler_nvim.exec() abort dict " {{{1
-  let self.cmd = self.build_cmd()
-  let l:cmd = has('win32')
-        \ ? 'cmd /s /c "' . self.cmd . '"'
-        \ : ['sh', '-c', self.cmd]
-
-  let l:shell = {
-        \ 'on_stdout' : function('s:callback_nvim_output'),
-        \ 'on_stderr' : function('s:callback_nvim_output'),
-        \ 'cwd' : self.root,
-        \ 'target' : self.target_path,
-        \ 'output' : self.output,
-        \}
-
-  if !self.continuous
-    let l:shell.on_exit = function('s:callback_nvim_exit')
-  endif
-
-  " Initialize output file
-  try
-    call writefile([], self.output)
-  endtry
-
-  let self.job = jobstart(l:cmd, l:shell)
-endfunction
-
-" }}}1
-function! s:compiler_nvim.start_single() abort dict " {{{1
-  let l:continuous = self.continuous
-  let self.continuous = 0
-  call self.start()
-  let self.continuous = l:continuous
-endfunction
-
-" }}}1
-function! s:compiler_nvim.kill() abort dict " {{{1
-  call jobstop(self.job)
-endfunction
-
-" }}}1
-function! s:compiler_nvim.is_running() abort dict " {{{1
-  try
-    let pid = jobpid(self.job)
-    return 1
-  catch
-    return 0
-  endtry
-endfunction
-
-" }}}1
-function! s:compiler_nvim.get_pid() abort dict " {{{1
-  try
-    return jobpid(self.job)
-  catch
-    return 0
-  endtry
-endfunction
-
-" }}}1
-function! s:callback_nvim_output(id, data, event) abort dict " {{{1
-  " Filter out unwanted newlines
-  let l:data = split(substitute(join(a:data, 'QQ'), '^QQ\|QQ$', '', ''), 'QQ')
-
-  if !empty(l:data) && filewritable(self.output)
-    call writefile(l:data, self.output, 'a')
-  endif
-
-  if match(a:data, 'vimtex_compiler_callback_success') != -1
-    call vimtex#compiler#callback(!vimtex#qf#inquire(self.target))
-  elseif match(a:data, 'vimtex_compiler_callback_failure') != -1
-    call vimtex#compiler#callback(0)
-  endif
-
-  try
-    for l:Hook in get(get(get(b:, 'vimtex', {}), 'compiler', {}), 'hooks', [])
-      call l:Hook(join(a:data, "\n"))
-    endfor
-  catch /E716/
-  endtry
-endfunction
-
-" }}}1
-function! s:callback_nvim_exit(id, data, event) abort dict " {{{1
-  let l:target = self.target !=# b:vimtex.tex ? self.target : ''
-  call vimtex#compiler#callback(!vimtex#qf#inquire(l:target))
-endfunction
-
-" }}}1
-
-endif