2 " Maintainer: David Baelde <firstname.name@ens-lyon.org>
3 " Mike Leary <leary@nwlink.com>
4 " Markus Mottl <markus.mottl@gmail.com>
5 " Stefano Zacchiroli <zack@bononia.it>
6 " Vincent Aravantinos <firstname.name@imag.fr>
7 " URL: http://www.ocaml.info/vim/ftplugin/ocaml.vim
8 " Last Change: 2008 Jul 17 - Bugfix related to fnameescape (VA)
9 " 2007 Sep 09 - Added .annot support for ocamlbuild, python not
11 " 2006 May 01 - Added .annot support for file.whateverext (SZ)
12 " 2006 Apr 11 - Fixed an initialization bug; fixed ASS abbrev (MM)
13 " 2005 Oct 13 - removed GPL; better matchit support (MM, SZ)
15 if exists("b:did_ftplugin")
21 if exists('*fnameescape')
22 function! s:Fnameescape(s)
23 return fnameescape(a:s)
26 function! s:Fnameescape(s)
27 return escape(a:s," \t\n*?[{`$\\%#'\"|!<")
31 " Error handling -- helps moving where the compiler wants you to go
32 let s:cposet=&cpoptions
35 \%EFile\ \"%f\"\\,\ line\ %l\\,\ characters\ %c-%*\\d:,
36 \%EFile\ \"%f\"\\,\ line\ %l\\,\ character\ %c:%m,
37 \%+EReference\ to\ unbound\ regexp\ name\ %m,
38 \%Eocamlyacc:\ e\ -\ line\ %l\ of\ \"%f\"\\,\ %m,
39 \%Wocamlyacc:\ w\ -\ %m,
42 \%D%*\\a[%*\\d]:\ Entering\ directory\ `%f',
43 \%X%*\\a[%*\\d]:\ Leaving\ directory\ `%f',
44 \%D%*\\a:\ Entering\ directory\ `%f',
45 \%X%*\\a:\ Leaving\ directory\ `%f',
46 \%DMaking\ %*\\a\ in\ %f
48 " Add mappings, unless the user didn't want this.
49 if !exists("no_plugin_maps") && !exists("no_ocaml_maps")
51 if !hasmapto('<Plug>Comment')
52 nmap <buffer> <LocalLeader>c <Plug>LUncomOn
53 vmap <buffer> <LocalLeader>c <Plug>BUncomOn
54 nmap <buffer> <LocalLeader>C <Plug>LUncomOff
55 vmap <buffer> <LocalLeader>C <Plug>BUncomOff
58 nnoremap <buffer> <Plug>LUncomOn mz0i(* <ESC>$A *)<ESC>`z
59 nnoremap <buffer> <Plug>LUncomOff :s/^(\* \(.*\) \*)/\1/<CR>:noh<CR>
60 vnoremap <buffer> <Plug>BUncomOn <ESC>:'<,'><CR>`<O<ESC>0i(*<ESC>`>o<ESC>0i*)<ESC>`<
61 vnoremap <buffer> <Plug>BUncomOff <ESC>:'<,'><CR>`<dd`>dd`<
63 if !hasmapto('<Plug>Abbrev')
64 iabbrev <buffer> ASS (assert (0=1) (* XXX *))
68 " Let % jump between structure elements (due to Issac Trotts)
70 let b:mw = b:mw . ',\<let\>:\<and\>:\(\<in\>\|;;\)'
71 let b:mw = b:mw . ',\<if\>:\<then\>:\<else\>'
72 let b:mw = b:mw . ',\<\(for\|while\)\>:\<do\>:\<done\>,'
73 let b:mw = b:mw . ',\<\(object\|sig\|struct\|begin\)\>:\<end\>'
74 let b:mw = b:mw . ',\<\(match\|try\)\>:\<with\>'
75 let b:match_words = b:mw
77 let b:match_ignorecase=0
79 " switching between interfaces (.mli) and implementations (.ml)
80 if !exists("g:did_ocaml_switch")
81 let g:did_ocaml_switch = 1
82 map <LocalLeader>s :call OCaml_switch(0)<CR>
83 map <LocalLeader>S :call OCaml_switch(1)<CR>
84 fun OCaml_switch(newwin)
85 if (match(bufname(""), "\\.mli$") >= 0)
86 let fname = s:Fnameescape(substitute(bufname(""), "\\.mli$", ".ml", ""))
92 elseif (match(bufname(""), "\\.ml$") >= 0)
93 let fname = s:Fnameescape(bufname("")) . "i"
105 " Get the modeline because folding depends on indentation
106 let s:s = line2byte(line('.'))+col('.')-1
107 if search('^\s*(\*:o\?caml:')
108 let s:modeline = getline(".")
116 " Get the indentation params
117 let s:m = matchstr(s:modeline,'default\s*=\s*\d\+')
119 let s:idef = matchstr(s:m,'\d\+')
120 elseif exists("g:omlet_indent")
121 let s:idef = g:omlet_indent
125 let s:m = matchstr(s:modeline,'struct\s*=\s*\d\+')
127 let s:i = matchstr(s:m,'\d\+')
128 elseif exists("g:omlet_indent_struct")
129 let s:i = g:omlet_indent_struct
134 " Set the folding method
135 if exists("g:ocaml_folding")
136 setlocal foldmethod=expr
137 setlocal foldexpr=OMLetFoldLevel(v:lnum)
140 " - Only definitions below, executed once -------------------------------------
142 if exists("*OMLetFoldLevel")
146 function s:topindent(lnum)
149 if getline(l) =~ '\s*\%(\<struct\>\|\<sig\>\|\<object\>\)'
157 function OMLetFoldLevel(l)
159 " This is for not merging blank lines around folds to them
160 if getline(a:l) !~ '\S'
164 " We start folds for modules, classes, and every toplevel definition
165 if getline(a:l) =~ '^\s*\%(\<val\>\|\<module\>\|\<class\>\|\<type\>\|\<method\>\|\<initializer\>\|\<inherit\>\|\<exception\>\|\<external\>\)'
166 exe 'return ">' (indent(a:l)/s:i)+1 '"'
169 " Toplevel let are detected thanks to the indentation
170 if getline(a:l) =~ '^\s*let\>' && indent(a:l) == s:i+s:topindent(a:l)
171 exe 'return ">' (indent(a:l)/s:i)+1 '"'
174 " We close fold on end which are associated to struct, sig or object.
175 " We use syntax information to do that.
176 if getline(a:l) =~ '^\s*end\>' && synIDattr(synID(a:l, indent(a:l)+1, 0), "name") != "ocamlKeyword"
177 return (indent(a:l)/s:i)+1
181 if getline(a:l) =~ '^\s*;;'
182 exe 'return "<' (indent(a:l)/s:i)+1 '"'
185 " Comments around folds aren't merged to them.
186 if synIDattr(synID(a:l, indent(a:l)+1, 0), "name") == "ocamlComment"
193 " Vim support for OCaml .annot files
195 " Last Change: 2007 Jul 17
196 " Maintainer: Vincent Aravantinos <vincent.aravantinos@gmail.com>
197 " License: public domain
199 " Originally inspired by 'ocaml-dtypes.vim' by Stefano Zacchiroli.
200 " The source code is quite radically different for we not use python anymore.
201 " However this plugin should have the exact same behaviour, that's why the
202 " following lines are the quite exact copy of Stefano's original plugin :
205 " Executing Ocaml_print_type(<mode>) function will display in the Vim bottom
206 " line(s) the type of an ocaml value getting it from the corresponding .annot
207 " file (if any). If Vim is in visual mode, <mode> should be "visual" and the
208 " selected ocaml value correspond to the highlighted text, otherwise (<mode>
209 " can be anything else) it corresponds to the literal found at the current
212 " Typing '<LocalLeader>t' (LocalLeader defaults to '\', see :h LocalLeader)
213 " will cause " Ocaml_print_type function to be invoked with the right
214 " argument depending on the current mode (visual or not).
217 " If you find something not matching this behaviour, please signal it.
220 " - no need for python support
221 " + plus : more portable
222 " + minus: no more lazy parsing, it looks very fast however
224 " - ocamlbuild support, ie.
225 " + the plugin finds the _build directory and looks for the
226 " corresponding file inside;
227 " + if the user decides to change the name of the _build directory thanks
228 " to the '-build-dir' option of ocamlbuild, the plugin will manage in
229 " most cases to find it out (most cases = if the source file has a unique
230 " name among your whole project);
231 " + if ocamlbuild is not used, the usual behaviour holds; ie. the .annot
232 " file should be in the same directory as the source file;
233 " + for vim plugin programmers:
234 " the variable 'b:_build_dir' contains the inferred path to the build
235 " directory, even if this one is not named '_build'.
238 " - latin1 accents are handled
239 " - lists are handled, even on multiple lines, you don't need the visual mode
240 " (the cursor must be on the first bracket)
241 " - parenthesized expressions, arrays, and structures (ie. '(...)', '[|...|]',
242 " and '{...}') are handled the same way
244 " Copied from Stefano's original plugin :
246 " .annot ocaml file representation
248 " File format (copied verbatim from caml-types.el)
251 " block ::= position <SP> position <LF> annotation *
252 " position ::= filename <SP> num <SP> num <SP> num
253 " annotation ::= keyword open-paren <LF> <SP> <SP> data <LF> close-paren
255 " <SP> is a space character (ASCII 0x20)
256 " <LF> is a line-feed character (ASCII 0x0A)
257 " num is a sequence of decimal digits
258 " filename is a string with the lexical conventions of O'Caml
259 " open-paren is an open parenthesis (ASCII 0x28)
260 " close-paren is a closed parenthesis (ASCII 0x29)
261 " data is any sequence of characters where <LF> is always followed by
262 " at least two space characters.
264 " - in each block, the two positions are respectively the start and the
265 " end of the range described by the block.
266 " - in a position, the filename is the name of the file, the first num
267 " is the line number, the second num is the offset of the beginning
268 " of the line, the third num is the offset of the position itself.
269 " - the char number within the line is the difference between the third
272 " For the moment, the only possible keyword is \"type\"."
276 " 1. Finding the annotation file even if we use ocamlbuild
278 " In: two strings representing paths
279 " Out: one string representing the common prefix between the two paths
280 function! s:Find_common_path (p1,p2)
282 while matchstr(a:p1,temp) == ''
283 let temp = substitute(temp,'/[^/]*$','','')
289 " - b:annot_file_path :
290 " path to the .annot file corresponding to the
291 " source file (dealing with ocamlbuild stuff)
293 " path to the build directory even if this one is
295 " - b:source_file_relative_path :
296 " relative path of the source file *in* the build
297 " directory ; this is how it is reffered to in the
299 function! s:Locate_annotation()
300 if !b:annotation_file_located
302 silent exe 'cd' s:Fnameescape(expand('%:p:h'))
304 let annot_file_name = s:Fnameescape(expand('%:r')).'.annot'
306 " 1st case : the annot file is in the same directory as the buffer (no ocamlbuild)
307 let b:annot_file_path = findfile(annot_file_name,'.')
308 if b:annot_file_path != ''
309 let b:annot_file_path = getcwd().'/'.b:annot_file_path
310 let b:_build_path = ''
311 let b:source_file_relative_path = s:Fnameescape(expand('%'))
313 " 2nd case : the buffer and the _build directory are in the same directory
319 let b:_build_path = finddir('_build','.')
320 if b:_build_path != ''
321 let b:_build_path = getcwd().'/'.b:_build_path
322 let b:annot_file_path = findfile(annot_file_name,'_build')
323 if b:annot_file_path != ''
324 let b:annot_file_path = getcwd().'/'.b:annot_file_path
326 let b:source_file_relative_path = s:Fnameescape(expand('%'))
328 " 3rd case : the _build directory is in a directory higher in the file hierarchy
329 " (it can't be deeper by ocamlbuild requirements)
338 let b:_build_path = finddir('_build',';')
339 if b:_build_path != ''
340 let project_path = substitute(b:_build_path,'/_build$','','')
341 let path_relative_to_project = s:Fnameescape(substitute(expand('%:p:h'),project_path.'/','',''))
342 let b:annot_file_path = findfile(annot_file_name,project_path.'/_build/'.path_relative_to_project)
343 let b:source_file_relative_path = s:Fnameescape(substitute(expand('%:p'),project_path.'/','',''))
345 let b:annot_file_path = findfile(annot_file_name,'**')
346 "4th case : what if the user decided to change the name of the _build directory ?
347 " -> we relax the constraints, it should work in most cases
348 if b:annot_file_path != ''
349 " 4a. we suppose the renamed _build directory is in the current directory
350 let b:_build_path = matchstr(b:annot_file_path,'^[^/]*')
351 if b:annot_file_path != ''
352 let b:annot_file_path = getcwd().'/'.b:annot_file_path
353 let b:_build_path = getcwd().'/'.b:_build_path
355 let b:source_file_relative_path = s:Fnameescape(expand('%'))
357 " 4b. anarchy : the renamed _build directory may be higher in the hierarchy
358 " this will work if the file for which we are looking annotations has a unique name in the whole project
359 " if this is not the case, it may still work, but no warranty here
360 let b:annot_file_path = findfile(annot_file_name,'**;')
361 let project_path = s:Find_common_path(b:annot_file_path,expand('%:p:h'))
362 let b:_build_path = matchstr(b:annot_file_path,project_path.'/[^/]*')
363 let b:source_file_relative_path = substitute(expand('%:p'),project_path.'/','','')
369 if b:annot_file_path == ''
370 throw 'E484: no annotation file found'
375 let b:annotation_file_located = 1
379 " This in order to locate the .annot file only once
380 let b:annotation_file_located = 0
382 " 2. Finding the type information in the annotation file
384 " a. The annotation file is opened in vim as a buffer that
385 " should be (almost) invisible to the user.
388 " The current buffer is now the one containing the .annot file.
389 " We manage to keep all this hidden to the user's eye.
390 function! s:Enter_annotation_buffer()
391 let s:current_pos = getpos('.')
392 let s:current_hidden = &l:hidden
394 let s:current_buf = bufname('%')
395 if bufloaded(b:annot_file_path)
396 silent exe 'keepj keepalt' 'buffer' s:Fnameescape(b:annot_file_path)
398 silent exe 'keepj keepalt' 'view' s:Fnameescape(b:annot_file_path)
403 " The original buffer has been restored in the exact same state as before.
404 function! s:Exit_annotation_buffer()
405 silent exe 'keepj keepalt' 'buffer' s:Fnameescape(s:current_buf)
406 let &l:hidden = s:current_hidden
407 call setpos('.',s:current_pos)
411 " The annot file is loaded and assigned to a buffer.
412 " This also handles the modification date of the .annot file, eg. after a
414 function! s:Load_annotation()
415 if bufloaded(b:annot_file_path) && b:annot_file_last_mod < getftime(b:annot_file_path)
416 call s:Enter_annotation_buffer()
418 call s:Exit_annotation_buffer()
420 if !bufloaded(b:annot_file_path)
421 call s:Enter_annotation_buffer()
423 setlocal bufhidden=hide
425 setlocal buftype=nowrite
426 call s:Exit_annotation_buffer()
427 let b:annot_file_last_mod = getftime(b:annot_file_path)
431 "b. 'search' and 'match' work to find the type information
433 "In: - lin1,col1: postion of expression first char
434 " - lin2,col2: postion of expression last char
435 "Out: - the pattern to be looked for to find the block
436 " Must be called in the source buffer (use of line2byte)
437 function! s:Block_pattern(lin1,lin2,col1,col2)
438 let start_num1 = a:lin1
439 let start_num2 = line2byte(a:lin1) - 1
440 let start_num3 = start_num2 + a:col1
441 let start_pos = '"'.b:source_file_relative_path.'" '.start_num1.' '.start_num2.' '.start_num3
442 let end_num1 = a:lin2
443 let end_num2 = line2byte(a:lin2) - 1
444 let end_num3 = end_num2 + a:col2
445 let end_pos = '"'.b:source_file_relative_path.'" '.end_num1.' '.end_num2.' '.end_num3
446 return '^'.start_pos.' '.end_pos."$"
447 " rq: the '^' here is not totally correct regarding the annot file "grammar"
448 " but currently the annotation file respects this, and it's a little bit faster with the '^';
449 " can be removed safely.
452 "In: (the cursor position should be at the start of an annotation)
453 "Out: the type information
454 " Must be called in the annotation buffer (use of search)
455 function! s:Match_data()
456 " rq: idem as previously, in the following, the '^' at start of patterns is not necessary
457 keepj while search('^type($','ce',line(".")) == 0
458 keepj if search('^.\{-}($','e') == 0
459 throw "no_annotation"
461 keepj if searchpair('(','',')') == 0
462 throw "malformed_annot_file"
465 let begin = line(".") + 1
466 keepj if searchpair('(','',')') == 0
467 throw "malformed_annot_file"
469 let end = line(".") - 1
470 return join(getline(begin,end),"\n")
473 "In: the pattern to look for in order to match the block
474 "Out: the type information (calls s:Match_data)
475 " Should be called in the annotation buffer
476 function! s:Extract_type_data(block_pattern)
477 call s:Enter_annotation_buffer()
479 if search(a:block_pattern,'e') == 0
480 throw "no_annotation"
482 call cursor(line(".") + 1,1)
483 let annotation = s:Match_data()
485 call s:Exit_annotation_buffer()
490 "c. link this stuff with what the user wants
491 " ie. get the expression selected/under the cursor
493 let s:ocaml_word_char = '\w|[À-ÿ]|'''
495 "In: the current mode (eg. "visual", "normal", etc.)
496 "Out: the borders of the expression we are looking for the type
497 function! s:Match_borders(mode)
498 if a:mode == "visual"
499 let cur = getpos(".")
506 call cursor(cur[1],cur[2])
507 return [lin1,lin2,col1-1,col2]
509 let cursor_line = line(".")
510 let cursor_col = col(".")
511 let line = getline('.')
512 if line[cursor_col-1:cursor_col] == '[|'
513 let [lin2,col2] = searchpairpos('\[|','','|\]','n')
514 return [cursor_line,lin2,cursor_col-1,col2+1]
515 elseif line[cursor_col-1] == '['
516 let [lin2,col2] = searchpairpos('\[','','\]','n')
517 return [cursor_line,lin2,cursor_col-1,col2]
518 elseif line[cursor_col-1] == '('
519 let [lin2,col2] = searchpairpos('(','',')','n')
520 return [cursor_line,lin2,cursor_col-1,col2]
521 elseif line[cursor_col-1] == '{'
522 let [lin2,col2] = searchpairpos('{','','}','n')
523 return [cursor_line,lin2,cursor_col-1,col2]
525 let [lin1,col1] = searchpos('\v%('.s:ocaml_word_char.'|\.)*','ncb')
526 let [lin2,col2] = searchpos('\v%('.s:ocaml_word_char.'|\.)*','nce')
527 if col1 == 0 || col2 == 0
528 throw "no_expression"
530 return [cursor_line,cursor_line,col1-1,col2]
535 "In: the current mode (eg. "visual", "normal", etc.)
536 "Out: the type information (calls s:Extract_type_data)
537 function! s:Get_type(mode)
538 let [lin1,lin2,col1,col2] = s:Match_borders(a:mode)
539 return s:Extract_type_data(s:Block_pattern(lin1,lin2,col1,col2))
543 "In: the current mode (eg. "visual", "normal", etc.)
544 "After call: the type information is displayed
545 if !exists("*Ocaml_get_type")
546 function Ocaml_get_type(mode)
547 call s:Locate_annotation()
548 call s:Load_annotation()
549 return s:Get_type(a:mode)
553 if !exists("*Ocaml_get_type_or_not")
554 function Ocaml_get_type_or_not(mode)
557 return Ocaml_get_type(a:mode)
564 if !exists("*Ocaml_print_type")
565 function Ocaml_print_type(mode)
566 if expand("%:e") == "mli"
567 echohl ErrorMsg | echo "No annotations for interface (.mli) files" | echohl None
571 echo Ocaml_get_type(a:mode)
573 echohl ErrorMsg | echo "No type annotations (.annot) file found" | echohl None
574 catch /no_expression/
575 echohl ErrorMsg | echo "No expression found under the cursor" | echohl None
576 catch /no_annotation/
577 echohl ErrorMsg | echo "No type annotation found for the given text" | echohl None
578 catch /malformed_annot_file/
579 echohl ErrorMsg | echo "Malformed .annot file" | echohl None
585 map <silent> <LocalLeader>t :call Ocaml_print_type("normal")<CR>
586 vmap <silent> <LocalLeader>t :<C-U>call Ocaml_print_type("visual")<CR>`<
588 let &cpoptions=s:cposet
591 " vim:sw=2 fdm=indent