Use regexp-opt and eval-and-compile to

build font-lock patterns.
(fortran-mode): Define indent-region-function,
indent-line-function.
(fortran-tab-mode-string): Make buffer-local.
(fortran-comment-indent-style): Custom tweak.
(fortran-comment-region, fortran-electric-line-number,
fortran-analyze-depth, fortran-break-before-delimiters,
fortran-mode): Doc fix.
(fortran-startup-message, bug-fortran-mode): Variables
deleted.
(fortran-font-lock-keywords-1): Add "select", "case"; allow
double-quoted strings.
(fortran-mode-map): Add fill-paragraph menu item.  Don't
define \t.
(fortran-mode): Make `fill-column' buffer-local; set
`fill-paragraph-function', `indent-region-function',
`indent-line-function'.
(calculate-fortran-indent): Renamed to:
(fortran-calculate-indent):
(fortran-split-line): Simplify.
(fortran-remove-continuation): New function.
(fortran-join-line): Use it.
(fortran-end-prog-re1, fortran-end-prog-re): New variables.
(beginning-of-fortran-subprogram, end-of-fortran-subprogram):
Use them.
(fortran-blink-matching-if, fortran-blink-matching-do,
fortran-indent-new-line): Bind case-fold-search.
(fortran-end-do, fortran-beginning-do, fortran-end-if,
fortran-beginning-if): Bind case-fold-search.  Allow labelled
blocks.  Use fortran-end-prog-re.
(fortran-if-start-re): New variable.
(fortran-calculate-indent): Allow labelled blocks.  Simplify the
conds.  Make select case indentation work.
(fortran-is-in-string-p): Ignore Emacs 18 bug kluge.
(fortran-fill): Allow double quotes in check for string.
(fortran-fill-paragraph): New function.
(fortran-fill-statement): New function.

1 files changed, 403 insertions, 334 deletions

diff --git a/lisp/progmodes/fortran.el b/lisp/progmodes/fortran.el
index 4b38c30cd0b..a20b42a19b5 100644
--- a/lisp/progmodes/fortran.el
+++ b/lisp/progmodes/fortran.el
@@ -42,6 +42,13 @@
 
 ;;; Code:
 
+;; Todo: 
+
+;; * Implement insertion and removal of statement continuations in
+;;   mixed f77/f90 style, with the first `&' past column 72 and the
+;;   second in column 6.
+;; * Support other f90-style stuff grokked by GNU Fortran.
+
 (require 'easymenu)
 
 (defgroup fortran nil
@@ -73,6 +80,7 @@ with a character in column 6."
   "String to appear in mode line when TAB format mode is on."
   :type '(choice (const nil) string)
   :group 'fortran-indent)
+(make-variable-buffer-local 'fortran-tab-mode-string)
 
 (defcustom fortran-do-indent 3
   "*Extra indentation applied to DO blocks."
@@ -102,7 +110,7 @@ columns beyond `fortran-minimum-statement-indent-fixed' (for
 `indent-tabs-mode' of nil) or `fortran-minimum-statement-indent-tab' (for
 `indent-tabs-mode' of t), and 'relative indents to current
 Fortran indentation plus `fortran-comment-line-extra-indent'."
-  :type '(radio (const nil) (const fixed) (const relative))
+  :type '(radio (const :tag "Untouched" nil) (const fixed) (const relative))
   :group 'fortran-indent)
 
 (defcustom fortran-comment-line-extra-indent 0
@@ -168,19 +176,14 @@ Normally $."
   :group 'fortran)
 
 (defcustom fortran-comment-region "c$$$"
-  "*String inserted by \\[fortran-comment-region]\
-at start of each line in region."
+  "*String inserted by \\[fortran-comment-region] at start of each \
+line in region."
   :type 'string
   :group 'fortran-comment)
 
 (defcustom fortran-electric-line-number t
-  "*Non-nil causes line number digits to be moved to the correct column as\
-typed."
-  :type 'boolean
-  :group 'fortran)
-
-(defcustom fortran-startup-message t
-  "*Non-nil displays a startup message when Fortran mode is first called."
+  "*Non-nil causes line number digits to be moved to the correct \
+column as typed."
   :type 'boolean
   :group 'fortran)
 
@@ -204,11 +207,11 @@ This variable used in TAB format mode.")
   "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.")
+  "Number of lines to scan to determine whether to use fixed or TAB \
+format style.")
 
 (defcustom fortran-break-before-delimiters t
-  "*Non-nil causes `fortran-fill' to break lines before delimiters."
+  "*Non-nil causes filling to break lines before delimiters."
   :type 'boolean
   :group 'fortran)
 
@@ -252,115 +255,109 @@ style.")
 (defconst fortran-font-lock-keywords-3 nil
   "Gaudy level highlighting for Fortran mode.")
 
-(let ((comment-chars "c!*")
-      (fortran-type-types
-;     (make-regexp
-;      (let ((simple-types '("character" "byte" "integer" "logical"
-;                           "none" "real" "complex"
-;                           "double[ \t]*precision" "double[ \t]*complex"))
-;           (structured-types '("structure" "union" "map"))
-;           (other-types '("record" "dimension" "parameter" "common" "save"
-;                          "external" "intrinsic" "data" "equivalence")))
-;       (append
-;        (mapcar (lambda (x) (concat "implicit[ \t]*" x)) simple-types)
-;        simple-types
-;        (mapcar (lambda (x) (concat "end[ \t]*" x)) structured-types)
-;        structured-types
-;        other-types)))
-          (concat "byte\\|c\\(haracter\\|om\\(mon\\|plex\\)\\)\\|"
-                  "d\\(ata\\|imension\\|ouble"
-                  "[ \t]*\\(complex\\|precision\\)\\)\\|"
-                  "e\\(nd[ \t]*\\(map\\|structure\\|union\\)\\|"
-                  "quivalence\\|xternal\\)\\|"
-                  "i\\(mplicit[ \t]*\\(byte\\|"
-                  "c\\(haracter\\|omplex\\)\\|"
-                  "double[ \t]*\\(complex\\|precision\\)\\|"
-                  "integer\\|logical\\|none\\|real\\)\\|"
-                  "nt\\(eger\\|rinsic\\)\\)\\|"
-                  "logical\\|map\\|none\\|parameter\\|re\\(al\\|cord\\)\\|"
-                  "s\\(ave\\|tructure\\)\\|union"))
-         (fortran-keywords
-;         ("continue" "format" "end" "enddo" "if" "then" "else" "endif"
-;          "elseif" "while" "inquire" "stop" "return" "include" "open"
-;          "close" "read" "write" "format" "print")
-          (concat "c\\(lose\\|ontinue\\)\\|"
-                  "e\\(lse\\(\\|if\\)\\|nd\\(\\|do\\|if\\)\\)\\|format\\|"
-                  "i\\(f\\|n\\(clude\\|quire\\)\\)\\|open\\|print\\|"
-                  "re\\(ad\\|turn\\)\\|stop\\|then\\|w\\(hile\\|rite\\)"))
+(eval-and-compile
+  (let ((comment-chars "c!*")
+        (fortran-type-types
+         (regexp-opt
+          (let ((simple-types '("character" "byte" "integer" "logical"
+                                "none" "real" "complex"
+                                "double[ \t]*precision" "double[ \t]*complex"))
+                (structured-types '("structure" "union" "map"))
+                (other-types '("record" "dimension" "parameter" "common" "save"
+                               "external" "intrinsic" "data" "equivalence")))
+            (append
+             (mapcar (lambda (x) (concat "implicit[ \t]*" x)) simple-types)
+             simple-types
+             (mapcar (lambda (x) (concat "end[ \t]*" x)) structured-types)
+             structured-types
+             other-types))))
+        (fortran-keywords
+         (regexp-opt '("continue" "format" "end" "enddo" "if" "then"
+                       "else" "endif" "elseif" "while" "inquire" "stop"
+                       "return" "include" "open" "close" "read" "write"
+                       "format" "print" "select" "case")))
         (fortran-logicals
-;       ("and" "or" "not" "lt" "le" "eq" "ge" "gt" "ne" "true" "false")
-         "and\\|eq\\|false\\|g[et]\\|l[et]\\|n\\(e\\|ot\\)\\|or\\|true"))
-
-  (setq fortran-font-lock-keywords-1
-   (list
-    ;;
-    ;; Fontify syntactically (assuming strings cannot be quoted or span lines).
-    (cons (concat "^[" comment-chars "].*") 'font-lock-comment-face)
-    '(fortran-match-!-comment . font-lock-comment-face)
-    (list (concat "^[^" comment-chars "\t\n]" (make-string 71 ?.) "\\(.*\\)")
-          '(1 font-lock-comment-face))
-    '("'[^'\n]*'?" . font-lock-string-face)
-    ;;
-    ;; Program, subroutine and function declarations, plus calls.
-    (list (concat "\\<\\(block[ \t]*data\\|call\\|entry\\|function\\|"
-                  "program\\|subroutine\\)\\>[ \t]*\\(\\sw+\\)?")
-          '(1 font-lock-keyword-face)
-          '(2 font-lock-function-name-face nil t))))
-
-  (setq fortran-font-lock-keywords-2
-   (append fortran-font-lock-keywords-1
-    (list
-     ;;
-     ;; Fontify all type specifiers (must be first; see below).
-     (cons (concat "\\<\\(" fortran-type-types "\\)\\>") 'font-lock-type-face)
-     ;;
-     ;; Fontify all builtin keywords (except logical, do and goto; see below).
-     (concat "\\<\\(" fortran-keywords "\\)\\>")
-     ;;
-     ;; Fontify all builtin operators.
-     (concat "\\.\\(" fortran-logicals "\\)\\.")
-     ;;
-     ;; Fontify do/goto keywords and targets, and goto tags.
-     (list "\\<\\(do\\|go *to\\)\\>[ \t]*\\([0-9]+\\)?"
-           '(1 font-lock-keyword-face)
-           '(2 font-lock-constant-face nil t))
-     (cons "^ *\\([0-9]+\\)" 'font-lock-constant-face))))
-
-  (setq fortran-font-lock-keywords-3
-   (append
-    ;;
-    ;; The list `fortran-font-lock-keywords-1'.
-    fortran-font-lock-keywords-1
-    ;;
-    ;; Fontify all type specifiers plus their declared items.
-    (list
-     (list (concat "\\<\\(" fortran-type-types "\\)\\>[ \t(/]*\\(*\\)?")
-           ;; Fontify the type specifier.
-           '(1 font-lock-type-face)
-           ;; Fontify each declaration item (or just the /.../ block name).
-           '(font-lock-match-c-style-declaration-item-and-skip-to-next
-             ;; Start after any *(...) expression.
-             (and (match-beginning 15) (forward-sexp 1))
-             ;; No need to clean up.
-             nil
-             ;; Fontify as a variable name, functions are fontified elsewhere.
-             (1 font-lock-variable-name-face nil t))))
-    ;;
-    ;; Things extra to `fortran-font-lock-keywords-3' (must be done first).
-    (list
-     ;;
-     ;; Fontify goto-like `err=label'/`end=label' in read/write statements.
-     '(", *\\(e\\(nd\\|rr\\)\\)\\> *\\(= *\\([0-9]+\\)\\)?"
-       (1 font-lock-keyword-face) (4 font-lock-constant-face nil t))
-     ;;
-     ;; Highlight standard continuation character and in a TAB-formatted line.
-     '("^     \\([^ 0]\\)" 1 font-lock-string-face)
-     '("^\t\\([1-9]\\)" 1 font-lock-string-face))
-    ;;
-    ;; The list `fortran-font-lock-keywords-2' less that for types (see above).
-    (cdr (nthcdr (length fortran-font-lock-keywords-1)
-                 fortran-font-lock-keywords-2))))
-  )
+         (regexp-opt '("and" "or" "not" "lt" "le" "eq" "ge" "gt" "ne"
+                       "true" "false"))))
+
+    (setq fortran-font-lock-keywords-1
+          (list
+           ;;
+           ;; Fontify syntactically (assuming strings cannot be quoted
+           ;; or span lines).
+           (cons (concat "^[" comment-chars "].*") 'font-lock-comment-face)
+           '(fortran-match-!-comment . font-lock-comment-face)
+           (list (concat "^[^" comment-chars "\t\n]" (make-string 71 ?.)
+                         "\\(.*\\)")
+                 '(1 font-lock-comment-face))
+           '("\\(\\s\"\\)\"[^\n]*\\1?" . font-lock-string-face)
+           ;;
+           ;; Program, subroutine and function declarations, plus calls.
+           (list (concat "\\<\\(block[ \t]*data\\|call\\|entry\\|function\\|"
+                         "program\\|subroutine\\)\\>[ \t]*\\(\\sw+\\)?")
+                 '(1 font-lock-keyword-face)
+                 '(2 font-lock-function-name-face nil t))))
+
+    (setq fortran-font-lock-keywords-2
+          (append fortran-font-lock-keywords-1
+                  (list
+                   ;;
+                   ;; Fontify all type specifiers (must be first; see below).
+                   (cons (concat "\\<\\(" fortran-type-types "\\)\\>") 
+                         'font-lock-type-face)
+                   ;;
+                   ;; Fontify all builtin keywords (except logical, do
+                   ;; and goto; see below).
+                   (concat "\\<\\(" fortran-keywords "\\)\\>")
+                   ;;
+                   ;; Fontify all builtin operators.
+                   (concat "\\.\\(" fortran-logicals "\\)\\.")
+                   ;;
+                   ;; Fontify do/goto keywords and targets, and goto tags.
+                   (list "\\<\\(do\\|go *to\\)\\>[ \t]*\\([0-9]+\\)?"
+                         '(1 font-lock-keyword-face)
+                         '(2 font-lock-constant-face nil t))
+                   (cons "^ *\\([0-9]+\\)" 'font-lock-constant-face))))
+
+    (setq fortran-font-lock-keywords-3
+          (append
+           ;;
+           ;; The list `fortran-font-lock-keywords-1'.
+           fortran-font-lock-keywords-1
+           ;;
+           ;; Fontify all type specifiers plus their declared items.
+           (list
+            (list (concat "\\<\\(" fortran-type-types "\\)\\>[ \t(/]*\\(*\\)?")
+                  ;; Fontify the type specifier.
+                  '(1 font-lock-type-face)
+                  ;; Fontify each declaration item (or just the /.../ block name).
+                  '(font-lock-match-c-style-declaration-item-and-skip-to-next
+                    ;; Start after any *(...) expression.
+                    (and (match-beginning 15) (forward-sexp))
+                    ;; No need to clean up.
+                    nil
+                    ;; Fontify as a variable name, functions are
+                    ;; fontified elsewhere.
+                    (1 font-lock-variable-name-face nil t))))
+           ;;
+           ;; Things extra to `fortran-font-lock-keywords-3'
+           ;; (must be done first).
+           (list
+            ;;
+            ;; Fontify goto-like `err=label'/`end=label' in read/write
+            ;; statements.
+            '(", *\\(e\\(nd\\|rr\\)\\)\\> *\\(= *\\([0-9]+\\)\\)?"
+              (1 font-lock-keyword-face) (4 font-lock-constant-face nil t))
+            ;;
+            ;; Highlight standard continuation character and in a
+            ;; TAB-formatted line.
+            '("^     \\([^ 0]\\)" 1 font-lock-string-face)
+            '("^\t\\([1-9]\\)" 1 font-lock-string-face))
+           ;;
+           ;; The list `fortran-font-lock-keywords-2' less that for types
+           ;; (see above).
+           (cdr (nthcdr (length fortran-font-lock-keywords-1)
+                        fortran-font-lock-keywords-2))))))
 
 (defvar fortran-font-lock-keywords fortran-font-lock-keywords-1
   "Default expressions to highlight in Fortran mode.")
@@ -378,8 +375,9 @@ style.")
     ;; index.  [This will be fooled by `end function' allowed by G77.
     ;; Also, it assumes sensible whitespace is employed.]
     (concat "^\\s-+\\(\
-\\(\\sw\\|\\s-\\|[*()+]\\)*\\<function\\|\
-subroutine\\|entry\\|block\\s-*data\\|program\\)[ \t" fortran-continuation-string "]+\
+\\(\\sw\\|\\s-\\|[*()+]\\)*\
+\\<function\\|subroutine\\|entry\\|block\\s-*data\\|program\\)\
+[ \t" fortran-continuation-string "]+\
 \\(\\sw+\\)")
     3)
    ;; Un-named block data
@@ -406,7 +404,7 @@ subroutine\\|entry\\|block\\s-*data\\|program\\)[ \t" fortran-continuation-strin
   (define-key fortran-mode-map "\C-c\C-n" 'fortran-next-statement)
   (define-key fortran-mode-map "\C-c\C-d" 'fortran-join-line)
   (define-key fortran-mode-map "\C-xnd" 'fortran-narrow-to-subprogram)
-  (define-key fortran-mode-map "\t" 'fortran-indent-line)
+  ;(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)
@@ -452,6 +450,7 @@ subroutine\\|entry\\|block\\s-*data\\|program\\)[ \t" fortran-continuation-strin
        "----"
        ["Break Line at Point" fortran-split-line t]
        ["Join Continuation Line" fortran-join-line t]
+       ["Fill Statement/Comment" fill-paragraph  t]
        "----"
        ["Add imenu menu"
         (progn (imenu-add-to-menubar "Index")
@@ -524,7 +523,9 @@ subroutine\\|entry\\|block\\s-*data\\|program\\)[ \t" fortran-continuation-strin
     (define-abbrev fortran-mode-abbrev-table  ";wh"  "where" nil)
     (setq abbrevs-changed ac)))
 
-(eval-when-compile (defvar imenu-syntax-alist nil)) ; silence compiler
+(eval-when-compile                      ; silence compiler
+  (defvar imenu-case-fold-search)
+  (defvar imenu-syntax-alist))
 
 ;;;###autoload
 (defun fortran-mode ()
@@ -532,8 +533,8 @@ subroutine\\|entry\\|block\\s-*data\\|program\\)[ \t" fortran-continuation-strin
 \\[fortran-indent-line] 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.
+Type ;? or ;\\[help-command] to display a list of built-in abbrevs for
+Fortran keywords.
 
 Key definitions:
 \\{fortran-mode-map}
@@ -591,7 +592,7 @@ Variables controlling indentation style and extra features:
     Non-nil causes line number digits to be moved to the correct column
     as typed.  (default t)
  fortran-break-before-delimiters
-    Non-nil causes `fortran-fill' breaks lines before delimiters.
+    Non-nil causes `fortran-fill' to break lines before delimiters.
     (default t)
 
 Turning on Fortran mode calls the value of the variable `fortran-mode-hook'
@@ -629,23 +630,28 @@ with no args, if that value is non-nil."
   (make-local-variable 'indent-tabs-mode)
   (setq indent-tabs-mode nil)
 ;;;(setq abbrev-mode t) ; ?? (abbrev-mode 1) instead??
-  (setq fill-column 72) ; Already local?
+  (set (make-local-variable 'fill-column) 72)
   (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-extra-indent)
   (make-local-variable 'fortran-minimum-statement-indent-fixed)
   (make-local-variable 'fortran-minimum-statement-indent-tab)
   (make-local-variable 'fortran-column-ruler-fixed)
-  (make-local-variable 'fortran-column-ruler-tab)
-  (make-local-variable 'fortran-tab-mode-string)
+  (make-local-variable 'fortran-column-ruler-tab) 
   (setq fortran-tab-mode-string " TAB-format")
   (setq indent-tabs-mode (fortran-analyze-file-format))
   (setq imenu-case-fold-search t)
   (make-local-variable 'imenu-generic-expression)
   (setq imenu-generic-expression fortran-imenu-generic-expression)
   (setq imenu-syntax-alist '(("_$" . "w")))
+  (set (make-local-variable 'fill-paragraph-function) 'fortran-fill-paragraph)
+  (set (make-local-variable 'indent-line-function) 'fortran-indent-line)
+  (set (make-local-variable 'indent-region-function)
+       (lambda (start end)
+         (let (fortran-blink-matching-if ; avoid blinking delay
+               indent-region-function)
+           (indent-region start end nil))))
   (run-hooks 'fortran-mode-hook))
 
 (defun fortran-comment-hook ()
@@ -693,7 +699,7 @@ or on a new line inserted before this line if this line is not blank."
          (insert-char (if (stringp fortran-comment-indent-char)
                           (aref fortran-comment-indent-char 0)
                         fortran-comment-indent-char)
-                      (- (calculate-fortran-indent) (current-column))))))
+                      (- (fortran-calculate-indent) (current-column))))))
 
 (defun fortran-comment-region (beg-region end-region arg)
   "Comments every line in the region.
@@ -806,26 +812,23 @@ See also `fortran-window-create'."
   (if (save-excursion (beginning-of-line) (looking-at comment-line-start-skip))
       (insert "\n" comment-line-start " ")
     (if indent-tabs-mode
-        (progn
-          (insert "\n\t")
-          (insert-char (fortran-numerical-continuation-char) 1))
-      (insert "\n " fortran-continuation-string)));Space after \n important
-  (fortran-indent-line))                ;when the cont string is C, c or *.
+        (insert "\n\t" (fortran-numerical-continuation-char))
+      (insert "\n " fortran-continuation-string))) ; Space after \n important
+  (fortran-indent-line))                ; when the cont string is C, c or *.
+
+(defun fortran-remove-continuation ()
+  (if (looking-at "\\(     [^ 0\n]\\|\t[1-9]\\|&\\)")
+      (progn (replace-match "")
+             (delete-indentation)
+             t)))
 
 (defun fortran-join-line ()
   "Join a continuation line to the previous one and re-indent."
   (interactive)
   (save-excursion
     (beginning-of-line)
-    (cond ((looking-at "     \\S-")
-           (delete-region (1- (point)) (+ (point) 7)))
-          ((looking-at "&")
-           (delete-region (1- (point)) (1+ (point))))
-          ((looking-at " *\t[1-9]")
-           (apply 'delete-region (match-data))
-           (delete-backward-char 1))
-          (t (error "This isn't a continuation line")))
-    (just-one-space)
+    (if (not (fortran-remove-continuation))
+        (error "Not a continuation line"))
     (fortran-indent-line)))
 
 (defun fortran-numerical-continuation-char ()
@@ -859,8 +862,8 @@ Auto-indent does not happen if a numeric ARG is used."
                    (beginning-of-line)
                    (looking-at "     ")));In col 5 with only spaces to left.
             (and (= (if indent-tabs-mode
-                  fortran-minimum-statement-indent-tab
-                fortran-minimum-statement-indent-fixed) (current-column))
+                        fortran-minimum-statement-indent-tab
+                      fortran-minimum-statement-indent-fixed) (current-column))
                  (save-excursion
                    (beginning-of-line)
                    (looking-at "\t"));In col 8 with a single tab to the left.
@@ -872,31 +875,34 @@ Auto-indent does not happen if a numeric ARG is used."
                                   (save-excursion
                                     (beginning-of-line)
                                     (point))
-                                  t)) ;not a line number
-            (looking-at "[0-9]")        ;within a line number
-            )
+                                  t))   ;not a line number
+            (looking-at "[0-9]"))       ;within a line number
         (self-insert-command (prefix-numeric-value arg))
       (skip-chars-backward " \t")
       (insert last-command-char)
       (fortran-indent-line))))
 
+(defvar fortran-end-prog-re1
+  "end\\b[ \t]*\\(\\(program\\|subroutine\\|function\\)[ \t]*\\)?[^ \t=\(a-z]")
+(defvar fortran-end-prog-re
+  (concat "^[ \t0-9]*" fortran-end-prog-re1))
+
 (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))))
+    (if (re-search-backward fortran-end-prog-re nil 'move)
+        (forward-line))))
 
 (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)
+    (re-search-forward fortran-end-prog-re nil 'move)
     (goto-char (match-beginning 0))
-    (forward-line 1)))
+    (forward-line)))
 
 (defun mark-fortran-subprogram ()
   "Put mark at end of Fortran subprogram, point at beginning.
@@ -963,8 +969,11 @@ The subprogram visible is the one that contains or follows point."
 
 (defun fortran-blink-matching-if ()
   ;; From a Fortran ENDIF statement, blink the matching IF statement.
-  (let ((top-of-window (window-start)) matching-if
-        (endif-point (point)) message)
+  (let ((top-of-window (window-start))
+        (endif-point (point))
+        (case-fold-search t)
+        matching-if
+        message)
     (if (save-excursion (beginning-of-line)
                         (skip-chars-forward " \t0-9")
                         (looking-at "end[ \t]*if\\b"))
@@ -988,8 +997,11 @@ The subprogram visible is the one that contains or follows point."
 (defun fortran-blink-matching-do ()
   ;; From a Fortran ENDDO statement, blink on the matching DO or DO WHILE
   ;; statement.  This is basically copied from fortran-blink-matching-if.
-  (let ((top-of-window (window-start)) matching-do
-        (enddo-point (point)) message)
+  (let ((top-of-window (window-start))
+        (enddo-point (point))
+        (case-fold-search t)
+        matching-do
+        message)
     (if (save-excursion (beginning-of-line)
                         (skip-chars-forward " \t0-9")
                         (looking-at "end[ \t]*do\\b"))
@@ -1025,52 +1037,54 @@ The marks are pushed."
 
 (defun fortran-end-do ()
   ;; Search forward for first unmatched ENDDO.  Return point or nil.
-  (if (save-excursion (beginning-of-line)
-                      (skip-chars-forward " \t0-9")
-                      (looking-at "end[ \t]*do\\b"))
-      ;; Sitting on one.
-      (match-beginning 0)
-    ;; Search for one.
-    (save-excursion
-      (let ((count 1))
+  (let ((case-fold-search t))
+    (if (save-excursion (beginning-of-line)
+                        (skip-chars-forward " \t0-9")
+                        (looking-at "end[ \t]*do\\b"))
+        ;; Sitting on one.
+        (match-beginning 0)
+      ;; Search for one.
+      (save-excursion
+        (let ((count 1))
         (while (and (not (= count 0))
-                    (not (eq (fortran-next-statement) 'last-statement))
-                    ;; Keep local to subprogram
-                    (not (looking-at "^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]")))
-
-          (skip-chars-forward " \t0-9")
-          (cond ((looking-at "end[ \t]*do\\b")
-                 (setq count (- count 1)))
-                ((looking-at "do[ \t]+[^0-9]")
+                      (not (eq (fortran-next-statement) 'last-statement))
+                      ;; Keep local to subprogram
+                      (not (looking-at fortran-end-prog-re)))
+
+            (skip-chars-forward " \t0-9")
+            (cond ((looking-at "end[ \t]*do\\b")
+                   (setq count (1- count)))
+                  ((looking-at "\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?do[ \t]+[^0-9]")
                  (setq count (+ count 1)))))
         (and (= count 0)
-             ;; All pairs accounted for.
-             (point))))))
+               ;; All pairs accounted for.
+               (point)))))))
 
 (defun fortran-beginning-do ()
   ;; Search backwards for first unmatched DO [WHILE].  Return point or nil.
-  (if (save-excursion (beginning-of-line)
-                      (skip-chars-forward " \t0-9")
-                      (looking-at "do[ \t]+"))
-      ;; Sitting on one.
-      (match-beginning 0)
-    ;; Search for one.
-    (save-excursion
-      (let ((count 1))
+  (let ((case-fold-search t))
+    (if (save-excursion (beginning-of-line)
+                        (skip-chars-forward " \t0-9")
+                        (looking-at "\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?do[ \t]+"))
+        ;; Sitting on one.
+        (match-beginning 0)
+      ;; Search for one.
+      (save-excursion
+        (let ((count 1))
         (while (and (not (= count 0))
-                    (not (eq (fortran-previous-statement) 'first-statement))
-                    ;; Keep local to subprogram
-                    (not (looking-at "^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]")))
+                      (not (eq (fortran-previous-statement) 'first-statement))
+                      ;; Keep local to subprogram
+                      (not (looking-at fortran-end-prog-re)))
 
-          (skip-chars-forward " \t0-9")
-          (cond ((looking-at "do[ \t]+[^0-9]")
-                 (setq count (- count 1)))
-                ((looking-at "end[ \t]*do\\b")
-                 (setq count (+ count 1)))))
+            (skip-chars-forward " \t0-9")
+            (cond ((looking-at "\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?do[ \t]+[^0-9]")
+                   (setq count (1- count)))
+                  ((looking-at "end[ \t]*do\\b")
+                   (setq count (1+ count)))))
 
         (and (= count 0)
-             ;; All pairs accounted for.
-             (point))))))
+               ;; All pairs accounted for.
+               (point)))))))
 
 (defun fortran-mark-if ()
   "Put mark at end of Fortran IF-ENDIF construct, point at beginning.
@@ -1085,113 +1099,115 @@ The marks are pushed."
           (push-mark)
           (goto-char if-point)))))
 
+(defvar fortran-if-start-re "\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?if[ \t]*(")
+
 (defun fortran-end-if ()
   ;; Search forwards for first unmatched ENDIF.  Return point or nil.
-  (if (save-excursion (beginning-of-line)
-                      (skip-chars-forward " \t0-9")
-                      (looking-at "end[ \t]*if\\b"))
-      ;; Sitting on one.
-      (match-beginning 0)
-    ;; Search for one.  The point has been already been moved to first
-    ;; letter on line but this should not cause troubles.
-    (save-excursion
-      (let ((count 1))
+  (let ((case-fold-search t))
+    (if (save-excursion (beginning-of-line)
+                        (skip-chars-forward " \t0-9")
+                        (looking-at "end[ \t]*if\\b"))
+        ;; Sitting on one.
+        (match-beginning 0)
+      ;; Search for one.  The point has been already been moved to first
+      ;; letter on line but this should not cause troubles.
+      (save-excursion
+        (let ((count 1))
         (while (and (not (= count 0))
-                    (not (eq (fortran-next-statement) 'last-statement))
-                    ;; Keep local to subprogram.
-                    (not (looking-at
-                          "^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]")))
+                      (not (eq (fortran-next-statement) 'last-statement))
+                      ;; Keep local to subprogram.
+                      (not (looking-at fortran-end-prog-re)))
 
-          (skip-chars-forward " \t0-9")
-          (cond ((looking-at "end[ \t]*if\\b")
+            (skip-chars-forward " \t0-9")
+            (cond ((looking-at "end[ \t]*if\\b")
                  (setq count (- count 1)))
 
-                ((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
+                  ((looking-at fortran-if-start-re)
+                   (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))
+                                     ;; 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)))))))
 
         (and (= count 0)
-             ;; All pairs accounted for.
-             (point))))))
+               ;; All pairs accounted for.
+               (point)))))))
 
 (defun fortran-beginning-if ()
   ;; Search backwards for first unmatched IF-THEN.  Return point or nil.
-  (if (save-excursion
-        ;; May be sitting on multi-line if-then statement, first move to
-        ;; beginning of current statement.  Note: `fortran-previous-statement'
-        ;; moves to previous statement *unless* current statement is first
-        ;; one.  Only move forward if not first-statement.
-        (if (not (eq (fortran-previous-statement) 'first-statement))
-            (fortran-next-statement))
-        (skip-chars-forward " \t0-9")
-        (and
-         (looking-at "if[ \t]*(")
-         (save-match-data
-           (or (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]")
-               ;; Multi-line if-then.
-               (let (then-test)
-                 (while
+  (let ((case-fold-search t))
+    (if (save-excursion
+          ;; May be sitting on multi-line if-then statement, first move to
+          ;; beginning of current statement.  Note: `fortran-previous-statement'
+          ;; moves to previous statement *unless* current statement is first
+          ;; one.  Only move forward if not first-statement.
+          (if (not (eq (fortran-previous-statement) 'first-statement))
+              (fortran-next-statement))
+          (skip-chars-forward " \t0-9")
+          (and
+           (looking-at fortran-if-start-re)
+           (save-match-data
+             (or (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]")
+                 ;; Multi-line if-then.
+                 (let (then-test)
+                   (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)))))
-      ;; Sitting on one.
-      (match-beginning 0)
-    ;; Search for one.
-    (save-excursion
-      (let ((count 1))
+                            ;; 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)))))
+        ;; Sitting on one.
+        (match-beginning 0)
+      ;; Search for one.
+      (save-excursion
+        (let ((count 1))
         (while (and (not (= count 0))
-                    (not (eq (fortran-previous-statement) 'first-statement))
-                    ;; Keep local to subprogram.
-                    (not (looking-at
-                          "^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]")))
-
-          (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
+                      (not (eq (fortran-previous-statement) 'first-statement))
+                      ;; Keep local to subprogram.
+                      (not (looking-at fortran-end-prog-re)))
+
+            (skip-chars-forward " \t0-9")
+            (cond ((looking-at fortran-if-start-re)
+                   (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))
+                                     ;; 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")
+                  ((looking-at "end[ \t]*if\\b")
                  (setq count (+ count 1)))))
 
         (and (= count 0)
-             ;; All pairs accounted for.
-             (point))))))
+               ;; All pairs accounted for.
+               (point)))))))
 
 (defun fortran-indent-line ()
   "Indent current Fortran line based on its contents and on previous lines."
   (interactive)
-  (let ((cfi (calculate-fortran-indent)))
+  (let ((cfi (fortran-calculate-indent)))
     (save-excursion
       (beginning-of-line)
       (if (or (not (= cfi (fortran-current-line-indentation)))
@@ -1223,11 +1239,12 @@ An abbrev before point is expanded if `abbrev-mode' is non-nil."
   (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)))
+    (let ((case-fold-search 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))))
   (newline)
   (fortran-indent-line))
 
@@ -1240,7 +1257,7 @@ An abbrev before point is expanded if `abbrev-mode' is non-nil."
     (indent-region (point) (mark) nil))
   (message "Indenting subprogram...done."))
 
-(defun calculate-fortran-indent ()
+(defun fortran-calculate-indent ()
   "Calculates the Fortran indent column based on previous lines."
   (let (icol first-statement (case-fold-search t)
              (fortran-minimum-statement-indent
@@ -1256,7 +1273,7 @@ An abbrev before point is expanded if `abbrev-mode' is non-nil."
               (setq icol fortran-minimum-statement-indent)
             (setq icol (fortran-current-line-indentation)))
           (skip-chars-forward " \t0-9")
-          (cond ((looking-at "if[ \t]*(")
+          (cond ((looking-at "\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?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)
@@ -1268,11 +1285,11 @@ An abbrev before point is expanded if `abbrev-mode' is non-nil."
 *[^ \t_$(=a-z0-9]")))))
                            then-test))
                      (setq icol (+ icol fortran-if-indent))))
-                ((looking-at "\\(else\\|elseif\\)\\b")
+                ((looking-at "else\\(if\\)?\\b")
                  (setq icol (+ icol fortran-if-indent)))
-                ((looking-at "select[ \t]*case[ \t](.*)\\b")
+                ((looking-at "select[ \t]*case[ \t](.*)")
                  (setq icol (+ icol fortran-if-indent)))
-                ((looking-at "case[ \t]*(.*)[ \t]*\n")
+                ((looking-at "case[ \t]*(.*)")
                  (setq icol (+ icol fortran-if-indent)))
                 ((looking-at "case[ \t]*default\\b")
                  (setq icol (+ icol fortran-if-indent)))
@@ -1285,7 +1302,7 @@ An abbrev before point is expanded if `abbrev-mode' is non-nil."
                 ((looking-at
                   "\\(structure\\|union\\|map\\|interface\\)\\b[ \t]*[^ \t=(a-z]")
                  (setq icol (+ icol fortran-structure-indent)))
-                ((looking-at "end\\b[ \t]*[^ \t=(a-z]")
+                ((looking-at fortran-end-prog-re1)
                  ;; Previous END resets indent to minimum
                  (setq icol fortran-minimum-statement-indent))))))
     (save-excursion
@@ -1313,31 +1330,23 @@ An abbrev before point is expanded if `abbrev-mode' is non-nil."
              (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")
+             (cond ((looking-at "end[ \t]*\\(if\\|select\\|where\\)\\b")
                     (setq icol (- icol fortran-if-indent)))
-                   ((looking-at "case[ \t]*(.*)[ \t]*\n")
+                   ((looking-at "else\\(if\\)?\\b")
                     (setq icol (- icol fortran-if-indent)))
-                   ((looking-at "case[ \t]*default\\b")
+                   ((looking-at "case[ \t]*\\((.*)\\|default\\>\\)")
                     (setq icol (- icol fortran-if-indent)))
                    ((looking-at "\\(otherwise\\|else[ \t]*where\\)\\b")
                     (setq icol (- icol fortran-if-indent)))
-                   ((looking-at "end[ \t]*where\\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)))
-                   ((looking-at
-                     "end[ \t]*\
+                   ((looking-at "end[ \t]*\
 \\(structure\\|union\\|map\\|interface\\)\\b[ \t]*[^ \t=(a-z]")
                     (setq icol (- icol fortran-structure-indent)))
-                   ((looking-at
-                     "end[ \t]*select\\b[ \t]*[^ \t=(a-z]")
-                    (setq icol (- icol fortran-if-indent)))
-                   ((and (looking-at "end\\b[ \t]*[^ \t=(a-z]")
+                   ((and (looking-at fortran-end-prog-re1)
                          (not (= icol fortran-minimum-statement-indent)))
                     (message "Warning: `end' not in column %d.  Probably\
  an unclosed block." fortran-minimum-statement-indent))))))
@@ -1459,7 +1468,7 @@ Otherwise return nil."
                                                    (point))))
             (beginning-of-line)
             (and (re-search-backward
-                  (concat "\\(^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]\\)\\|"
+                  (concat "\\(" fortran-end-prog-re "\\)\\|"
                           "\\(^[ \t0-9]*do[ \t]*0*" charnum "\\b\\)\\|"
                           "\\(^[ \t]*0*" charnum "\\b\\)")
                   nil t)
@@ -1468,10 +1477,10 @@ Otherwise return nil."
 (defun fortran-find-comment-start-skip ()
   "Move to past `comment-start-skip' found on current line.
 Return t if `comment-start-skip' found, nil if not."
-;;; In order to move point only if comment-start-skip is found,
-;;; this one uses a lot of save-excursions.  Note that re-search-forward
-;;; moves point even if comment-start-skip is inside a string-constant.
-;;; Some code expects certain values for match-beginning and end
+  ;; In order to move point only if comment-start-skip is found, this
+  ;; one uses a lot of save-excursions.  Note that re-search-forward
+  ;; moves point even if comment-start-skip is inside a string-constant.
+  ;; Some code expects certain values for match-beginning and end
   (interactive)
   (if (save-excursion
         (re-search-forward comment-start-skip
@@ -1489,8 +1498,8 @@ Return t if `comment-start-skip' found, nil if not."
           t))
     nil))
 
-;;;From: simon@gnu (Simon Marshall)
-;;; Find the next ! not in a string.
+;;From: simon@gnu (Simon Marshall)
+;; Find the next ! not in a string.
 (defun fortran-match-!-comment (limit)
   (let (found)
     (while (and (setq found (search-forward "!" limit t))
@@ -1509,8 +1518,8 @@ Return t if `comment-start-skip' found, nil if not."
 ;;                (fortran-is-in-string-p (match-beginning 0))))
 ;;    found))
 
-;;;From: ralf@up3aud1.gwdg.de (Ralf Fassel)
-;;; Test if TAB format continuation lines work.
+;;From: ralf@up3aud1.gwdg.de (Ralf Fassel)
+;; Test if TAB format continuation lines work.
 (defun fortran-is-in-string-p (where)
   "Return non-nil iff WHERE (a buffer position) is inside a Fortran string."
   (save-excursion
@@ -1518,7 +1527,8 @@ Return t if `comment-start-skip' found, nil if not."
     (cond
      ((bolp) nil)                       ; bol is never inside a string
      ((save-excursion                   ; comment lines too
-        (beginning-of-line)(looking-at comment-line-start-skip)) nil)
+        (beginning-of-line)
+        (looking-at comment-line-start-skip)) nil)
      (t (let (;; ok, serious now. Init some local vars:
               (parse-state '(0 nil nil nil nil nil 0))
               (quoted-comment-start (if comment-start
@@ -1542,8 +1552,7 @@ Return t if `comment-start-skip' found, nil if not."
                       comment-start
                       (equal comment-start
                              (char-to-string (preceding-char)))))
-                ;; get around a bug in forward-line in versions <= 18.57
-                (if (or (> (forward-line 1) 0) (eobp))
+                (if (> (forward-line) 0)
                     (setq not-done nil))
               ;; else:
               ;; if we are at beginning of code line, skip any
@@ -1582,7 +1591,7 @@ automatically breaks the line at a previous space."
                (if (if (null arg)
                        (not auto-fill-function)
                      (> (prefix-numeric-value arg) 0))
-                   'fortran-do-auto-fill
+                   #'fortran-do-auto-fill
                  nil))
     (force-mode-line-update)))
 
@@ -1602,19 +1611,16 @@ automatically breaks the line at a previous space."
             (if (looking-at comment-line-start-skip)
                 nil                     ; OK to break quotes on comment lines.
               (move-to-column fill-column)
-              (cond ((fortran-is-in-string-p (point))
-                     (save-excursion (re-search-backward "[^']'[^']" bol t)
-                                     (if fortran-break-before-delimiters
-                                         (point)
-                                       (1+ (point)))))
-                    (t nil)))))
-         ;;
+              (if (fortran-is-in-string-p (point))
+                  (save-excursion (re-search-backward "\\S\"\\s\"\\S\"" bol t)
+                                  (if fortran-break-before-delimiters
+                                      (point)
+                                    (1+ (point))))))))
          ;; decide where to split the line. If a position for a quoted
          ;; string was found above then use that, else break the line
          ;; before the last delimiter.
          ;; Delimiters are whitespace, commas, and operators.
          ;; Will break before a pair of *'s.
-         ;;
          (fill-point
           (or quote
               (save-excursion
@@ -1626,19 +1632,18 @@ automatically breaks the line at a previous space."
                 (if (<= (point) (1+ bos))
                     (progn
                       (move-to-column (1+ fill-column))
-;;;what is this doing???
+                      ;;what is this doing???
                       (if (not (re-search-forward "[\t\n,'+-/*)=]" eol t))
                           (goto-char bol))))
                 (if (bolp)
                     (re-search-forward "[ \t]" opoint t)
-                  (forward-char -1)
-                  (if (looking-at "'")
-                      (forward-char 1)
+                  (backward-char)
+                  (if (looking-at "\\s\"")
+                      (forward-char)
                     (skip-chars-backward " \t\*")))
                 (if fortran-break-before-delimiters
                     (point)
-                  (1+ (point))))))
-         )
+                  (1+ (point)))))))
     ;; if we are in an in-line comment, don't break unless the
     ;; line of code is longer than it should be. Otherwise
     ;; break the line at the column computed above.
@@ -1663,7 +1668,7 @@ automatically breaks the line at a previous space."
             (if (> (save-excursion
                      (goto-char fill-point)
                      (current-column))
-                   (+ (calculate-fortran-indent) fortran-continuation-indent))
+                   (+ (fortran-calculate-indent) fortran-continuation-indent))
                 (progn
                   (goto-char fill-point)
                   (fortran-break-line))))))
@@ -1680,8 +1685,8 @@ automatically breaks the line at a previous space."
             (re-search-backward comment-start-skip bol t)
             (setq comment-string (buffer-substring (point) eol))
             (delete-region (point) eol))))
-;;; Forward line 1 really needs to go to next non white line
-    (if (save-excursion (forward-line 1)
+    ;; Forward line 1 really needs to go to next non white line
+    (if (save-excursion (forward-line)
                         (or (looking-at "     [^ 0\n]")
                             (looking-at "\t[1-9]")))
         (progn
@@ -1725,6 +1730,70 @@ file before the end or the first `fortran-analyze-depth' lines."
                               (indent-tabs-mode fortran-tab-mode-string))
                             minor-mode-alist)))
 
+(defun fortran-fill-paragraph (&optional justify)
+  "Fill surrounding comment block as paragraphs, else fill statement.
+
+Intended as the value of `fill-paragraph-function'."
+  (interactive "P")
+  (save-excursion
+    (beginning-of-line)
+    (if (not (looking-at "[Cc*]"))
+        (fortran-fill-statement)
+      ;; We're in a comment block.  Find the start and end of a
+      ;; paragraph, delimited either by non-comment lines or empty
+      ;; comments.  (Get positions as markers, since the
+      ;; `indent-region' below can shift the block's end).
+      (let* ((non-empty-comment (concat "\\(" comment-line-start-skip
+                                        "\\)" "[^ \t\n]"))
+             (start (save-excursion
+                      ;; Find (start of) first line.
+                      (while (and (zerop (forward-line -1))
+                                  (looking-at non-empty-comment)))
+                      (or (looking-at non-empty-comment)
+                          (forward-line)) ; overshot
+                      (point-marker)))
+             (end (save-excursion
+                    ;; Find start of first line past region to fill.
+                    (while (progn (forward-line)
+                                  (looking-at non-empty-comment)))
+                    (point-marker))))
+        ;; Indent the block, find the string comprising the effective
+        ;; comment start skip and use that as a fill-prefix for
+        ;; filling the region.
+        (indent-region start end nil)
+        (let ((paragraph-ignore-fill-prefix nil)
+              (fill-prefix (progn (beginning-of-line)
+                                  (looking-at comment-line-start-skip)
+                                  (match-string 0))))
+          (let (fill-paragraph-function)
+            (fill-region start end justify))) ; with normal `fill-paragraph'
+        (set-marker start nil)
+        (set-marker end nil)))))
+
+(defun fortran-fill-statement ()
+  "Fill a fortran statement up to `fill-column'."
+  (interactive)
+  (if (not (save-excursion
+             (beginning-of-line)
+             (or (looking-at "[ \t]*$")
+                 (looking-at comment-line-start-skip)
+                 (and comment-start-skip
+                      (looking-at (concat "[ \t]*" comment-start-skip))))))
+      (save-excursion
+        ;; Find beginning of statement.
+        (fortran-next-statement)
+        (fortran-previous-statement)
+        ;; Re-indent initially.
+        (fortran-indent-line)
+        ;; Replace newline plus continuation field plus indentation with
+        ;; single space.
+        (while (progn 
+                 (forward-line)
+                 (fortran-remove-continuation)))
+        (fortran-previous-statement)))
+    (fortran-indent-line)
+  t)                                    ; must return t for fill-paragraph
+
 (provide 'fortran)
 
 ;;; fortran.el ends here