1 ;;; fortran.el --- Fortran mode for GNU Emacs
3 ;; Copyright (c) 1986, 93, 94, 95, 97, 98, 99, 2000
4 ;; Free Software Foundation, Inc.
6 ;; Author: Michael D. Prange <prange@erl.mit.edu>
7 ;; Maintainer: Dave Love <fx@gnu.org>
10 ;; This file is part of GNU Emacs.
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)
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.
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.
29 ;; This mode is documented in the Emacs manual.
31 ;; Note that it is for editing Fortran77 or Fortran90 fixed source
32 ;; form. For editing Fortran 90 free format source, use `f90-mode'
37 ;; Fortran mode was upgraded by Stephen A. Wood (saw@cebaf.gov).
39 ;; We acknowledge many contributions and valuable suggestions by
40 ;; Lawrence R. Dodd, Ralf Fassel, Ralph Finch, Stephen Gildea,
41 ;; Dr. Anil Gokhale, Ulrich Mueller, Mark Neale, Eric Prestemon,
42 ;; Gary Sabot and Richard Stallman.
48 ;; * Tidy it all up (more)!
49 ;; * Implement insertion and removal of statement continuations in
50 ;; mixed f77/f90 style, with the first `&' past column 72 and the
51 ;; second in column 6.
52 ;; * Support any other extensions to f77 grokked by GNU Fortran.
55 "Fortran mode for Emacs"
56 :link
'(custom-manual "(emacs)Fortran")
59 (defgroup fortran-indent nil
60 "Indentation variables in Fortran mode"
64 (defgroup fortran-comment nil
65 "Comment-handling variables in Fortran mode"
71 (defcustom fortran-tab-mode-default nil
72 "*Default tabbing/carriage control style for empty files in Fortran mode.
73 A value of t specifies tab-digit style of continuation control.
74 A value of nil specifies that continuation lines are marked
75 with a character in column 6."
77 :group
'fortran-indent
)
79 ;; Buffer local, used to display mode line.
80 (defcustom fortran-tab-mode-string nil
81 "String to appear in mode line when TAB format mode is on."
82 :type
'(choice (const nil
) string
)
83 :group
'fortran-indent
)
84 (make-variable-buffer-local 'fortran-tab-mode-string
)
86 (defcustom fortran-do-indent
3
87 "*Extra indentation applied to DO blocks."
89 :group
'fortran-indent
)
91 (defcustom fortran-if-indent
3
92 "*Extra indentation applied to IF blocks."
94 :group
'fortran-indent
)
96 (defcustom fortran-structure-indent
3
97 "*Extra indentation applied to STRUCTURE, UNION, MAP and INTERFACE blocks."
99 :group
'fortran-indent
)
101 (defcustom fortran-continuation-indent
5
102 "*Extra indentation applied to Fortran continuation lines."
104 :group
'fortran-indent
)
106 (defcustom fortran-comment-indent-style
'fixed
107 "*How to indent comments.
108 nil forces comment lines not to be touched,
109 'fixed makes fixed comment indentation to `fortran-comment-line-extra-indent'
110 columns beyond `fortran-minimum-statement-indent-fixed' (for
111 `indent-tabs-mode' of nil) or `fortran-minimum-statement-indent-tab' (for
112 `indent-tabs-mode' of t), and 'relative indents to current
113 Fortran indentation plus `fortran-comment-line-extra-indent'."
114 :type
'(radio (const :tag
"Untouched" nil
) (const fixed
) (const relative
))
115 :group
'fortran-indent
)
117 (defcustom fortran-comment-line-extra-indent
0
118 "*Amount of extra indentation for text within full-line comments."
120 :group
'fortran-indent
121 :group
'fortran-comment
)
123 (defcustom fortran-comment-line-start
"C"
124 "*Delimiter inserted to start new full-line comment.
125 You might want to change this to \"*\", for instance."
128 :group
'fortran-comment
)
130 ;; This used to match preprocessor lines too, but that messes up
131 ;; filling and doesn't seem to be necessary.
132 (defcustom fortran-comment-line-start-skip
133 "^[CcDd*!]\\(\\([^ \t\n]\\)\\2\\2*\\)?[ \t]*"
134 "*Regexp to match the start of a full-line comment."
137 :group
'fortran-comment
)
139 (defcustom fortran-minimum-statement-indent-fixed
6
140 "*Minimum statement indentation for fixed format continuation style."
142 :group
'fortran-indent
)
144 (defcustom fortran-minimum-statement-indent-tab
(max tab-width
6)
145 "*Minimum statement indentation for TAB format continuation style."
147 :group
'fortran-indent
)
149 ;; Note that this is documented in the v18 manuals as being a string
150 ;; of length one rather than a single character.
151 ;; The code in this file accepts either format for compatibility.
152 (defcustom fortran-comment-indent-char
" "
153 "*Single-character string inserted for Fortran comment indentation.
156 :group
'fortran-comment
)
158 (defcustom fortran-line-number-indent
1
159 "*Maximum indentation for Fortran line numbers.
160 5 means right-justify them within their five-column field."
162 :group
'fortran-indent
)
164 (defcustom fortran-check-all-num-for-matching-do nil
165 "*Non-nil causes all numbered lines to be treated as possible DO loop ends."
169 (defcustom fortran-blink-matching-if nil
170 "*Non-nil causes \\[fortran-indent-line] on ENDIF statement to blink on matching IF.
171 Also, from an ENDDO statement blink on matching DO [WHILE] statement."
175 (defcustom fortran-continuation-string
"$"
176 "*Single-character string used for Fortran continuation lines.
177 In fixed format continuation style, this character is inserted in
178 column 6 by \\[fortran-split-line] to begin a continuation line.
179 Also, if \\[fortran-indent-line] finds this at the beginning of a line, it will
180 convert the line into a continuation line of the appropriate style.
185 (defcustom fortran-comment-region
"c$$$"
186 "*String inserted by \\[fortran-comment-region] at start of each \
189 :group
'fortran-comment
)
191 (defcustom fortran-electric-line-number t
192 "*Non-nil causes line number digits to be moved to the correct \
197 (defvar fortran-column-ruler-fixed
198 "0 4 6 10 20 30 40 5\
200 \[ ]|{ | | | | | | | | \
202 "String displayed above current line by \\[fortran-column-ruler].
203 This variable used in fixed format mode.")
205 (defvar fortran-column-ruler-tab
208 \[ ]| { | | | | | | | | \
210 "String displayed above current line by \\[fortran-column-ruler].
211 This variable used in TAB format mode.")
213 (defvar fortran-analyze-depth
100
214 "Number of lines to scan to determine whether to use fixed or TAB \
217 (defcustom fortran-break-before-delimiters t
218 "*Non-nil causes filling to break lines before delimiters."
222 (defvar fortran-mode-syntax-table
223 (let ((table (make-syntax-table)))
224 ;; We might like `;' to be punctuation (g77 multi-statement
225 ;; lines), but that screws abbrevs.
226 (modify-syntax-entry ?\
; "w" table)
227 (modify-syntax-entry ?
\r " " table
)
228 (modify-syntax-entry ?
+ "." table
)
229 (modify-syntax-entry ?-
"." table
)
230 (modify-syntax-entry ?
= "." table
)
231 (modify-syntax-entry ?
* "." table
)
232 (modify-syntax-entry ?
/ "." table
)
233 (modify-syntax-entry ?
\' "\"" table
)
234 (modify-syntax-entry ?
\" "\"" table
)
235 (modify-syntax-entry ?
\\ "\\" table
)
236 ;; This might be better as punctuation, as for C, but this way you
237 ;; can treat floating-point numbers as symbols.
238 (modify-syntax-entry ?.
"_" table
) ; e.g. `a.ne.b'
239 (modify-syntax-entry ?_
"_" table
)
240 (modify-syntax-entry ?$
"_" table
) ; esp. VMSisms
241 (modify-syntax-entry ?\
! "<" table
)
242 (modify-syntax-entry ?
\n ">" table
)
244 "Syntax table in use in Fortran mode buffers.")
246 ;; Comments are real pain in Fortran because there is no way to
247 ;; represent the standard comment syntax in an Emacs syntax table.
248 ;; (We can do so for F90-style). Therefore an unmatched quote in a
249 ;; standard comment will throw fontification off on the wrong track.
250 ;; So we do syntactic fontification with regexps.
252 (defvar fortran-font-lock-keywords-1 nil
253 "Subdued level highlighting for Fortran mode.")
255 (defvar fortran-font-lock-keywords-2 nil
256 "Medium level highlighting for Fortran mode.")
258 (defvar fortran-font-lock-keywords-3 nil
259 "Gaudy level highlighting for Fortran mode.")
261 (defvar fortran-font-lock-syntactic-keywords nil
262 "`font-lock-syntactic-keywords' for Fortran.
263 These get fixed-format comments fontified.")
265 (let ((comment-chars "cd\\*") ; `d' for `debugging' comments
268 (let ((re (regexp-opt
270 '("character" "byte" "integer" "logical"
271 "none" "real" "complex"
272 "double precision" "double complex"))
273 (structured-types '("structure" "union" "map"))
274 (other-types '("record" "dimension"
275 "parameter" "common" "save"
276 "external" "intrinsic" "data"
279 (mapcar (lambda (x) (concat "implicit " x
))
282 (mapcar (lambda (x) (concat "end " x
))
286 ;; In the optimized regexp above, replace spaces by a
287 ;; regexp for optional whitespace; regexp-opt would have
289 (mapconcat #'identity
(split-string re
) "[ \t]*"))))
292 (regexp-opt '("continue" "format" "end" "enddo" "if" "then"
293 "else" "endif" "elseif" "while" "inquire" "stop"
294 "return" "include" "open" "close" "read" "write"
295 "format" "print" "select" "case" "cycle" "exit"))))
298 (regexp-opt '("and" "or" "not" "lt" "le" "eq" "ge" "gt" "ne"
300 (setq fortran-font-lock-syntactic-keywords
301 ;; Fixed format comments. (!-style handled normally.)
303 (list (concat "^[" comment-chars
"]") 0 '(11))
304 (list (concat "^[^" comment-chars
"\t\n]" ".\\{71\\}"
307 (setq fortran-font-lock-keywords-1
309 ;; Program, subroutine and function declarations, plus calls.
310 (list (concat "\\<\\(block[ \t]*data\\|call\\|entry\\|function\\|"
311 "program\\|subroutine\\)\\>[ \t]*\\(\\sw+\\)?")
312 '(1 font-lock-keyword-face
)
313 '(2 font-lock-function-name-face nil t
))))
314 (setq fortran-font-lock-keywords-2
315 (append fortran-font-lock-keywords-1
317 ;; Fontify all type specifiers (must be first; see below).
318 (cons (concat "\\<\\(" fortran-type-types
"\\)\\>")
319 'font-lock-type-face
)
320 ;; Fontify all builtin keywords (except logical, do
321 ;; and goto; see below).
322 (concat "\\<\\(" fortran-keywords
"\\)\\>")
323 ;; Fontify all builtin operators.
324 (concat "\\.\\(" fortran-logicals
"\\)\\.")
325 ;; Fontify do/goto keywords and targets, and goto tags.
326 (list "\\<\\(do\\|go *to\\)\\>[ \t]*\\([0-9]+\\)?"
327 '(1 font-lock-keyword-face
)
328 '(2 font-lock-constant-face nil t
))
329 (cons "^ *\\([0-9]+\\)" 'font-lock-constant-face
))))
330 (setq fortran-font-lock-keywords-3
332 ;; The list `fortran-font-lock-keywords-1'.
333 fortran-font-lock-keywords-1
334 ;; Fontify all type specifiers plus their declared items.
336 (list (concat "\\<\\(" fortran-type-types
"\\)\\>[ \t(/]*\\(*\\)?")
337 ;; Fontify the type specifier.
338 '(1 font-lock-type-face
)
339 ;; Fontify each declaration item (or just the /.../ block name).
340 `(font-lock-match-c-style-declaration-item-and-skip-to-next
341 ;; Start after any *(...) expression.
343 (and (and (match-beginning ,(+ 2 (regexp-opt-depth
344 fortran-type-types
)))
348 ;; No need to clean up.
350 ;; Fontify as a variable name, functions are
351 ;; fontified elsewhere.
352 (1 font-lock-variable-name-face nil t
))))
353 ;; Things extra to `fortran-font-lock-keywords-3'
354 ;; (must be done first).
356 ;; Fontify goto-like `err=label'/`end=label' in read/write
358 '(", *\\(e\\(nd\\|rr\\)\\)\\> *\\(= *\\([0-9]+\\)\\)?"
359 (1 font-lock-keyword-face
) (4 font-lock-constant-face nil t
))
360 ;; Highlight standard continuation character and in a
361 ;; TAB-formatted line.
362 '("^ \\([^ 0]\\)" 1 font-lock-string-face
)
363 '("^\t\\([1-9]\\)" 1 font-lock-string-face
))
366 '("^# *[a-z]+" . font-lock-keyword-face
))
367 ;; The list `fortran-font-lock-keywords-2' less that for types
369 (cdr (nthcdr (length fortran-font-lock-keywords-1
)
370 fortran-font-lock-keywords-2
)))))
372 (defvar fortran-font-lock-keywords fortran-font-lock-keywords-1
373 "Default expressions to highlight in Fortran mode.")
375 (defvar fortran-imenu-generic-expression
376 ;; These patterns could be confused by sequence nos. in cols 72+ and
377 ;; don't allow continuations everywhere.
381 ;; [This will be fooled by `end function' allowed by G77. Also,
382 ;; it assumes sensible whitespace is employed.]
384 ;; leading whitespace:
386 ;; function declaration with optional type, e.g. `real',
387 ;; `real*4', character(*), `double precision':
388 "\\(\\sw\\|\\s-\\|[*()+]\\)*"
389 "\\<function\\|subroutine\\|entry\\|block\\s-*data\\|program\\)"
390 ;; Possible statement continuation:
391 "[ \t" fortran-continuation-string
"]+"
392 ;; Variable to index:
395 ;; Un-named block data
396 (list nil
"^\\s-+\\(block\\s-*data\\)\\s-*$" 1))
397 "Imenu generic expression for `imenu-default-create-index-function'.")
399 (defvar fortran-mode-map
400 (let ((map (make-sparse-keymap)))
401 (define-key map
";" 'fortran-abbrev-start
)
402 (define-key map
"\C-c;" 'fortran-comment-region
)
403 (define-key map
"\M-;" 'fortran-indent-comment
)
404 (define-key map
"\M-\n" 'fortran-split-line
)
405 (define-key map
"\M-\C-q" 'fortran-indent-subprogram
)
406 (define-key map
"\C-c\C-w" 'fortran-window-create-momentarily
)
407 (define-key map
"\C-c\C-r" 'fortran-column-ruler
)
408 (define-key map
"\C-c\C-p" 'fortran-previous-statement
)
409 (define-key map
"\C-c\C-n" 'fortran-next-statement
)
410 (define-key map
"\C-c\C-d" 'fortran-join-line
) ; like f90
411 (define-key map
"\M-^" 'fortran-join-line
) ; subvert delete-indentation
412 (define-key map
"0" 'fortran-electric-line-number
)
413 (define-key map
"1" 'fortran-electric-line-number
)
414 (define-key map
"2" 'fortran-electric-line-number
)
415 (define-key map
"3" 'fortran-electric-line-number
)
416 (define-key map
"4" 'fortran-electric-line-number
)
417 (define-key map
"5" 'fortran-electric-line-number
)
418 (define-key map
"6" 'fortran-electric-line-number
)
419 (define-key map
"7" 'fortran-electric-line-number
)
420 (define-key map
"8" 'fortran-electric-line-number
)
421 (define-key map
"9" 'fortran-electric-line-number
)
424 (unless (boundp 'fortran-mode-menu
)
426 fortran-mode-menu map
""
428 ["Manual" (info "(emacs)Fortran")]
429 ["Customize" :filter
(lambda (&rest junk
)
430 (cdr (custom-menu-create 'fortran
)))]
432 ["Save" Custom-save t
]
433 ["Reset to Current" Custom-reset-current t
]
434 ["Reset to Saved" Custom-reset-saved t
]
435 ["Reset to Standard Settings" Custom-reset-standard t
]
437 ["Toggle Auto-fill" auto-fill-mode
:style toggle
438 :selected auto-fill-function
]
439 ["Toggle abbrev-mode" abbrev-mode
:style toggle
:selected abbrev-mode
]
441 ["Comment-out Region" fortran-comment-region mark-active
]
442 ["Uncomment-out region"
443 (fortran-comment-region (region-beginning) (region-end) 1)
445 ["Indent Region" indent-region mark-active
]
446 ["Indent Subprogram" fortran-indent-subprogram t
]
448 ["Beginning of Subprogram" fortran-beginning-of-subprogram t
]
449 ["End of Subprogram" fortran-end-of-subprogram t
]
451 ["Subprogram" mark-defun
t]
452 ["IF Block" fortran-mark-if t
]
453 ["DO Block" fortran-mark-do t
])
454 ["Narrow to Subprogram" narrow-to-defun
t]
457 ["Temporary column ruler" fortran-column-ruler t
]
458 ["72-column window" fortran-window-create t
]
460 (enlarge-window-horizontally (- (frame-width) (window-width)))
461 (< (window-width) (frame-width))]
462 ["Momentary 72-column window" fortran-window-create-momentarily t
]
464 ["Break Line at Point" fortran-split-line t
]
465 ["Join Line" fortran-join-line t
]
466 ["Fill Statement/Comment" fill-paragraph t
]
469 imenu-add-menubar-index
(not (and (boundp 'imenu--index-alist
)
470 imenu--index-alist
))])))
472 "Keymap used in Fortran mode.")
474 (defvar fortran-mode-abbrev-table
475 (let ((ac abbrevs-changed
))
476 (define-abbrev-table 'fortran-mode-abbrev-table
())
477 (define-abbrev fortran-mode-abbrev-table
";au" "automatic" nil
)
478 (define-abbrev fortran-mode-abbrev-table
";b" "byte" nil
)
479 (define-abbrev fortran-mode-abbrev-table
";bd" "block data" nil
)
480 (define-abbrev fortran-mode-abbrev-table
";ch" "character" nil
)
481 (define-abbrev fortran-mode-abbrev-table
";cl" "close" nil
)
482 (define-abbrev fortran-mode-abbrev-table
";c" "continue" nil
)
483 (define-abbrev fortran-mode-abbrev-table
";cm" "common" nil
)
484 (define-abbrev fortran-mode-abbrev-table
";cx" "complex" nil
)
485 (define-abbrev fortran-mode-abbrev-table
";df" "define" nil
)
486 (define-abbrev fortran-mode-abbrev-table
";di" "dimension" nil
)
487 (define-abbrev fortran-mode-abbrev-table
";do" "double" nil
)
488 (define-abbrev fortran-mode-abbrev-table
";dc" "double complex" nil
)
489 (define-abbrev fortran-mode-abbrev-table
";dp" "double precision" nil
)
490 (define-abbrev fortran-mode-abbrev-table
";dw" "do while" nil
)
491 (define-abbrev fortran-mode-abbrev-table
";e" "else" nil
)
492 (define-abbrev fortran-mode-abbrev-table
";ed" "enddo" nil
)
493 (define-abbrev fortran-mode-abbrev-table
";el" "elseif" nil
)
494 (define-abbrev fortran-mode-abbrev-table
";en" "endif" nil
)
495 (define-abbrev fortran-mode-abbrev-table
";eq" "equivalence" nil
)
496 (define-abbrev fortran-mode-abbrev-table
";ew" "endwhere" nil
)
497 (define-abbrev fortran-mode-abbrev-table
";ex" "external" nil
)
498 (define-abbrev fortran-mode-abbrev-table
";ey" "entry" nil
)
499 (define-abbrev fortran-mode-abbrev-table
";f" "format" nil
)
500 (define-abbrev fortran-mode-abbrev-table
";fa" ".false." nil
)
501 (define-abbrev fortran-mode-abbrev-table
";fu" "function" nil
)
502 (define-abbrev fortran-mode-abbrev-table
";g" "goto" nil
)
503 (define-abbrev fortran-mode-abbrev-table
";im" "implicit" nil
)
504 (define-abbrev fortran-mode-abbrev-table
";ib" "implicit byte" nil
)
505 (define-abbrev fortran-mode-abbrev-table
";ic" "implicit complex" nil
)
506 (define-abbrev fortran-mode-abbrev-table
";ich" "implicit character" nil
)
507 (define-abbrev fortran-mode-abbrev-table
";ii" "implicit integer" nil
)
508 (define-abbrev fortran-mode-abbrev-table
";il" "implicit logical" nil
)
509 (define-abbrev fortran-mode-abbrev-table
";ir" "implicit real" nil
)
510 (define-abbrev fortran-mode-abbrev-table
";inc" "include" nil
)
511 (define-abbrev fortran-mode-abbrev-table
";in" "integer" nil
)
512 (define-abbrev fortran-mode-abbrev-table
";intr" "intrinsic" nil
)
513 (define-abbrev fortran-mode-abbrev-table
";l" "logical" nil
)
514 (define-abbrev fortran-mode-abbrev-table
";n" "namelist" nil
)
515 (define-abbrev fortran-mode-abbrev-table
";o" "open" nil
) ; was ;op
516 (define-abbrev fortran-mode-abbrev-table
";pa" "parameter" nil
)
517 (define-abbrev fortran-mode-abbrev-table
";pr" "program" nil
)
518 (define-abbrev fortran-mode-abbrev-table
";ps" "pause" nil
)
519 (define-abbrev fortran-mode-abbrev-table
";p" "print" nil
)
520 (define-abbrev fortran-mode-abbrev-table
";rc" "record" nil
)
521 (define-abbrev fortran-mode-abbrev-table
";re" "real" nil
)
522 (define-abbrev fortran-mode-abbrev-table
";r" "read" nil
)
523 (define-abbrev fortran-mode-abbrev-table
";rt" "return" nil
)
524 (define-abbrev fortran-mode-abbrev-table
";rw" "rewind" nil
)
525 (define-abbrev fortran-mode-abbrev-table
";s" "stop" nil
)
526 (define-abbrev fortran-mode-abbrev-table
";sa" "save" nil
)
527 (define-abbrev fortran-mode-abbrev-table
";st" "structure" nil
)
528 (define-abbrev fortran-mode-abbrev-table
";sc" "static" nil
)
529 (define-abbrev fortran-mode-abbrev-table
";su" "subroutine" nil
)
530 (define-abbrev fortran-mode-abbrev-table
";tr" ".true." nil
)
531 (define-abbrev fortran-mode-abbrev-table
";ty" "type" nil
)
532 (define-abbrev fortran-mode-abbrev-table
";vo" "volatile" nil
)
533 (define-abbrev fortran-mode-abbrev-table
";w" "write" nil
)
534 (define-abbrev fortran-mode-abbrev-table
";wh" "where" nil
)
535 (setq abbrevs-changed ac
)
536 fortran-mode-abbrev-table
))
538 (eval-when-compile ; silence compiler
539 (defvar imenu-case-fold-search
)
540 (defvar imenu-syntax-alist
))
542 (defcustom fortran-mode-hook nil
543 "Hook run by Fortran mode."
548 (defun fortran-mode ()
549 "Major mode for editing Fortran code.
550 \\[fortran-indent-line] indents the current Fortran line correctly.
551 DO statements must not share a common CONTINUE.
553 Type ;? or ;\\[help-command] to display a list of built-in abbrevs for
559 Variables controlling indentation style and extra features:
562 If you want to use comments starting with `!',
563 set this to the string \"!\".
565 Extra indentation within do blocks. (default 3)
567 Extra indentation within if blocks. (default 3)
568 `fortran-structure-indent'
569 Extra indentation within structure, union, map and interface blocks.
571 `fortran-continuation-indent'
572 Extra indentation applied to continuation statements. (default 5)
573 `fortran-comment-line-extra-indent'
574 Amount of extra indentation for text within full-line comments. (default 0)
575 `fortran-comment-indent-style'
576 nil means don't change indentation of text in full-line comments,
577 fixed means indent that text at `fortran-comment-line-extra-indent' beyond
578 the value of `fortran-minimum-statement-indent-fixed' (for fixed
579 format continuation style) or `fortran-minimum-statement-indent-tab'
580 (for TAB format continuation style).
581 relative means indent at `fortran-comment-line-extra-indent' beyond the
582 indentation for a line of code.
584 `fortran-comment-indent-char'
585 Single-character string to be inserted instead of space for
586 full-line comment indentation. (default \" \")
587 `fortran-minimum-statement-indent-fixed'
588 Minimum indentation for Fortran statements in fixed format mode. (def.6)
589 `fortran-minimum-statement-indent-tab'
590 Minimum indentation for Fortran statements in TAB format mode. (default 9)
591 `fortran-line-number-indent'
592 Maximum indentation for line numbers. A line number will get
593 less than this much indentation if necessary to avoid reaching
594 column 5. (default 1)
595 `fortran-check-all-num-for-matching-do'
596 Non-nil causes all numbered lines to be treated as possible \"continue\"
597 statements. (default nil)
598 `fortran-blink-matching-if'
599 Non-nil causes \\[fortran-indent-line] on an ENDIF statement to blink on
600 matching IF. Also, from an ENDDO statement, blink on matching DO [WHILE]
601 statement. (default nil)
602 `fortran-continuation-string'
603 Single-character string to be inserted in column 5 of a continuation
604 line. (default \"$\")
605 `fortran-comment-region'
606 String inserted by \\[fortran-comment-region] at start of each line in
607 region. (default \"c$$$\")
608 `fortran-electric-line-number'
609 Non-nil causes line number digits to be moved to the correct column
610 as typed. (default t)
611 `fortran-break-before-delimiters'
612 Non-nil causes lines to be broken before delimiters.
615 Turning on Fortran mode calls the value of the variable `fortran-mode-hook'
616 with no args, if that value is non-nil."
618 (kill-all-local-variables)
619 (setq local-abbrev-table fortran-mode-abbrev-table
)
620 (set-syntax-table fortran-mode-syntax-table
)
621 ;; Font Lock mode support.
622 (make-local-variable 'font-lock-defaults
)
623 (setq font-lock-defaults
'((fortran-font-lock-keywords
624 fortran-font-lock-keywords-1
625 fortran-font-lock-keywords-2
626 fortran-font-lock-keywords-3
)
627 nil t
((?
/ .
"$/") ("_$" .
"w"))
628 fortran-beginning-of-subprogram
))
629 (set (make-local-variable 'font-lock-syntactic-keywords
)
630 fortran-font-lock-syntactic-keywords
)
631 (make-local-variable 'fortran-break-before-delimiters
)
632 (setq fortran-break-before-delimiters t
)
633 (make-local-variable 'indent-line-function
)
634 (setq indent-line-function
'fortran-indent-line
)
635 (make-local-variable 'comment-indent-function
)
636 (setq comment-indent-function
'fortran-comment-indent
)
637 (make-local-variable 'comment-start-skip
)
638 (setq comment-start-skip
"![ \t]*")
639 (setq fortran-comment-line-start-skip
640 "^[Cc*]\\(\\([^ \t\n]\\)\\2\\2*\\)?[ \t]*\\|^#.*")
641 (make-local-variable 'comment-start
)
642 (setq fortran-comment-line-start
"c")
643 (make-local-variable 'require-final-newline
)
644 (setq require-final-newline t
)
645 (make-local-variable 'abbrev-all-caps
)
646 (setq abbrev-all-caps t
)
647 (make-local-variable 'indent-tabs-mode
)
648 (setq indent-tabs-mode nil
)
649 ;;;(setq abbrev-mode t) ; ?? (abbrev-mode 1) instead??
650 (set (make-local-variable 'fill-column
) 72)
651 (use-local-map fortran-mode-map
)
652 (setq mode-name
"Fortran")
653 (setq major-mode
'fortran-mode
)
654 (make-local-variable 'fortran-comment-line-extra-indent
)
655 (make-local-variable 'fortran-minimum-statement-indent-fixed
)
656 (make-local-variable 'fortran-minimum-statement-indent-tab
)
657 (make-local-variable 'fortran-column-ruler-fixed
)
658 (make-local-variable 'fortran-column-ruler-tab
)
659 (setq fortran-tab-mode-string
" TAB-format")
660 (setq indent-tabs-mode
(fortran-analyze-file-format))
661 (setq imenu-case-fold-search t
)
662 (setq imenu-generic-expression fortran-imenu-generic-expression
)
663 (setq imenu-syntax-alist
'(("_$" .
"w")))
664 (set (make-local-variable 'fill-paragraph-function
) 'fortran-fill-paragraph
)
665 (set (make-local-variable 'normal-auto-fill-function
) 'fortran-auto-fill
)
666 (set (make-local-variable 'indent-line-function
) 'fortran-indent-line
)
667 (set (make-local-variable 'indent-region-function
)
669 (let (fortran-blink-matching-if ; avoid blinking delay
670 indent-region-function
)
671 (indent-region start end nil
))))
672 (set (make-local-variable 'beginning-of-defun-function
)
673 #'fortran-beginning-of-subprogram
)
674 (set (make-local-variable 'end-of-defun-function
)
675 #'fortran-end-of-subprogram
)
676 (set (make-local-variable 'add-log-current-defun-function
)
677 #'fortran-current-defun
)
678 (set (make-local-variable 'dabbrev-case-fold-search
) 'case-fold-search
)
679 (run-hooks 'fortran-mode-hook
))
681 (defsubst fortran-comment-indent
()
683 (skip-chars-backward " \t")
684 (max (+ 1 (current-column))
687 (defun fortran-indent-comment ()
688 "Align or create comment on current line.
689 Existing comments of all types are recognized and aligned.
690 If the line has no comment, a side-by-side comment is inserted and aligned
691 if the value of `comment-start' is not nil.
692 Otherwise, a separate-line comment is inserted, on this line
693 or on a new line inserted before this line if this line is not blank."
696 ;; Recognize existing comments of either kind.
697 (cond ((looking-at fortran-comment-line-start-skip
)
698 (fortran-indent-line))
699 ((fortran-find-comment-start-skip) ; catches any inline comment and
700 ; leaves point after comment-start-skip
701 (if comment-start-skip
702 (progn (goto-char (match-beginning 0))
703 (if (not (= (current-column)
704 (fortran-comment-indent)))
705 (progn (delete-horizontal-space)
706 (indent-to (fortran-comment-indent)))))
707 (end-of-line))) ; otherwise goto end of line or sth else?
708 ;; No existing comment.
709 ;; If side-by-side comments are defined, insert one,
710 ;; unless line is now blank.
711 ((and comment-start
(not (looking-at "^[ \t]*$")))
713 (delete-horizontal-space)
714 (indent-to (fortran-comment-indent))
715 (insert comment-start
))
716 ;; Else insert separate-line comment, making a new line if nec.
718 (if (looking-at "^[ \t]*$")
719 (delete-horizontal-space)
723 (insert fortran-comment-line-start
)
724 (insert-char (if (stringp fortran-comment-indent-char
)
725 (aref fortran-comment-indent-char
0)
726 fortran-comment-indent-char
)
727 (- (fortran-calculate-indent) (current-column))))))
729 (defun fortran-comment-region (beg-region end-region arg
)
730 "Comments every line in the region.
731 Puts `fortran-comment-region' at the beginning of every line in the region.
732 BEG-REGION and END-REGION are args which specify the region boundaries.
733 With non-nil ARG, uncomments the region."
734 (interactive "*r\nP")
735 (let ((end-region-mark (copy-marker beg-region
))
736 (save-point (point-marker)))
737 (goto-char beg-region
)
739 (if (not arg
) ;comment the region
740 (progn (insert fortran-comment-region
)
741 (while (and (= (forward-line 1) 0)
742 (< (point) end-region-mark
))
743 (insert fortran-comment-region
)))
744 (let ((com (regexp-quote fortran-comment-region
))) ;uncomment the region
746 (delete-region (point) (match-end 0)))
747 (while (and (= (forward-line 1) 0)
748 (< (point) end-region-mark
))
750 (delete-region (point) (match-end 0))))))
751 (goto-char save-point
)
752 (set-marker end-region-mark nil
)
753 (set-marker save-point nil
)))
755 (defun fortran-abbrev-start ()
756 "Typing ;\\[help-command] or ;? lists all the Fortran abbrevs.
757 Any other key combination is executed normally."
760 (insert last-command-char
)
761 (if (or (eq (setq c
(read-event)) ??
) ;insert char if not equal to `?'
763 (fortran-abbrev-help)
764 (setq unread-command-events
(list c
)))))
766 (defun fortran-abbrev-help ()
767 "List the currently defined abbrevs in Fortran mode."
769 (message "Listing abbrev table...")
770 (display-buffer (fortran-prepare-abbrev-list-buffer))
771 (message "Listing abbrev table...done"))
773 (defun fortran-prepare-abbrev-list-buffer ()
775 (set-buffer (get-buffer-create "*Abbrevs*"))
777 (insert-abbrev-table-description 'fortran-mode-abbrev-table t
)
778 (goto-char (point-min))
779 (set-buffer-modified-p nil
)
781 (get-buffer-create "*Abbrevs*"))
783 (defun fortran-column-ruler ()
784 "Insert a column ruler momentarily above current line, till next keystroke.
785 The ruler is defined by the value of `fortran-column-ruler-fixed' when in fixed
786 format mode, and `fortran-column-ruler-tab' when in TAB format mode.
787 The key typed is executed unless it is SPC."
789 (momentary-string-display
791 fortran-column-ruler-tab
792 fortran-column-ruler-fixed
)
795 (if (eq (window-start (selected-window))
796 (window-point (selected-window)))
797 (line-beginning-position 2)
799 nil
"Type SPC or any command to erase ruler."))
801 (defun fortran-window-create ()
802 "Make the window 72 columns wide.
803 See also `fortran-window-create-momentarily'."
805 (condition-case error
807 (let ((window-min-width 2))
808 (if (< (window-width) (frame-width))
809 (enlarge-window-horizontally (- (frame-width)
811 (let* ((window-edges (window-edges))
812 (scroll-bar-width (- (nth 2 window-edges
)
815 (split-window-horizontally (+ 72 scroll-bar-width
)))
817 (switch-to-buffer " fortran-window-extra" t
)
818 (select-window (previous-window))))
819 (error (message "No room for Fortran window.")
822 (defun fortran-window-create-momentarily (&optional arg
)
823 "Momentarily make the window 72 columns wide.
824 Optional ARG non-nil and non-unity disables the momentary feature.
825 See also `fortran-window-create'."
829 (save-window-excursion
830 (if (not (equal (fortran-window-create) 'error
))
831 (progn (message "Type SPC to continue editing.")
832 (let ((char (read-event)))
833 (or (equal char
(string-to-char " "))
834 (setq unread-command-events
(list char
)))))))
835 (fortran-window-create)))
837 (defun fortran-split-line ()
838 "Break line at point and insert continuation marker and alignment."
840 (delete-horizontal-space)
843 (looking-at fortran-comment-line-start-skip
))
844 (insert ?
\n fortran-comment-line-start ?
)
846 (insert ?
\n ?
\t (fortran-numerical-continuation-char))
847 (insert "\n " fortran-continuation-string
))) ; Space after \n important
848 (fortran-indent-line)) ; when the cont string is C, c or *.
850 (defun fortran-remove-continuation ()
851 (if (looking-at "\\( [^ 0\n]\\|\t[1-9]\\|&\\)")
852 (progn (replace-match "")
856 (defun fortran-join-line (arg)
857 "Join current line to the previous one and re-indent.
858 With a prefix argument, repeat this operation that many times.
859 If the prefix argument ARG is negative, join the next -ARG lines.
860 Continuation lines are correctly handled."
866 (while (not (zerop arg
))
868 (or (fortran-remove-continuation)
869 (delete-indentation))
871 (fortran-indent-line)))
873 (defun fortran-numerical-continuation-char ()
874 "Return a digit for tab-digit style of continuation lines.
875 If, previous line is a tab-digit continuation line, returns that digit
876 plus one. Otherwise return 1. Zero not allowed."
879 (if (looking-at "\t[1-9]")
880 (+ ?
1 (%
(- (char-after (+ (point) 1)) ?
0) 9))
883 (put 'fortran-electric-line-number
'delete-selection t
)
884 (defun fortran-electric-line-number (arg)
885 "Self insert, but if part of a Fortran line number indent it automatically.
886 Auto-indent does not happen if a numeric ARG is used."
888 (if (or arg
(not fortran-electric-line-number
))
890 (self-insert-command (prefix-numeric-value arg
))
891 (self-insert-command 1))
892 (if (or (and (= 5 (current-column))
895 (looking-at " \\{5\\}"))) ;In col 5 with only spaces to left.
896 (and (= (if indent-tabs-mode
897 fortran-minimum-statement-indent-tab
898 fortran-minimum-statement-indent-fixed
) (current-column))
899 (eq ?
\t (char-after (line-beginning-position))) ;In col 8
900 ; with a single tab to the left.
901 (not (or (eq last-command
'fortran-indent-line
)
903 'fortran-indent-new-line
))))
905 (re-search-backward "[^ \t0-9]"
906 (line-beginning-position)
907 t
)) ;not a line number
908 (looking-at "[0-9]")) ;within a line number
909 (self-insert-command (prefix-numeric-value arg
))
910 (skip-chars-backward " \t")
911 (insert last-command-char
)
912 (fortran-indent-line))))
914 (defvar fortran-end-prog-re1
916 \\([ \t]*\\(program\\|subroutine\\|function\\|block[ \t]*data\\)\\>\
917 \\([ \t]*\\(\\sw\\|\\s_\\)+\\)?\\)?")
918 (defvar fortran-end-prog-re
919 (concat "^[ \t0-9]*" fortran-end-prog-re1
)
920 "Regexp possibly marking subprogram end.")
922 (defun fortran-check-end-prog-re ()
923 "Check a preliminary match against `fortran-end-prog-re'."
924 ;; Having got a possible match for the subprogram end, we need a
925 ;; match of whitespace, avoiding possible column 73+ stuff.
927 (string-match "^\\s-*\\(\\'\\|\\s<\\)"
928 (buffer-substring (match-end 0)
929 (min (line-end-position)
930 (+ 72 (line-beginning-position)))))))
932 ;; Note that you can't just check backwards for `subroutine' &c in
933 ;; case of un-marked main programs not at the start of the file.
934 (defun fortran-beginning-of-subprogram ()
935 "Moves point to the beginning of the current Fortran subprogram."
938 (let ((case-fold-search t
))
939 (beginning-of-line -
1)
941 (while (re-search-backward fortran-end-prog-re nil
'move
)
942 (if (fortran-check-end-prog-re)
946 (defun fortran-end-of-subprogram ()
947 "Moves point to the end of the current Fortran subprogram."
950 (let ((case-fold-search t
))
951 (if (save-excursion ; on END
953 (and (looking-at fortran-end-prog-re
)
954 (fortran-check-end-prog-re)))
956 (beginning-of-line 2)
958 (while (re-search-forward fortran-end-prog-re nil
'move
)
959 (if (fortran-check-end-prog-re)
961 (goto-char (match-beginning 0))
964 (defun fortran-previous-statement ()
965 "Moves point to beginning of the previous Fortran statement.
966 Returns `first-statement' if that statement is the first
967 non-comment Fortran statement in the file, and nil otherwise."
969 (let (not-first-statement continue-test
)
973 (not (looking-at fortran-comment-line-start-skip
))
976 (regexp-quote fortran-continuation-string
)))
977 (looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]"))))
978 (while (and (setq not-first-statement
(= (forward-line -
1) 0))
979 (or (looking-at fortran-comment-line-start-skip
)
980 (looking-at "[ \t]*$\\| \\{5\\}[^ 0\n]\\|\t[1-9]")
981 (looking-at (concat "[ \t]*" comment-start-skip
)))))
982 (cond ((and continue-test
983 (not not-first-statement
))
984 (message "Incomplete continuation statement."))
986 (fortran-previous-statement))
987 ((not not-first-statement
)
990 (defun fortran-next-statement ()
991 "Moves point to beginning of the next Fortran statement.
992 Returns `last-statement' if that statement is the last
993 non-comment Fortran statement in the file, and nil otherwise."
995 (let (not-last-statement)
997 (while (and (setq not-last-statement
998 (and (= (forward-line 1) 0)
1000 (or (looking-at fortran-comment-line-start-skip
)
1001 (looking-at "[ \t]*$\\| [^ 0\n]\\|\t[1-9]")
1002 (looking-at (concat "[ \t]*" comment-start-skip
)))))
1003 (if (not not-last-statement
)
1006 (defun fortran-blink-match (regex keyword find-begin
)
1007 "From a line matching REGEX, blink matching KEYWORD statement line.
1008 Use function FIND-BEGIN to match it."
1009 (let ((top-of-window (window-start))
1011 (case-fold-search t
)
1016 (skip-chars-forward " \t0-9")
1019 (if (not (setq matching
(funcall find-begin
)))
1020 (setq message
(concat "No matching " keyword
"."))
1021 (if (< matching top-of-window
)
1023 (goto-char matching
)
1027 (buffer-substring (point)
1028 (line-end-position)))))))
1030 (message "%s" message
)
1031 (goto-char matching
)
1033 (goto-char end-point
))))))
1035 (defun fortran-blink-matching-if ()
1036 "From an ENDIF or ELSE statement, blink the matching IF statement."
1037 (fortran-blink-match "e\\(nd[ \t]*if\\|lse\\([ \t]*if\\)?\\)\\b"
1038 "if" #'fortran-beginning-if
))
1040 (defun fortran-blink-matching-do ()
1041 "From an ENDDO statement, blink the matching DO or DO WHILE statement."
1042 (fortran-blink-match "end[ \t]*do\\b" "do" #'fortran-beginning-do
))
1044 (defun fortran-mark-do ()
1045 "Put mark at end of Fortran DO [WHILE]-ENDDO construct, point at beginning.
1046 The marks are pushed."
1048 (let (enddo-point do-point
)
1049 (if (setq enddo-point
(fortran-end-do))
1050 (if (not (setq do-point
(fortran-beginning-do)))
1051 (message "No matching do.")
1052 (goto-char enddo-point
)
1054 (goto-char do-point
)))))
1056 (defun fortran-end-do ()
1057 "Search forward for first unmatched ENDDO.
1058 Return point or nil."
1059 (let ((case-fold-search t
))
1060 (if (save-excursion (beginning-of-line)
1061 (skip-chars-forward " \t0-9")
1062 (looking-at "end[ \t]*do\\b"))
1068 (while (and (not (= count
0))
1069 (not (eq (fortran-next-statement) 'last-statement
))
1070 ;; Keep local to subprogram
1071 (not (and (looking-at fortran-end-prog-re
)
1072 (fortran-check-end-prog-re))))
1073 (skip-chars-forward " \t0-9")
1074 (cond ((looking-at "end[ \t]*do\\b")
1075 (setq count
(1- count
)))
1077 "\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?do[ \t]+[^0-9]")
1078 (setq count
(+ count
1)))))
1080 ;; All pairs accounted for.
1083 (defun fortran-beginning-do ()
1084 "Search backwards for first unmatched DO [WHILE].
1085 Return point or nil."
1086 (let ((case-fold-search t
))
1089 (skip-chars-forward " \t0-9")
1090 (looking-at "\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?do[ \t]+"))
1096 (while (and (not (= count
0))
1097 (not (eq (fortran-previous-statement) 'first-statement
))
1098 ;; Keep local to subprogram
1099 (not (and (looking-at fortran-end-prog-re
)
1100 (fortran-check-end-prog-re))))
1101 (skip-chars-forward " \t0-9")
1103 "\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?do[ \t]+[^0-9]")
1104 (setq count
(1- count
)))
1105 ((looking-at "end[ \t]*do\\b")
1106 (setq count
(1+ count
)))))
1108 ;; All pairs accounted for.
1111 (defun fortran-mark-if ()
1112 "Put mark at end of Fortran IF-ENDIF construct, point at beginning.
1113 The marks are pushed."
1115 (let (endif-point if-point
)
1116 (if (setq endif-point
(fortran-end-if))
1117 (if (not (setq if-point
(fortran-beginning-if)))
1118 (message "No matching if.")
1119 ;; Set mark, move point.
1120 (goto-char endif-point
)
1122 (goto-char if-point
)))))
1124 (defvar fortran-if-start-re
"\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?if[ \t]*(")
1126 (defun fortran-end-if ()
1127 "Search forwards for first unmatched ENDIF.
1128 Return point or nil."
1129 (let ((case-fold-search t
))
1130 (if (save-excursion (beginning-of-line)
1131 (skip-chars-forward " \t0-9")
1132 (looking-at "end[ \t]*if\\b"))
1135 ;; Search for one. The point has been already been moved to first
1136 ;; letter on line but this should not cause troubles.
1139 (while (and (not (= count
0))
1140 (not (eq (fortran-next-statement) 'last-statement
))
1141 ;; Keep local to subprogram.
1142 (not (and (looking-at fortran-end-prog-re
)
1143 (fortran-check-end-prog-re))))
1144 (skip-chars-forward " \t0-9")
1145 (cond ((looking-at "end[ \t]*if\\b")
1146 (setq count
(- count
1)))
1147 ((looking-at fortran-if-start-re
)
1150 (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]")
1151 (let (then-test) ; Multi-line if-then.
1154 (= (forward-line 1) 0)
1155 ;; Search forward for then.
1156 (looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]")
1160 ".*then\\b[ \t]*[^ \t(=a-z0-9]")))))
1162 (setq count
(+ count
1)))))))
1164 ;; All pairs accounted for.
1167 (defun fortran-beginning-if ()
1168 "Search backwards for first unmatched IF-THEN.
1169 Return point or nil."
1170 (let ((case-fold-search t
))
1172 ;; May be sitting on multi-line if-then statement, first
1173 ;; move to beginning of current statement. Note:
1174 ;; `fortran-previous-statement' moves to previous statement
1175 ;; *unless* current statement is first one. Only move
1176 ;; forward if not first-statement.
1177 (if (not (eq (fortran-previous-statement) 'first-statement
))
1178 (fortran-next-statement))
1179 (skip-chars-forward " \t0-9")
1181 (looking-at fortran-if-start-re
)
1183 (or (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]")
1184 ;; Multi-line if-then.
1187 (and (= (forward-line 1) 0)
1188 ;; Search forward for then.
1189 (looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]")
1193 ".*then\\b[ \t]*[^ \t(=a-z0-9]")))))
1200 (while (and (not (= count
0))
1201 (not (eq (fortran-previous-statement) 'first-statement
))
1202 ;; Keep local to subprogram.
1203 (not (and (looking-at fortran-end-prog-re
)
1204 (fortran-check-end-prog-re))))
1205 (skip-chars-forward " \t0-9")
1206 (cond ((looking-at fortran-if-start-re
)
1209 (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]")
1210 (let (then-test) ; Multi-line if-then.
1213 (= (forward-line 1) 0)
1214 ;; Search forward for then.
1215 (looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]")
1219 (concat ".*then\\b[ \t]*"
1220 "[^ \t(=a-z[0-9]]"))))))
1222 (setq count
(- count
1)))))
1223 ((looking-at "end[ \t]*if\\b")
1224 (setq count
(+ count
1)))))
1226 ;; All pairs accounted for.
1229 (defun fortran-indent-line ()
1230 "Indent current Fortran line based on its contents and on previous lines."
1232 (let ((cfi (fortran-calculate-indent)))
1235 (if (or (not (= cfi
(fortran-current-line-indentation)))
1236 (and (re-search-forward "^[ \t]*[0-9]+" (+ (point) 4) t
)
1237 (not (fortran-line-number-indented-correctly-p))))
1238 (fortran-indent-to-column cfi
)
1240 (if (and (not (looking-at fortran-comment-line-start-skip
))
1241 (fortran-find-comment-start-skip))
1242 (fortran-indent-comment))))
1243 ;; Never leave point in left margin.
1244 (if (< (current-column) cfi
)
1245 (move-to-column cfi
))
1246 (if (and auto-fill-function
1247 (> (save-excursion (end-of-line) (current-column))
1252 (if fortran-blink-matching-if
1254 (fortran-blink-matching-if)
1255 (fortran-blink-matching-do)))))
1257 (defun fortran-auto-fill ()
1258 (if (> (current-column) (current-fill-column))
1259 (let ((cfi (fortran-calculate-indent)))
1262 (if (or (not (= cfi
(fortran-current-line-indentation)))
1263 (and (re-search-forward "^[ \t]*[0-9]+"
1265 (not (fortran-line-number-indented-correctly-p))))
1266 (fortran-indent-to-column cfi
)
1268 (if (and (not (looking-at fortran-comment-line-start-skip
))
1269 (fortran-find-comment-start-skip))
1270 (fortran-indent-comment))))
1272 ;; Never leave point in left margin.
1273 (if (< (current-column) cfi
)
1274 (move-to-column cfi
)))))
1276 ;; Historically this was a separate function which advertised itself
1277 ;; as reindenting but only did so where `most likely to be necessary'.
1278 (defalias 'fortran-indent-new-line
'reindent-then-newline-and-indent
)
1280 (defun fortran-indent-subprogram ()
1281 "Properly indent the Fortran subprogram which contains point."
1285 (message "Indenting subprogram...")
1286 (indent-region (point) (mark) nil
))
1287 (message "Indenting subprogram...done."))
1289 (defun fortran-calculate-indent ()
1290 "Calculates the Fortran indent column based on previous lines."
1291 (let (icol first-statement
(case-fold-search t
)
1292 (fortran-minimum-statement-indent
1293 (if indent-tabs-mode
1294 fortran-minimum-statement-indent-tab
1295 fortran-minimum-statement-indent-fixed
)))
1297 (setq first-statement
(fortran-previous-statement))
1299 (setq icol fortran-minimum-statement-indent
)
1301 (if (= (point) (point-min))
1302 (setq icol fortran-minimum-statement-indent
)
1303 (setq icol
(fortran-current-line-indentation)))
1304 (skip-chars-forward " \t0-9")
1305 (cond ((looking-at "\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?if[ \t]*(")
1306 (if (or (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t_$(=a-z0-9]")
1307 (let (then-test) ;multi-line if-then
1308 (while (and (= (forward-line 1) 0)
1309 ;;search forward for then
1310 (looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]")
1311 (not (setq then-test
1314 *[^ \t_$(=a-z0-9]")))))
1316 (setq icol
(+ icol fortran-if-indent
))))
1317 ((looking-at "else\\(if\\)?\\b")
1318 (setq icol
(+ icol fortran-if-indent
)))
1319 ((looking-at "select[ \t]*case[ \t](.*)")
1320 (setq icol
(+ icol fortran-if-indent
)))
1321 ((looking-at "case[ \t]*(.*)")
1322 (setq icol
(+ icol fortran-if-indent
)))
1323 ((looking-at "case[ \t]*default\\b")
1324 (setq icol
(+ icol fortran-if-indent
)))
1325 ((looking-at "\\(otherwise\\|else[ \t]*where\\)\\b")
1326 (setq icol
(+ icol fortran-if-indent
)))
1327 ((looking-at "where[ \t]*(.*)[ \t]*\n")
1328 (setq icol
(+ icol fortran-if-indent
)))
1329 ((looking-at "do\\b")
1330 (setq icol
(+ icol fortran-do-indent
)))
1332 "\\(structure\\|union\\|map\\|interface\\)\
1333 \\b[ \t]*[^ \t=(a-z]")
1334 (setq icol
(+ icol fortran-structure-indent
)))
1335 ((and (looking-at fortran-end-prog-re1
)
1336 (fortran-check-end-prog-re))
1337 ;; Previous END resets indent to minimum
1338 (setq icol fortran-minimum-statement-indent
))))))
1341 (cond ((looking-at "[ \t]*$"))
1342 ((looking-at fortran-comment-line-start-skip
)
1343 (cond ((eq fortran-comment-indent-style
'relative
)
1344 (setq icol
(+ icol fortran-comment-line-extra-indent
)))
1345 ((eq fortran-comment-indent-style
'fixed
)
1346 (setq icol
(+ fortran-minimum-statement-indent
1347 fortran-comment-line-extra-indent
))))
1348 (setq fortran-minimum-statement-indent
0))
1349 ((or (looking-at (concat "[ \t]*"
1351 fortran-continuation-string
)))
1352 (looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]"))
1353 (setq icol
(+ icol fortran-continuation-indent
)))
1354 ((looking-at "[ \t]*#") ; Check for cpp directive.
1355 (setq fortran-minimum-statement-indent
0 icol
0))
1357 ((and fortran-check-all-num-for-matching-do
1358 (looking-at "[ \t]*[0-9]+")
1359 (fortran-check-for-matching-do))
1360 (setq icol
(- icol fortran-do-indent
)))
1362 (skip-chars-forward " \t0-9")
1363 (cond ((looking-at "end[ \t]*\\(if\\|select\\|where\\)\\b")
1364 (setq icol
(- icol fortran-if-indent
)))
1365 ((looking-at "else\\(if\\)?\\b")
1366 (setq icol
(- icol fortran-if-indent
)))
1367 ((looking-at "case[ \t]*\\((.*)\\|default\\>\\)")
1368 (setq icol
(- icol fortran-if-indent
)))
1369 ((looking-at "\\(otherwise\\|else[ \t]*where\\)\\b")
1370 (setq icol
(- icol fortran-if-indent
)))
1371 ((and (looking-at "continue\\b")
1372 (fortran-check-for-matching-do))
1373 (setq icol
(- icol fortran-do-indent
)))
1374 ((looking-at "end[ \t]*do\\b")
1375 (setq icol
(- icol fortran-do-indent
)))
1376 ((looking-at "end[ \t]*\
1377 \\(structure\\|union\\|map\\|interface\\)\\b[ \t]*[^ \t=(a-z]")
1378 (setq icol
(- icol fortran-structure-indent
)))
1379 ((and (looking-at fortran-end-prog-re1
)
1380 (fortran-check-end-prog-re)
1381 (not (= icol fortran-minimum-statement-indent
)))
1382 (message "Warning: `end' not in column %d. Probably\
1383 an unclosed block." fortran-minimum-statement-indent
))))))
1384 (max fortran-minimum-statement-indent icol
)))
1386 (defun fortran-current-line-indentation ()
1387 "Indentation of current line, ignoring Fortran line number or continuation.
1388 This is the column position of the first non-whitespace character
1389 aside from the line number and/or column 5/8 line-continuation character.
1390 For comment lines, returns indentation of the first
1391 non-indentation text within the comment."
1394 (cond ((looking-at fortran-comment-line-start-skip
)
1395 (goto-char (match-end 0))
1397 (if (stringp fortran-comment-indent-char
)
1398 fortran-comment-indent-char
1399 (char-to-string fortran-comment-indent-char
))))
1400 ((or (looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]"))
1401 (goto-char (match-end 0)))
1403 ;; Move past line number.
1404 (skip-chars-forward "[ \t0-9]")))
1405 ;; Move past whitespace.
1406 (skip-chars-forward " \t")
1409 (defun fortran-indent-to-column (col)
1410 "Indent current line with spaces to column COL.
1411 notes: 1) A non-zero/non-blank character in column 5 indicates a continuation
1412 line, and this continuation character is retained on indentation;
1413 2) If `fortran-continuation-string' is the first non-whitespace
1414 character, this is a continuation line;
1415 3) A non-continuation line which has a number as the first
1416 non-whitespace character is a numbered line.
1417 4) A TAB followed by a digit indicates a continuation line."
1420 (if (looking-at fortran-comment-line-start-skip
)
1421 (if fortran-comment-indent-style
1422 (let* ((char (if (stringp fortran-comment-indent-char
)
1423 (aref fortran-comment-indent-char
0)
1424 fortran-comment-indent-char
))
1425 (chars (string ? ?
\t char
)))
1426 (goto-char (match-end 0))
1427 (skip-chars-backward chars
)
1428 (delete-region (point) (progn (skip-chars-forward chars
)
1430 (insert-char char
(- col
(current-column)))))
1431 (if (looking-at "\t[1-9]")
1432 (if indent-tabs-mode
1433 (goto-char (match-end 0))
1436 (insert fortran-continuation-string
))
1437 (if (looking-at " \\{5\\}[^ 0\n]")
1438 (if indent-tabs-mode
1439 (progn (delete-char 6)
1440 (insert ?
\t (fortran-numerical-continuation-char) 1))
1442 (delete-horizontal-space)
1443 ;; Put line number in columns 0-4
1444 ;; or put continuation character in column 5.
1446 ((looking-at (regexp-quote fortran-continuation-string
))
1447 (if indent-tabs-mode
1450 (if indent-tabs-mode
1451 fortran-minimum-statement-indent-tab
1452 fortran-minimum-statement-indent-fixed
))
1454 (insert-char (fortran-numerical-continuation-char) 1))
1457 ((looking-at "[0-9]+")
1458 (let ((extra-space (- 5 (- (match-end 0) (point)))))
1459 (if (< extra-space
0)
1460 (message "Warning: line number exceeds 5-digit limit.")
1461 (indent-to (min fortran-line-number-indent extra-space
))))
1462 (skip-chars-forward "0-9")))))
1463 ;; Point is now after any continuation character or line number.
1464 ;; Put body of statement where specified.
1465 (delete-horizontal-space)
1467 ;; Indent any comment following code on the same line.
1468 (if (and comment-start-skip
1469 (fortran-find-comment-start-skip))
1470 (progn (goto-char (match-beginning 0))
1471 (if (not (= (current-column)
1472 (fortran-comment-indent)))
1473 (progn (delete-horizontal-space)
1474 (indent-to (fortran-comment-indent)))))))))
1476 (defun fortran-line-number-indented-correctly-p ()
1477 "Return t if current line's line number is correctly indented.
1478 Do not call if there is no line number."
1481 (skip-chars-forward " \t")
1482 (and (<= (current-column) fortran-line-number-indent
)
1483 (or (= (current-column) fortran-line-number-indent
)
1484 (progn (skip-chars-forward "0-9")
1485 (= (current-column) 5))))))
1487 (defun fortran-check-for-matching-do ()
1488 "When called from a numbered statement, return t if matching DO is found.
1489 Otherwise return nil."
1490 (let ((case-fold-search t
)
1494 (if (looking-at "[ \t]*[0-9]+")
1496 (skip-chars-forward " \t")
1497 (skip-chars-forward "0") ;skip past leading zeros
1499 (buffer-substring (point) (progn
1500 (skip-chars-forward "0-9")
1506 (and (re-search-backward
1508 "\\(^[ \t0-9]*do[ \t]*0*"
1509 charnum
"\\b\\)\\|" "\\(^[ \t]*0*"
1513 (concat "^[ \t0-9]*do[ \t]*0*"
1516 (defun fortran-find-comment-start-skip ()
1517 "Move to past `comment-start-skip' found on current line.
1518 Return t if `comment-start-skip' found, nil if not."
1519 ;; In order to move point only if comment-start-skip is found, this
1520 ;; one uses a lot of save-excursions. Note that re-search-forward
1521 ;; moves point even if comment-start-skip is inside a string-constant.
1522 ;; Some code expects certain values for match-beginning and end.
1524 (if (and comment-start-skip
1526 (re-search-forward comment-start-skip
(line-end-position) t
)))
1527 (let ((save-match-beginning (match-beginning 0))
1528 (save-match-end (match-end 0)))
1529 (if (fortran-is-in-string-p (match-beginning 0))
1531 (goto-char save-match-end
)
1532 (fortran-find-comment-start-skip)) ; recurse for rest of line
1533 (goto-char save-match-beginning
)
1534 (re-search-forward comment-start-skip
(line-end-position) t
)
1535 (goto-char (match-end 0))
1538 ;;From: ralf@up3aud1.gwdg.de (Ralf Fassel)
1539 ;; Test if TAB format continuation lines work.
1540 (defun fortran-is-in-string-p (where)
1541 "Return non-nil iff WHERE (a buffer position) is inside a Fortran string."
1545 ((bolp) nil
) ; bol is never inside a string
1546 ((save-excursion ; comment lines too
1548 (looking-at fortran-comment-line-start-skip
)) nil
)
1549 (t (let (;; ok, serious now. Init some local vars:
1550 (parse-state '(0 nil nil nil nil nil
0))
1551 (quoted-comment-start (if comment-start
1552 (regexp-quote comment-start
)))
1554 parse-limit end-of-line
)
1555 ;; move to start of current statement
1556 (fortran-next-statement)
1557 (fortran-previous-statement)
1558 ;; now parse up to WHERE
1560 (if (or ;; skip to next line if:
1562 (looking-at fortran-comment-line-start-skip
)
1563 ;; - at end of line?
1565 ;; - not in a string and after comment-start?
1566 (and (not (nth 3 parse-state
))
1568 (equal comment-start
1569 (char-to-string (preceding-char)))))
1570 (if (> (forward-line) 0)
1571 (setq not-done nil
))
1573 ;; if we are at beginning of code line, skip any
1574 ;; whitespace, labels and tab continuation markers.
1575 (if (bolp) (skip-chars-forward " \t0-9"))
1576 ;; if we are in column <= 5 now, check for continuation char
1577 (cond ((= 5 (current-column)) (forward-char 1))
1578 ((and (< (current-column) 5)
1579 (equal fortran-continuation-string
1580 (char-to-string (following-char)))
1582 ;; find out parse-limit from here
1583 (setq end-of-line
(line-end-position))
1584 (setq parse-limit
(min where end-of-line
))
1585 ;; parse max up to comment-start, if non-nil and in current line
1588 (if (re-search-forward quoted-comment-start end-of-line t
)
1589 (setq parse-limit
(min (point) parse-limit
)))))
1590 ;; now parse if still in limits
1591 (if (< (point) where
)
1592 (setq parse-state
(parse-partial-sexp
1593 (point) parse-limit nil nil parse-state
))
1594 (setq not-done nil
))))
1596 (nth 3 parse-state
))))))
1598 ;; From old version.
1599 (defalias 'fortran-auto-fill-mode
'auto-fill-mode
)
1601 (defun fortran-fill ()
1602 (let* ((auto-fill-function #'fortran-auto-fill
)
1604 (bol (line-beginning-position))
1605 (eol (line-end-position))
1606 (bos (min eol
(+ bol
(fortran-current-line-indentation))))
1610 (if (looking-at fortran-comment-line-start-skip
)
1611 nil
; OK to break quotes on comment lines.
1612 (move-to-column fill-column
)
1613 (if (fortran-is-in-string-p (point))
1614 (save-excursion (re-search-backward "\\S\"\\s\"\\S\"" bol t
)
1615 (if fortran-break-before-delimiters
1618 ;; decide where to split the line. If a position for a quoted
1619 ;; string was found above then use that, else break the line
1620 ;; before the last delimiter.
1621 ;; Delimiters are whitespace, commas, and operators.
1622 ;; Will break before a pair of *'s.
1626 (move-to-column (1+ fill-column
))
1627 (skip-chars-backward "^ \t\n,'+-/*=)"
1628 ;;; (if fortran-break-before-delimiters
1629 ;;; "^ \t\n,'+-/*=" "^ \t\n,'+-/*=)")
1631 (if (<= (point) (1+ bos
))
1633 (move-to-column (1+ fill-column
))
1634 ;;what is this doing???
1635 (if (not (re-search-forward "[\t\n,'+-/*)=]" eol t
))
1638 (re-search-forward "[ \t]" opoint t
)
1640 (if (looking-at "\\s\"")
1642 (skip-chars-backward " \t\*")))
1643 (if fortran-break-before-delimiters
1646 ;; if we are in an in-line comment, don't break unless the
1647 ;; line of code is longer than it should be. Otherwise
1648 ;; break the line at the column computed above.
1650 ;; Need to use fortran-find-comment-start-skip to make sure that quoted !'s
1651 ;; don't prevent a break.
1652 (if (not (or (save-excursion
1653 (if (and comment-start-skip
1654 (re-search-backward comment-start-skip bol t
)
1655 (not (fortran-is-in-string-p (point))))
1657 (skip-chars-backward " \t")
1658 (< (current-column) (1+ fill-column
)))))
1660 (goto-char fill-point
)
1662 (when (> (save-excursion
1665 (min (1+ fill-column
)
1666 (+ (fortran-calculate-indent)
1667 fortran-continuation-indent
)))
1668 (goto-char fill-point
)
1669 (fortran-break-line)
1672 (defun fortran-break-line ()
1673 (let ((opoint (point))
1674 (bol (line-beginning-position))
1675 (eol (line-end-position))
1676 (comment-string nil
))
1678 (if (and comment-start-skip
(fortran-find-comment-start-skip))
1680 (re-search-backward comment-start-skip bol t
)
1681 (setq comment-string
(buffer-substring (point) eol
))
1682 (delete-region (point) eol
))))
1683 ;; Forward line 1 really needs to go to next non white line
1684 (if (save-excursion (forward-line)
1685 (or (looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]")))
1688 (delete-region (point) (match-end 0))
1689 (delete-horizontal-space)
1691 (fortran-split-line))
1696 (delete-horizontal-space)
1697 (indent-to (fortran-comment-indent))
1698 (insert comment-string
)))))
1700 (defun fortran-analyze-file-format ()
1701 "Return nil if fixed format is used, t if TAB formatting is used.
1702 Use `fortran-tab-mode-default' if no non-comment statements are found in the
1703 file before the end or the first `fortran-analyze-depth' lines."
1706 (goto-char (point-min))
1710 (eq (char-after) ?
\t)
1711 (looking-at " \\{6\\}")
1712 (> i fortran-analyze-depth
)))
1716 ((eq (char-after) ?
\t) t
)
1717 ((looking-at " \\{6\\}") nil
)
1718 (fortran-tab-mode-default t
)
1721 (or (assq 'fortran-tab-mode-string minor-mode-alist
)
1722 (setq minor-mode-alist
(cons
1723 '(fortran-tab-mode-string
1724 (indent-tabs-mode fortran-tab-mode-string
))
1727 (defun fortran-fill-paragraph (&optional justify
)
1728 "Fill surrounding comment block as paragraphs, else fill statement.
1729 Intended as the value of `fill-paragraph-function'."
1733 (if (not (looking-at fortran-comment-line-start-skip
))
1734 (fortran-fill-statement)
1735 ;; We're in a comment block. Find the start and end of a
1736 ;; paragraph, delimited either by non-comment lines or empty
1737 ;; comments. (Get positions as markers, since the
1738 ;; `indent-region' below can shift the block's end).
1739 (let* ((non-empty-comment
1740 (concat "\\(" fortran-comment-line-start-skip
"\\)"
1742 (start (save-excursion
1743 ;; Find (start of) first line.
1744 (while (and (zerop (forward-line -
1))
1745 (looking-at non-empty-comment
)))
1746 (or (looking-at non-empty-comment
)
1747 (forward-line)) ; overshot
1749 (end (save-excursion
1750 ;; Find start of first line past region to fill.
1753 (looking-at non-empty-comment
)))
1755 ;; Indent the block, find the string comprising the effective
1756 ;; comment start skip and use that as a fill-prefix for
1757 ;; filling the region.
1758 (indent-region start end nil
)
1759 (let ((paragraph-ignore-fill-prefix nil
)
1762 (looking-at fortran-comment-line-start-skip
)
1764 (let (fill-paragraph-function)
1765 (fill-region start end justify
))) ; with normal `fill-paragraph'
1766 (set-marker start nil
)
1767 (set-marker end nil
))))
1770 (defun fortran-fill-statement ()
1771 "Fill a fortran statement up to `fill-column'."
1773 (let ((auto-fill-function #'fortran-auto-fill
))
1774 (if (not (save-excursion
1776 (or (looking-at "[ \t]*$")
1777 (looking-at fortran-comment-line-start-skip
)
1778 (and comment-start-skip
1779 (looking-at (concat "[ \t]*"
1780 comment-start-skip
))))))
1782 ;; Find beginning of statement.
1783 (fortran-next-statement)
1784 (fortran-previous-statement)
1785 ;; Re-indent initially.
1786 (fortran-indent-line)
1787 ;; Replace newline plus continuation field plus indentation with
1791 (fortran-remove-continuation)))
1792 (fortran-previous-statement)))
1793 (fortran-indent-line)))
1795 (defun fortran-strip-sqeuence-nos (do-space)
1796 "Delete all text after column 72 (assumed to be sequence numbers).
1797 Also delete trailing whitespace after stripping such text. Supplying
1798 prefix arg DO-SPACE prevent stripping the whitespace."
1801 (goto-char (point-min))
1802 (while (re-search-forward (concat "^" (make-string 72 ?.
)" \\(.*\\)")
1804 (replace-match "" nil nil nil
1)
1805 (unless do-space
(delete-horizontal-space)))))
1807 ;; This code used to live in add-log.el, but this is a better place
1809 (defun fortran-current-defun ()
1810 "Function to use for `add-log-current-defun-function' in Fortran mode."
1811 ;; We must be inside function body for this to work.
1812 (fortran-beginning-of-subprogram)
1813 (let ((case-fold-search t
)) ; case-insensitive
1814 ;; search for fortran subprogram start
1815 (if (re-search-forward
1816 (concat "^[ \t]*\\(program\\|subroutine\\|function"
1817 "\\|[ \ta-z0-9*()]*[ \t]+function\\|"
1818 "\\(block[ \t]*data\\)\\)")
1819 (save-excursion (fortran-end-of-subprogram)
1822 (or (match-string-no-properties 2)
1824 ;; move to EOL or before first left paren
1825 (if (re-search-forward "[(\n]" nil t
)
1826 (progn (backward-char)
1827 (skip-chars-backward " \t"))
1829 ;; Use the name preceding that.
1830 (buffer-substring-no-properties (point) (progn (backward-sexp)
1836 ;;; fortran.el ends here