lisp/progmodes/fortran.el

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