最近需要在linux系统下编辑fortran的代码，但是系统自带的编辑器vim本身对fortran的支持不够强大，但是好在vim本身是一个扩展性极强的编辑器，在CSDN上查找到一篇搬运的教程，但是本身没有写全，原链接又时效了，于是倒腾了一上午，结果如下：
实现了vim对fortran语法高亮的优化
image.png
自动识别自由格式，自动折叠特定模块
image.png
编辑模式下，按F7自动补全语法结束语句。
image.png
image.png
PS:本人额外添加了许多类似的模块结束语句补全功能。
实现方法：
1.打开vim对Python的支持
这一步最新版vim已经不需要执行了，因为大家都跨入py3的时代了，并且这个教程内使用到的py2脚本我也已经优化成py3格式了～～～
这里说的python是指python2+,所以需要用apt从新安装
输入sudo apt-get install vim-nox-py2 可以安装vim的特定Python支持版本，之后需要切换版本则可以使用sudo update-alternatives --config vim来切换。
这时输入vim --version | grep python 应该可以看见：
image.png
2.打开~/.vimrc文件
添加如下内容
"这是建立的vim配置文件，需要移植请拷贝致~.vimrc处。
" 这行定义了文字编码规则序列
set encoding=utf-8
set fileencodings=ucs-bom,utf-8,utf-16,gbk,big5,gb18030,shift-jis,euc-jp,euc-kr,latin1
set fileencoding=utf-8
"fortran code improve set
let s:extfname=expand("%:e")
if s:extfname==?"f90"
let fortran_free_source=1
unlet! fortran_fixed_source
else
let fortran_fixed_source=1
unlet! fortran_free_source
endif
let fortran_more_precise=1
let fortran_do_enddo=1
"去掉固定格式每行开头的红色区域
let fortran_have_tabs=1
"允许折叠
let fortran_fold=1
let fortran_fold_conditionals=1
"折叠方式
set foldmethod=syntax
"加载第三方插件
filetype plugin on
3.在~/.vim/after/indent文件夹内添加如下文件
文件命名为fortran.vim
内容为：
" Vim indent file
" Language: Fortran 95, Fortran 90 (free source form)
" Description: Indentation rules for continued statements and preprocessor
" instructions
" Indentation rules for subroutine, function and forall
" statements
" Installation: Place this script in the $HOME/.vim/after/indent/ directory
" and use it with Vim 7.1 and Ajit J. Thakkar's Vim scripts
" for Fortran (http://www.unb.ca/chem/ajit/)
" Maintainer: S閎astien Burton <sebastien.burton@gmail.com>
" License: Public domain
" Version: 0.4
" Last Change: 2011 May 25
" Modified indentation rules are used if the Fortran source code is free
" source form, else nothing is done
if (b:fortran_fixed_source != 1)
setlocal indentexpr=SebuFortranGetFreeIndent()
setlocal indentkeys+==~subroutine,=~function,=~forall
setlocal indentkeys+==~endsubroutine,=~endfunction,=~endforall
" Only define the functions once
if exists("*SebuFortranGetFreeIndent")
finish
endif
else
finish
endif
" SebuFortranGetFreeIndent() is modified FortranGetFreeIndent():
" Returns the indentation of the current line
function SebuFortranGetFreeIndent()
" No indentation for preprocessor instructions
if getline(v:lnum) =~ '^\s*#'
return 0
endif
" Previous non-blank non-preprocessor line
let lnum = SebuPrevNonBlankNonCPP(v:lnum-1)
" No indentation at the top of the file
if lnum == 0
return 0
endif
" Original indentation rules
let ind = FortranGetIndent(lnum)
" Continued statement indentation rule
" Truth table (kind of)
" Symbol '&' | Result
" No 0 0 | 0 No change
" Appearing 0 1 | 1 Indent
" Disappering 1 0 | -1 Unindent
" Continued 1 1 | 0 No change
let result = -SebuIsFortranContStat(lnum-1)+SebuIsFortranContStat(lnum)
" One shiftwidth indentation for continued statements
let ind += result*&sw
" One shiftwidth indentation for subroutine, function and forall's bodies
let line = getline(lnum)
if line =~? '^\s*\(\(recursive\s*\)\=pure\|elemental\)\=\s*subroutine\|program\|module'
\ || line =~? '^\s*\(\(recursive\s*\)\=pure\|elemental\)\=\s*'
\ . '\(\(integer\|real\|complex\|logical\|character\|type\)'
\ . '\((\S\+)\)\=\)\=\s*function'
\ || line =~? '^\s*\(forall\)'
let ind += &sw
endif
if getline(v:lnum) =~? '^\s*end\s*\(subroutine\|function\|forall\|program\|module\)'
let ind -= &sw
endif
" You shouldn't use variable names begining with 'puresubroutine',
" 'function', 'endforall', etc. as these would make the indentation
" collapse: it's easier to pay attention than to implement the exceptions
return ind
endfunction
" SebuPrevNonBlankNonCPP(lnum) is modified prevnonblank(lnum):
" Returns the line number of the first line at or above 'lnum' that is
" neither blank nor preprocessor instruction.
function SebuPrevNonBlankNonCPP(lnum)
let lnum = prevnonblank(a:lnum)
while getline(lnum) =~ '^#'
let lnum = prevnonblank(lnum-1)
endwhile
return lnum
endfunction
" SebuIsFortranContStat(lnum):
" Returns 1 if the 'lnum' statement ends with the Fortran continue mark '&'
" and 0 else.
function SebuIsFortranContStat(lnum)
let line = getline(a:lnum)
return substitute(line,'!.*$','','') =~ '&\s*$'
endfunction
4.在~/.vim/ftplugin文件夹下新建
文件名问：fortran_codecomplete.vim
(文件本身原本使用的python2语法，我已经优化成py3语法了，并且添加了对program和module块的补完操作)
内容为：
" File: fortran_codecomplete.vim
" Author: Michael Goerz (goerz AT physik DOT fu MINUS berlin DOT de)
" Version: 0.9
" Copyright: Copyright (C) 2008 Michael Goerz
" This program is free software: you can redistribute it and/or modify
" it under the terms of the GNU General Public License as published by
" the Free Software Foundation, either version 3 of the License, or
" (at your option) any later version.
"
" This program is distributed in the hope that it will be useful,
" but WITHOUT ANY WARRANTY; without even the implied warranty of
" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
" GNU General Public License for more details.
"
" Description:
" This maps the <F7> key to complete Fortran 90 constructs"
" Installation:
" Copy this file into your ftplugin directory.
python3 << EOF
import re
import vim
class SyntaxElement:
def __init__(self, pattern, closingline):
self.pattern = pattern
self.closingline = closingline
def match(self, line):
""" Return (indent, closingline) or (None, None)"""
match = self.pattern.search(line)
if match:
indentpattern = re.compile(r'^\s*')
variablepattern = re.compile(r'\$\{(?P<varname>[a-zA-Z0-9_]*)\}')
indent = indentpattern.search(line).group(0)
closingline = self.closingline
# expand variables in closingline
while True:
variable_match = variablepattern.search(closingline)
if variable_match:
try:
replacement = match.group(variable_match.group('varname'))
except:
print("Group %s is not defined in pattern" % variable_match.group('varname'))
replacement = variable_match.group('varname')
try:
closingline = closingline.replace(variable_match.group(0), replacement)
except TypeError:
if replacement is None:
replacement = ""
closingline = closingline.replace(variable_match.group(0), str(replacement))
else:
break
else:
return (None, None)
closingline = closingline.rstrip()
return (indent, closingline)
def fortran_complete():
syntax_elements = [
SyntaxElement(re.compile(r'^\s*program\s+(?P<name>[a-zA-Z0-9_]+)'),
'end program ${name}' ),
SyntaxElement(re.compile(r'^\s*type\s+(?P<name>[a-zA-Z0-9_]+)'),
'end type ${name}' ),
SyntaxElement(re.compile(r'^\s*interface\s+'),
'end interface' ),
SyntaxElement(re.compile(r'^\s*module\s+(?P<name>[a-zA-Z0-9_]+)'),
'end module ${name}' ),
SyntaxElement(re.compile(r'^\s*subroutine\s+(?P<name>[a-zA-Z0-9_]+)'),
'end subroutine ${name}' ),
SyntaxElement(re.compile(r'^\s*\w*\s*function\s+(?P<name>[a-zA-Z0-9_]+)'),
'end function ${name}' ),
SyntaxElement(re.compile(r'^\s*((?P<name>([a-zA-Z0-9_]+))\s*:)?\s*if \s*\(.*\) \s*then'),
'end if ${name}' ),
SyntaxElement(re.compile(r'^\s*((?P<name>([a-zA-Z0-9_]+))\s*:)?\s*do'),
'end do ${name}' ),
SyntaxElement(re.compile(r'^\s*select case '),
'end select' )
]
cb = vim.current.buffer
line = vim.current.window.cursor[0] - 1
cline = cb[line]
for syntax_element in syntax_elements:
(indent, closingline) = syntax_element.match(cline)
if closingline is not None:
vim.command('s/$/\x0D\x0D/') # insert two lines
shiftwidth = int(vim.eval("&shiftwidth"))
cb[line+1] = indent + (" " * shiftwidth)
cb[line+2] = indent + closingline
vim.current.window.cursor = (line+2, 1)
EOF
nmap <F7> :python3 fortran_complete()<cr>A
imap <F7> ^[:python3 fortran_complete()<cr>A
