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

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