code.delx.au - gnu-emacs/blob - lisp/progmodes/fortran.el

   1 ;;; fortran.el --- Fortran mode for GNU Emacs
   2
   3 ;; Copyright (c) 1986, 93, 94, 95, 97, 98, 99, 2000 Free Software Foundation, Inc.
   4
   5 ;; Author: Michael D. Prange <prange@erl.mit.edu>
   6 ;; Maintainer: Dave Love <fx@gnu.org>
   7 ;; Keywords: languages
   8
   9 ;; This file is part of GNU Emacs.
  10
  11 ;; GNU Emacs is free software; you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation; either version 2, or (at your option)
  14 ;; any later version.
  15
  16 ;; GNU Emacs is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  23 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  24 ;; Boston, MA 02111-1307, USA.
  25
  26 ;;; Commentary:
  27
  28 ;; This mode is documented in the Emacs manual.
  29 ;;
  30 ;; Note that it is for editing Fortran77 or Fortran90 fixed source
  31 ;; form.  For editing Fortran 90 free format source, use `f90-mode'
  32 ;; (f90.el).
  33
  34 ;;; History:
  35
  36 ;; Fortran mode was upgraded by Stephen A. Wood (saw@cebaf.gov).
  37
  38 ;; We acknowledge many contributions and valuable suggestions by
  39 ;; Lawrence R. Dodd, Ralf Fassel, Ralph Finch, Stephen Gildea,
  40 ;; Dr. Anil Gokhale, Ulrich Mueller, Mark Neale, Eric Prestemon,
  41 ;; Gary Sabot and Richard Stallman.
  42
  43 ;;; Code:
  44
  45 ;; Todo:
  46
  47 ;; * Tidy it all up!
  48 ;; * Implement insertion and removal of statement continuations in
  49 ;;   mixed f77/f90 style, with the first `&' past column 72 and the
  50 ;;   second in column 6.
  51 ;; * Support any other extensions to f77 grokked by GNU Fortran.
  52
  53 (require 'easymenu)
  54
  55 (defgroup fortran nil
  56   "Fortran mode for Emacs"
  57   :link '(custom-manual "(emacs)Fortran")
  58   :group 'languages)
  59
  60 (defgroup fortran-indent nil
  61   "Indentation variables in Fortran mode"
  62   :prefix "fortran-"
  63   :group 'fortran)
  64
  65 (defgroup fortran-comment nil
  66   "Comment-handling variables in Fortran mode"
  67   :prefix "fortran-"
  68   :group 'fortran)
  69
  70
  71 ;;;###autoload
  72 (defcustom fortran-tab-mode-default nil
  73   "*Default tabbing/carriage control style for empty files in Fortran mode.
  74 A value of t specifies tab-digit style of continuation control.
  75 A value of nil specifies that continuation lines are marked
  76 with a character in column 6."
  77   :type 'boolean
  78   :group 'fortran-indent)
  79
  80 ;; Buffer local, used to display mode line.
  81 (defcustom fortran-tab-mode-string nil
  82   "String to appear in mode line when TAB format mode is on."
  83   :type '(choice (const nil) string)
  84   :group 'fortran-indent)
  85 (make-variable-buffer-local 'fortran-tab-mode-string)
  86
  87 (defcustom fortran-do-indent 3
  88   "*Extra indentation applied to DO blocks."
  89   :type 'integer
  90   :group 'fortran-indent)
  91
  92 (defcustom fortran-if-indent 3
  93   "*Extra indentation applied to IF blocks."
  94   :type 'integer
  95   :group 'fortran-indent)
  96
  97 (defcustom fortran-structure-indent 3
  98   "*Extra indentation applied to STRUCTURE, UNION, MAP and INTERFACE blocks."
  99   :type 'integer
 100   :group 'fortran-indent)
 101
 102 (defcustom fortran-continuation-indent 5
 103   "*Extra indentation applied to Fortran continuation lines."
 104   :type 'integer
 105   :group 'fortran-indent)
 106
 107 (defcustom fortran-comment-indent-style 'fixed
 108   "*How to indent comments.
 109 nil forces comment lines not to be touched,
 110 'fixed makes fixed comment indentation to `fortran-comment-line-extra-indent'
 111 columns beyond `fortran-minimum-statement-indent-fixed' (for
 112 `indent-tabs-mode' of nil) or `fortran-minimum-statement-indent-tab' (for
 113 `indent-tabs-mode' of t), and 'relative indents to current
 114 Fortran indentation plus `fortran-comment-line-extra-indent'."
 115   :type '(radio (const :tag "Untouched" nil) (const fixed) (const relative))
 116   :group 'fortran-indent)
 117
 118 (defcustom fortran-comment-line-extra-indent 0
 119   "*Amount of extra indentation for text within full-line comments."
 120   :type 'integer
 121   :group 'fortran-indent
 122   :group 'fortran-comment)
 123
 124 (defcustom fortran-comment-line-start "C"
 125   "*Delimiter inserted to start new full-line comment.
 126 You might want to change this to \"*\", for instance."
 127   :version "21.1"
 128   :type 'string
 129   :group 'fortran-comment)
 130
 131 ;; This used to match preprocessor lines too, but that messes up
 132 ;; filling and doesn't seem to be necessary.
 133 (defcustom fortran-comment-line-start-skip
 134   "^[CcDd*!]\\(\\([^ \t\n]\\)\\2\\2*\\)?[ \t]*"
 135   "*Regexp to match the start of a full-line comment."
 136   :version "21.1"
 137   :type 'regexp
 138   :group 'fortran-comment)
 139
 140 (defcustom fortran-minimum-statement-indent-fixed 6
 141   "*Minimum statement indentation for fixed format continuation style."
 142   :type 'integer
 143   :group 'fortran-indent)
 144
 145 (defcustom fortran-minimum-statement-indent-tab (max tab-width 6)
 146   "*Minimum statement indentation for TAB format continuation style."
 147   :type 'integer
 148   :group 'fortran-indent)
 149
 150 ;; Note that this is documented in the v18 manuals as being a string
 151 ;; of length one rather than a single character.
 152 ;; The code in this file accepts either format for compatibility.
 153 (defcustom fortran-comment-indent-char " "
 154   "*Single-character string inserted for Fortran comment indentation.
 155 Normally a space."
 156   :type 'string
 157   :group 'fortran-comment)
 158
 159 (defcustom fortran-line-number-indent 1
 160   "*Maximum indentation for Fortran line numbers.
 161 5 means right-justify them within their five-column field."
 162   :type 'integer
 163   :group 'fortran-indent)
 164
 165 (defcustom fortran-check-all-num-for-matching-do nil
 166   "*Non-nil causes all numbered lines to be treated as possible DO loop ends."
 167   :type 'boolean
 168   :group 'fortran)
 169
 170 (defcustom fortran-blink-matching-if nil
 171   "*Non-nil causes \\[fortran-indent-line] on ENDIF statement to blink on matching IF.
 172 Also, from an ENDDO statement blink on matching DO [WHILE] statement."
 173   :type 'boolean
 174   :group 'fortran)
 175
 176 (defcustom fortran-continuation-string "$"
 177   "*Single-character string used for Fortran continuation lines.
 178 In fixed format continuation style, this character is inserted in
 179 column 6 by \\[fortran-split-line] to begin a continuation line.
 180 Also, if \\[fortran-indent-line] finds this at the beginning of a line, it will
 181 convert the line into a continuation line of the appropriate style.
 182 Normally $."
 183   :type 'string
 184   :group 'fortran)
 185
 186 (defcustom fortran-comment-region "c$$$"
 187   "*String inserted by \\[fortran-comment-region] at start of each \
 188 line in region."
 189   :type 'string
 190   :group 'fortran-comment)
 191
 192 (defcustom fortran-electric-line-number t
 193   "*Non-nil causes line number digits to be moved to the correct \
 194 column as typed."
 195   :type 'boolean
 196   :group 'fortran)
 197
 198 (defvar fortran-column-ruler-fixed
 199   "0   4 6  10        20        30        40        5\
 200 0        60        70\n\
 201 \[   ]|{   |    |    |    |    |    |    |    |    \
 202 \|    |    |    |    |}\n"
 203   "String displayed above current line by \\[fortran-column-ruler].
 204 This variable used in fixed format mode.")
 205
 206 (defvar fortran-column-ruler-tab
 207   "0       810        20        30        40        5\
 208 0        60        70\n\
 209 \[   ]|  { |    |    |    |    |    |    |    |    \
 210 \|    |    |    |    |}\n"
 211   "String displayed above current line by \\[fortran-column-ruler].
 212 This variable used in TAB format mode.")
 213
 214 (defvar fortran-mode-syntax-table nil
 215   "Syntax table in use in Fortran mode buffers.")
 216
 217 (defvar fortran-analyze-depth 100
 218   "Number of lines to scan to determine whether to use fixed or TAB \
 219 format style.")
 220
 221 (defcustom fortran-break-before-delimiters t
 222   "*Non-nil causes filling to break lines before delimiters."
 223   :type 'boolean
 224   :group 'fortran)
 225
 226 (if fortran-mode-syntax-table
 227     ()
 228   (setq fortran-mode-syntax-table (make-syntax-table))
 229   ;; We might like `;' to be punctuation (g77 multi-statement lines),
 230   ;; but that screws abbrevs.
 231   (modify-syntax-entry ?\; "w" fortran-mode-syntax-table)
 232   (modify-syntax-entry ?\r " " fortran-mode-syntax-table)
 233   (modify-syntax-entry ?+ "." fortran-mode-syntax-table)
 234   (modify-syntax-entry ?- "." fortran-mode-syntax-table)
 235   (modify-syntax-entry ?= "." fortran-mode-syntax-table)
 236   (modify-syntax-entry ?* "." fortran-mode-syntax-table)
 237   (modify-syntax-entry ?/ "." fortran-mode-syntax-table)
 238   (modify-syntax-entry ?\' "\"" fortran-mode-syntax-table)
 239   (modify-syntax-entry ?\" "\"" fortran-mode-syntax-table)
 240   (modify-syntax-entry ?\\ "\\" fortran-mode-syntax-table)
 241   ;; This might be better as punctuation, as for C, but this way you
 242   ;; can treat floating-point numbers as symbols.
 243   (modify-syntax-entry ?. "_" fortran-mode-syntax-table) ; e.g. `a.ne.b'
 244   (modify-syntax-entry ?_ "_" fortran-mode-syntax-table)
 245   (modify-syntax-entry ?$ "_" fortran-mode-syntax-table) ; esp. VMSisms
 246   (modify-syntax-entry ?\! "<" fortran-mode-syntax-table)
 247   (modify-syntax-entry ?\n ">" fortran-mode-syntax-table))
 248
 249 ;; Comments are real pain in Fortran because there is no way to
 250 ;; represent the standard comment syntax in an Emacs syntax table.
 251 ;; (We can do so for F90-style).  Therefore an unmatched quote in a
 252 ;; standard comment will throw fontification off on the wrong track.
 253 ;; So we do syntactic fontification with regexps.
 254 \f
 255 ;; Regexps done by simon@gnu with help from Ulrik Dickow <dickow@nbi.dk> and
 256 ;; probably others Si's forgotten about (sorry).
 257
 258 (defconst fortran-font-lock-keywords-1 nil
 259   "Subdued level highlighting for Fortran mode.")
 260
 261 (defconst fortran-font-lock-keywords-2 nil
 262   "Medium level highlighting for Fortran mode.")
 263
 264 (defconst fortran-font-lock-keywords-3 nil
 265   "Gaudy level highlighting for Fortran mode.")
 266
 267 (defconst fortran-font-lock-syntactic-keywords nil
 268   "`font-lock-syntactic-keywords' for Fortran.
 269 These get fixed-format comments fontified.")
 270
 271 (let ((comment-chars "cd\\*")           ; `d' for `debugging' comments
 272       (fortran-type-types
 273        (eval-when-compile
 274          (let ((re (regexp-opt
 275                     (let ((simple-types
 276                            '("character" "byte" "integer" "logical"
 277                              "none" "real" "complex"
 278                              "double precision" "double complex"))
 279                           (structured-types '("structure" "union" "map"))
 280                           (other-types '("record" "dimension"
 281                                          "parameter" "common" "save"
 282                                          "external" "intrinsic" "data"
 283                                          "equivalence")))
 284                       (append
 285                        (mapcar (lambda (x) (concat "implicit " x))
 286                                simple-types)
 287                        simple-types
 288                        (mapcar (lambda (x) (concat "end " x))
 289                                structured-types)
 290                        structured-types
 291                        other-types)))))
 292            ;; In the optimized regexp above, replace spaces by regexp
 293            ;; for optional whitespace, which regexp-opt would have
 294            ;; escaped.
 295            (mapconcat #'identity (split-string re) "[ \t]*"))))
 296       (fortran-keywords
 297        (eval-when-compile
 298          (regexp-opt '("continue" "format" "end" "enddo" "if" "then"
 299                        "else" "endif" "elseif" "while" "inquire" "stop"
 300                        "return" "include" "open" "close" "read" "write"
 301                        "format" "print" "select" "case" "cycle" "exit"))))
 302       (fortran-logicals
 303        (eval-when-compile
 304          (regexp-opt '("and" "or" "not" "lt" "le" "eq" "ge" "gt" "ne"
 305                        "true" "false")))))
 306   (setq fortran-font-lock-syntactic-keywords
 307         ;; Fixed format comments.  (!-style handled normally.)
 308         (list
 309          (list (concat "^[" comment-chars "]") 0 '(11))
 310          (list (concat "^[^" comment-chars "\t\n]" (make-string 71 ?.)
 311                        "\\([^\n]+\\)")
 312                1 '(11))))
 313   (setq fortran-font-lock-keywords-1
 314         (list
 315          ;; Program, subroutine and function declarations, plus calls.
 316          (list (concat "\\<\\(block[ \t]*data\\|call\\|entry\\|function\\|"
 317                        "program\\|subroutine\\)\\>[ \t]*\\(\\sw+\\)?")
 318                '(1 font-lock-keyword-face)
 319                '(2 font-lock-function-name-face nil t))))
 320   (setq fortran-font-lock-keywords-2
 321         (append fortran-font-lock-keywords-1
 322                 (list
 323                  ;; Fontify all type specifiers (must be first; see below).
 324                  (cons (concat "\\<\\(" fortran-type-types "\\)\\>")
 325                        'font-lock-type-face)
 326                  ;; Fontify all builtin keywords (except logical, do
 327                  ;; and goto; see below).
 328                  (concat "\\<\\(" fortran-keywords "\\)\\>")
 329                  ;; Fontify all builtin operators.
 330                  (concat "\\.\\(" fortran-logicals "\\)\\.")
 331                  ;; Fontify do/goto keywords and targets, and goto tags.
 332                  (list "\\<\\(do\\|go *to\\)\\>[ \t]*\\([0-9]+\\)?"
 333                        '(1 font-lock-keyword-face)
 334                        '(2 font-lock-constant-face nil t))
 335                  (cons "^ *\\([0-9]+\\)" 'font-lock-constant-face))))
 336   (setq fortran-font-lock-keywords-3
 337         (append
 338          ;; The list `fortran-font-lock-keywords-1'.
 339          fortran-font-lock-keywords-1
 340          ;; Fontify all type specifiers plus their declared items.
 341          (list
 342           (list (concat "\\<\\(" fortran-type-types "\\)\\>[ \t(/]*\\(*\\)?")
 343                 ;; Fontify the type specifier.
 344                 '(1 font-lock-type-face)
 345                 ;; Fontify each declaration item (or just the /.../ block name).
 346                 `(font-lock-match-c-style-declaration-item-and-skip-to-next
 347                   ;; Start after any *(...) expression.
 348                   (condition-case nil
 349                       (and (and (match-beginning ,(+ 2 (regexp-opt-depth
 350                                                         fortran-type-types)))
 351                                 (forward-sexp))
 352                            (forward-sexp))
 353                     (error nil))
 354                   ;; No need to clean up.
 355                   nil
 356                   ;; Fontify as a variable name, functions are
 357                   ;; fontified elsewhere.
 358                   (1 font-lock-variable-name-face nil t))))
 359          ;; Things extra to `fortran-font-lock-keywords-3'
 360          ;; (must be done first).
 361          (list
 362           ;; Fontify goto-like `err=label'/`end=label' in read/write
 363           ;; statements.
 364           '(", *\\(e\\(nd\\|rr\\)\\)\\> *\\(= *\\([0-9]+\\)\\)?"
 365             (1 font-lock-keyword-face) (4 font-lock-constant-face nil t))
 366           ;; Highlight standard continuation character and in a
 367           ;; TAB-formatted line.
 368           '("^     \\([^ 0]\\)" 1 font-lock-string-face)
 369           '("^\t\\([1-9]\\)" 1 font-lock-string-face))
 370          (list
 371           ;; cpp stuff (ugh)
 372           '("^# *[a-z]+" . font-lock-keyword-face))
 373          ;; The list `fortran-font-lock-keywords-2' less that for types
 374          ;; (see above).
 375          (cdr (nthcdr (length fortran-font-lock-keywords-1)
 376                       fortran-font-lock-keywords-2)))))
 377
 378 (defvar fortran-font-lock-keywords fortran-font-lock-keywords-1
 379   "Default expressions to highlight in Fortran mode.")
 380 \f
 381 (defvar fortran-imenu-generic-expression
 382   ;; These patterns could be confused by sequence nos. in cols 72+ and
 383   ;; don't allow continuations everywhere.
 384   (list
 385    (list
 386     nil
 387     ;; Lines below are: 1. leading whitespace; 2. function
 388     ;; declaration with optional type, e.g. `real', `real*4',
 389     ;; character(*), `double precision' and possible statement
 390     ;; continuation; 3. untyped declarations; 4. the variable to
 391     ;; index.  [This will be fooled by `end function' allowed by G77.
 392     ;; Also, it assumes sensible whitespace is employed.]
 393     (concat "^\\s-+\\(\
 394 \\(\\sw\\|\\s-\\|[*()+]\\)*\
 395 \\<function\\|subroutine\\|entry\\|block\\s-*data\\|program\\)\
 396 [ \t" fortran-continuation-string "]+\
 397 \\(\\sw+\\)")
 398     3)
 399    ;; Un-named block data
 400    (list nil "^\\s-+\\(block\\s-*data\\)\\s-*$" 1))
 401   "Imenu generic expression for `imenu-default-create-index-function'.")
 402
 403 (defvar fortran-mode-map
 404   (let ((fortran-mode-map (make-sparse-keymap)))
 405     (define-key fortran-mode-map ";" 'fortran-abbrev-start)
 406     (define-key fortran-mode-map "\C-c;" 'fortran-comment-region)
 407     (define-key fortran-mode-map "\M-;" 'fortran-indent-comment)
 408     (define-key fortran-mode-map "\M-\n" 'fortran-split-line)
 409     (define-key fortran-mode-map "\M-\C-q" 'fortran-indent-subprogram)
 410     (define-key fortran-mode-map "\C-c\C-w" 'fortran-window-create-momentarily)
 411     (define-key fortran-mode-map "\C-c\C-r" 'fortran-column-ruler)
 412     (define-key fortran-mode-map "\C-c\C-p" 'fortran-previous-statement)
 413     (define-key fortran-mode-map "\C-c\C-n" 'fortran-next-statement)
 414     (define-key fortran-mode-map "\C-c\C-d" 'fortran-join-line) ; like f90
 415     (define-key fortran-mode-map "\M-^" 'fortran-join-line) ; subvert delete-indentation
 416     (define-key fortran-mode-map "0" 'fortran-electric-line-number)
 417     (define-key fortran-mode-map "1" 'fortran-electric-line-number)
 418     (define-key fortran-mode-map "2" 'fortran-electric-line-number)
 419     (define-key fortran-mode-map "3" 'fortran-electric-line-number)
 420     (define-key fortran-mode-map "4" 'fortran-electric-line-number)
 421     (define-key fortran-mode-map "5" 'fortran-electric-line-number)
 422     (define-key fortran-mode-map "6" 'fortran-electric-line-number)
 423     (define-key fortran-mode-map "7" 'fortran-electric-line-number)
 424     (define-key fortran-mode-map "8" 'fortran-electric-line-number)
 425     (define-key fortran-mode-map "9" 'fortran-electric-line-number)
 426
 427     ;; Menu
 428     (unless (boundp 'fortran-mode-menu)
 429       (easy-menu-define
 430        fortran-mode-menu fortran-mode-map ""
 431        `("Fortran"
 432          ["Manual" (info "(emacs)Fortran")]
 433 ;;; This loads cus-edit as things stand -- needs to be done lazily.
 434 ;;;      ,(customize-menu-create 'fortran)
 435 ;;;      ["Set" Custom-set t]
 436 ;;;      ["Save" Custom-save t]
 437 ;;;      ["Reset to Current" Custom-reset-current t]
 438 ;;;      ["Reset to Saved" Custom-reset-saved t]
 439 ;;;      ["Reset to Standard Settings" Custom-reset-standard t]
 440          "----"
 441          ["Toggle Auto-fill" fortran-auto-fill-mode :style toggle
 442           :selected (eq auto-fill-function 'fortran-do-auto-fill)]
 443          ["Toggle abbrev-mode" abbrev-mode :style toggle :selected abbrev-mode]
 444          "----"
 445          ["Comment-out Region" fortran-comment-region mark-active]
 446          ["Uncomment-out region"
 447           (fortran-comment-region (region-beginning) (region-end) 1)
 448           mark-active]
 449          ["Indent Region" indent-region mark-active]
 450          ["Indent Subprogram" fortran-indent-subprogram t]
 451          "----"
 452          ["Beginning of Subprogram" fortran-beginning-of-subprogram t]
 453          ["End of Subprogram" fortran-end-of-subprogram t]
 454          ("Mark"
 455           ["Subprogram" mark-defun t]
 456           ["IF Block" fortran-mark-if t]
 457           ["DO Block" fortran-mark-do t])
 458          ["Narrow to Subprogram" narrow-to-defun t]
 459          ["Widen" widen t]
 460          "----"
 461          ["Temporary column ruler" fortran-column-ruler t]
 462          ["72-column window" fortran-window-create t]
 463          ["Full Width Window"
 464           (enlarge-window-horizontally (- (frame-width) (window-width)))
 465           (< (window-width) (frame-width))]
 466          ["Momentary 72-column window" fortran-window-create-momentarily t]
 467          "----"
 468          ["Break Line at Point" fortran-split-line t]
 469          ["Join Line" fortran-join-line t]
 470          ["Fill Statement/Comment" fill-paragraph  t]
 471          "----"
 472          ["Add imenu menu"
 473           imenu-add-menubar-index (not (and (boundp 'imenu--index-alist)
 474                                             imenu--index-alist))])))
 475     fortran-mode-map)
 476   "Keymap used in Fortran mode.")
 477 \f
 478 (defvar fortran-mode-abbrev-table
 479   (let ((ac abbrevs-changed))
 480     (define-abbrev-table 'fortran-mode-abbrev-table ())
 481     (define-abbrev fortran-mode-abbrev-table  ";au"  "automatic" nil)
 482     (define-abbrev fortran-mode-abbrev-table  ";b"   "byte" nil)
 483     (define-abbrev fortran-mode-abbrev-table  ";bd"  "block data" nil)
 484     (define-abbrev fortran-mode-abbrev-table  ";ch"  "character" nil)
 485     (define-abbrev fortran-mode-abbrev-table  ";cl"  "close" nil)
 486     (define-abbrev fortran-mode-abbrev-table  ";c"   "continue" nil)
 487     (define-abbrev fortran-mode-abbrev-table  ";cm"  "common" nil)
 488     (define-abbrev fortran-mode-abbrev-table  ";cx"  "complex" nil)
 489     (define-abbrev fortran-mode-abbrev-table  ";df"  "define" nil)
 490     (define-abbrev fortran-mode-abbrev-table  ";di"  "dimension" nil)
 491     (define-abbrev fortran-mode-abbrev-table  ";do"  "double" nil)
 492     (define-abbrev fortran-mode-abbrev-table  ";dc"  "double complex" nil)
 493     (define-abbrev fortran-mode-abbrev-table  ";dp"  "double precision" nil)
 494     (define-abbrev fortran-mode-abbrev-table  ";dw"  "do while" nil)
 495     (define-abbrev fortran-mode-abbrev-table  ";e"   "else" nil)
 496     (define-abbrev fortran-mode-abbrev-table  ";ed"  "enddo" nil)
 497     (define-abbrev fortran-mode-abbrev-table  ";el"  "elseif" nil)
 498     (define-abbrev fortran-mode-abbrev-table  ";en"  "endif" nil)
 499     (define-abbrev fortran-mode-abbrev-table  ";eq"  "equivalence" nil)
 500     (define-abbrev fortran-mode-abbrev-table  ";ew"  "endwhere" nil)
 501     (define-abbrev fortran-mode-abbrev-table  ";ex"  "external" nil)
 502     (define-abbrev fortran-mode-abbrev-table  ";ey"  "entry" nil)
 503     (define-abbrev fortran-mode-abbrev-table  ";f"   "format" nil)
 504     (define-abbrev fortran-mode-abbrev-table  ";fa"  ".false." nil)
 505     (define-abbrev fortran-mode-abbrev-table  ";fu"  "function" nil)
 506     (define-abbrev fortran-mode-abbrev-table  ";g"   "goto" nil)
 507     (define-abbrev fortran-mode-abbrev-table  ";im"  "implicit" nil)
 508     (define-abbrev fortran-mode-abbrev-table  ";ib"  "implicit byte" nil)
 509     (define-abbrev fortran-mode-abbrev-table  ";ic"  "implicit complex" nil)
 510     (define-abbrev fortran-mode-abbrev-table  ";ich" "implicit character" nil)
 511     (define-abbrev fortran-mode-abbrev-table  ";ii"  "implicit integer" nil)
 512     (define-abbrev fortran-mode-abbrev-table  ";il"  "implicit logical" nil)
 513     (define-abbrev fortran-mode-abbrev-table  ";ir"  "implicit real" nil)
 514     (define-abbrev fortran-mode-abbrev-table  ";inc" "include" nil)
 515     (define-abbrev fortran-mode-abbrev-table  ";in"  "integer" nil)
 516     (define-abbrev fortran-mode-abbrev-table  ";intr" "intrinsic" nil)
 517     (define-abbrev fortran-mode-abbrev-table  ";l"   "logical" nil)
 518     (define-abbrev fortran-mode-abbrev-table  ";n"   "namelist" nil)
 519     (define-abbrev fortran-mode-abbrev-table  ";o"   "open" nil) ; was ;op
 520     (define-abbrev fortran-mode-abbrev-table  ";pa"  "parameter" nil)
 521     (define-abbrev fortran-mode-abbrev-table  ";pr"  "program" nil)
 522     (define-abbrev fortran-mode-abbrev-table  ";ps"  "pause" nil)
 523     (define-abbrev fortran-mode-abbrev-table  ";p"   "print" nil)
 524     (define-abbrev fortran-mode-abbrev-table  ";rc"  "record" nil)
 525     (define-abbrev fortran-mode-abbrev-table  ";re"  "real" nil)
 526     (define-abbrev fortran-mode-abbrev-table  ";r"   "read" nil)
 527     (define-abbrev fortran-mode-abbrev-table  ";rt"  "return" nil)
 528     (define-abbrev fortran-mode-abbrev-table  ";rw"  "rewind" nil)
 529     (define-abbrev fortran-mode-abbrev-table  ";s"   "stop" nil)
 530     (define-abbrev fortran-mode-abbrev-table  ";sa"  "save" nil)
 531     (define-abbrev fortran-mode-abbrev-table  ";st"  "structure" nil)
 532     (define-abbrev fortran-mode-abbrev-table  ";sc"  "static" nil)
 533     (define-abbrev fortran-mode-abbrev-table  ";su"  "subroutine" nil)
 534     (define-abbrev fortran-mode-abbrev-table  ";tr"  ".true." nil)
 535     (define-abbrev fortran-mode-abbrev-table  ";ty"  "type" nil)
 536     (define-abbrev fortran-mode-abbrev-table  ";vo"  "volatile" nil)
 537     (define-abbrev fortran-mode-abbrev-table  ";w"   "write" nil)
 538     (define-abbrev fortran-mode-abbrev-table  ";wh"  "where" nil)
 539     (setq abbrevs-changed ac)
 540     fortran-mode-abbrev-table))
 541 \f
 542 (eval-when-compile                      ; silence compiler
 543   (defvar imenu-case-fold-search)
 544   (defvar imenu-syntax-alist))
 545
 546 (defcustom fortran-mode-hook nil
 547   "Hook run by Fortran mode."
 548   :type 'hook
 549   :group 'fortran)
 550
 551 ;;;###autoload
 552 (defun fortran-mode ()
 553   "Major mode for editing Fortran code.
 554 \\[fortran-indent-line] indents the current Fortran line correctly.
 555 DO statements must not share a common CONTINUE.
 556
 557 Type ;? or ;\\[help-command] to display a list of built-in abbrevs for
 558 Fortran keywords.
 559
 560 Key definitions:
 561 \\{fortran-mode-map}
 562
 563 Variables controlling indentation style and extra features:
 564
 565  `comment-start'
 566     Normally nil in Fortran mode.  If you want to use comments
 567     starting with `!', set this to the string \"!\".
 568  `fortran-do-indent'
 569     Extra indentation within do blocks.  (default 3)
 570  `fortran-if-indent'
 571     Extra indentation within if blocks.  (default 3)
 572  `fortran-structure-indent'
 573     Extra indentation within structure, union, map and interface blocks.
 574     (default 3)
 575  `fortran-continuation-indent'
 576     Extra indentation applied to continuation statements.  (default 5)
 577  `fortran-comment-line-extra-indent'
 578     Amount of extra indentation for text within full-line comments.  (default 0)
 579  `fortran-comment-indent-style'
 580     nil    means don't change indentation of text in full-line comments,
 581     fixed  means indent that text at `fortran-comment-line-extra-indent' beyond
 582            the value of `fortran-minimum-statement-indent-fixed' (for fixed
 583            format continuation style) or `fortran-minimum-statement-indent-tab'
 584            (for TAB format continuation style).
 585     relative  means indent at `fortran-comment-line-extra-indent' beyond the
 586               indentation for a line of code.
 587     (default 'fixed)
 588  `fortran-comment-indent-char'
 589     Single-character string to be inserted instead of space for
 590     full-line comment indentation.  (default \" \")
 591  `fortran-minimum-statement-indent-fixed'
 592     Minimum indentation for Fortran statements in fixed format mode.  (def.6)
 593  `fortran-minimum-statement-indent-tab'
 594     Minimum indentation for Fortran statements in TAB format mode.  (default 9)
 595  `fortran-line-number-indent'
 596     Maximum indentation for line numbers.  A line number will get
 597     less than this much indentation if necessary to avoid reaching
 598     column 5.  (default 1)
 599  `fortran-check-all-num-for-matching-do'
 600     Non-nil causes all numbered lines to be treated as possible \"continue\"
 601     statements.  (default nil)
 602  `fortran-blink-matching-if'
 603     Non-nil causes \\[fortran-indent-line] on an ENDIF statement to blink on
 604     matching IF.  Also, from an ENDDO statement, blink on matching DO [WHILE]
 605     statement.  (default nil)
 606  `fortran-continuation-string'
 607     Single-character string to be inserted in column 5 of a continuation
 608     line.  (default \"$\")
 609  `fortran-comment-region'
 610     String inserted by \\[fortran-comment-region] at start of each line in
 611     region.  (default \"c$$$\")
 612  `fortran-electric-line-number'
 613     Non-nil causes line number digits to be moved to the correct column
 614     as typed.  (default t)
 615  `fortran-break-before-delimiters'
 616     Non-nil causes lines to be broken before delimiters.
 617     (default t)
 618
 619 Turning on Fortran mode calls the value of the variable `fortran-mode-hook'
 620 with no args, if that value is non-nil."
 621   (interactive)
 622   (kill-all-local-variables)
 623   (setq local-abbrev-table fortran-mode-abbrev-table)
 624   (set-syntax-table fortran-mode-syntax-table)
 625   ;; Font Lock mode support.
 626   (make-local-variable 'font-lock-defaults)
 627   (setq font-lock-defaults '((fortran-font-lock-keywords
 628                               fortran-font-lock-keywords-1
 629                               fortran-font-lock-keywords-2
 630                               fortran-font-lock-keywords-3)
 631                              nil t ((?/ . "$/") ("_$" . "w"))
 632                              fortran-beginning-of-subprogram))
 633   (set (make-local-variable 'font-lock-syntactic-keywords)
 634        fortran-font-lock-syntactic-keywords)
 635   (make-local-variable 'fortran-break-before-delimiters)
 636   (setq fortran-break-before-delimiters t)
 637   (make-local-variable 'indent-line-function)
 638   (setq indent-line-function 'fortran-indent-line)
 639   (make-local-variable 'comment-indent-function)
 640   (setq comment-indent-function 'fortran-comment-indent-function)
 641   (make-local-variable 'comment-start-skip)
 642   (setq comment-start-skip "![ \t]*")
 643   (make-local-variable 'comment-start)
 644   (setq comment-start "C")
 645   (make-local-variable 'require-final-newline)
 646   (setq require-final-newline t)
 647   (make-local-variable 'abbrev-all-caps)
 648   (setq abbrev-all-caps t)
 649   (make-local-variable 'indent-tabs-mode)
 650   (setq indent-tabs-mode nil)
 651 ;;;(setq abbrev-mode t) ; ?? (abbrev-mode 1) instead??
 652   (set (make-local-variable 'fill-column) 72)
 653   (use-local-map fortran-mode-map)
 654   (setq mode-name "Fortran")
 655   (setq major-mode 'fortran-mode)
 656   (make-local-variable 'fortran-comment-line-extra-indent)
 657   (make-local-variable 'fortran-minimum-statement-indent-fixed)
 658   (make-local-variable 'fortran-minimum-statement-indent-tab)
 659   (make-local-variable 'fortran-column-ruler-fixed)
 660   (make-local-variable 'fortran-column-ruler-tab)
 661   (setq fortran-tab-mode-string " TAB-format")
 662   (setq indent-tabs-mode (fortran-analyze-file-format))
 663   (setq imenu-case-fold-search t)
 664   (setq imenu-generic-expression fortran-imenu-generic-expression)
 665   (setq imenu-syntax-alist '(("_$" . "w")))
 666   (set (make-local-variable 'fill-paragraph-function) 'fortran-fill-paragraph)
 667   (set (make-local-variable 'indent-line-function) 'fortran-indent-line)
 668   (set (make-local-variable 'indent-region-function)
 669        (lambda (start end)
 670          (let (fortran-blink-matching-if ; avoid blinking delay
 671                indent-region-function)
 672            (indent-region start end nil))))
 673   (set (make-local-variable 'beginning-of-defun-function)
 674        #'fortran-beginning-of-subprogram)
 675   (set (make-local-variable 'end-of-defun-function)
 676        #'fortran-end-of-subprogram)
 677   (set (make-local-variable 'add-log-current-defun-function)
 678        #'fortran-current-defun)
 679   (run-hooks 'fortran-mode-hook))
 680 \f
 681 (defun fortran-comment-indent-function ()
 682   (save-excursion
 683     (skip-chars-backward " \t")
 684     (max (+ 1 (current-column))
 685          comment-column)))
 686
 687 (defun fortran-indent-comment ()
 688   "Align or create comment on current line.
 689 Existing comments of all types are recognized and aligned.
 690 If the line has no comment, a side-by-side comment is inserted and aligned
 691 if the value of  `comment-start'  is not nil.
 692 Otherwise, a separate-line comment is inserted, on this line
 693 or on a new line inserted before this line if this line is not blank."
 694   (interactive)
 695   (beginning-of-line)
 696   ;; Recognize existing comments of either kind.
 697   (cond ((looking-at fortran-comment-line-start-skip)
 698          (fortran-indent-line))
 699         ((fortran-find-comment-start-skip) ; catches any inline comment and
 700                                         ; leaves point after comment-start-skip
 701          (if comment-start-skip
 702              (progn (goto-char (match-beginning 0))
 703                     (if (not (= (current-column) (fortran-comment-indent-function)))
 704                         (progn (delete-horizontal-space)
 705                                (indent-to (fortran-comment-indent-function)))))
 706            (end-of-line)))        ; otherwise goto end of line or sth else?
 707         ;; No existing comment.
 708         ;; If side-by-side comments are defined, insert one,
 709         ;; unless line is now blank.
 710         ((and comment-start (not (looking-at "^[ \t]*$")))
 711          (end-of-line)
 712          (delete-horizontal-space)
 713          (indent-to (fortran-comment-indent-function))
 714          (insert comment-start))
 715         ;; Else insert separate-line comment, making a new line if nec.
 716         (t
 717          (if (looking-at "^[ \t]*$")
 718              (delete-horizontal-space)
 719            (beginning-of-line)
 720            (insert ?\n)
 721            (forward-char -1))
 722          (insert fortran-comment-line-start)
 723          (insert-char (if (stringp fortran-comment-indent-char)
 724                           (aref fortran-comment-indent-char 0)
 725                         fortran-comment-indent-char)
 726                       (- (fortran-calculate-indent) (current-column))))))
 727
 728 (defun fortran-comment-region (beg-region end-region arg)
 729   "Comments every line in the region.
 730 Puts `fortran-comment-region' at the beginning of every line in the region.
 731 BEG-REGION and END-REGION are args which specify the region boundaries.
 732 With non-nil ARG, uncomments the region."
 733   (interactive "*r\nP")
 734   (let ((end-region-mark (make-marker)) (save-point (point-marker)))
 735     (set-marker end-region-mark end-region)
 736     (goto-char beg-region)
 737     (beginning-of-line)
 738     (if (not arg)                       ;comment the region
 739         (progn (insert fortran-comment-region)
 740                (while (and  (= (forward-line 1) 0)
 741                             (< (point) end-region-mark))
 742                  (insert fortran-comment-region)))
 743       (let ((com (regexp-quote fortran-comment-region))) ;uncomment the region
 744         (if (looking-at com)
 745             (delete-region (point) (match-end 0)))
 746         (while (and  (= (forward-line 1) 0)
 747                      (< (point) end-region-mark))
 748           (if (looking-at com)
 749               (delete-region (point) (match-end 0))))))
 750     (goto-char save-point)
 751     (set-marker end-region-mark nil)
 752     (set-marker save-point nil)))
 753 \f
 754 (defun fortran-abbrev-start ()
 755   "Typing ;\\[help-command] or ;? lists all the Fortran abbrevs.
 756 Any other key combination is executed normally."
 757   (interactive)
 758   (let (c)
 759     (insert last-command-char)
 760     (if (or (eq (setq c (read-event)) ??)    ;insert char if not equal to `?'
 761             (eq c help-char))
 762         (fortran-abbrev-help)
 763       (setq unread-command-events (list c)))))
 764
 765 (defun fortran-abbrev-help ()
 766   "List the currently defined abbrevs in Fortran mode."
 767   (interactive)
 768   (message "Listing abbrev table...")
 769   (display-buffer (fortran-prepare-abbrev-list-buffer))
 770   (message "Listing abbrev table...done"))
 771
 772 (defun fortran-prepare-abbrev-list-buffer ()
 773   (save-excursion
 774     (set-buffer (get-buffer-create "*Abbrevs*"))
 775     (erase-buffer)
 776     (insert-abbrev-table-description 'fortran-mode-abbrev-table t)
 777     (goto-char (point-min))
 778     (set-buffer-modified-p nil)
 779     (edit-abbrevs-mode))
 780   (get-buffer-create "*Abbrevs*"))
 781
 782 (defun fortran-column-ruler ()
 783   "Insert a column ruler momentarily above current line, till next keystroke.
 784 The ruler is defined by the value of `fortran-column-ruler-fixed' when in fixed
 785 format mode, and `fortran-column-ruler-tab' when in TAB format mode.
 786 The key typed is executed unless it is SPC."
 787   (interactive)
 788   (momentary-string-display
 789    (if indent-tabs-mode
 790        fortran-column-ruler-tab
 791      fortran-column-ruler-fixed)
 792    (save-excursion
 793      (beginning-of-line)
 794      (if (eq (window-start (selected-window))
 795              (window-point (selected-window)))
 796          (line-beginning-position 2)
 797        (point)))
 798    nil "Type SPC or any command to erase ruler."))
 799
 800 (defun fortran-window-create ()
 801   "Make the window 72 columns wide.
 802 See also `fortran-window-create-momentarily'."
 803   (interactive)
 804   (condition-case error
 805       (progn
 806         (let ((window-min-width 2))
 807           (if (< (window-width) (frame-width))
 808               (enlarge-window-horizontally (- (frame-width)
 809                                               (window-width) 1)))
 810           (let* ((window-edges (window-edges))
 811                  (scroll-bar-width (- (nth 2 window-edges)
 812                                       (car window-edges)
 813                                       (window-width))))
 814             (split-window-horizontally (+ 72 scroll-bar-width)))
 815           (other-window 1)
 816           (switch-to-buffer " fortran-window-extra" t)
 817           (select-window (previous-window))))
 818     (error (message "No room for Fortran window.")
 819            'error)))
 820
 821 (defun fortran-window-create-momentarily (&optional arg)
 822   "Momentarily make the window 72 columns wide.
 823 Optional ARG non-nil and non-unity disables the momentary feature.
 824 See also `fortran-window-create'."
 825   (interactive "p")
 826   (if (or (not arg)
 827           (= arg 1))
 828       (save-window-excursion
 829         (if (not (equal (fortran-window-create) 'error))
 830             (progn (message "Type SPC to continue editing.")
 831                    (let ((char (read-event)))
 832                      (or (equal char (string-to-char " "))
 833                          (setq unread-command-events (list char)))))))
 834     (fortran-window-create)))
 835
 836 (defun fortran-split-line ()
 837   "Break line at point and insert continuation marker and alignment."
 838   (interactive)
 839   (delete-horizontal-space)
 840   (if (save-excursion
 841         (beginning-of-line)
 842         (looking-at fortran-comment-line-start-skip))
 843       (insert ?\n fortran-comment-line-start ? )
 844     (if indent-tabs-mode
 845         (insert ?\n ?\t (fortran-numerical-continuation-char))
 846       (insert "\n " fortran-continuation-string))) ; Space after \n important
 847   (fortran-indent-line))                ; when the cont string is C, c or *.
 848
 849 (defun fortran-remove-continuation ()
 850   (if (looking-at "\\(     [^ 0\n]\\|\t[1-9]\\|&\\)")
 851       (progn (replace-match "")
 852              (delete-indentation)
 853              t)))
 854
 855 (defun fortran-join-line (arg)
 856   "Join current line to the previous one and re-indent.
 857 With a prefix argument, repeat this operation that many times.
 858 If the prefix argument ARG is negative, join the next -ARG lines.
 859 Continuation lines are correctly handled."
 860   (interactive "*p")
 861   (save-excursion
 862     (when (> 0 arg)
 863       (setq arg (- arg))
 864       (forward-line arg))
 865     (while (not (zerop arg))
 866       (beginning-of-line)
 867       (or (fortran-remove-continuation)
 868           (delete-indentation))
 869       (setq arg (1- arg)))
 870     (fortran-indent-line)))
 871
 872 (defun fortran-numerical-continuation-char ()
 873   "Return a digit for tab-digit style of continuation lines.
 874 If, previous line is a tab-digit continuation line, returns that digit
 875 plus one.  Otherwise return 1.  Zero not allowed."
 876   (save-excursion
 877     (forward-line -1)
 878     (if (looking-at "\t[1-9]")
 879         (+ ?1 (% (- (char-after (+ (point) 1)) ?0) 9))
 880       ?1)))
 881
 882 (put 'fortran-electric-line-number 'delete-selection t)
 883 (defun fortran-electric-line-number (arg)
 884   "Self insert, but if part of a Fortran line number indent it automatically.
 885 Auto-indent does not happen if a numeric ARG is used."
 886   (interactive "P")
 887   (if (or arg (not fortran-electric-line-number))
 888       (if arg
 889           (self-insert-command (prefix-numeric-value arg))
 890         (self-insert-command 1))
 891     (if (or (and (= 5 (current-column))
 892                  (save-excursion
 893                    (beginning-of-line)
 894                    (looking-at "     "))) ;In col 5 with only spaces to left.
 895             (and (= (if indent-tabs-mode
 896                         fortran-minimum-statement-indent-tab
 897                       fortran-minimum-statement-indent-fixed) (current-column))
 898                  (eq ?\t (char-after (line-beginning-position))) ;In col 8
 899                                         ; with a single tab to the left.
 900                  (not (or (eq last-command 'fortran-indent-line)
 901                           (eq last-command
 902                               'fortran-indent-new-line))))
 903             (save-excursion
 904               (re-search-backward "[^ \t0-9]"
 905                                   (line-beginning-position)
 906                                   t))   ;not a line number
 907             (looking-at "[0-9]"))       ;within a line number
 908         (self-insert-command (prefix-numeric-value arg))
 909       (skip-chars-backward " \t")
 910       (insert last-command-char)
 911       (fortran-indent-line))))
 912 \f
 913 (defvar fortran-end-prog-re1
 914   "end\
 915 \\([ \t]*\\(program\\|subroutine\\|function\\|block[ \t]*data\\)\\>\
 916 \\([ \t]*\\(\\sw\\|\\s_\\)+\\)?\\)?")
 917 (defvar fortran-end-prog-re
 918   (concat "^[ \t0-9]*" fortran-end-prog-re1)
 919   "Regexp possibly marking subprogram end.")
 920
 921 (defun fortran-check-end-prog-re ()
 922   "Check a preliminary match against `fortran-end-prog-re'."
 923   ;; Having got a possible match for the subprogram end, we need a
 924   ;; match of whitespace, avoiding possible column 73+ stuff.
 925   (save-match-data
 926     (string-match "^\\s-*\\(\\'\\|\\s<\\)"
 927                   (buffer-substring (match-end 0)
 928                                     (min (line-end-position)
 929                                          (+ 72 (line-beginning-position)))))))
 930
 931 ;; Note that you can't just check backwards for `subroutine' &c in
 932 ;; case of un-marked main programs not at the start of the file.
 933 (defun fortran-beginning-of-subprogram ()
 934   "Moves point to the beginning of the current Fortran subprogram."
 935   (interactive)
 936   (save-match-data
 937     (let ((case-fold-search t))
 938       (beginning-of-line -1)
 939       (if (catch 'ok
 940             (while (re-search-backward fortran-end-prog-re nil 'move)
 941               (if (fortran-check-end-prog-re)
 942                   (throw 'ok t))))
 943           (forward-line)))))
 944
 945 (defun fortran-end-of-subprogram ()
 946   "Moves point to the end of the current Fortran subprogram."
 947   (interactive)
 948   (save-match-data
 949     (let ((case-fold-search t))
 950       (if (save-excursion               ; on END
 951             (beginning-of-line)
 952             (and (looking-at fortran-end-prog-re)
 953                  (fortran-check-end-prog-re)))
 954           (forward-line)
 955         (beginning-of-line 2)
 956         (catch 'ok
 957           (while (re-search-forward fortran-end-prog-re nil 'move)
 958             (if (fortran-check-end-prog-re)
 959                 (throw 'ok t))))
 960         (goto-char (match-beginning 0))
 961         (forward-line)))))
 962
 963 (defun fortran-previous-statement ()
 964   "Moves point to beginning of the previous Fortran statement.
 965 Returns `first-statement' if that statement is the first
 966 non-comment Fortran statement in the file, and nil otherwise."
 967   (interactive)
 968   (let (not-first-statement continue-test)
 969     (beginning-of-line)
 970     (setq continue-test
 971           (and
 972            (not (looking-at fortran-comment-line-start-skip))
 973            (or (looking-at
 974                 (concat "[ \t]*" (regexp-quote fortran-continuation-string)))
 975                (looking-at "     [^ 0\n]\\|\t[1-9]"))))
 976     (while (and (setq not-first-statement (= (forward-line -1) 0))
 977                 (or (looking-at fortran-comment-line-start-skip)
 978                     (looking-at "[ \t]*$\\|     [^ 0\n]\\|\t[1-9]")
 979                     (looking-at (concat "[ \t]*"  comment-start-skip)))))
 980     (cond ((and continue-test
 981                 (not not-first-statement))
 982            (message "Incomplete continuation statement."))
 983           (continue-test
 984            (fortran-previous-statement))
 985           ((not not-first-statement)
 986            'first-statement))))
 987
 988 (defun fortran-next-statement ()
 989   "Moves point to beginning of the next Fortran statement.
 990 Returns `last-statement' if that statement is the last
 991 non-comment Fortran statement in the file, and nil otherwise."
 992   (interactive)
 993   (let (not-last-statement)
 994     (beginning-of-line)
 995     (while (and (setq not-last-statement
 996                       (and (= (forward-line 1) 0)
 997                            (not (eobp))))
 998                 (or (looking-at fortran-comment-line-start-skip)
 999                     (looking-at "[ \t]*$\\|     [^ 0\n]\\|\t[1-9]")
1000                     (looking-at (concat "[ \t]*"  comment-start-skip)))))
1001     (if (not not-last-statement)
1002         'last-statement)))
1003 \f
1004 (defun fortran-blink-match (regex keyword find-begin)
1005   "From a line matching REGEX, blink matching KEYWORD statement line.
1006 Use function FIND-BEGIN to match it."
1007   (let ((top-of-window (window-start))
1008         (end-point (point))
1009         (case-fold-search t)
1010         matching
1011         message)
1012     (if (save-excursion
1013           (beginning-of-line)
1014           (skip-chars-forward " \t0-9")
1015           (looking-at regex))
1016         (progn
1017           (if (not (setq matching (funcall find-begin)))
1018               (setq message (concat "No matching " keyword "."))
1019             (if (< matching top-of-window)
1020                 (save-excursion
1021                   (goto-char matching)
1022                   (beginning-of-line)
1023                   (setq message
1024                         (concat "Matches "
1025                                 (buffer-substring (point)
1026                                                   (line-end-position)))))))
1027           (if message
1028               (message "%s" message)
1029             (goto-char matching)
1030             (sit-for 1)
1031             (goto-char end-point))))))
1032
1033 (defun fortran-blink-matching-if ()
1034   "From an ENDIF or ELSE statement, blink the matching IF statement."
1035   (fortran-blink-match "e\\(nd[ \t]*if\\|lse\\([ \t]*if\\)?\\)\\b"
1036                        "if" #'fortran-beginning-if))
1037
1038 (defun fortran-blink-matching-do ()
1039   "From an ENDDO statement, blink the matching DO or DO WHILE statement."
1040   (fortran-blink-match "end[ \t]*do\\b" "do" #'fortran-beginning-do))
1041
1042 (defun fortran-mark-do ()
1043   "Put mark at end of Fortran DO [WHILE]-ENDDO construct, point at beginning.
1044 The marks are pushed."
1045   (interactive)
1046   (let (enddo-point do-point)
1047     (if (setq enddo-point (fortran-end-do))
1048         (if (not (setq do-point (fortran-beginning-do)))
1049             (message "No matching do.")
1050           (goto-char enddo-point)
1051           (push-mark)
1052           (goto-char do-point)))))
1053
1054 (defun fortran-end-do ()
1055   "Search forward for first unmatched ENDDO.
1056 Return point or nil."
1057   (let ((case-fold-search t))
1058     (if (save-excursion (beginning-of-line)
1059                         (skip-chars-forward " \t0-9")
1060                         (looking-at "end[ \t]*do\\b"))
1061         ;; Sitting on one.
1062         (match-beginning 0)
1063       ;; Search for one.
1064       (save-excursion
1065         (let ((count 1))
1066           (while (and (not (= count 0))
1067                       (not (eq (fortran-next-statement) 'last-statement))
1068                       ;; Keep local to subprogram
1069                       (not (and (looking-at fortran-end-prog-re)
1070                                 (fortran-check-end-prog-re))))
1071             (skip-chars-forward " \t0-9")
1072             (cond ((looking-at "end[ \t]*do\\b")
1073                    (setq count (1- count)))
1074                   ((looking-at
1075                     "\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?do[ \t]+[^0-9]")
1076                    (setq count (+ count 1)))))
1077           (and (= count 0)
1078                ;; All pairs accounted for.
1079                (point)))))))
1080
1081 (defun fortran-beginning-do ()
1082   "Search backwards for first unmatched DO [WHILE].
1083 Return point or nil."
1084   (let ((case-fold-search t))
1085     (if (save-excursion
1086           (beginning-of-line)
1087           (skip-chars-forward " \t0-9")
1088           (looking-at "\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?do[ \t]+"))
1089         ;; Sitting on one.
1090         (match-beginning 0)
1091       ;; Search for one.
1092       (save-excursion
1093         (let ((count 1))
1094           (while (and (not (= count 0))
1095                       (not (eq (fortran-previous-statement) 'first-statement))
1096                       ;; Keep local to subprogram
1097                       (not (and (looking-at fortran-end-prog-re)
1098                                 (fortran-check-end-prog-re))))
1099             (skip-chars-forward " \t0-9")
1100             (cond ((looking-at
1101                     "\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?do[ \t]+[^0-9]")
1102                    (setq count (1- count)))
1103                   ((looking-at "end[ \t]*do\\b")
1104                    (setq count (1+ count)))))
1105           (and (= count 0)
1106                ;; All pairs accounted for.
1107                (point)))))))
1108
1109 (defun fortran-mark-if ()
1110   "Put mark at end of Fortran IF-ENDIF construct, point at beginning.
1111 The marks are pushed."
1112   (interactive)
1113   (let (endif-point if-point)
1114     (if (setq endif-point (fortran-end-if))
1115         (if (not (setq if-point (fortran-beginning-if)))
1116             (message "No matching if.")
1117           ;; Set mark, move point.
1118           (goto-char endif-point)
1119           (push-mark)
1120           (goto-char if-point)))))
1121
1122 (defvar fortran-if-start-re "\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?if[ \t]*(")
1123
1124 (defun fortran-end-if ()
1125   "Search forwards for first unmatched ENDIF.
1126 Return point or nil."
1127   (let ((case-fold-search t))
1128     (if (save-excursion (beginning-of-line)
1129                         (skip-chars-forward " \t0-9")
1130                         (looking-at "end[ \t]*if\\b"))
1131         ;; Sitting on one.
1132         (match-beginning 0)
1133       ;; Search for one.  The point has been already been moved to first
1134       ;; letter on line but this should not cause troubles.
1135       (save-excursion
1136         (let ((count 1))
1137           (while (and (not (= count 0))
1138                       (not (eq (fortran-next-statement) 'last-statement))
1139                       ;; Keep local to subprogram.
1140                       (not (and (looking-at fortran-end-prog-re)
1141                                 (fortran-check-end-prog-re))))
1142             (skip-chars-forward " \t0-9")
1143             (cond ((looking-at "end[ \t]*if\\b")
1144                    (setq count (- count 1)))
1145                   ((looking-at fortran-if-start-re)
1146                    (save-excursion
1147                      (if (or
1148                           (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]")
1149                           (let (then-test) ; Multi-line if-then.
1150                             (while
1151                                 (and (= (forward-line 1) 0)
1152                                      ;; Search forward for then.
1153                                      (looking-at "     [^ 0\n]\\|\t[1-9]")
1154                                      (not
1155                                       (setq then-test
1156                                             (looking-at
1157                                              ".*then\\b[ \t]*[^ \t(=a-z0-9]")))))
1158                             then-test))
1159                          (setq count (+ count 1)))))))
1160           (and (= count 0)
1161                ;; All pairs accounted for.
1162                (point)))))))
1163
1164 (defun fortran-beginning-if ()
1165   "Search backwards for first unmatched IF-THEN.
1166 Return point or nil."
1167   (let ((case-fold-search t))
1168     (if (save-excursion
1169           ;; May be sitting on multi-line if-then statement, first
1170           ;; move to beginning of current statement.  Note:
1171           ;; `fortran-previous-statement' moves to previous statement
1172           ;; *unless* current statement is first one.  Only move
1173           ;; forward if not first-statement.
1174           (if (not (eq (fortran-previous-statement) 'first-statement))
1175               (fortran-next-statement))
1176           (skip-chars-forward " \t0-9")
1177           (and
1178            (looking-at fortran-if-start-re)
1179            (save-match-data
1180              (or (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]")
1181                  ;; Multi-line if-then.
1182                  (let (then-test)
1183                    (while
1184                      (and (= (forward-line 1) 0)
1185                             ;; Search forward for then.
1186                             (looking-at "     [^ 0\n]\\|\t[1-9]")
1187                             (not
1188                              (setq then-test
1189                                    (looking-at
1190                                     ".*then\\b[ \t]*[^ \t(=a-z0-9]")))))
1191                    then-test)))))
1192         ;; Sitting on one.
1193         (match-beginning 0)
1194       ;; Search for one.
1195       (save-excursion
1196         (let ((count 1))
1197           (while (and (not (= count 0))
1198                       (not (eq (fortran-previous-statement) 'first-statement))
1199                       ;; Keep local to subprogram.
1200                       (not (and (looking-at fortran-end-prog-re)
1201                                 (fortran-check-end-prog-re))))
1202             (skip-chars-forward " \t0-9")
1203             (cond ((looking-at fortran-if-start-re)
1204                    (save-excursion
1205                      (if (or
1206                           (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]")
1207                           (let (then-test) ; Multi-line if-then.
1208                             (while
1209                                 (and (= (forward-line 1) 0)
1210                                      ;; Search forward for then.
1211                                      (looking-at "     [^ 0\n]\\|\t[1-9]")
1212                                      (not
1213                                       (setq then-test
1214                                             (looking-at
1215                                              ".*then\\b[ \t]*[^ \t(=a-z0-9]")))))
1216                             then-test))
1217                          (setq count (- count 1)))))
1218                   ((looking-at "end[ \t]*if\\b")
1219                    (setq count (+ count 1)))))
1220           (and (= count 0)
1221                ;; All pairs accounted for.
1222                (point)))))))
1223 \f
1224 (defun fortran-indent-line ()
1225   "Indent current Fortran line based on its contents and on previous lines."
1226   (interactive)
1227   (let ((cfi (fortran-calculate-indent)))
1228     (save-excursion
1229       (beginning-of-line)
1230       (if (or (not (= cfi (fortran-current-line-indentation)))
1231               (and (re-search-forward "^[ \t]*[0-9]+" (+ (point) 4) t)
1232                    (not (fortran-line-number-indented-correctly-p))))
1233           (fortran-indent-to-column cfi)
1234         (beginning-of-line)
1235         (if (and (not (looking-at fortran-comment-line-start-skip))
1236                  (fortran-find-comment-start-skip))
1237             (fortran-indent-comment))))
1238     ;; Never leave point in left margin.
1239     (if (< (current-column) cfi)
1240         (move-to-column cfi))
1241     (if (and auto-fill-function
1242              (> (save-excursion (end-of-line) (current-column))
1243                 fill-column))
1244         (save-excursion
1245           (end-of-line)
1246           (fortran-fill)))
1247     (if fortran-blink-matching-if
1248         (progn
1249           (fortran-blink-matching-if)
1250           (fortran-blink-matching-do)))))
1251
1252 ;; Historically this was a separate function which advertised itself
1253 ;; as reindenting but only did so where `most likely to be necessary'.
1254 (defalias 'fortran-indent-new-line 'reindent-then-newline-and-indent)
1255
1256 (defun fortran-indent-subprogram ()
1257   "Properly indent the Fortran subprogram which contains point."
1258   (interactive)
1259   (save-excursion
1260     (mark-defun)
1261     (message "Indenting subprogram...")
1262     (indent-region (point) (mark) nil))
1263   (message "Indenting subprogram...done."))
1264
1265 (defun fortran-calculate-indent ()
1266   "Calculates the Fortran indent column based on previous lines."
1267   (let (icol first-statement (case-fold-search t)
1268              (fortran-minimum-statement-indent
1269               (if indent-tabs-mode
1270                   fortran-minimum-statement-indent-tab
1271                 fortran-minimum-statement-indent-fixed)))
1272     (save-excursion
1273       (setq first-statement (fortran-previous-statement))
1274       (if first-statement
1275           (setq icol fortran-minimum-statement-indent)
1276         (progn
1277           (if (= (point) (point-min))
1278               (setq icol fortran-minimum-statement-indent)
1279             (setq icol (fortran-current-line-indentation)))
1280           (skip-chars-forward " \t0-9")
1281           (cond ((looking-at "\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?if[ \t]*(")
1282                  (if (or (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t_$(=a-z0-9]")
1283                          (let (then-test)       ;multi-line if-then
1284                            (while (and (= (forward-line 1) 0)
1285                                        ;;search forward for then
1286                                        (looking-at "     [^ 0\n]\\|\t[1-9]")
1287                                        (not (setq then-test
1288                                                   (looking-at
1289                                                    ".*then\\b[ \t]\
1290 *[^ \t_$(=a-z0-9]")))))
1291                            then-test))
1292                      (setq icol (+ icol fortran-if-indent))))
1293                 ((looking-at "else\\(if\\)?\\b")
1294                  (setq icol (+ icol fortran-if-indent)))
1295                 ((looking-at "select[ \t]*case[ \t](.*)")
1296                  (setq icol (+ icol fortran-if-indent)))
1297                 ((looking-at "case[ \t]*(.*)")
1298                  (setq icol (+ icol fortran-if-indent)))
1299                 ((looking-at "case[ \t]*default\\b")
1300                  (setq icol (+ icol fortran-if-indent)))
1301                 ((looking-at "\\(otherwise\\|else[ \t]*where\\)\\b")
1302                  (setq icol (+ icol fortran-if-indent)))
1303                 ((looking-at "where[ \t]*(.*)[ \t]*\n")
1304                  (setq icol (+ icol fortran-if-indent)))
1305                 ((looking-at "do\\b")
1306                  (setq icol (+ icol fortran-do-indent)))
1307                 ((looking-at
1308                   "\\(structure\\|union\\|map\\|interface\\)\
1309 \\b[ \t]*[^ \t=(a-z]")
1310                  (setq icol (+ icol fortran-structure-indent)))
1311                 ((and (looking-at fortran-end-prog-re1)
1312                       (fortran-check-end-prog-re))
1313                  ;; Previous END resets indent to minimum
1314                  (setq icol fortran-minimum-statement-indent))))))
1315     (save-excursion
1316       (beginning-of-line)
1317       (cond ((looking-at "[ \t]*$"))
1318             ((looking-at fortran-comment-line-start-skip)
1319              (cond ((eq fortran-comment-indent-style 'relative)
1320                     (setq icol (+ icol fortran-comment-line-extra-indent)))
1321                    ((eq fortran-comment-indent-style 'fixed)
1322                     (setq icol (+ fortran-minimum-statement-indent
1323                                   fortran-comment-line-extra-indent))))
1324              (setq fortran-minimum-statement-indent 0))
1325             ((or (looking-at (concat "[ \t]*"
1326                                      (regexp-quote
1327                                       fortran-continuation-string)))
1328                  (looking-at "     [^ 0\n]\\|\t[1-9]"))
1329              (setq icol (+ icol fortran-continuation-indent)))
1330             ((looking-at "[ \t]*#")     ; Check for cpp directive.
1331              (setq fortran-minimum-statement-indent 0 icol 0))
1332             (first-statement)
1333             ((and fortran-check-all-num-for-matching-do
1334                   (looking-at "[ \t]*[0-9]+")
1335                   (fortran-check-for-matching-do))
1336              (setq icol (- icol fortran-do-indent)))
1337             (t
1338              (skip-chars-forward " \t0-9")
1339              (cond ((looking-at "end[ \t]*\\(if\\|select\\|where\\)\\b")
1340                     (setq icol (- icol fortran-if-indent)))
1341                    ((looking-at "else\\(if\\)?\\b")
1342                     (setq icol (- icol fortran-if-indent)))
1343                    ((looking-at "case[ \t]*\\((.*)\\|default\\>\\)")
1344                     (setq icol (- icol fortran-if-indent)))
1345                    ((looking-at "\\(otherwise\\|else[ \t]*where\\)\\b")
1346                     (setq icol (- icol fortran-if-indent)))
1347                    ((and (looking-at "continue\\b")
1348                          (fortran-check-for-matching-do))
1349                     (setq icol (- icol fortran-do-indent)))
1350                    ((looking-at "end[ \t]*do\\b")
1351                     (setq icol (- icol fortran-do-indent)))
1352                    ((looking-at "end[ \t]*\
1353 \\(structure\\|union\\|map\\|interface\\)\\b[ \t]*[^ \t=(a-z]")
1354                     (setq icol (- icol fortran-structure-indent)))
1355                    ((and (looking-at fortran-end-prog-re1)
1356                          (fortran-check-end-prog-re)
1357                          (not (= icol fortran-minimum-statement-indent)))
1358                     (message "Warning: `end' not in column %d.  Probably\
1359  an unclosed block." fortran-minimum-statement-indent))))))
1360     (max fortran-minimum-statement-indent icol)))
1361 \f
1362 (defun fortran-current-line-indentation ()
1363   "Indentation of current line, ignoring Fortran line number or continuation.
1364 This is the column position of the first non-whitespace character
1365 aside from the line number and/or column 5/8 line-continuation character.
1366 For comment lines, returns indentation of the first
1367 non-indentation text within the comment."
1368   (save-excursion
1369     (beginning-of-line)
1370     (cond ((looking-at fortran-comment-line-start-skip)
1371            (goto-char (match-end 0))
1372            (skip-chars-forward
1373             (if (stringp fortran-comment-indent-char)
1374                 fortran-comment-indent-char
1375               (char-to-string fortran-comment-indent-char))))
1376           ((or (looking-at "     [^ 0\n]\\|\t[1-9]"))
1377            (goto-char (match-end 0)))
1378           (t
1379            ;; Move past line number.
1380            (skip-chars-forward "[ \t0-9]")))
1381     ;; Move past whitespace.
1382     (skip-chars-forward " \t")
1383     (current-column)))
1384
1385 (defun fortran-indent-to-column (col)
1386   "Indent current line with spaces to column COL.
1387 notes: 1) A non-zero/non-blank character in column 5 indicates a continuation
1388           line, and this continuation character is retained on indentation;
1389        2) If `fortran-continuation-string' is the first non-whitespace
1390           character, this is a continuation line;
1391        3) A non-continuation line which has a number as the first
1392           non-whitespace character is a numbered line.
1393        4) A TAB followed by a digit indicates a continuation line."
1394   (save-excursion
1395     (beginning-of-line)
1396     (if (looking-at fortran-comment-line-start-skip)
1397         (if fortran-comment-indent-style
1398             (let* ((char (if (stringp fortran-comment-indent-char)
1399                              (aref fortran-comment-indent-char 0)
1400                            fortran-comment-indent-char))
1401                    (chars (string ?  ?\t char)))
1402               (goto-char (match-end 0))
1403               (skip-chars-backward chars)
1404               (delete-region (point) (progn (skip-chars-forward chars)
1405                                             (point)))
1406               (insert-char char (- col (current-column)))))
1407       (if (looking-at "\t[1-9]")
1408           (if indent-tabs-mode
1409               (goto-char (match-end 0))
1410             (delete-char 2)
1411             (insert-char ?  5)
1412             (insert fortran-continuation-string))
1413         (if (looking-at "     [^ 0\n]")
1414             (if indent-tabs-mode
1415                 (progn (delete-char 6)
1416                        (insert ?\t (fortran-numerical-continuation-char) 1))
1417               (forward-char 6))
1418           (delete-horizontal-space)
1419           ;; Put line number in columns 0-4
1420           ;; or put continuation character in column 5.
1421           (cond ((eobp))
1422                 ((looking-at (regexp-quote fortran-continuation-string))
1423                  (if indent-tabs-mode
1424                      (progn
1425                        (indent-to
1426                         (if indent-tabs-mode
1427                             fortran-minimum-statement-indent-tab
1428                           fortran-minimum-statement-indent-fixed))
1429                        (delete-char 1)
1430                        (insert-char (fortran-numerical-continuation-char) 1))
1431                    (indent-to 5)
1432                    (forward-char 1)))
1433                 ((looking-at "[0-9]+")
1434                  (let ((extra-space (- 5 (- (match-end 0) (point)))))
1435                    (if (< extra-space 0)
1436                        (message "Warning: line number exceeds 5-digit limit.")
1437                      (indent-to (min fortran-line-number-indent extra-space))))
1438                  (skip-chars-forward "0-9")))))
1439       ;; Point is now after any continuation character or line number.
1440       ;; Put body of statement where specified.
1441       (delete-horizontal-space)
1442       (indent-to col)
1443       ;; Indent any comment following code on the same line.
1444       (if (and comment-start-skip
1445                (fortran-find-comment-start-skip))
1446           (progn (goto-char (match-beginning 0))
1447                  (if (not (= (current-column)
1448                              (fortran-comment-indent-function)))
1449                      (progn (delete-horizontal-space)
1450                             (indent-to
1451                              (fortran-comment-indent-function)))))))))
1452
1453 (defun fortran-line-number-indented-correctly-p ()
1454   "Return t if current line's line number is correctly indented.
1455 Do not call if there is no line number."
1456   (save-excursion
1457     (beginning-of-line)
1458     (skip-chars-forward " \t")
1459     (and (<= (current-column) fortran-line-number-indent)
1460          (or (= (current-column) fortran-line-number-indent)
1461              (progn (skip-chars-forward "0-9")
1462                     (= (current-column) 5))))))
1463
1464 (defun fortran-check-for-matching-do ()
1465   "When called from a numbered statement, return t if matching DO is found.
1466 Otherwise return nil."
1467   (let ((case-fold-search t)
1468         charnum)
1469     (save-excursion
1470       (beginning-of-line)
1471       (if (looking-at "[ \t]*[0-9]+")
1472           (progn
1473             (skip-chars-forward " \t")
1474             (skip-chars-forward "0")    ;skip past leading zeros
1475             (setq charnum
1476                   (buffer-substring (point) (progn
1477                                               (skip-chars-forward "0-9")
1478                                               (point))))
1479             (beginning-of-line)
1480             (save-restriction
1481               (save-excursion
1482                 (narrow-to-defun)
1483                 (and (re-search-backward
1484                       (concat "\\(^[ \t0-9]*do[ \t]*0*" charnum "\\b\\)\\|"
1485                               "\\(^[ \t]*0*" charnum "\\b\\)")
1486                       nil t)
1487                      (looking-at (concat "^[ \t0-9]*do[ \t]*0*"
1488                                          charnum))))))))))
1489
1490 (defun fortran-find-comment-start-skip ()
1491   "Move to past `comment-start-skip' found on current line.
1492 Return t if `comment-start-skip' found, nil if not."
1493   ;; In order to move point only if comment-start-skip is found, this
1494   ;; one uses a lot of save-excursions.  Note that re-search-forward
1495   ;; moves point even if comment-start-skip is inside a string-constant.
1496   ;; Some code expects certain values for match-beginning and end
1497   (interactive)
1498   (if (save-excursion
1499         (re-search-forward comment-start-skip (line-end-position) t))
1500       (let ((save-match-beginning (match-beginning 0))
1501             (save-match-end (match-end 0)))
1502         (if (fortran-is-in-string-p (match-beginning 0))
1503             (save-excursion
1504               (goto-char save-match-end)
1505               (fortran-find-comment-start-skip)) ; recurse for rest of line
1506           (goto-char save-match-beginning)
1507           (re-search-forward comment-start-skip (line-end-position) t)
1508           (goto-char (match-end 0))
1509           t))
1510     nil))
1511
1512 ;;From: ralf@up3aud1.gwdg.de (Ralf Fassel)
1513 ;; Test if TAB format continuation lines work.
1514 (defun fortran-is-in-string-p (where)
1515   "Return non-nil iff WHERE (a buffer position) is inside a Fortran string."
1516   (save-excursion
1517     (goto-char where)
1518     (cond
1519      ((bolp) nil)                       ; bol is never inside a string
1520      ((save-excursion                   ; comment lines too
1521         (beginning-of-line)
1522         (looking-at fortran-comment-line-start-skip)) nil)
1523      (t (let (;; ok, serious now. Init some local vars:
1524               (parse-state '(0 nil nil nil nil nil 0))
1525               (quoted-comment-start (if comment-start
1526                                         (regexp-quote comment-start)))
1527               (not-done t)
1528               parse-limit end-of-line)
1529           ;; move to start of current statement
1530           (fortran-next-statement)
1531           (fortran-previous-statement)
1532           ;; now parse up to WHERE
1533           (while not-done
1534             (if (or ;; skip to next line if:
1535                  ;; - comment line?
1536                  (looking-at fortran-comment-line-start-skip)
1537                  ;; - at end of line?
1538                  (eolp)
1539                  ;; - not in a string and after comment-start?
1540                  (and (not (nth 3 parse-state))
1541                       comment-start
1542                       (equal comment-start
1543                              (char-to-string (preceding-char)))))
1544                 (if (> (forward-line) 0)
1545                     (setq not-done nil))
1546               ;; else:
1547               ;; if we are at beginning of code line, skip any
1548               ;; whitespace, labels and tab continuation markers.
1549               (if (bolp) (skip-chars-forward " \t0-9"))
1550               ;; if we are in column <= 5 now, check for continuation char
1551               (cond ((= 5 (current-column)) (forward-char 1))
1552                     ((and (< (current-column) 5)
1553                           (equal fortran-continuation-string
1554                                  (char-to-string (following-char)))
1555                           (forward-char 1))))
1556               ;; find out parse-limit from here
1557               (setq end-of-line (line-end-position))
1558               (setq parse-limit (min where end-of-line))
1559               ;; parse max up to comment-start, if non-nil and in current line
1560               (if comment-start
1561                   (save-excursion
1562                     (if (re-search-forward quoted-comment-start end-of-line t)
1563                         (setq parse-limit (min (point) parse-limit)))))
1564               ;; now parse if still in limits
1565               (if (< (point) where)
1566                   (setq parse-state (parse-partial-sexp
1567                                      (point) parse-limit nil nil parse-state))
1568                 (setq not-done nil))))
1569           ;; result is
1570           (nth 3 parse-state))))))
1571
1572 (defun fortran-auto-fill-mode (arg)
1573   "Toggle fortran-auto-fill mode.
1574 With ARG, turn `fortran-auto-fill' mode on iff ARG is positive.
1575 In `fortran-auto-fill' mode, inserting a space at a column beyond `fill-column'
1576 automatically breaks the line at a previous space."
1577   (interactive "P")
1578   (prog1 (setq auto-fill-function
1579                (if (if (null arg)
1580                        (not auto-fill-function)
1581                      (> (prefix-numeric-value arg) 0))
1582                    #'fortran-do-auto-fill
1583                  nil))
1584     (force-mode-line-update)))
1585
1586 (defun fortran-do-auto-fill ()
1587   (if (> (current-column) fill-column)
1588       (fortran-indent-line)))
1589
1590 (defun fortran-fill ()
1591   (let* ((auto-fill-function #'fortran-do-auto-fill)
1592          (opoint (point))
1593          (bol (line-beginning-position))
1594          (eol (line-end-position))
1595          (bos (min eol (+ bol (fortran-current-line-indentation))))
1596          (quote
1597           (save-excursion
1598             (goto-char bol)
1599             (if (looking-at fortran-comment-line-start-skip)
1600                 nil                     ; OK to break quotes on comment lines.
1601               (move-to-column fill-column)
1602               (if (fortran-is-in-string-p (point))
1603                   (save-excursion (re-search-backward "\\S\"\\s\"\\S\"" bol t)
1604                                   (if fortran-break-before-delimiters
1605                                       (point)
1606                                     (1+ (point))))))))
1607          ;; decide where to split the line. If a position for a quoted
1608          ;; string was found above then use that, else break the line
1609          ;; before the last delimiter.
1610          ;; Delimiters are whitespace, commas, and operators.
1611          ;; Will break before a pair of *'s.
1612          (fill-point
1613           (or quote
1614               (save-excursion
1615                 (move-to-column (1+ fill-column))
1616                 (skip-chars-backward "^ \t\n,'+-/*=)"
1617 ;;;              (if fortran-break-before-delimiters
1618 ;;;                  "^ \t\n,'+-/*=" "^ \t\n,'+-/*=)")
1619                  )
1620                 (if (<= (point) (1+ bos))
1621                     (progn
1622                       (move-to-column (1+ fill-column))
1623                       ;;what is this doing???
1624                       (if (not (re-search-forward "[\t\n,'+-/*)=]" eol t))
1625                           (goto-char bol))))
1626                 (if (bolp)
1627                     (re-search-forward "[ \t]" opoint t)
1628                   (backward-char)
1629                   (if (looking-at "\\s\"")
1630                       (forward-char)
1631                     (skip-chars-backward " \t\*")))
1632                 (if fortran-break-before-delimiters
1633                     (point)
1634                   (1+ (point)))))))
1635     ;; if we are in an in-line comment, don't break unless the
1636     ;; line of code is longer than it should be. Otherwise
1637     ;; break the line at the column computed above.
1638     ;;
1639     ;; Need to use fortran-find-comment-start-skip to make sure that quoted !'s
1640     ;; don't prevent a break.
1641     (if (not (or (save-excursion
1642                    (if (and (re-search-backward comment-start-skip bol t)
1643                             (not (fortran-is-in-string-p (point))))
1644                        (progn
1645                          (skip-chars-backward " \t")
1646                          (< (current-column) (1+ fill-column)))))
1647                  (save-excursion
1648                    (goto-char fill-point)
1649                    (bolp))))
1650         (if (> (save-excursion
1651                  (goto-char fill-point)
1652                  (current-column))
1653                (1+ fill-column))
1654             (progn (goto-char fill-point)
1655                    (fortran-break-line))
1656           (save-excursion
1657             (if (> (save-excursion
1658                      (goto-char fill-point)
1659                      (current-column))
1660                    (+ (fortran-calculate-indent) fortran-continuation-indent))
1661                 (progn
1662                   (goto-char fill-point)
1663                   (fortran-break-line))))))))
1664
1665 (defun fortran-break-line ()
1666   (let ((opoint (point))
1667         (bol (line-beginning-position))
1668         (eol (line-end-position))
1669         (comment-string nil))
1670     (save-excursion
1671       (if (and comment-start-skip (fortran-find-comment-start-skip))
1672           (progn
1673             (re-search-backward comment-start-skip bol t)
1674             (setq comment-string (buffer-substring (point) eol))
1675             (delete-region (point) eol))))
1676     ;; Forward line 1 really needs to go to next non white line
1677     (if (save-excursion (forward-line)
1678                         (or (looking-at "     [^ 0\n]\\|\t[1-9]")))
1679         (progn
1680           (end-of-line)
1681           (delete-region (point) (match-end 0))
1682           (delete-horizontal-space)
1683           (fortran-fill))
1684       (fortran-split-line))
1685     (if comment-string
1686         (save-excursion
1687           (goto-char bol)
1688           (end-of-line)
1689           (delete-horizontal-space)
1690           (indent-to (fortran-comment-indent-function))
1691           (insert comment-string)))))
1692
1693 (defun fortran-analyze-file-format ()
1694   "Return nil if fixed format is used, t if TAB formatting is used.
1695 Use `fortran-tab-mode-default' if no non-comment statements are found in the
1696 file before the end or the first `fortran-analyze-depth' lines."
1697   (let ((i 0))
1698     (save-excursion
1699       (goto-char (point-min))
1700       (setq i 0)
1701       (while (not (or
1702                    (eobp)
1703                    (eq (char-after) ?\t)
1704                    (looking-at "      ")
1705                    (> i fortran-analyze-depth)))
1706         (forward-line)
1707         (setq i (1+ i)))
1708       (cond
1709        ((eq (char-after) ?\t) t)
1710        ((looking-at "      ") nil)
1711        (fortran-tab-mode-default t)
1712        (t nil)))))
1713
1714 (or (assq 'fortran-tab-mode-string minor-mode-alist)
1715     (setq minor-mode-alist (cons
1716                             '(fortran-tab-mode-string
1717                               (indent-tabs-mode fortran-tab-mode-string))
1718                             minor-mode-alist)))
1719
1720 (defun fortran-fill-paragraph (&optional justify)
1721   "Fill surrounding comment block as paragraphs, else fill statement.
1722 Intended as the value of `fill-paragraph-function'."
1723   (interactive "P")
1724   (save-excursion
1725     (beginning-of-line)
1726     (if (not (looking-at fortran-comment-line-start-skip))
1727         (fortran-fill-statement)
1728         ;; We're in a comment block.  Find the start and end of a
1729         ;; paragraph, delimited either by non-comment lines or empty
1730         ;; comments.  (Get positions as markers, since the
1731         ;; `indent-region' below can shift the block's end).
1732         (let* ((non-empty-comment
1733                 (concat "\\(" fortran-comment-line-start-skip "\\)"
1734                         "[^ \t\n]"))
1735                (start (save-excursion
1736                         ;; Find (start of) first line.
1737                         (while (and (zerop (forward-line -1))
1738                                     (looking-at non-empty-comment)))
1739                         (or (looking-at non-empty-comment)
1740                             (forward-line)) ; overshot
1741                         (point-marker)))
1742                (end (save-excursion
1743                       ;; Find start of first line past region to fill.
1744                       (while (progn
1745                                (forward-line)
1746                                (looking-at non-empty-comment)))
1747                       (point-marker))))
1748           ;; Indent the block, find the string comprising the effective
1749           ;; comment start skip and use that as a fill-prefix for
1750           ;; filling the region.
1751           (indent-region start end nil)
1752           (let ((paragraph-ignore-fill-prefix nil)
1753                 (fill-prefix (progn
1754                                (beginning-of-line)
1755                                (looking-at fortran-comment-line-start-skip)
1756                                (match-string 0))))
1757             (let (fill-paragraph-function)
1758               (fill-region start end justify))) ; with normal `fill-paragraph'
1759           (set-marker start nil)
1760           (set-marker end nil))))
1761   t)
1762
1763 (defun fortran-fill-statement ()
1764   "Fill a fortran statement up to `fill-column'."
1765   (interactive)
1766   (let ((auto-fill-function #'fortran-do-auto-fill))
1767     (if (not (save-excursion
1768                (beginning-of-line)
1769                (or (looking-at "[ \t]*$")
1770                    (looking-at fortran-comment-line-start-skip)
1771                    (and comment-start-skip
1772                         (looking-at (concat "[ \t]*" comment-start-skip))))))
1773         (save-excursion
1774           ;; Find beginning of statement.
1775           (fortran-next-statement)
1776           (fortran-previous-statement)
1777           ;; Re-indent initially.
1778           (fortran-indent-line)
1779           ;; Replace newline plus continuation field plus indentation with
1780           ;; single space.
1781           (while (progn
1782                    (forward-line)
1783                    (fortran-remove-continuation)))
1784           (fortran-previous-statement)))
1785     (fortran-indent-line)))
1786
1787 (defun fortran-strip-sqeuence-nos (do-space)
1788   "Delete all text after column 72 (assumed to be sequence numbers).
1789 Also delete trailing whitespace after stripping such text.  Supplying
1790 prefix arg DO-SPACE prevent stripping the whitespace."
1791   (interactive "p")
1792   (save-excursion
1793     (goto-char (point-min))
1794     (while (re-search-forward (concat "^" (make-string 72 ?.)" \\(.*\\)")
1795                               nil t)
1796       (replace-match "" nil nil nil 1)
1797       (unless do-space (delete-horizontal-space)))))
1798
1799 ;; This code used to live in add-log.el, but this is a better place
1800 ;; for it.
1801 (defun fortran-current-defun ()
1802   "Function to use for `add-log-current-defun-function' in Fortran mode."
1803   ;; We must be inside function body for this to work.
1804   (fortran-beginning-of-subprogram)
1805   (let ((case-fold-search t))           ; case-insensitive
1806     ;; search for fortran subprogram start
1807     (if (re-search-forward
1808          "^[ \t]*\\(program\\|subroutine\\|function\
1809 \\|[ \ta-z0-9*()]*[ \t]+function\\|\\(block[ \t]*data\\)\\)"
1810          (save-excursion (fortran-end-of-subprogram)
1811                          (point))
1812          t)
1813         (or (match-string-no-properties 2)
1814             (progn
1815               ;; move to EOL or before first left paren
1816               (if (re-search-forward "[(\n]" nil t)
1817                   (progn (backward-char)
1818                          (skip-chars-backward " \t"))
1819                 (end-of-line))
1820               ;; Use the name preceding that.
1821               (buffer-substring-no-properties (point) (progn (backward-sexp)
1822                                                              (point)))))
1823       "main")))
1824
1825 (provide 'fortran)
1826
1827 ;;; fortran.el ends here