Introduction

fortran ide for vim. It is intended to make the coding with fortran easier and faster in vim.

Features

Install

The easiest way of installation is to use a vim plugin manager.

 Plugin 'rudrab/vimf90' 
 Plug 'rudrab/vimf90' 

Dependencies

  1. Modern vim, tested and developed with 8+. Vim must be build with python3+
  2. Ultisnips: (Essential) Snippetes.
  3. language server protocol aka fortls: Highly recommended.
  4. coc-nvim: Recommended to use fortls.
  5. fprettify.

fortls and fprettify will be installed automatically if you enable the feature (see below.)

Options

There are several options to configure how VimF90 will work.

  1. fortran_leader: Set your leader. Default is “`”
  2. fortran_linter: Rudimentary linting (unless you use 2). Default is 1. 2 is preferred). Option 2 will install fprettify and fortls. For a better linting, you should use a dedicated package like ALE or coc.nvim.
  3. fortran_completer: Completing do, if etc. Default is <F3>.
  4. fprettify_options: Works only with fortran_linter=2. Check fprettify --help for available options. Default is --silent.

N.B fortran_leader is different from <Leader>. <Leader> is a universal key for vim. Check your leader using :echo mapleader and :h Leader. By default, it’s \.

Features

Default leader key used here is `. You can change this by using:

let fortran_leader = "your chosen key"

in your .vimrc.

Completions

There are two ways to do the completions. One is Inbuilt Completions and Completions using Ultisnips

Inbuilt (completed using fortran_leader)

if,do,select etc statements, that are closed by a corresponding end is defined here. after typing the first line, pressing <F3> will complete the construct. for example: you type:

trial: do i=1,10<F3>        

you will get:

trial: do i=1,10
  <cursor here>
end do trial
Constructs
type: get
[name:]do[iterator]<f7> do construct
[name:]if(condition)then<f7> if construct
selectcase<f7> select construct
forall<f7> forall construct
type::name<f7> type construct

NB: this part is shamelessly copied from fortran-codecomplete

Statements

Some statements is included here for less typing. these are mostly one-liner or part of the line:

you type: you get
`wr write(⌶,*)<++>
`rd read(⌶,*)<++>
`re real(⌶)::<++>
`int integer(⌶)::<++>
`ch character(len=⌶)::<++>
`par parameter
`sre selected_real_kind(⌶)
`sie selected_integer_kind(⌶)

The <++> is a nice option, a <c-j> will put your cursor in that position. Use

 inoremap <c-j> <Esc>/<++><CR><Esc><cf>

in your .vimrc for this feature.

Subprograms (completed using fortran_completor)

These key-combinations makes program and subprograms header. It supports program(`prg), module(`mod), subroutine(`sub) and function(`fun). The initiator ` can be changed using fortran_leader (See Options for more). For example,

`prg

will yeild:

!this is file : <your file name>
! author= <users login name>
! started at: <current time>
! 
program  <filename>
implicit none
  <++start typing++>
end program  <filename>
available constructs
type: get:
`prg program header
`mod module header
`sub subroutine header
`fun function header

Ultisnips

Completions can also be achieved using Ultisnips (Few snippets are supplied with this code, as ultisnips does not provide fortran snippets. More snippets are welcome!). if, do, do while etc is inbuilt. You should define your ultisnips trigger in your vimrc(<c-b> here).

Type Get
do<c-b> do construct
if<c-b> if construct

and so on. Please check vimf90/Ultisnips/fortran.snippets in your .vim/ for complete list. (Too lazy to type all.)

NB: Kindly consider submitting your snippets as pull request. This will help me enhance my snippets.

Linting (Controlled by fortran_linter)

Basic linting is enabled. So, when a operator is typed preceded by a space, e.g. A =B⌶, a space is automatically inserted, yielding A = B⌶. This basically enables python’s pep8-like whitespace rule in fortran. You can enable/disable linting behaviour using

let fortran_linter =0/1/2/-1

where

For more, use dedicated linting packages like fortls or ALE.

Compile and Autotool Support

Some build and GNU autotool features are added. You can configure the options to your tastes.

Available compilation options
variables

Menu is added for gui-help. it helps building project using gnu-autotool. Every fortran file will open with fortran90 element in the menubar. it currently has the option of compile(make, make clean, build current file), automake( a rudimentary configure.ac and makefile.am file generator) and programing blocks (as given in Subprograms).

Language Server Protocol

To enable language server, we need coc-nvim and language server protocol aka fortls. coc-nvim is a vim plugin, use your favourite plugin manager to install it. fortls is automatically installed if fortran_linter=2).

An example vimrc for fortls using coc-nvim is shown here

let g:coc_start_at_startup = 0
augroup coc
  autocmd!
  autocmd VimEnter * :silent CocStart
augroup end
let g:coc_user_config = {
      \   'languageserver': {
      \     'fortran': {
      \       'command': '/home/rudra/.local/bin/fortls',
      \       'args': ['--lowercase_intrinsics'],
      \       'filetypes': ['fortran'],
      \       'rootPatterns': ['.fortls', '.git/'],
      \     }
      }

Contact

The preferred way to contact me is through github issues.

My other apps

Other apps I have developed: