diff options
Diffstat (limited to 'ftplugin/ocaml.vim')
| -rw-r--r-- | ftplugin/ocaml.vim | 505 |
1 files changed, 505 insertions, 0 deletions
diff --git a/ftplugin/ocaml.vim b/ftplugin/ocaml.vim new file mode 100644 index 00000000..2b39d27c --- /dev/null +++ b/ftplugin/ocaml.vim @@ -0,0 +1,505 @@ +" Language: OCaml +" Maintainer: David Baelde <firstname.name@ens-lyon.org> +" Mike Leary <leary@nwlink.com> +" Markus Mottl <markus.mottl@gmail.com> +" Stefano Zacchiroli <zack@bononia.it> +" 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>) +" +if exists("b:did_ftplugin") + finish +endif +let b:did_ftplugin=1 + +" 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 + +" 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 + nmap <buffer> <LocalLeader>C <Plug>LUncomOff + vmap <buffer> <LocalLeader>C <Plug>BUncomOff + endif + + nnoremap <buffer> <Plug>LUncomOn mz0i(* <ESC>$A *)<ESC>`z + 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`< + + if !hasmapto('<Plug>Abbrev') + iabbrev <buffer> ASF (assert false (* XXX *)) + iabbrev <buffer> ASS (assert (0=1) (* XXX *)) + endif +endif + +" Let % jump between structure elements (due to Issac Trotts) +let b:mw = '' +let b:mw = 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 . ',\<\(object\|sig\|struct\|begin\)\>:\<end\>' +let b:mw = b:mw . ',\<\(match\|try\)\>:\<with\>' +let b:match_words = b:mw + +let b:match_ignorecase=0 + +" 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> + fun OCaml_switch(newwin) + if (match(bufname(""), "\\.mli$") >= 0) + let fname = 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" + if (a:newwin == 1) + exec "new " . fname + else + exec "arge " . fname + endif + endif + endfun +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 + +" Get the indentation params +let s:m = matchstr(s:modeline,'default\s*=\s*\d\+') +if s:m != "" + let s:idef = matchstr(s:m,'\d\+') +elseif exists("g:omlet_indent") + let s:idef = g:omlet_indent +else + let s:idef = 2 +endif +let s:m = matchstr(s:modeline,'struct\s*=\s*\d\+') +if s:m != "" + let s:i = matchstr(s:m,'\d\+') +elseif exists("g:omlet_indent_struct") + let s:i = g:omlet_indent_struct +else + let s:i = s:idef +endif + +" Set the folding method +if exists("g:ocaml_folding") + setlocal foldmethod=expr + setlocal foldexpr=OMLetFoldLevel(v:lnum) +endif + +" - Only definitions below, executed once ------------------------------------- + +if exists("*OMLetFoldLevel") + finish +endif + +function s:topindent(lnum) + let l = a:lnum + while l > 0 + if getline(l) =~ '\s*\%(\<struct\>\|\<sig\>\|\<object\>\)' + return indent(l) + endif + let l = l-1 + endwhile + return -s:i +endfunction + +function OMLetFoldLevel(l) + + " This is for not merging blank lines around folds to them + if getline(a:l) !~ '\S' + return -1 + endif + + " We start folds for modules, classes, and every toplevel definition + if getline(a:l) =~ '^\s*\%(\<val\>\|\<module\>\|\<class\>\|\<type\>\|\<method\>\|\<initializer\>\|\<inherit\>\|\<exception\>\|\<external\>\)' + exe 'return ">' (indent(a:l)/s:i)+1 '"' + endif + + " Toplevel let are detected thanks to the indentation + if getline(a:l) =~ '^\s*let\>' && indent(a:l) == s:i+s:topindent(a:l) + exe 'return ">' (indent(a:l)/s:i)+1 '"' + endif + + " We close fold on end which are associated to struct, sig or object. + " We use syntax information to do that. + if getline(a:l) =~ '^\s*end\>' && synIDattr(synID(a:l, indent(a:l)+1, 0), "name") != "ocamlKeyword" + return (indent(a:l)/s:i)+1 + endif + + " Folds end on ;; + if getline(a:l) =~ '^\s*;;' + exe 'return "<' (indent(a:l)/s:i)+1 '"' + endif + + " Comments around folds aren't merged to them. + if synIDattr(synID(a:l, indent(a:l)+1, 0), "name") == "ocamlComment" + return -1 + endif + + return '=' +endfunction + +" Vim support for OCaml .annot files (requires Vim with python support) +" +" Executing OCamlPrintType(<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). +" +" Copyright (C) <2003-2004> Stefano Zacchiroli <zack@bononia.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) +" +" 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) +" +" Copyright (C) 2009 <ygrek@autistici.org> + +if !has("python") + finish +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 + +fun! OCamlGotoDefinition(current_mode) + if (a:current_mode == "visual") + python gotoOCamlDefinition("visual") + else + python gotoOCamlDefinition("normal") + endif +endfun + +fun! OCamlParseAnnot() + python parseOCamlAnnot() +endfun + +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> + +let &cpoptions=s:cposet +unlet s:cposet + +" vim:sw=2 |