mirror of
https://git.savannah.gnu.org/git/emacs.git
synced 2024-11-23 07:19:15 +00:00
1010 lines
41 KiB
EmacsLisp
1010 lines
41 KiB
EmacsLisp
;;; fortran.el --- Fortran mode for GNU Emacs
|
||
|
||
;; Author: Michael D. Prange <prange@erl.mit.edu>
|
||
;; Maintainer: bug-fortran-mode@erl.mit.edu
|
||
;; Version 1.28.3
|
||
;; Last-Modified: 15 Jul 1991
|
||
|
||
;;; Copyright (c) 1991 Free Software Foundation, Inc.
|
||
|
||
;; This file is part of GNU Emacs.
|
||
|
||
;; GNU Emacs 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 2, or (at your option)
|
||
;; any later version.
|
||
|
||
;; GNU Emacs 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.
|
||
|
||
;; You should have received a copy of the GNU General Public License
|
||
;; along with GNU Emacs; see the file COPYING. If not, write to
|
||
;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
||
|
||
;;; Commentary:
|
||
|
||
;;; Written by Michael D. Prange (prange@erl.mit.edu)
|
||
;;; Maintained (as of version 1.28) by Stephen A. Wood (saw@hallc1.cebaf.gov)
|
||
;;; This version is an update of version 1.21 (Oct 1, 1985).
|
||
;;; Updated by Stephen A. Wood (saw@hallc1.cebaf.gov) to use tab format
|
||
;;; continuation control and indentation. (Digit after TAB to signify
|
||
;;; continuation line. This version also incorporates suggestions from
|
||
;;; Richard Stallman, and the ideas in two previous unpublished versions of
|
||
;;; fortran .el (version 1.21.1 (from gildea@expo.lcs.mit.edu) and 1.27
|
||
;;; (prange@erl.mit.edu).)
|
||
|
||
;;; Notes to fortran-mode version 1.28
|
||
;;; 1. Fortran mode can support either fixed format or tab format. Fixed
|
||
;;; format is where statements start in column 6 (first column is 0)
|
||
;;; and continuation lines are denoted by a character in column 5.
|
||
;;; In tab mode, statements follow a tab character. Continuation lines
|
||
;;; are where the first character on a line is a tab and the second is
|
||
;;; a digit from 1 to 9.
|
||
;;; 2. When fortran mode is called, the buffer is analyzed to determine what
|
||
;;; kind of formating is used. Starting at the top of the file, lines
|
||
;;; are scanned until a line is found that begins with a tab or 6 spaces.
|
||
;;; The mode for that buffer is then set to either tab or fixed format
|
||
;;; based on that line. If no line starting with a tab or 6 spaces is
|
||
;;; found before the end of the buffer or in the first 100 lines, the
|
||
;;; mode is set from the variable `fortran-tab-mode-default'. t is tab
|
||
;;; mode, nil is fixed format mode. By default, fixed format mode is used.
|
||
;;; To use tabbing mode as the default, put the following line in .emacs
|
||
;;; (setq fortran-tab-mode-default t)
|
||
;;; This line should not be in the hook since the hook is called only
|
||
;;; after the file is analyzed.
|
||
;;; To force a particular mode independent of the analysis, attach
|
||
;;; (fortran-tab-mode t) or (fortran-tab-mode nil)
|
||
;;; to fortran-mode-hook.
|
||
;;; 3. The command `fortran-tab-mode' will toggle between fixed and tab
|
||
;;; formatting modes. The file will not automatically be reformatted,
|
||
;;; but either `indent-region' or `fortran-indent-subprogram' can be
|
||
;;; used to reformat portions of the file.
|
||
;;; 4. Several abbreviations have been added. Abbreviation mode is turned
|
||
;;; on by default.
|
||
;;; 5. The routine fortran-blink-matching if has been incorporated (from
|
||
;;; experimental version 1.27). If the variable of the same name is set
|
||
;;; to t, the the matching if statement is blinked whenever an endif
|
||
;;; line is indented.
|
||
;;; 6. C-c C-w is now bound to fortran-window-create-momentarily (from
|
||
;;; experimental version 1.27.)
|
||
;;; 7. LFD is now bound to fortran-reindent-then-newline-and-indent.
|
||
;;; 8. fortran-continuation-string (was fortran-continuation-char) is now
|
||
;;; a string rather than a character.
|
||
;;; 9. Fixed a bug from 1.21 that gave max-lisp-eval-depth exceeded when
|
||
;;; Comments lines had !'s in them.
|
||
;;; 10. DEC fortran recognizes a & in the first column as a continuation.
|
||
;;; character. This mode does not recognize the & as a continuation
|
||
;;; character.
|
||
;;; 11. fortran-blink-matching-if still is in effect when indenting a region.
|
||
;;; Is this a desirable effect? (It looks kind of neat)
|
||
;;; 12. If you strike a digit and there are exactly 5 characters, all spaces
|
||
;;; to the left of the point, the digit will be inserted in place to
|
||
;;; serve as a continuation line marker. Similarly, if the only thing to
|
||
;;; the left of the point is a single tab, and the last command issued
|
||
;;; was neither fortran-indent-line (TAB) or fortran-reindent-then-newline-
|
||
;;; and-indent (LFD), the digit is inserted as a tab format style
|
||
;;; continuation character.
|
||
;;; 13. Both modes should usually work with tab-width set to other than 8.
|
||
;;; However, in tab-mode, if tab-width is less than 6, the column number
|
||
;;; for the minimum indentation is set to 6 so that all line numbers will
|
||
;;; have have a tab after them. This may be a bit ugly, but why would
|
||
;;; you want to use a tab-width other than 8 anyway?
|
||
;;; 14. When in tab mode, the fortran column ruler will not be correct if
|
||
;;; tab-width is not 8.
|
||
|
||
;;; Author acknowledges help from Stephen Gildea <gildea@erl.mit.edu>
|
||
|
||
;;; Bugs to bug-fortran-mode@erl.mit.edu
|
||
|
||
;;; Code:
|
||
|
||
;;;###autoload
|
||
(defvar fortran-tab-mode-default nil
|
||
"*Default tabbing/carriage control style for empty files in fortran mode.
|
||
t indicates that tab-digit style of continuation control will be used.
|
||
nil indicates that continuation lines are marked with a character in
|
||
column 6.")
|
||
|
||
(defvar fortran-do-indent 3
|
||
"*Extra indentation applied to `do' blocks.")
|
||
|
||
(defvar fortran-if-indent 3
|
||
"*Extra indentation applied to `if' blocks.")
|
||
|
||
(defvar fortran-continuation-indent 5
|
||
"*Extra indentation applied to `continuation' lines.")
|
||
|
||
(defvar fortran-comment-indent-style 'fixed
|
||
"*nil forces comment lines not to be touched,
|
||
'fixed produces fixed comment indentation to comment-column,
|
||
and 'relative indents to current fortran indentation plus comment-column.")
|
||
|
||
(defvar fortran-comment-line-column 6
|
||
"*Indentation for text in comment lines.")
|
||
|
||
(defvar comment-line-start nil
|
||
"*Delimiter inserted to start new full-line comment.")
|
||
|
||
(defvar comment-line-start-skip nil
|
||
"*Regexp to match the start of a full-line comment.")
|
||
|
||
(defvar fortran-minimum-statement-indent 6
|
||
"*Minimum indentation for fortran statements.")
|
||
|
||
;; Note that this is documented in the v18 manuals as being a string
|
||
;; of length one rather than a single character.
|
||
;; The code in this file accepts either format for compatibility.
|
||
(defvar fortran-comment-indent-char " "
|
||
"*Single-character string inserted for Fortran comment indentation.
|
||
Normally a space.")
|
||
|
||
(defvar fortran-line-number-indent 1
|
||
"*Maximum indentation for Fortran line numbers.
|
||
5 means right-justify them within their five-column field.")
|
||
|
||
(defvar fortran-check-all-num-for-matching-do nil
|
||
"*Non-nil causes all numbered lines to be treated as possible do-loop ends.")
|
||
|
||
(defvar fortran-blink-matching-if nil
|
||
"*From a fortran `endif' statement, blink the matching `if' statement.")
|
||
|
||
(defvar fortran-continuation-string "$"
|
||
"*Single-character string used for fortran continuation lines.
|
||
In fixed format continuation style, this character is inserted in
|
||
column 6 by \\[fortran-split-line] to begin a continuation line.
|
||
Also, if \\[fortran-indent-line] finds this at the beginning of a line, it will
|
||
convert the line into a continuation line of the appropriate style.
|
||
Normally $.")
|
||
|
||
(defvar fortran-comment-region "c$$$"
|
||
"*String inserted by \\[fortran-comment-region]\
|
||
at start of each line in region.")
|
||
|
||
(defvar fortran-electric-line-number t
|
||
"*Non-nil causes line number digits to be moved to the correct column as\
|
||
typed.")
|
||
|
||
(defvar fortran-startup-message t
|
||
"*Non-nil displays a startup message when Fortran mode is first called.")
|
||
|
||
(defvar fortran-column-ruler " "
|
||
"*String displayed above current line by \\[fortran-column-ruler].")
|
||
|
||
(defconst bug-fortran-mode "bug-fortran-mode@erl.mit.edu"
|
||
"Address of mailing list for Fortran mode bugs.")
|
||
|
||
(defconst fortran-mode-version "1.28.3")
|
||
|
||
(defvar fortran-mode-syntax-table nil
|
||
"Syntax table in use in Fortran mode buffers.")
|
||
|
||
(defvar fortran-analyze-depth 100
|
||
"Number of lines to scan to determine whether to use fixed or tab format\
|
||
style.")
|
||
|
||
(if fortran-mode-syntax-table
|
||
()
|
||
(setq fortran-mode-syntax-table (make-syntax-table))
|
||
(modify-syntax-entry ?\; "w" fortran-mode-syntax-table)
|
||
(modify-syntax-entry ?\r " " fortran-mode-syntax-table)
|
||
(modify-syntax-entry ?+ "." fortran-mode-syntax-table)
|
||
(modify-syntax-entry ?- "." fortran-mode-syntax-table)
|
||
(modify-syntax-entry ?= "." fortran-mode-syntax-table)
|
||
(modify-syntax-entry ?* "." fortran-mode-syntax-table)
|
||
(modify-syntax-entry ?/ "." fortran-mode-syntax-table)
|
||
(modify-syntax-entry ?\' "\"" fortran-mode-syntax-table)
|
||
(modify-syntax-entry ?\" "\"" fortran-mode-syntax-table)
|
||
(modify-syntax-entry ?\\ "/" fortran-mode-syntax-table)
|
||
(modify-syntax-entry ?. "w" fortran-mode-syntax-table)
|
||
(modify-syntax-entry ?\n ">" fortran-mode-syntax-table))
|
||
|
||
(defvar fortran-mode-map ()
|
||
"Keymap used in fortran mode.")
|
||
(if fortran-mode-map
|
||
()
|
||
(setq fortran-mode-map (make-sparse-keymap))
|
||
(define-key fortran-mode-map ";" 'fortran-abbrev-start)
|
||
(define-key fortran-mode-map "\C-c;" 'fortran-comment-region)
|
||
(define-key fortran-mode-map "\e\C-a" 'beginning-of-fortran-subprogram)
|
||
(define-key fortran-mode-map "\e\C-e" 'end-of-fortran-subprogram)
|
||
(define-key fortran-mode-map "\e;" 'fortran-indent-comment)
|
||
(define-key fortran-mode-map "\e\C-h" 'mark-fortran-subprogram)
|
||
(define-key fortran-mode-map "\e\n" 'fortran-split-line)
|
||
(define-key fortran-mode-map "\n" 'fortran-reindent-then-newline-and-indent)
|
||
(define-key fortran-mode-map "\e\C-q" 'fortran-indent-subprogram)
|
||
(define-key fortran-mode-map "\C-c\C-w" 'fortran-window-create-momentarily)
|
||
(define-key fortran-mode-map "\C-c\C-r" 'fortran-column-ruler)
|
||
(define-key fortran-mode-map "\C-c\C-p" 'fortran-previous-statement)
|
||
(define-key fortran-mode-map "\C-c\C-n" 'fortran-next-statement)
|
||
(define-key fortran-mode-map "\t" 'fortran-indent-line)
|
||
(define-key fortran-mode-map "0" 'fortran-electric-line-number)
|
||
(define-key fortran-mode-map "1" 'fortran-electric-line-number)
|
||
(define-key fortran-mode-map "2" 'fortran-electric-line-number)
|
||
(define-key fortran-mode-map "3" 'fortran-electric-line-number)
|
||
(define-key fortran-mode-map "4" 'fortran-electric-line-number)
|
||
(define-key fortran-mode-map "5" 'fortran-electric-line-number)
|
||
(define-key fortran-mode-map "6" 'fortran-electric-line-number)
|
||
(define-key fortran-mode-map "7" 'fortran-electric-line-number)
|
||
(define-key fortran-mode-map "8" 'fortran-electric-line-number)
|
||
(define-key fortran-mode-map "9" 'fortran-electric-line-number))
|
||
|
||
(defvar fortran-mode-abbrev-table nil)
|
||
(if fortran-mode-abbrev-table
|
||
()
|
||
(let ((ac abbrevs-changed))
|
||
(define-abbrev-table 'fortran-mode-abbrev-table ())
|
||
(define-abbrev fortran-mode-abbrev-table ";au" "automatic" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";b" "byte" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";bl" "block data" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";ch" "character" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";cl" "close" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";c" "continue" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";cm" "common" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";cx" "complex" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";df" "define" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";di" "dimension" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";do" "double" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";dc" "double complex" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";dp" "double precision" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";dw" "do while" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";e" "else" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";ed" "enddo" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";el" "elseif" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";en" "endif" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";eq" "equivalence" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";ex" "external" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";ey" "entry" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";f" "format" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";fa" ".false." nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";fu" "function" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";g" "goto" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";im" "implicit" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";ib" "implicit byte" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";ic" "implicit complex" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";ich" "implicit character" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";ii" "implicit integer" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";il" "implicit logical" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";ir" "implicit real" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";inc" "include" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";in" "integer" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";intr" "intrinsic" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";l" "logical" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";n" "namelist" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";o" "open" nil) ; was ;op
|
||
(define-abbrev fortran-mode-abbrev-table ";pa" "parameter" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";pr" "program" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";ps" "pause" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";p" "print" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";rc" "record" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";re" "real" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";r" "read" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";rt" "return" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";rw" "rewind" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";s" "stop" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";sa" "save" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";st" "structure" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";sc" "static" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";su" "subroutine" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";tr" ".true." nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";ty" "type" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";vo" "volatile" nil)
|
||
(define-abbrev fortran-mode-abbrev-table ";w" "write" nil)
|
||
(setq abbrevs-changed ac)))
|
||
|
||
;;;###autoload
|
||
(defun fortran-mode ()
|
||
"Major mode for editing fortran code.
|
||
Tab indents the current fortran line correctly.
|
||
`do' statements must not share a common `continue'.
|
||
|
||
Type `;?' or `;\\[help-command]' to display a list of built-in\
|
||
abbrevs for Fortran keywords.
|
||
|
||
Key definitions:
|
||
\\{fortran-mode-map}
|
||
|
||
Variables controlling indentation style and extra features:
|
||
|
||
comment-start
|
||
Normally nil in Fortran mode. If you want to use comments
|
||
starting with `!', set this to the string \"!\".
|
||
fortran-do-indent
|
||
Extra indentation within do blocks. (default 3)
|
||
fortran-if-indent
|
||
Extra indentation within if blocks. (default 3)
|
||
fortran-continuation-indent
|
||
Extra indentation appled to continuation statements. (default 5)
|
||
fortran-comment-line-column
|
||
Amount of indentation for text within full-line comments. (default 6)
|
||
fortran-comment-indent-style
|
||
nil means don't change indentation of text in full-line comments,
|
||
fixed means indent that text at column fortran-comment-line-column
|
||
relative means indent at fortran-comment-line-column beyond the
|
||
indentation for a line of code.
|
||
(default 'fixed)
|
||
fortran-comment-indent-char
|
||
Single-character string be inserted instead of space for
|
||
full-line comment indentation. (default \" \")
|
||
fortran-minimum-statement-indent
|
||
Minimum indentation for fortran statements. (default 6)
|
||
fortran-line-number-indent
|
||
Maximum indentation for line numbers. A line number will get
|
||
less than this much indentation if necessary to avoid reaching
|
||
column 5. (default 1)
|
||
fortran-check-all-num-for-matching-do
|
||
Non-nil causes all numbered lines to be treated as possible 'continue'
|
||
statements. (default nil)
|
||
fortran-blink-matching-if
|
||
From a fortran `endif' statement, blink the matching `if' statement.
|
||
(default nil)
|
||
fortran-continuation-string
|
||
Single-character string to be inserted in column 5 of a continuation
|
||
line. (default \"$\")
|
||
fortran-comment-region
|
||
String inserted by \\[fortran-comment-region] at start of each line in
|
||
region. (default \"c$$$\")
|
||
fortran-electric-line-number
|
||
Non-nil causes line number digits to be moved to the correct column
|
||
as typed. (default t)
|
||
fortran-startup-message
|
||
Set to nil to inhibit message first time Fortran mode is used.
|
||
|
||
Turning on Fortran mode calls the value of the variable fortran-mode-hook
|
||
with no args, if that value is non-nil."
|
||
(interactive)
|
||
(kill-all-local-variables)
|
||
(if fortran-startup-message
|
||
(message "Emacs Fortran mode version %s. Bugs to %s"
|
||
fortran-mode-version bug-fortran-mode))
|
||
(setq fortran-startup-message nil)
|
||
(setq local-abbrev-table fortran-mode-abbrev-table)
|
||
(set-syntax-table fortran-mode-syntax-table)
|
||
(make-local-variable 'indent-line-function)
|
||
(setq indent-line-function 'fortran-indent-line)
|
||
(make-local-variable 'comment-indent-hook)
|
||
(setq comment-indent-hook 'fortran-comment-hook)
|
||
(make-local-variable 'comment-line-start-skip)
|
||
(setq comment-line-start-skip
|
||
"^[Cc*]\\(\\([^ \t\n]\\)\\1*\\)?[ \t]*") ;[^ \t\n]* handles c$$$
|
||
(make-local-variable 'comment-line-start)
|
||
(setq comment-line-start "c")
|
||
(make-local-variable 'comment-start-skip)
|
||
(setq comment-start-skip "![ \t]*")
|
||
(make-local-variable 'comment-start)
|
||
(setq comment-start nil)
|
||
(make-local-variable 'require-final-newline)
|
||
(setq require-final-newline t)
|
||
(make-local-variable 'abbrev-all-caps)
|
||
(setq abbrev-all-caps t)
|
||
(make-local-variable 'indent-tabs-mode)
|
||
(setq indent-tabs-mode nil)
|
||
(setq abbrev-mode t) ; ?? (abbrev-mode 1) instead??
|
||
(use-local-map fortran-mode-map)
|
||
(setq mode-name "Fortran")
|
||
(setq major-mode 'fortran-mode)
|
||
(make-local-variable 'fortran-tab-mode)
|
||
(make-local-variable 'fortran-comment-line-column)
|
||
(make-local-variable 'fortran-minimum-statement-indent)
|
||
(make-local-variable 'fortran-column-ruler)
|
||
(make-local-variable 'fortran-tab-mode-string)
|
||
(fortran-tab-mode (fortran-analyze-file-format))
|
||
(run-hooks 'fortran-mode-hook))
|
||
|
||
(defun fortran-comment-hook ()
|
||
(save-excursion
|
||
(skip-chars-backward " \t")
|
||
(max (+ 1 (current-column))
|
||
comment-column)))
|
||
|
||
(defun fortran-indent-comment ()
|
||
"Align or create comment on current line.
|
||
Existing comments of all types are recognized and aligned.
|
||
If the line has no comment, a side-by-side comment is inserted and aligned
|
||
if the value of comment-start is not nil.
|
||
Otherwise, a separate-line comment is inserted, on this line
|
||
or on a new line inserted before this line if this line is not blank."
|
||
(interactive)
|
||
(beginning-of-line)
|
||
;; Recognize existing comments of either kind.
|
||
(cond ((looking-at comment-line-start-skip)
|
||
(fortran-indent-line))
|
||
((re-search-forward comment-start-skip
|
||
(save-excursion (end-of-line) (point)) t)
|
||
(indent-for-comment))
|
||
;; No existing comment.
|
||
;; If side-by-side comments are defined, insert one,
|
||
;; unless line is now blank.
|
||
((and comment-start (not (looking-at "^[ \t]*$")))
|
||
(end-of-line)
|
||
(delete-horizontal-space)
|
||
(indent-to (fortran-comment-hook))
|
||
(insert comment-start))
|
||
;; Else insert separate-line comment, making a new line if nec.
|
||
(t
|
||
(if (looking-at "^[ \t]*$")
|
||
(delete-horizontal-space)
|
||
(beginning-of-line)
|
||
(insert "\n")
|
||
(forward-char -1))
|
||
(insert comment-line-start)
|
||
(insert-char (if (stringp fortran-comment-indent-char)
|
||
(aref fortran-comment-indent-char 0)
|
||
fortran-comment-indent-char)
|
||
(- (calculate-fortran-indent) (current-column))))))
|
||
|
||
(defun fortran-comment-region (beg-region end-region arg)
|
||
"Comments every line in the region.
|
||
Puts fortran-comment-region at the beginning of every line in the region.
|
||
BEG-REGION and END-REGION are args which specify the region boundaries.
|
||
With non-nil ARG, uncomments the region."
|
||
(interactive "*r\nP")
|
||
(let ((end-region-mark (make-marker)) (save-point (point-marker)))
|
||
(set-marker end-region-mark end-region)
|
||
(goto-char beg-region)
|
||
(beginning-of-line)
|
||
(if (not arg) ;comment the region
|
||
(progn (insert fortran-comment-region)
|
||
(while (and (= (forward-line 1) 0)
|
||
(< (point) end-region-mark))
|
||
(insert fortran-comment-region)))
|
||
(let ((com (regexp-quote fortran-comment-region))) ;uncomment the region
|
||
(if (looking-at com)
|
||
(delete-region (point) (match-end 0)))
|
||
(while (and (= (forward-line 1) 0)
|
||
(< (point) end-region-mark))
|
||
(if (looking-at com)
|
||
(delete-region (point) (match-end 0))))))
|
||
(goto-char save-point)
|
||
(set-marker end-region-mark nil)
|
||
(set-marker save-point nil)))
|
||
|
||
(defun fortran-abbrev-start ()
|
||
"Typing \";\\[help-command]\" or \";?\" lists all the fortran abbrevs.
|
||
Any other key combination is executed normally."
|
||
(interactive)
|
||
(let (c)
|
||
(insert last-command-char)
|
||
(if (or (= (setq c (read-char)) ??) ;insert char if not equal to `?'
|
||
(= c help-char))
|
||
(fortran-abbrev-help)
|
||
(setq unread-command-char c))))
|
||
|
||
(defun fortran-abbrev-help ()
|
||
"List the currently defined abbrevs in Fortran mode."
|
||
(interactive)
|
||
(message "Listing abbrev table...")
|
||
(require 'abbrevlist)
|
||
(list-one-abbrev-table fortran-mode-abbrev-table "*Help*")
|
||
(message "Listing abbrev table...done"))
|
||
|
||
(defun fortran-column-ruler ()
|
||
"Inserts a column ruler momentarily above current line, till next keystroke.
|
||
The ruler is defined by the value of fortran-column-ruler.
|
||
The key typed is executed unless it is SPC."
|
||
(interactive)
|
||
(momentary-string-display
|
||
fortran-column-ruler (save-excursion (beginning-of-line) (point))
|
||
nil "Type SPC or any command to erase ruler."))
|
||
|
||
(defun fortran-window-create ()
|
||
"Makes the window 72 columns wide.
|
||
See also fortran-window-create-momentarily."
|
||
(interactive)
|
||
(condition-case error
|
||
(progn
|
||
(let ((window-min-width 2))
|
||
(if (< (window-width) (frame-width))
|
||
(enlarge-window-horizontally (- (frame-width)
|
||
(window-width) 1)))
|
||
(split-window-horizontally 73)
|
||
(other-window 1)
|
||
(switch-to-buffer " fortran-window-extra" t)
|
||
(select-window (previous-window))))
|
||
(error (message "No room for fortran window.")
|
||
'error)))
|
||
|
||
(defun fortran-window-create-momentarily (&optional arg)
|
||
"Momentarily makes the window 72 columns wide.
|
||
Optional ARG non-nil and non-unity disables the momentary feature.
|
||
See also fortran-window-create."
|
||
(interactive "p")
|
||
(if (or (not arg)
|
||
(= arg 1))
|
||
(save-window-excursion
|
||
(if (not (equal (fortran-window-create) 'error))
|
||
(progn (message "Type SPC to continue editing.")
|
||
(let ((char (read-char)))
|
||
(or (equal char (string-to-char " "))
|
||
(setq unread-command-char char))))))
|
||
(fortran-window-create)))
|
||
|
||
(defun fortran-split-line ()
|
||
"Break line at point and insert continuation marker and alignment."
|
||
(interactive)
|
||
(delete-horizontal-space)
|
||
(if (save-excursion (beginning-of-line) (looking-at comment-line-start-skip))
|
||
(insert "\n" comment-line-start " ")
|
||
(if fortran-tab-mode
|
||
(progn
|
||
(insert "\n\t")
|
||
(insert-char (fortran-numerical-continuation-char) 1))
|
||
(insert "\n" fortran-continuation-string)))
|
||
(fortran-indent-line))
|
||
|
||
(defun fortran-numerical-continuation-char ()
|
||
"Return a digit for tab-digit style of continution lines.
|
||
If, previous line is a tab-digit continuation line, returns that digit
|
||
plus one. Otherwise return 1. Zero not allowed."
|
||
(save-excursion
|
||
(forward-line -1)
|
||
(if (looking-at "\t[1-9]")
|
||
(+ ?1 (% (- (char-after (+ (point) 1)) ?0) 9))
|
||
?1)))
|
||
|
||
(defun delete-horizontal-regexp (chars)
|
||
"Delete all characters in CHARS around point.
|
||
CHARS is like the inside of a [...] in a regular expression
|
||
except that ] is never special and \ quotes ^, - or \."
|
||
(interactive "*s")
|
||
(skip-chars-backward chars)
|
||
(delete-region (point) (progn (skip-chars-forward chars) (point))))
|
||
|
||
(defun fortran-electric-line-number (arg)
|
||
"Self insert, but if part of a Fortran line number indent it automatically.
|
||
Auto-indent does not happen if a numeric arg is used."
|
||
;The use of arg may be superfluous here since there apears to be no way to
|
||
;prefix a digit key with an argument.
|
||
(interactive "P")
|
||
(if (or arg (not fortran-electric-line-number))
|
||
(if arg
|
||
(self-insert-command arg)
|
||
(self-insert-command 1))
|
||
(if (or (and (= 5 (current-column))
|
||
(save-excursion
|
||
(beginning-of-line)
|
||
(looking-at " ")));In col 5 with only spaces to left.
|
||
(and (= fortran-minimum-statement-indent (current-column))
|
||
(save-excursion
|
||
(beginning-of-line)
|
||
(looking-at "\t"));In col 8 with a single tab to the left.
|
||
(not (or (eq last-command 'fortran-indent-line)
|
||
(eq last-command
|
||
'fortran-reindent-then-newline-and-indent))))
|
||
(save-excursion
|
||
(re-search-backward "[^ \t0-9]"
|
||
(save-excursion
|
||
(beginning-of-line)
|
||
(point))
|
||
t)) ;not a line number
|
||
(looking-at "[0-9]") ;within a line number
|
||
)
|
||
(insert last-command-char)
|
||
(skip-chars-backward " \t")
|
||
(insert last-command-char)
|
||
(fortran-indent-line))))
|
||
|
||
(defun beginning-of-fortran-subprogram ()
|
||
"Moves point to the beginning of the current fortran subprogram."
|
||
(interactive)
|
||
(let ((case-fold-search t))
|
||
(beginning-of-line -1)
|
||
(re-search-backward "^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]" nil 'move)
|
||
(if (looking-at "^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]")
|
||
(forward-line 1))))
|
||
|
||
(defun end-of-fortran-subprogram ()
|
||
"Moves point to the end of the current fortran subprogram."
|
||
(interactive)
|
||
(let ((case-fold-search t))
|
||
(beginning-of-line 2)
|
||
(re-search-forward "^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]" nil 'move)
|
||
(goto-char (match-beginning 0))
|
||
(forward-line 1)))
|
||
|
||
(defun mark-fortran-subprogram ()
|
||
"Put mark at end of fortran subprogram, point at beginning.
|
||
The marks are pushed."
|
||
(interactive)
|
||
(end-of-fortran-subprogram)
|
||
(push-mark (point))
|
||
(beginning-of-fortran-subprogram))
|
||
|
||
(defun fortran-previous-statement ()
|
||
"Moves point to beginning of the previous fortran statement.
|
||
Returns 'first-statement if that statement is the first
|
||
non-comment Fortran statement in the file, and nil otherwise."
|
||
(interactive)
|
||
(let (not-first-statement continue-test)
|
||
(beginning-of-line)
|
||
(setq continue-test
|
||
(or (looking-at
|
||
(concat "[ \t]*" (regexp-quote fortran-continuation-string)))
|
||
(or (looking-at " [^ 0\n]")
|
||
(looking-at "\t[1-9]"))))
|
||
(while (and (setq not-first-statement (= (forward-line -1) 0))
|
||
(or (looking-at comment-line-start-skip)
|
||
(looking-at "[ \t]*$")
|
||
(looking-at " [^ 0\n]")
|
||
(looking-at "\t[1-9]")
|
||
(looking-at (concat "[ \t]*" comment-start-skip)))))
|
||
(cond ((and continue-test
|
||
(not not-first-statement))
|
||
(message "Incomplete continuation statement."))
|
||
(continue-test
|
||
(fortran-previous-statement))
|
||
((not not-first-statement)
|
||
'first-statement))))
|
||
|
||
(defun fortran-next-statement ()
|
||
"Moves point to beginning of the next fortran statement.
|
||
Returns `last-statement' if that statement is the last
|
||
non-comment Fortran statement in the file, and nil otherwise."
|
||
(interactive)
|
||
(let (not-last-statement)
|
||
(beginning-of-line)
|
||
(while (and (setq not-last-statement (= (forward-line 1) 0))
|
||
(or (looking-at comment-line-start-skip)
|
||
(looking-at "[ \t]*$")
|
||
(looking-at " [^ 0\n]")
|
||
(looking-at "\t[1-9]")
|
||
(looking-at (concat "[ \t]*" comment-start-skip)))))
|
||
(if (not not-last-statement)
|
||
'last-statement)))
|
||
|
||
(defun fortran-blink-matching-if ()
|
||
"From a fortran `endif' statement, blink the matching `if' statement."
|
||
(let ((count 1) (top-of-window (window-start)) matching-if
|
||
(endif-point (point)) message)
|
||
(if (save-excursion (beginning-of-line)
|
||
(skip-chars-forward " \t0-9")
|
||
(looking-at "end[ \t]*if\\b"))
|
||
(progn
|
||
(save-excursion
|
||
(while (and (not (= count 0))
|
||
(not (eq (fortran-previous-statement)
|
||
'first-statement))
|
||
(not (looking-at
|
||
"^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]")))
|
||
; Keep local to subprogram
|
||
(skip-chars-forward " \t0-9")
|
||
(cond ((looking-at "if[ \t]*(")
|
||
(save-excursion (if (or (looking-at ".*)[
|
||
\t]*then\\b[ \t]*[^ \t(=a-z0-9]")
|
||
(let (then-test);multi-line if-then
|
||
(while (and (= (forward-line 1) 0)
|
||
;search forward for then
|
||
(or
|
||
(looking-at " [^ 0\n]")
|
||
|
||
(looking-at "\t[1-9]"))
|
||
(not (setq
|
||
then-test (looking-at
|
||
|
||
".*then\\b[ \t]*[^ \t(=a-z0-9]")))))
|
||
then-test))
|
||
(setq count (- count 1)))))
|
||
((looking-at "end[ \t]*if\\b")
|
||
(setq count (+ count 1)))))
|
||
(if (not (= count 0))
|
||
(setq message "No matching if.")
|
||
(if (< (point) top-of-window)
|
||
(setq message (concat "Matches " (buffer-substring
|
||
(progn (beginning-of-line)
|
||
(point))
|
||
(progn (end-of-line)
|
||
(point)))))
|
||
(setq matching-if (point)))))
|
||
(if message
|
||
(message message)
|
||
(goto-char matching-if)
|
||
(sit-for 1)
|
||
(goto-char endif-point))))))
|
||
|
||
(defun fortran-indent-line ()
|
||
"Indents current fortran line based on its contents and on previous lines."
|
||
(interactive)
|
||
(let ((cfi (calculate-fortran-indent)))
|
||
(save-excursion
|
||
(beginning-of-line)
|
||
(if (or (not (= cfi (fortran-current-line-indentation)))
|
||
(and (re-search-forward "^[ \t]*[0-9]+" (+ (point) 4) t)
|
||
(not (fortran-line-number-indented-correctly-p))))
|
||
(fortran-indent-to-column cfi)
|
||
(beginning-of-line)
|
||
(if (and (not (looking-at comment-line-start-skip))
|
||
(re-search-forward comment-start-skip
|
||
(save-excursion (end-of-line) (point)) 'move))
|
||
(fortran-indent-comment))))
|
||
;; Never leave point in left margin.
|
||
(if (< (current-column) cfi)
|
||
(move-to-column cfi))
|
||
(if fortran-blink-matching-if
|
||
(fortran-blink-matching-if))))
|
||
|
||
(defun fortran-reindent-then-newline-and-indent ()
|
||
"Reindent the current fortran line, insert a newline and indent the newline.
|
||
An abbrev before point is expanded if abbrev-mode is non-nil."
|
||
(interactive)
|
||
(if abbrev-mode (expand-abbrev))
|
||
(save-excursion
|
||
(beginning-of-line)
|
||
(skip-chars-forward " \t")
|
||
(if (or (looking-at "[0-9]") ;Reindent only where it is most
|
||
(looking-at "end") ;likely to be necessary
|
||
(looking-at "else")
|
||
(looking-at (regexp-quote fortran-continuation-string)))
|
||
(fortran-indent-line)))
|
||
(insert "\n")
|
||
(fortran-indent-line))
|
||
|
||
(defun fortran-indent-subprogram ()
|
||
"Properly indents the Fortran subprogram which contains point."
|
||
(interactive)
|
||
(save-excursion
|
||
(mark-fortran-subprogram)
|
||
(message "Indenting subprogram...")
|
||
(indent-region (point) (mark) nil))
|
||
(message "Indenting subprogram...done."))
|
||
|
||
(defun calculate-fortran-indent ()
|
||
"Calculates the fortran indent column based on previous lines."
|
||
(let (icol first-statement (case-fold-search t)
|
||
(fortran-minimum-statement-indent
|
||
fortran-minimum-statement-indent))
|
||
(save-excursion
|
||
(setq first-statement (fortran-previous-statement))
|
||
(if first-statement
|
||
(setq icol fortran-minimum-statement-indent)
|
||
(progn
|
||
(if (= (point) (point-min))
|
||
(setq icol fortran-minimum-statement-indent)
|
||
(setq icol (fortran-current-line-indentation)))
|
||
(skip-chars-forward " \t0-9")
|
||
(cond ((looking-at "if[ \t]*(")
|
||
(if (or (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]")
|
||
(let (then-test) ;multi-line if-then
|
||
(while (and (= (forward-line 1) 0)
|
||
;search forward for then
|
||
(or (looking-at " [^ 0\n]")
|
||
(looking-at "\t[1-9]"))
|
||
(not (setq then-test (looking-at
|
||
".*then\\b[ \t]*[^ \t(=a-z0-9]")))))
|
||
then-test))
|
||
(setq icol (+ icol fortran-if-indent))))
|
||
((looking-at "\\(else\\|elseif\\)\\b")
|
||
(setq icol (+ icol fortran-if-indent)))
|
||
((looking-at "do\\b")
|
||
(setq icol (+ icol fortran-do-indent)))
|
||
((looking-at "end\\b[ \t]*[^ \t=(a-z]")
|
||
; Previous END resets indent to minimum
|
||
(setq icol fortran-minimum-statement-indent))))))
|
||
(save-excursion
|
||
(beginning-of-line)
|
||
(cond ((looking-at "[ \t]*$"))
|
||
((looking-at comment-line-start-skip)
|
||
(setq fortran-minimum-statement-indent 0)
|
||
(cond ((eq fortran-comment-indent-style 'relative)
|
||
(setq icol (+ icol fortran-comment-line-column)))
|
||
((eq fortran-comment-indent-style 'fixed)
|
||
(setq icol fortran-comment-line-column))))
|
||
((or (looking-at (concat "[ \t]*"
|
||
(regexp-quote fortran-continuation-string)))
|
||
(looking-at " [^ 0\n]")
|
||
(looking-at "\t[1-9]"))
|
||
(setq icol (+ icol fortran-continuation-indent)))
|
||
(first-statement)
|
||
((and fortran-check-all-num-for-matching-do
|
||
(looking-at "[ \t]*[0-9]+")
|
||
(fortran-check-for-matching-do))
|
||
(setq icol (- icol fortran-do-indent)))
|
||
(t
|
||
(skip-chars-forward " \t0-9")
|
||
(cond ((looking-at "end[ \t]*if\\b")
|
||
(setq icol (- icol fortran-if-indent)))
|
||
((looking-at "\\(else\\|elseif\\)\\b")
|
||
(setq icol (- icol fortran-if-indent)))
|
||
((and (looking-at "continue\\b")
|
||
(fortran-check-for-matching-do))
|
||
(setq icol (- icol fortran-do-indent)))
|
||
((looking-at "end[ \t]*do\\b")
|
||
(setq icol (- icol fortran-do-indent)))
|
||
((and (looking-at "end\\b[ \t]*[^ \t=(a-z]")
|
||
(not (= icol fortran-minimum-statement-indent)))
|
||
(message "Warning: `end' not in column %d. Probably\
|
||
an unclosed block." fortran-minimum-statement-indent))))))
|
||
(max fortran-minimum-statement-indent icol)))
|
||
|
||
(defun fortran-current-line-indentation ()
|
||
"Indentation of current line, ignoring Fortran line number or continuation.
|
||
This is the column position of the first non-whitespace character
|
||
aside from the line number and/or column 5/8 line-continuation character.
|
||
For comment lines, returns indentation of the first
|
||
non-indentation text within the comment."
|
||
(save-excursion
|
||
(beginning-of-line)
|
||
(cond ((looking-at comment-line-start-skip)
|
||
(goto-char (match-end 0))
|
||
(skip-chars-forward
|
||
(if (stringp fortran-comment-indent-char)
|
||
fortran-comment-indent-char
|
||
(char-to-string fortran-comment-indent-char))))
|
||
((or (looking-at " [^ 0\n]")
|
||
(looking-at "\t[1-9]"))
|
||
(goto-char (match-end 0)))
|
||
(t
|
||
;; Move past line number.
|
||
(re-search-forward "^[ \t0-9]*" (+ (point) 4) t)))
|
||
;; Move past whitespace.
|
||
(skip-chars-forward " \t")
|
||
(current-column)))
|
||
|
||
(defun fortran-indent-to-column (col)
|
||
"Indents current line with spaces to column COL.
|
||
notes: 1) A non-zero/non-blank character in column 5 indicates a continuation
|
||
line, and this continuation character is retained on indentation;
|
||
2) If fortran-continuation-string is the first non-whitespace character,
|
||
this is a continuation line;
|
||
3) A non-continuation line which has a number as the first
|
||
non-whitespace character is a numbered line.
|
||
4) A tab followed by a digit indicates a continuation line."
|
||
(save-excursion
|
||
(beginning-of-line)
|
||
(if (looking-at comment-line-start-skip)
|
||
(if fortran-comment-indent-style
|
||
(let ((char (if (stringp fortran-comment-indent-char)
|
||
(aref fortran-comment-indent-char 0)
|
||
fortran-comment-indent-char)))
|
||
(goto-char (match-end 0))
|
||
(delete-horizontal-regexp (concat " \t" (char-to-string char)))
|
||
(insert-char char (- col (current-column)))))
|
||
(if (looking-at "\t[1-9]")
|
||
(if fortran-tab-mode
|
||
(goto-char (match-end 0))
|
||
(delete-char 2)
|
||
(insert " ")
|
||
(insert fortran-continuation-string))
|
||
(if (looking-at " [^ 0\n]")
|
||
(if fortran-tab-mode
|
||
(progn (delete-char 6)
|
||
(insert "\t")
|
||
(insert-char (fortran-numerical-continuation-char) 1))
|
||
(forward-char 6))
|
||
(delete-horizontal-space)
|
||
;; Put line number in columns 0-4
|
||
;; or put continuation character in column 5.
|
||
(cond ((eobp))
|
||
((looking-at (regexp-quote fortran-continuation-string))
|
||
(if fortran-tab-mode
|
||
(progn
|
||
(indent-to fortran-minimum-statement-indent)
|
||
(delete-char 1)
|
||
(insert-char (fortran-numerical-continuation-char) 1))
|
||
(indent-to 5))
|
||
(forward-char 1))
|
||
((looking-at "[0-9]+")
|
||
(let ((extra-space (- 5 (- (match-end 0) (point)))))
|
||
(if (< extra-space 0)
|
||
(message "Warning: line number exceeds 5-digit limit.")
|
||
(indent-to (min fortran-line-number-indent extra-space))))
|
||
(skip-chars-forward "0-9")))))
|
||
;; Point is now after any continuation character or line number.
|
||
;; Put body of statement where specified.
|
||
(delete-horizontal-space)
|
||
(indent-to col)
|
||
;; Indent any comment following code on the same line.
|
||
(if (and comment-start-skip
|
||
(re-search-forward comment-start-skip
|
||
(save-excursion (end-of-line) (point)) t))
|
||
(progn (goto-char (match-beginning 0))
|
||
(if (not (= (current-column) (fortran-comment-hook)))
|
||
(progn (delete-horizontal-space)
|
||
(indent-to (fortran-comment-hook)))))))))
|
||
|
||
(defun fortran-line-number-indented-correctly-p ()
|
||
"Return t if current line's line number is correctly indented.
|
||
Do not call if there is no line number."
|
||
(save-excursion
|
||
(beginning-of-line)
|
||
(skip-chars-forward " \t")
|
||
(and (<= (current-column) fortran-line-number-indent)
|
||
(or (= (current-column) fortran-line-number-indent)
|
||
(progn (skip-chars-forward "0-9")
|
||
(= (current-column) 5))))))
|
||
|
||
(defun fortran-check-for-matching-do ()
|
||
"When called from a numbered statement, returns t if matching 'do' is found.
|
||
Otherwise return a nil."
|
||
(let (charnum
|
||
(case-fold-search t))
|
||
(save-excursion
|
||
(beginning-of-line)
|
||
(if (looking-at "[ \t]*[0-9]+")
|
||
(progn
|
||
(skip-chars-forward " \t")
|
||
(skip-chars-forward "0") ;skip past leading zeros
|
||
(setq charnum (buffer-substring (point)
|
||
(progn (skip-chars-forward "0-9")
|
||
(point))))
|
||
(beginning-of-line)
|
||
(and (re-search-backward
|
||
(concat
|
||
"\\(^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]\\)\\|\\(^[ \t0-9]*do[ \t]*0*"
|
||
charnum "\\b\\)\\|\\(^[ \t]*0*" charnum "\\b\\)")
|
||
nil t)
|
||
(looking-at (concat "^[ \t0-9]*do[ \t]*0*" charnum))))))))
|
||
|
||
(defun fortran-analyze-file-format ()
|
||
"Return 0 if Fixed format is used, 1 if Tab formatting is used.
|
||
Use fortran-tab-mode-default if no non-comment statements are found in the
|
||
file before the end or the first fortran-analyze-depth lines."
|
||
(save-excursion
|
||
(goto-char (point-min))
|
||
(setq i 0)
|
||
(while (not (or
|
||
(eobp)
|
||
(looking-at "\t")
|
||
(looking-at " ")
|
||
(> i fortran-analyze-depth)))
|
||
(forward-line)
|
||
(setq i (1+ i)))
|
||
(cond
|
||
((looking-at "\t") 1)
|
||
((looking-at " ") 0)
|
||
(fortran-tab-mode-default 1)
|
||
(t 0))))
|
||
|
||
(defun fortran-tab-mode (arg)
|
||
"Toggle fortran-tab-mode which indicates style of continuation lines.
|
||
With no argument, toggle on/off the tabbing mode of continuation lines.
|
||
If argument is a positive number, or non-nil if not a number, fortran-tab-mode
|
||
is turned on. Otherwise
|
||
If `fortran-tab-mode' is false"
|
||
(interactive "P")
|
||
(setq fortran-tab-mode
|
||
(if (null arg) (not fortran-tab-mode)
|
||
(if (numberp arg)
|
||
(> (prefix-numeric-value arg) 0)
|
||
(arg))))
|
||
(if fortran-tab-mode
|
||
(fortran-setup-tab-format-style)
|
||
(fortran-setup-fixed-format-style))
|
||
(set-buffer-modified-p (buffer-modified-p))) ;No-op, but updates mode line.
|
||
|
||
(defun fortran-setup-tab-format-style ()
|
||
"Set up fortran mode to use the TAB-digit mode of continuation lines.
|
||
Use the command fortran-tab-mode to toggle between this and fixed format style."
|
||
(setq fortran-comment-line-column (max tab-width 6))
|
||
(setq fortran-minimum-statement-indent (max tab-width 6))
|
||
(setq indent-tabs-mode t)
|
||
(setq fortran-column-ruler
|
||
(concat
|
||
"0 810 20 30 40 50 60 70\n"
|
||
"[ ]| { | | | | | | | | | | | | |}\n"))
|
||
(setq fortran-tab-mode-string " TAB-format")
|
||
(set-buffer-modified-p (buffer-modified-p)))
|
||
|
||
(defun fortran-setup-fixed-format-style ()
|
||
"Set up fortran mode to use the column 6 mode of continuation lines.
|
||
Use the command fortran-tab-mode to toggle between this and tab
|
||
character format style."
|
||
(setq fortran-comment-line-column 6)
|
||
(setq fortran-minimum-statement-indent 6)
|
||
(setq indent-tabs-mode nil)
|
||
(setq fortran-column-ruler
|
||
(concat
|
||
"0 4 6 10 20 30 40 50 60 70\n"
|
||
"[ ]|{ | | | | | | | | | | | | |}\n"))
|
||
(setq fortran-tab-mode-string " Fixed-format")
|
||
(set-buffer-modified-p (buffer-modified-p)))
|
||
|
||
(or (assq 'fortran-tab-mode minor-mode-alist)
|
||
(setq minor-mode-alist (cons
|
||
'(fortran-tab-mode-string fortran-tab-mode-string)
|
||
minor-mode-alist)))
|
||
|
||
(provide 'fortran)
|
||
|
||
;;; fortran.el ends here
|