diff options
Diffstat (limited to 'lisp/fortran.el')
| -rw-r--r-- | lisp/fortran.el | 654 |
1 files changed, 654 insertions, 0 deletions
diff --git a/lisp/fortran.el b/lisp/fortran.el new file mode 100644 index 00000000000..065cad638a0 --- /dev/null +++ b/lisp/fortran.el @@ -0,0 +1,654 @@ +;;; Fortran mode for GNU Emacs (beta test version 1.21, Oct. 1, 1985) +;;; Copyright (c) 1986 Free Software Foundation, Inc. +;;; Written by Michael D. Prange (prange@erl.mit.edu) + +;; 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 1, 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. + +;;; Author acknowledges help from Stephen Gildea <gildea@erl.mit.edu> + +;;; Bugs to bug-fortran-mode@erl.mit.edu. + +(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 ? + "*Character to be 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-continuation-char ?$ + "*Character which is inserted in column 5 by \\[fortran-split-line] +to begin a continuation line. 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 + (concat "0 4 6 10 20 30 40 50 60 70\n" + "[ ]|{ | | | | | | | | | | | | |}\n") + "*String displayed above current line by \\[fortran-column-ruler].") + +(defconst fortran-mode-version "1.21") + +(defvar fortran-mode-syntax-table nil + "Syntax table in use in fortran-mode buffers.") + +(if fortran-mode-syntax-table + () + (setq fortran-mode-syntax-table (make-syntax-table)) + (modify-syntax-entry ?\; "w" 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 "\e\C-q" 'fortran-indent-subprogram) + (define-key fortran-mode-map "\C-c\C-w" 'fortran-window-create) + (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 + () + (define-abbrev-table 'fortran-mode-abbrev-table ()) + (let ((abbrevs-changed nil)) + (define-abbrev fortran-mode-abbrev-table ";b" "byte" 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 ";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 ";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 ";op" "open" nil) + (define-abbrev fortran-mode-abbrev-table ";pa" "parameter" nil) + (define-abbrev fortran-mode-abbrev-table ";pr" "program" nil) + (define-abbrev fortran-mode-abbrev-table ";p" "print" 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 ";su" "subroutine" nil) + (define-abbrev fortran-mode-abbrev-table ";ty" "type" nil) + (define-abbrev fortran-mode-abbrev-table ";w" "write" nil))) + +(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. + +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 value is fixed. + fortran-comment-indent-char + Character to be inserted instead of space for full-line comment + indentation. (default is a space) + 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-continuation-char + character 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. +\\{fortran-mode-map}" + (interactive) + (kill-all-local-variables) + (if fortran-startup-message + (message "Emacs Fortran mode version %s. Bugs to bug-fortran-mode@erl.mit.edu" fortran-mode-version)) + (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]*[ \t]*") ;[^ \t\n]* handles comment strings such as 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) + (use-local-map fortran-mode-map) + (setq mode-name "Fortran") + (setq major-mode 'fortran-mode) + (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." ;\\[help-command] is just a way to print the value of the variable help-char. + (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." + (interactive) + (let ((window-min-width 2)) + (split-window-horizontally 73)) + (other-window 1) + (switch-to-buffer " fortran-window-extra" t) + (select-window (previous-window))) + +(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 " ") + (insert "\n " fortran-continuation-char)) + (fortran-indent-line)) + +(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." + (interactive "P") + (if (or arg (not fortran-electric-line-number)) + (self-insert-command arg) + (if (or (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 (char-to-string + fortran-continuation-char)))) + (looking-at " [^ 0\n]"))) + (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 (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 (concat "[ \t]*" comment-start-skip))))) + (if (not not-last-statement) + 'last-statement))) + +(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 (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)))) + +(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)) + (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 + (looking-at " [^ 0]") + (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))))))) + (save-excursion + (beginning-of-line) + (cond ((looking-at "[ \t]*$")) + ((looking-at comment-line-start-skip) + (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 (char-to-string fortran-continuation-char)))) + (looking-at " [^ 0\n]")) + (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 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)))) + ((looking-at " [^ 0\n]") + (goto-char (match-end 0))) + (t + ;; Move past line number. + (move-to-column 5))) + ;; 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-char 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." + (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 " [^ 0\n]") + (forward-char 6) + (delete-horizontal-space) + ;; Put line number in columns 0-4 + ;; or put continuation character in column 5. + (cond ((eobp)) + ((= (following-char) fortran-continuation-char) + (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 (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 indente. +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, and nil otherwise." + (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)))))))) + + |