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