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