diff options
Diffstat (limited to 'ftplugin/ocaml.vim')
| -rw-r--r-- | ftplugin/ocaml.vim | 835 |
1 files changed, 485 insertions, 350 deletions
diff --git a/ftplugin/ocaml.vim b/ftplugin/ocaml.vim index 5766d3e6..77f8fef0 100644 --- a/ftplugin/ocaml.vim +++ b/ftplugin/ocaml.vim @@ -6,82 +6,116 @@ endif " Maintainer: David Baelde <firstname.name@ens-lyon.org> " Mike Leary <leary@nwlink.com> " Markus Mottl <markus.mottl@gmail.com> +" Pierre Vittet <pierre-vittet@pvittet.com> " Stefano Zacchiroli <zack@bononia.it> +" Vincent Aravantinos <firstname.name@imag.fr> " URL: http://www.ocaml.info/vim/ftplugin/ocaml.vim -" Last Change: 2009 Nov 10 - Improved .annot support -" (MM for <radugrigore@gmail.com>) -" 2009 Nov 10 - Added support for looking up definitions -" (MM for <ygrek@autistici.org>) -" +" Last Change: +" 2013 Oct 27 - Added commentstring (MM) +" 2013 Jul 26 - load default compiler settings (MM) +" 2013 Jul 24 - removed superfluous efm-setting (MM) +" 2013 Jul 22 - applied fixes supplied by Hirotaka Hamada (MM) + if exists("b:did_ftplugin") finish endif let b:did_ftplugin=1 +" Use standard compiler settings unless user wants otherwise +if !exists("current_compiler") + :compiler ocaml +endif + +" some macro +if exists('*fnameescape') + function! s:Fnameescape(s) + return fnameescape(a:s) + endfun +else + function! s:Fnameescape(s) + return escape(a:s," \t\n*?[{`$\\%#'\"|!<") + endfun +endif + " Error handling -- helps moving where the compiler wants you to go let s:cposet=&cpoptions -set cpo-=C -setlocal efm= - \%EFile\ \"%f\"\\,\ line\ %l\\,\ characters\ %c-%*\\d:, - \%EFile\ \"%f\"\\,\ line\ %l\\,\ character\ %c:%m, - \%+EReference\ to\ unbound\ regexp\ name\ %m, - \%Eocamlyacc:\ e\ -\ line\ %l\ of\ \"%f\"\\,\ %m, - \%Wocamlyacc:\ w\ -\ %m, - \%-Zmake%.%#, - \%C%m, - \%D%*\\a[%*\\d]:\ Entering\ directory\ `%f', - \%X%*\\a[%*\\d]:\ Leaving\ directory\ `%f', - \%D%*\\a:\ Entering\ directory\ `%f', - \%X%*\\a:\ Leaving\ directory\ `%f', - \%DMaking\ %*\\a\ in\ %f +set cpo&vim + +" Comment string +setlocal comments= +setlocal commentstring=(*%s*) " Add mappings, unless the user didn't want this. if !exists("no_plugin_maps") && !exists("no_ocaml_maps") " (un)commenting if !hasmapto('<Plug>Comment') nmap <buffer> <LocalLeader>c <Plug>LUncomOn - vmap <buffer> <LocalLeader>c <Plug>BUncomOn + xmap <buffer> <LocalLeader>c <Plug>BUncomOn nmap <buffer> <LocalLeader>C <Plug>LUncomOff - vmap <buffer> <LocalLeader>C <Plug>BUncomOff + xmap <buffer> <LocalLeader>C <Plug>BUncomOff endif - nnoremap <buffer> <Plug>LUncomOn mz0i(* <ESC>$A *)<ESC>`z + nnoremap <buffer> <Plug>LUncomOn gI(* <End> *)<ESC> nnoremap <buffer> <Plug>LUncomOff :s/^(\* \(.*\) \*)/\1/<CR>:noh<CR> - vnoremap <buffer> <Plug>BUncomOn <ESC>:'<,'><CR>`<O<ESC>0i(*<ESC>`>o<ESC>0i*)<ESC>`< - vnoremap <buffer> <Plug>BUncomOff <ESC>:'<,'><CR>`<dd`>dd`< + xnoremap <buffer> <Plug>BUncomOn <ESC>:'<,'><CR>`<O<ESC>0i(*<ESC>`>o<ESC>0i*)<ESC>`< + xnoremap <buffer> <Plug>BUncomOff <ESC>:'<,'><CR>`<dd`>dd`< - if !hasmapto('<Plug>Abbrev') - iabbrev <buffer> ASF (assert false (* XXX *)) - iabbrev <buffer> ASS (assert (0=1) (* XXX *)) - endif + nmap <buffer> <LocalLeader>s <Plug>OCamlSwitchEdit + nmap <buffer> <LocalLeader>S <Plug>OCamlSwitchNewWin + + nmap <buffer> <LocalLeader>t <Plug>OCamlPrintType + xmap <buffer> <LocalLeader>t <Plug>OCamlPrintType endif " Let % jump between structure elements (due to Issac Trotts) -let b:mw = '' -let b:mw = b:mw . ',\<let\>:\<and\>:\(\<in\>\|;;\)' +let b:mw = '\<let\>:\<and\>:\(\<in\>\|;;\)' let b:mw = b:mw . ',\<if\>:\<then\>:\<else\>' -let b:mw = b:mw . ',\<\(for\|while\)\>:\<do\>:\<done\>,' +let b:mw = b:mw . ',\<\(for\|while\)\>:\<do\>:\<done\>' let b:mw = b:mw . ',\<\(object\|sig\|struct\|begin\)\>:\<end\>' let b:mw = b:mw . ',\<\(match\|try\)\>:\<with\>' let b:match_words = b:mw let b:match_ignorecase=0 +function! s:OcpGrep(bang,args) abort + let grepprg = &l:grepprg + let grepformat = &l:grepformat + let shellpipe = &shellpipe + try + let &l:grepprg = "ocp-grep -c never" + setlocal grepformat=%f:%l:%m + if &shellpipe ==# '2>&1| tee' || &shellpipe ==# '|& tee' + let &shellpipe = "| tee" + endif + execute 'grep! '.a:args + if empty(a:bang) && !empty(getqflist()) + return 'cfirst' + else + return '' + endif + finally + let &l:grepprg = grepprg + let &l:grepformat = grepformat + let &shellpipe = shellpipe + endtry +endfunction +command! -bar -bang -complete=file -nargs=+ Ocpgrep exe s:OcpGrep(<q-bang>, <q-args>) + " switching between interfaces (.mli) and implementations (.ml) if !exists("g:did_ocaml_switch") let g:did_ocaml_switch = 1 - map <LocalLeader>s :call OCaml_switch(0)<CR> - map <LocalLeader>S :call OCaml_switch(1)<CR> + nnoremap <Plug>OCamlSwitchEdit :<C-u>call OCaml_switch(0)<CR> + nnoremap <Plug>OCamlSwitchNewWin :<C-u>call OCaml_switch(1)<CR> fun OCaml_switch(newwin) if (match(bufname(""), "\\.mli$") >= 0) - let fname = substitute(bufname(""), "\\.mli$", ".ml", "") + let fname = s:Fnameescape(substitute(bufname(""), "\\.mli$", ".ml", "")) if (a:newwin == 1) exec "new " . fname else exec "arge " . fname endif elseif (match(bufname(""), "\\.ml$") >= 0) - let fname = bufname("") . "i" + let fname = s:Fnameescape(bufname("")) . "i" if (a:newwin == 1) exec "new " . fname else @@ -94,15 +128,8 @@ endif " Folding support " Get the modeline because folding depends on indentation -let s:s = line2byte(line('.'))+col('.')-1 -if search('^\s*(\*:o\?caml:') - let s:modeline = getline(".") -else - let s:modeline = "" -endif -if s:s > 0 - exe 'goto' s:s -endif +let lnum = search('^\s*(\*:o\?caml:', 'n') +let s:modeline = lnum? getline(lnum): "" " Get the indentation params let s:m = matchstr(s:modeline,'default\s*=\s*\d\+') @@ -128,6 +155,10 @@ if exists("g:ocaml_folding") setlocal foldexpr=OMLetFoldLevel(v:lnum) endif +let b:undo_ftplugin = "setlocal efm< foldmethod< foldexpr<" + \ . "| unlet! b:mw b:match_words b:match_ignorecase" + + " - Only definitions below, executed once ------------------------------------- if exists("*OMLetFoldLevel") @@ -181,329 +212,433 @@ function OMLetFoldLevel(l) return '=' endfunction -" Vim support for OCaml .annot files (requires Vim with python support) +" Vim support for OCaml .annot files " -" Executing OCamlPrintType(<mode>) function will display in the Vim bottom +" Last Change: 2007 Jul 17 +" Maintainer: Vincent Aravantinos <vincent.aravantinos@gmail.com> +" License: public domain +" +" Originally inspired by 'ocaml-dtypes.vim' by Stefano Zacchiroli. +" The source code is quite radically different for we not use python anymore. +" However this plugin should have the exact same behaviour, that's why the +" following lines are the quite exact copy of Stefano's original plugin : +" +" << +" Executing Ocaml_print_type(<mode>) function will display in the Vim bottom " line(s) the type of an ocaml value getting it from the corresponding .annot " file (if any). If Vim is in visual mode, <mode> should be "visual" and the " selected ocaml value correspond to the highlighted text, otherwise (<mode> " can be anything else) it corresponds to the literal found at the current " cursor position. " -" .annot files are parsed lazily the first time OCamlPrintType is invoked; is -" also possible to force the parsing using the OCamlParseAnnot() function. -" -" Typing '<LocalLeader>t' (usually ',t') will cause OCamlPrintType function -" to be invoked with the right argument depending on the current mode (visual -" or not). +" Typing '<LocalLeader>t' (LocalLeader defaults to '\', see :h LocalLeader) +" will cause " Ocaml_print_type function to be invoked with the right +" argument depending on the current mode (visual or not). +" >> " -" Copyright (C) <2003-2004> Stefano Zacchiroli <zack@bononia.it> +" If you find something not matching this behaviour, please signal it. " -" Created: Wed, 01 Oct 2003 18:16:22 +0200 zack -" LastModified: Wed, 25 Aug 2004 18:28:39 +0200 zack - -" '<LocalLeader>d' will find the definition of the name under the cursor -" and position cursor on it (only for current file) or print fully qualified name -" (for external definitions). (ocaml >= 3.11) +" Differences are: +" - no need for python support +" + plus : more portable +" + minus: no more lazy parsing, it looks very fast however " -" Additionally '<LocalLeader>t' will show whether function call is tail call -" or not. Current implementation requires selecting the whole function call -" expression (in visual mode) to work. (ocaml >= 3.11) +" - ocamlbuild support, ie. +" + the plugin finds the _build directory and looks for the +" corresponding file inside; +" + if the user decides to change the name of the _build directory thanks +" to the '-build-dir' option of ocamlbuild, the plugin will manage in +" most cases to find it out (most cases = if the source file has a unique +" name among your whole project); +" + if ocamlbuild is not used, the usual behaviour holds; ie. the .annot +" file should be in the same directory as the source file; +" + for vim plugin programmers: +" the variable 'b:_build_dir' contains the inferred path to the build +" directory, even if this one is not named '_build'. " -" Copyright (C) 2009 <ygrek@autistici.org> +" Bonus : +" - latin1 accents are handled +" - lists are handled, even on multiple lines, you don't need the visual mode +" (the cursor must be on the first bracket) +" - parenthesized expressions, arrays, and structures (ie. '(...)', '[|...|]', +" and '{...}') are handled the same way + + " Copied from Stefano's original plugin : + " << + " .annot ocaml file representation + " + " File format (copied verbatim from caml-types.el) + " + " file ::= block * + " block ::= position <SP> position <LF> annotation * + " position ::= filename <SP> num <SP> num <SP> num + " annotation ::= keyword open-paren <LF> <SP> <SP> data <LF> close-paren + " + " <SP> is a space character (ASCII 0x20) + " <LF> is a line-feed character (ASCII 0x0A) + " num is a sequence of decimal digits + " filename is a string with the lexical conventions of O'Caml + " open-paren is an open parenthesis (ASCII 0x28) + " close-paren is a closed parenthesis (ASCII 0x29) + " data is any sequence of characters where <LF> is always followed by + " at least two space characters. + " + " - in each block, the two positions are respectively the start and the + " end of the range described by the block. + " - in a position, the filename is the name of the file, the first num + " is the line number, the second num is the offset of the beginning + " of the line, the third num is the offset of the position itself. + " - the char number within the line is the difference between the third + " and second nums. + " + " For the moment, the only possible keyword is \"type\"." + " >> + + +" 1. Finding the annotation file even if we use ocamlbuild + + " In: two strings representing paths + " Out: one string representing the common prefix between the two paths + function! s:Find_common_path (p1,p2) + let temp = a:p2 + while matchstr(a:p1,temp) == '' + let temp = substitute(temp,'/[^/]*$','','') + endwhile + return temp + endfun -if !has("python") - finish -endif + " After call: + " + " Following information have been put in s:annot_file_list, using + " annot_file_name name as key: + " - annot_file_path : + " path to the .annot file corresponding to the + " source file (dealing with ocamlbuild stuff) + " - _build_path: + " path to the build directory even if this one is + " not named '_build' + " - date_of_last annot: + " Set to 0 until we load the file. It contains the + " date at which the file has been loaded. + function! s:Locate_annotation() + let annot_file_name = s:Fnameescape(expand('%:t:r')).'.annot' + if !exists ("s:annot_file_list[annot_file_name]") + silent exe 'cd' s:Fnameescape(expand('%:p:h')) + " 1st case : the annot file is in the same directory as the buffer (no ocamlbuild) + let annot_file_path = findfile(annot_file_name,'.') + if annot_file_path != '' + let annot_file_path = getcwd().'/'.annot_file_path + let _build_path = '' + else + " 2nd case : the buffer and the _build directory are in the same directory + " .. + " / \ + " / \ + " _build .ml + " + let _build_path = finddir('_build','.') + if _build_path != '' + let _build_path = getcwd().'/'._build_path + let annot_file_path = findfile(annot_file_name,'_build') + if annot_file_path != '' + let annot_file_path = getcwd().'/'.annot_file_path + endif + else + " 3rd case : the _build directory is in a directory higher in the file hierarchy + " (it can't be deeper by ocamlbuild requirements) + " .. + " / \ + " / \ + " _build ... + " \ + " \ + " .ml + " + let _build_path = finddir('_build',';') + if _build_path != '' + let project_path = substitute(_build_path,'/_build$','','') + let path_relative_to_project = s:Fnameescape(substitute(expand('%:p:h'),project_path.'/','','')) + let annot_file_path = findfile(annot_file_name,project_path.'/_build/'.path_relative_to_project) + else + let annot_file_path = findfile(annot_file_name,'**') + "4th case : what if the user decided to change the name of the _build directory ? + " -> we relax the constraints, it should work in most cases + if annot_file_path != '' + " 4a. we suppose the renamed _build directory is in the current directory + let _build_path = matchstr(annot_file_path,'^[^/]*') + if annot_file_path != '' + let annot_file_path = getcwd().'/'.annot_file_path + let _build_path = getcwd().'/'._build_path + endif + else + let annot_file_name = '' + "(Pierre Vittet: I have commented 4b because this was chrashing + "my vim (it produced infinite loop)) + " + " 4b. anarchy : the renamed _build directory may be higher in the hierarchy + " this will work if the file for which we are looking annotations has a unique name in the whole project + " if this is not the case, it may still work, but no warranty here + "let annot_file_path = findfile(annot_file_name,'**;') + "let project_path = s:Find_common_path(annot_file_path,expand('%:p:h')) + "let _build_path = matchstr(annot_file_path,project_path.'/[^/]*') + endif + endif + endif + endif -python << EOF - -import re -import os -import os.path -import string -import time -import vim - -debug = False - -class AnnExc(Exception): - def __init__(self, reason): - self.reason = reason - -no_annotations = AnnExc("No annotations (.annot) file found") -annotation_not_found = AnnExc("No type annotation found for the given text") -definition_not_found = AnnExc("No definition found for the given text") -def malformed_annotations(lineno, reason): - return AnnExc("Malformed .annot file (line = %d, reason = %s)" % (lineno,reason)) - -class Annotations: - """ - .annot ocaml file representation - - File format (copied verbatim from caml-types.el) - - file ::= block * - block ::= position <SP> position <LF> annotation * - position ::= filename <SP> num <SP> num <SP> num - annotation ::= keyword open-paren <LF> <SP> <SP> data <LF> close-paren - - <SP> is a space character (ASCII 0x20) - <LF> is a line-feed character (ASCII 0x0A) - num is a sequence of decimal digits - filename is a string with the lexical conventions of O'Caml - open-paren is an open parenthesis (ASCII 0x28) - close-paren is a closed parenthesis (ASCII 0x29) - data is any sequence of characters where <LF> is always followed by - at least two space characters. - - - in each block, the two positions are respectively the start and the - end of the range described by the block. - - in a position, the filename is the name of the file, the first num - is the line number, the second num is the offset of the beginning - of the line, the third num is the offset of the position itself. - - the char number within the line is the difference between the third - and second nums. - - Possible keywords are \"type\", \"ident\" and \"call\". - """ - - def __init__(self): - self.__filename = None # last .annot parsed file - self.__ml_filename = None # as above but s/.annot/.ml/ - self.__timestamp = None # last parse action timestamp - self.__annot = {} - self.__refs = {} - self.__calls = {} - self.__re = re.compile( - '^"[^"]*"\s+(\d+)\s+(\d+)\s+(\d+)\s+"[^"]*"\s+(\d+)\s+(\d+)\s+(\d+)$') - self.__re_int_ref = re.compile('^int_ref\s+(\w+)\s"[^"]*"\s+(\d+)\s+(\d+)\s+(\d+)') - self.__re_def_full = re.compile( - '^def\s+(\w+)\s+"[^"]*"\s+(\d+)\s+(\d+)\s+(\d+)\s+"[^"]*"\s+(\d+)\s+(\d+)\s+(\d+)$') - self.__re_def = re.compile('^def\s+(\w+)\s"[^"]*"\s+(\d+)\s+(\d+)\s+(\d+)\s+') - self.__re_ext_ref = re.compile('^ext_ref\s+(\S+)') - self.__re_kw = re.compile('^(\w+)\($') - - def __parse(self, fname): - try: - f = open(fname) - self.__annot = {} # erase internal mappings when file is reparsed - self.__refs = {} - self.__calls = {} - line = f.readline() # position line - lineno = 1 - while (line != ""): - m = self.__re.search(line) - if (not m): - raise malformed_annotations(lineno,"re doesn't match") - line1 = int(m.group(1)) - col1 = int(m.group(3)) - int(m.group(2)) - line2 = int(m.group(4)) - col2 = int(m.group(6)) - int(m.group(5)) - while 1: - line = f.readline() # keyword or position line - lineno += 1 - m = self.__re_kw.search(line) - if (not m): - break - desc = [] - line = f.readline() # description - lineno += 1 - if (line == ""): raise malformed_annotations(lineno,"no content") - while line != ")\n": - desc.append(string.strip(line)) - line = f.readline() - lineno += 1 - if (line == ""): raise malformed_annotations(lineno,"bad content") - desc = string.join(desc, "\n") - key = ((line1, col1), (line2, col2)) - if (m.group(1) == "type"): - if not self.__annot.has_key(key): - self.__annot[key] = desc - if (m.group(1) == "call"): # region, accessible only in visual mode - if not self.__calls.has_key(key): - self.__calls[key] = desc - if (m.group(1) == "ident"): - m = self.__re_int_ref.search(desc) - if m: - line = int(m.group(2)) - col = int(m.group(4)) - int(m.group(3)) - name = m.group(1) - else: - line = -1 - col = -1 - m = self.__re_ext_ref.search(desc) - if m: - name = m.group(1) - else: - line = -2 - col = -2 - name = desc - if not self.__refs.has_key(key): - self.__refs[key] = (line,col,name) - f.close() - self.__filename = fname - self.__ml_filename = vim.current.buffer.name - self.__timestamp = int(time.time()) - except IOError: - raise no_annotations - - def parse(self): - annot_file = os.path.splitext(vim.current.buffer.name)[0] + ".annot" - previous_head, head, tail = '***', annot_file, '' - while not os.path.isfile(annot_file) and head != previous_head: - previous_head = head - head, x = os.path.split(head) - if tail == '': - tail = x - else: - os.path.join(x, tail) - annot_file = os.path.join(head, '_build', tail) - self.__parse(annot_file) - - def check_file(self): - if vim.current.buffer.name == None: - raise no_annotations - if vim.current.buffer.name != self.__ml_filename or \ - os.stat(self.__filename).st_mtime > self.__timestamp: - self.parse() - - def get_type(self, (line1, col1), (line2, col2)): - if debug: - print line1, col1, line2, col2 - self.check_file() - try: - try: - extra = self.__calls[(line1, col1), (line2, col2)] - if extra == "tail": - extra = " (* tail call *)" - else: - extra = " (* function call *)" - except KeyError: - extra = "" - return self.__annot[(line1, col1), (line2, col2)] + extra - except KeyError: - raise annotation_not_found - - def get_ident(self, (line1, col1), (line2, col2)): - if debug: - print line1, col1, line2, col2 - self.check_file() - try: - (line,col,name) = self.__refs[(line1, col1), (line2, col2)] - if line >= 0 and col >= 0: - vim.command("normal "+str(line)+"gg"+str(col+1)+"|") - #current.window.cursor = (line,col) - if line == -2: - m = self.__re_def_full.search(name) - if m: - l2 = int(m.group(5)) - c2 = int(m.group(7)) - int(m.group(6)) - name = m.group(1) - else: - m = self.__re_def.search(name) - if m: - l2 = int(m.group(2)) - c2 = int(m.group(4)) - int(m.group(3)) - name = m.group(1) - else: - l2 = -1 - if False and l2 >= 0: - # select region - if c2 == 0 and l2 > 0: - vim.command("normal v"+str(l2-1)+"gg"+"$") - else: - vim.command("normal v"+str(l2)+"gg"+str(c2)+"|") - return name - except KeyError: - raise definition_not_found - -word_char_RE = re.compile("^[\w.]$") - - # TODO this function should recognize ocaml literals, actually it's just an - # hack that recognize continuous sequences of word_char_RE above -def findBoundaries(line, col): - """ given a cursor position (as returned by vim.current.window.cursor) - return two integers identify the beggining and end column of the word at - cursor position, if any. If no word is at the cursor position return the - column cursor position twice """ - left, right = col, col - line = line - 1 # mismatch vim/python line indexes - (begin_col, end_col) = (0, len(vim.current.buffer[line]) - 1) - try: - while word_char_RE.search(vim.current.buffer[line][left - 1]): - left = left - 1 - except IndexError: - pass - try: - while word_char_RE.search(vim.current.buffer[line][right + 1]): - right = right + 1 - except IndexError: - pass - return (left, right) - -annot = Annotations() # global annotation object - -def get_marks(mode): - if mode == "visual": # visual mode: lookup highlighted text - (line1, col1) = vim.current.buffer.mark("<") - (line2, col2) = vim.current.buffer.mark(">") - else: # any other mode: lookup word at cursor position - (line, col) = vim.current.window.cursor - (col1, col2) = findBoundaries(line, col) - (line1, line2) = (line, line) - begin_mark = (line1, col1) - end_mark = (line2, col2 + 1) - return (begin_mark,end_mark) - -def printOCamlType(mode): - try: - (begin_mark,end_mark) = get_marks(mode) - print annot.get_type(begin_mark, end_mark) - except AnnExc, exc: - print exc.reason - -def gotoOCamlDefinition(mode): - try: - (begin_mark,end_mark) = get_marks(mode) - print annot.get_ident(begin_mark, end_mark) - except AnnExc, exc: - print exc.reason - -def parseOCamlAnnot(): - try: - annot.parse() - except AnnExc, exc: - print exc.reason - -EOF - -fun! OCamlPrintType(current_mode) - if (a:current_mode == "visual") - python printOCamlType("visual") - else - python printOCamlType("normal") - endif -endfun + if annot_file_path == '' + throw 'E484: no annotation file found' + endif -fun! OCamlGotoDefinition(current_mode) - if (a:current_mode == "visual") - python gotoOCamlDefinition("visual") - else - python gotoOCamlDefinition("normal") - endif -endfun + silent exe 'cd' '-' + let s:annot_file_list[annot_file_name]= [annot_file_path, _build_path, 0] + endif + endfun + + " This variable contain a dictionnary of list. Each element of the dictionnary + " represent an annotation system. An annotation system is a list with : + " - annotation file name as it's key + " - annotation file path as first element of the contained list + " - build path as second element of the contained list + " - annot_file_last_mod (contain the date of .annot file) as third element + let s:annot_file_list = {} + +" 2. Finding the type information in the annotation file + + " a. The annotation file is opened in vim as a buffer that + " should be (almost) invisible to the user. + + " After call: + " The current buffer is now the one containing the .annot file. + " We manage to keep all this hidden to the user's eye. + function! s:Enter_annotation_buffer(annot_file_path) + let s:current_pos = getpos('.') + let s:current_hidden = &l:hidden + set hidden + let s:current_buf = bufname('%') + if bufloaded(a:annot_file_path) + silent exe 'keepj keepalt' 'buffer' s:Fnameescape(a:annot_file_path) + else + silent exe 'keepj keepalt' 'view' s:Fnameescape(a:annot_file_path) + endif + call setpos(".", [0, 0 , 0 , 0]) + endfun + + " After call: + " The original buffer has been restored in the exact same state as before. + function! s:Exit_annotation_buffer() + silent exe 'keepj keepalt' 'buffer' s:Fnameescape(s:current_buf) + let &l:hidden = s:current_hidden + call setpos('.',s:current_pos) + endfun + + " After call: + " The annot file is loaded and assigned to a buffer. + " This also handles the modification date of the .annot file, eg. after a + " compilation (return an updated annot_file_list). + function! s:Load_annotation(annot_file_name) + let annot = s:annot_file_list[a:annot_file_name] + let annot_file_path = annot[0] + let annot_file_last_mod = 0 + if exists("annot[2]") + let annot_file_last_mod = annot[2] + endif + if bufloaded(annot_file_path) && annot_file_last_mod < getftime(annot_file_path) + " if there is a more recent file + let nr = bufnr(annot_file_path) + silent exe 'keepj keepalt' 'bunload' nr + endif + if !bufloaded(annot_file_path) + call s:Enter_annotation_buffer(annot_file_path) + setlocal nobuflisted + setlocal bufhidden=hide + setlocal noswapfile + setlocal buftype=nowrite + call s:Exit_annotation_buffer() + let annot[2] = getftime(annot_file_path) + " List updated with the new date + let s:annot_file_list[a:annot_file_name] = annot + endif + endfun + + "b. 'search' and 'match' work to find the type information + + "In: - lin1,col1: postion of expression first char + " - lin2,col2: postion of expression last char + "Out: - the pattern to be looked for to find the block + " Must be called in the source buffer (use of line2byte) + function! s:Block_pattern(lin1,lin2,col1,col2) + let start_num1 = a:lin1 + let start_num2 = line2byte(a:lin1) - 1 + let start_num3 = start_num2 + a:col1 + let path = '"\(\\"\|[^"]\)\+"' + let start_pos = path.' '.start_num1.' '.start_num2.' '.start_num3 + let end_num1 = a:lin2 + let end_num2 = line2byte(a:lin2) - 1 + let end_num3 = end_num2 + a:col2 + let end_pos = path.' '.end_num1.' '.end_num2.' '.end_num3 + return '^'.start_pos.' '.end_pos."$" + " rq: the '^' here is not totally correct regarding the annot file "grammar" + " but currently the annotation file respects this, and it's a little bit faster with the '^'; + " can be removed safely. + endfun + + "In: (the cursor position should be at the start of an annotation) + "Out: the type information + " Must be called in the annotation buffer (use of search) + function! s:Match_data() + " rq: idem as previously, in the following, the '^' at start of patterns is not necessary + keepj while search('^type($','ce',line(".")) == 0 + keepj if search('^.\{-}($','e') == 0 + throw "no_annotation" + endif + keepj if searchpair('(','',')') == 0 + throw "malformed_annot_file" + endif + endwhile + let begin = line(".") + 1 + keepj if searchpair('(','',')') == 0 + throw "malformed_annot_file" + endif + let end = line(".") - 1 + return join(getline(begin,end),"\n") + endfun + + "In: the pattern to look for in order to match the block + "Out: the type information (calls s:Match_data) + " Should be called in the annotation buffer + function! s:Extract_type_data(block_pattern, annot_file_name) + let annot_file_path = s:annot_file_list[a:annot_file_name][0] + call s:Enter_annotation_buffer(annot_file_path) + try + if search(a:block_pattern,'e') == 0 + throw "no_annotation" + endif + call cursor(line(".") + 1,1) + let annotation = s:Match_data() + finally + call s:Exit_annotation_buffer() + endtry + return annotation + endfun + + "c. link this stuff with what the user wants + " ie. get the expression selected/under the cursor + + let s:ocaml_word_char = '\w|[À-ÿ]|''' + + "In: the current mode (eg. "visual", "normal", etc.) + "Out: the borders of the expression we are looking for the type + function! s:Match_borders(mode) + if a:mode == "visual" + let cur = getpos(".") + normal `< + let col1 = col(".") + let lin1 = line(".") + normal `> + let col2 = col(".") + let lin2 = line(".") + call cursor(cur[1],cur[2]) + return [lin1,lin2,col1-1,col2] + else + let cursor_line = line(".") + let cursor_col = col(".") + let line = getline('.') + if line[cursor_col-1:cursor_col] == '[|' + let [lin2,col2] = searchpairpos('\[|','','|\]','n') + return [cursor_line,lin2,cursor_col-1,col2+1] + elseif line[cursor_col-1] == '[' + let [lin2,col2] = searchpairpos('\[','','\]','n') + return [cursor_line,lin2,cursor_col-1,col2] + elseif line[cursor_col-1] == '(' + let [lin2,col2] = searchpairpos('(','',')','n') + return [cursor_line,lin2,cursor_col-1,col2] + elseif line[cursor_col-1] == '{' + let [lin2,col2] = searchpairpos('{','','}','n') + return [cursor_line,lin2,cursor_col-1,col2] + else + let [lin1,col1] = searchpos('\v%('.s:ocaml_word_char.'|\.)*','ncb') + let [lin2,col2] = searchpos('\v%('.s:ocaml_word_char.'|\.)*','nce') + if col1 == 0 || col2 == 0 + throw "no_expression" + endif + return [cursor_line,cursor_line,col1-1,col2] + endif + endif + endfun + + "In: the current mode (eg. "visual", "normal", etc.) + "Out: the type information (calls s:Extract_type_data) + function! s:Get_type(mode, annot_file_name) + let [lin1,lin2,col1,col2] = s:Match_borders(a:mode) + return s:Extract_type_data(s:Block_pattern(lin1,lin2,col1,col2), a:annot_file_name) + endfun + + "In: A string destined to be printed in the 'echo buffer'. It has line + "break and 2 space at each line beginning. + "Out: A string destined to be yanked, without space and double space. + function s:unformat_ocaml_type(res) + "Remove end of line. + let res = substitute (a:res, "\n", "", "g" ) + "remove double space + let res =substitute(res , " ", " ", "g") + "remove space at begining of string. + let res = substitute(res, "^ *", "", "g") + return res + endfunction + + "d. main + "In: the current mode (eg. "visual", "normal", etc.) + "After call: the type information is displayed + if !exists("*Ocaml_get_type") + function Ocaml_get_type(mode) + let annot_file_name = s:Fnameescape(expand('%:t:r')).'.annot' + call s:Locate_annotation() + call s:Load_annotation(annot_file_name) + let res = s:Get_type(a:mode, annot_file_name) + " Copy result in the unnamed buffer + let @" = s:unformat_ocaml_type(res) + return res + endfun + endif -fun! OCamlParseAnnot() - python parseOCamlAnnot() -endfun + if !exists("*Ocaml_get_type_or_not") + function Ocaml_get_type_or_not(mode) + let t=reltime() + try + let res = Ocaml_get_type(a:mode) + return res + catch + return "" + endtry + endfun + endif + + if !exists("*Ocaml_print_type") + function Ocaml_print_type(mode) + if expand("%:e") == "mli" + echohl ErrorMsg | echo "No annotations for interface (.mli) files" | echohl None + return + endif + try + echo Ocaml_get_type(a:mode) + catch /E484:/ + echohl ErrorMsg | echo "No type annotations (.annot) file found" | echohl None + catch /no_expression/ + echohl ErrorMsg | echo "No expression found under the cursor" | echohl None + catch /no_annotation/ + echohl ErrorMsg | echo "No type annotation found for the given text" | echohl None + catch /malformed_annot_file/ + echohl ErrorMsg | echo "Malformed .annot file" | echohl None + endtry + endfun + endif -map <LocalLeader>t :call OCamlPrintType("normal")<RETURN> -vmap <LocalLeader>t :call OCamlPrintType("visual")<RETURN> -map <LocalLeader>d :call OCamlGotoDefinition("normal")<RETURN> -vmap <LocalLeader>d :call OCamlGotoDefinition("visual")<RETURN> +" Maps + nnoremap <silent> <Plug>OCamlPrintType :<C-U>call Ocaml_print_type("normal")<CR> + xnoremap <silent> <Plug>OCamlPrintType :<C-U>call Ocaml_print_type("visual")<CR>`< let &cpoptions=s:cposet unlet s:cposet -" vim:sw=2 +" vim:sw=2 fdm=indent |