emacs: lisp/progmodes/fortran.el comparison

comparison lisp/progmodes/fortran.el @ 85579:fb34ccab73f6

Untabify.

author	Glenn Morris <rgm@gnu.org>
date	Tue, 23 Oct 2007 07:02:42 +0000
parents	e164769e7a33
children	b4eec406ec78

comparison

equal deleted inserted replaced

-:40360655a978
+:fb34ccab73f6
 A simple regexp cannot do this in fully correct fashion, so this
 tries to strike a compromise between complexity and flexibility.
 Used in the Fortran entry in `hs-special-modes-alist'.")
 (add-to-list 'hs-special-modes-alist
-	     `(fortran-mode ,fortran-start-block-re ,fortran-end-block-re
+`(fortran-mode ,fortran-start-block-re ,fortran-end-block-re
 "^[cC*!]" fortran-end-of-block nil))
 (defvar fortran-mode-syntax-table
 (let ((table (make-syntax-table)))
 value of either
 `fortran-minimum-statement-indent-fixed' (fixed format) or
 `fortran-minimum-statement-indent-tab' (TAB format),
 depending on the continuation format in use.
 relative  indent to `fortran-comment-line-extra-indent' beyond the
-	      indentation for a line of code.
+indentation for a line of code.
 (default 'fixed)
 `fortran-comment-indent-char'
 Single-character string to be inserted instead of space for
 full-line comment indentation (default \" \").
 `fortran-minimum-statement-indent-fixed'
 or on a new line inserted before this line if this line is not blank."
 (interactive "*")
 (beginning-of-line)
 ;; Recognize existing comments of either kind.
 (cond ((fortran-find-comment-start-skip 'all)
-	 (goto-char (match-beginning 0))
+(goto-char (match-beginning 0))
-	 (if (bolp)
+(if (bolp)
-	     (fortran-indent-line)
+(fortran-indent-line)
-	   (unless (= (current-column) (fortran-comment-indent))
+(unless (= (current-column) (fortran-comment-indent))
 (delete-horizontal-space)
 (indent-to (fortran-comment-indent)))))
-	;; No existing comment.
+;; No existing comment.
-	;; If side-by-side comments are defined, insert one,
+;; If side-by-side comments are defined, insert one,
-	;; unless line is now blank.
+;; unless line is now blank.
-	((and comment-start (not (looking-at "[ \t]*$"))
+((and comment-start (not (looking-at "[ \t]*$"))
-	      (string-match comment-start-skip (concat " " comment-start)))
+(string-match comment-start-skip (concat " " comment-start)))
-	 (end-of-line)
+(end-of-line)
-	 (delete-horizontal-space)
+(delete-horizontal-space)
-	 (indent-to (fortran-comment-indent))
+(indent-to (fortran-comment-indent))
-	 (insert comment-start))
+(insert comment-start))
-	;; Else insert separate-line comment, making a new line if nec.
+;; Else insert separate-line comment, making a new line if nec.
-	(t
+(t
-	 (if (looking-at "^[ \t]*$")
+(if (looking-at "^[ \t]*$")
-	     (delete-horizontal-space)
+(delete-horizontal-space)
-	   (beginning-of-line)
+(beginning-of-line)
-	   (insert ?\n)
+(insert ?\n)
-	   (forward-char -1))
+(forward-char -1))
-	 (insert fortran-comment-line-start)
+(insert fortran-comment-line-start)
-	 (insert-char (if (stringp fortran-comment-indent-char)
+(insert-char (if (stringp fortran-comment-indent-char)
-			  (aref fortran-comment-indent-char 0)
+(aref fortran-comment-indent-char 0)
-			fortran-comment-indent-char)
+fortran-comment-indent-char)
-		      (- (fortran-calculate-indent) (current-column))))))
+(- (fortran-calculate-indent) (current-column))))))
 (defun fortran-comment-region (beg-region end-region arg)
 "Comment every line in the region.
 Inserts the string variable `fortran-comment-region' at the beginning of
 every line in the region.
 BEG-REGION and END-REGION specify the region boundaries.
 With non-nil ARG, uncomments the region."
 (interactive "*r\nP")
 (let ((end-region-mark (copy-marker end-region))
-	(save-point (point-marker)))
+(save-point (point-marker)))
 (goto-char beg-region)
 (beginning-of-line)
 (if arg
 (let ((com (regexp-quote fortran-comment-region))) ; uncomment
 (if (looking-at com)
 (char (if (fboundp 'event-to-character)
 (event-to-character event) event)))
 ;; Insert char if not equal to `?', or if abbrev-mode is off.
 (if (and abbrev-mode (or (eq char ??) (eq char help-char)
 (memq event help-event-list)))
-	(fortran-abbrev-help)
+(fortran-abbrev-help)
 (push event unread-command-events))))
 (defun fortran-abbrev-help ()
 "List the currently defined abbrevs in Fortran mode."
 (interactive)
 fortran-column-ruler-tab
 fortran-column-ruler-fixed)
 (save-excursion
 (beginning-of-line)
 (if (eq (window-start (selected-window))
-	     (window-point (selected-window)))
+(window-point (selected-window)))
-	 (line-beginning-position 2)
+(line-beginning-position 2)
 (point)))
 nil "Type SPC or any command to erase ruler."))
 (defun fortran-window-create ()
 "Make the window `fortran-line-length' (default 72) columns wide.
 See also `fortran-window-create-momentarily'."
 (interactive)
 (let ((window-min-width 2))
 (unless (window-full-width-p)
-	(enlarge-window-horizontally (- (frame-width)
+(enlarge-window-horizontally (- (frame-width)
-					(window-width) 1)))
+(window-width) 1)))
 (let* ((window-edges (window-edges))
-	   (scroll-bar-width (- (nth 2 window-edges)
+(scroll-bar-width (- (nth 2 window-edges)
-				(car window-edges)
+(car window-edges)
-				(window-width))))
+(window-width))))
 (split-window-horizontally (+ fortran-line-length scroll-bar-width)))
 (other-window 1)
 (switch-to-buffer " fortran-window-extra" t)
 (select-window (previous-window))))
 "Momentarily make the window `fortran-line-length' (default 72) columns wide.
 Optional ARG non-nil and non-unity disables the momentary feature.
 See also `fortran-window-create'."
 (interactive "p")
 (if (or (not arg)
-	  (= arg 1))
+(= arg 1))
 (save-window-excursion
-	(progn
+(progn
-	  (condition-case nil
+(condition-case nil
-	      (fortran-window-create)
+(fortran-window-create)
-	    (error (error "No room for Fortran window")))
+(error (error "No room for Fortran window")))
-	  (message "Type SPC to continue editing.")
+(message "Type SPC to continue editing.")
-	  (let ((char (read-event)))
+(let ((char (read-event)))
-	    (or (equal char ?\s)
+(or (equal char ?\s)
-		(setq unread-command-events (list char))))))
+(setq unread-command-events (list char))))))
 (fortran-window-create)))
 (defun fortran-split-line ()
 "Break line at point and insert continuation marker and alignment."
 (interactive "*")
 (delete-horizontal-space)
 (if (save-excursion
-	(let ((pos (point)))
+(let ((pos (point)))
-	  (beginning-of-line)
+(beginning-of-line)
-	  (and (fortran-find-comment-start-skip 'all)
+(and (fortran-find-comment-start-skip 'all)
-	       (< (match-beginning 0) pos))))
+(< (match-beginning 0) pos))))
 (insert ?\n (match-string 0))
 (if indent-tabs-mode
-	(insert ?\n ?\t (fortran-numerical-continuation-char))
+(insert ?\n ?\t (fortran-numerical-continuation-char))
 (insert "\n " fortran-continuation-string))) ; space after \n important
 (fortran-indent-line))               ; when cont string is C, c or *
 (defun fortran-remove-continuation ()
 "Delete any Fortran continuation characters at point.
 If previous line is a tab-digit continuation line, return that digit
 plus one, otherwise return 1.  Zero not allowed."
 (save-excursion
 (forward-line -1)
 (if (looking-at "\t[1-9]")
-	(+ ?1 (% (- (char-after (1+ (point))) ?0) 9))
+(+ ?1 (% (- (char-after (1+ (point))) ?0) 9))
 ?1)))
 (put 'fortran-electric-line-number 'delete-selection t)
 (defun fortran-electric-line-number (arg)
 "Self insert, but if part of a Fortran line number indent it automatically.
 Auto-indent does not happen if a numeric ARG is used."
 (interactive "*P")
 (if (or arg (not fortran-electric-line-number))
 (if arg
-	  (self-insert-command (prefix-numeric-value arg))
+(self-insert-command (prefix-numeric-value arg))
-	(self-insert-command 1))
+(self-insert-command 1))
 (if (or (and (= 5 (current-column))
-		 (save-excursion
+(save-excursion
-		   (beginning-of-line)
+(beginning-of-line)
 ;; In col 5 with only spaces to the left.
-		   (looking-at " \\{5\\}")))
+(looking-at " \\{5\\}")))
-	    (and (= (if indent-tabs-mode
+(and (= (if indent-tabs-mode
-			fortran-minimum-statement-indent-tab
+fortran-minimum-statement-indent-tab
-		      fortran-minimum-statement-indent-fixed) (current-column))
+fortran-minimum-statement-indent-fixed) (current-column))
 ;; In col 8 with a single tab to the left.
-		 (eq ?\t (char-after (line-beginning-position)))
+(eq ?\t (char-after (line-beginning-position)))
-		 (not (or (eq last-command 'fortran-indent-line)
+(not (or (eq last-command 'fortran-indent-line)
-			  (eq last-command
+(eq last-command
-			      'fortran-indent-new-line))))
+'fortran-indent-new-line))))
-	    (save-excursion
+(save-excursion
-	      (re-search-backward "[^ \t0-9]"
+(re-search-backward "[^ \t0-9]"
-				  (line-beginning-position)
+(line-beginning-position)
-				  t))	; not a line number
+t))   ; not a line number
-	    (looking-at "[0-9]"))	; within a line number
+(looking-at "[0-9]"))       ; within a line number
-	(self-insert-command (prefix-numeric-value arg))
+(self-insert-command (prefix-numeric-value arg))
 (skip-chars-backward " \t")
 (insert last-command-char)
 (fortran-indent-line))))
 "Check a preliminary match against `fortran-end-prog-re'."
 ;; Having got a possible match for the subprogram end, we need a
 ;; match of whitespace, avoiding possible column 73+ stuff.
 (save-match-data
 (string-match "^\\s-*\\(\\'\\|\\s<\\)"
-		  (buffer-substring (match-end 0)
+(buffer-substring (match-end 0)
-				    (min (line-end-position)
+(min (line-end-position)
-					 (+ fortran-line-length
+(+ fortran-line-length
 (line-beginning-position)))))))
 ;; Note that you can't just check backwards for `subroutine' &c in
 ;; case of un-marked main programs not at the start of the file.
 (defun fortran-beginning-of-subprogram ()
 (interactive)
 (save-match-data
 (let ((case-fold-search t))
 (beginning-of-line -1)
 (if (catch 'ok
-	    (while (re-search-backward fortran-end-prog-re nil 'move)
+(while (re-search-backward fortran-end-prog-re nil 'move)
-	      (if (fortran-check-end-prog-re)
+(if (fortran-check-end-prog-re)
-		  (throw 'ok t))))
+(throw 'ok t))))
-	  (forward-line)))))
+(forward-line)))))
 (defun fortran-end-of-subprogram ()
 "Move point to the end of the current Fortran subprogram."
 (interactive)
 (save-match-data
 (let ((case-fold-search t))
-(if (save-excursion		; on END
+(if (save-excursion               ; on END
-	    (beginning-of-line)
+(beginning-of-line)
-	    (and (looking-at fortran-end-prog-re)
+(and (looking-at fortran-end-prog-re)
-		 (fortran-check-end-prog-re)))
+(fortran-check-end-prog-re)))
-	  (forward-line)
+(forward-line)
-	(beginning-of-line 2)
+(beginning-of-line 2)
-	(catch 'ok
+(catch 'ok
-	  (while (re-search-forward fortran-end-prog-re nil 'move)
+(while (re-search-forward fortran-end-prog-re nil 'move)
-	    (if (fortran-check-end-prog-re)
+(if (fortran-check-end-prog-re)
-		(throw 'ok t))))
+(throw 'ok t))))
-	(goto-char (match-beginning 0))
+(goto-char (match-beginning 0))
-	(forward-line)))))
+(forward-line)))))
 (defun fortran-previous-statement ()
 "Move point to beginning of the previous Fortran statement.
 Returns 'first-statement if that statement is the first
 non-comment Fortran statement in the file, and nil otherwise.
 Directive lines are treated as comments."
 (interactive)
 (let (not-first-statement continue-test)
 (beginning-of-line)
 (setq continue-test
-	  (and
+(and
-	   (not (looking-at fortran-comment-line-start-skip))
+(not (looking-at fortran-comment-line-start-skip))
 (not (looking-at fortran-directive-re))
-	   (or (looking-at
+(or (looking-at
-	        (concat "[ \t]*"
+(concat "[ \t]*"
-			(regexp-quote fortran-continuation-string)))
+(regexp-quote fortran-continuation-string)))
-	       (looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]"))))
+(looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]"))))
 (while (and (setq not-first-statement (zerop (forward-line -1)))
-		(or (looking-at fortran-comment-line-start-skip)
+(or (looking-at fortran-comment-line-start-skip)
 (looking-at fortran-directive-re)
 (looking-at
 (concat "[ \t]*"
 (regexp-quote fortran-continuation-string)))
-		    (looking-at "[ \t]*$\\| \\{5\\}[^ 0\n]\\|\t[1-9]")
+(looking-at "[ \t]*$\\| \\{5\\}[^ 0\n]\\|\t[1-9]")
-		    (looking-at (concat "[ \t]*" comment-start-skip)))))
+(looking-at (concat "[ \t]*" comment-start-skip)))))
 (cond ((and continue-test
-		(not not-first-statement))
+(not not-first-statement))
-	   (message "Incomplete continuation statement."))
+(message "Incomplete continuation statement."))
-	  (continue-test
+(continue-test
-	   (fortran-previous-statement))
+(fortran-previous-statement))
-	  ((not not-first-statement)
+((not not-first-statement)
-	   'first-statement))))
+'first-statement))))
 (defun fortran-next-statement ()
 "Move point to beginning of the next Fortran statement.
 Returns 'last-statement if that statement is the last
 non-comment Fortran statement in the file, and nil otherwise.
 Directive lines are treated as comments."
 (interactive)
 (let (not-last-statement)
 (beginning-of-line)
 (while (and (setq not-last-statement
-		      (and (zerop (forward-line 1))
+(and (zerop (forward-line 1))
-			   (not (eobp))))
+(not (eobp))))
-		(or (looking-at fortran-comment-line-start-skip)
+(or (looking-at fortran-comment-line-start-skip)
 (looking-at fortran-directive-re)
-		    (looking-at "[ \t]*$\\|     [^ 0\n]\\|\t[1-9]")
+(looking-at "[ \t]*$\\|     [^ 0\n]\\|\t[1-9]")
-		    (looking-at (concat "[ \t]*" comment-start-skip)))))
+(looking-at (concat "[ \t]*" comment-start-skip)))))
 (if (not not-last-statement)
-	'last-statement)))
+'last-statement)))
 (defun fortran-looking-at-if-then ()
 "Return non-nil if at the start of a line with an IF ... THEN statement."
 ;; cf f90-looking-at-if-then.
 (let ((p (point))
 (defun fortran-blink-match (regex keyword find-begin)
 "From a line matching REGEX, blink matching KEYWORD statement line.
 Use function FIND-BEGIN to match it."
 (let ((top-of-window (window-start))
-	(end-point (point))
+(end-point (point))
-	(case-fold-search t)
+(case-fold-search t)
-	matching
+matching
-	message)
+message)
 (when (save-excursion
 (beginning-of-line)
 (skip-chars-forward " \t0-9")
 (looking-at regex))
 (if (not (setq matching (funcall find-begin)))
 (goto-char end-point)))))
 (defun fortran-blink-matching-if ()
 "From an ENDIF or ELSE statement, blink the matching IF statement."
 (fortran-blink-match "e\\(nd[ \t]*if\\|lse\\([ \t]*if\\)?\\)\\b"
-		       "if" #'fortran-beginning-if))
+"if" #'fortran-beginning-if))
 (defun fortran-blink-matching-do ()
 "From an ENDDO statement, blink the matching DO or DO WHILE statement."
 (fortran-blink-match "end[ \t]*do\\b" "do" #'fortran-beginning-do))
 (defun fortran-end-do ()
 "Search forward for first unmatched ENDDO.
 Return point or nil."
 (let ((case-fold-search t))
 (if (save-excursion (beginning-of-line)
-			(skip-chars-forward " \t0-9")
+(skip-chars-forward " \t0-9")
-			(looking-at "end[ \t]*do\\b"))
+(looking-at "end[ \t]*do\\b"))
-	;; Sitting on one.
+;; Sitting on one.
-	(match-beginning 0)
+(match-beginning 0)
 ;; Search for one.
 (save-excursion
-	(let ((count 1))
+(let ((count 1))
-	  (while (and (not (zerop count))
+(while (and (not (zerop count))
-		      (not (eq (fortran-next-statement) 'last-statement))
+(not (eq (fortran-next-statement) 'last-statement))
-		      ;; Keep local to subprogram.
+;; Keep local to subprogram.
-		      (not (and (looking-at fortran-end-prog-re)
+(not (and (looking-at fortran-end-prog-re)
-				(fortran-check-end-prog-re))))
+(fortran-check-end-prog-re))))
-	    (skip-chars-forward " \t0-9")
+(skip-chars-forward " \t0-9")
-	    (cond ((looking-at "end[ \t]*do\\b")
+(cond ((looking-at "end[ \t]*do\\b")
-		   (setq count (1- count)))
+(setq count (1- count)))
-		  ((looking-at
+((looking-at
-		    "\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?do[ \t]+[^0-9]")
+"\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?do[ \t]+[^0-9]")
-		   (setq count (1+ count)))))
+(setq count (1+ count)))))
-	  (and (zerop count)
+(and (zerop count)
-	       ;; All pairs accounted for.
+;; All pairs accounted for.
-	       (point)))))))
+(point)))))))
 (defun fortran-beginning-do ()
 "Search backwards for first unmatched DO [WHILE].
 Return point or nil.  Ignores labelled DO loops (ie DO 10 ... 10 CONTINUE)."
 (let ((case-fold-search t)
 (dostart-re "\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?do[ \t]+[^0-9]"))
 (if (save-excursion
-	  (beginning-of-line)
+(beginning-of-line)
-	  (skip-chars-forward " \t0-9")
+(skip-chars-forward " \t0-9")
-	  (looking-at dostart-re))
+(looking-at dostart-re))
-	;; Sitting on one.
+;; Sitting on one.
-	(match-beginning 0)
+(match-beginning 0)
 ;; Search for one.
 (save-excursion
-	(let ((count 1))
+(let ((count 1))
-	  (while (and (not (zerop count))
+(while (and (not (zerop count))
-		      (not (eq (fortran-previous-statement) 'first-statement))
+(not (eq (fortran-previous-statement) 'first-statement))
-		      ;; Keep local to subprogram.
+;; Keep local to subprogram.
-		      (not (and (looking-at fortran-end-prog-re)
+(not (and (looking-at fortran-end-prog-re)
-				(fortran-check-end-prog-re))))
+(fortran-check-end-prog-re))))
-	    (skip-chars-forward " \t0-9")
+(skip-chars-forward " \t0-9")
-	    (cond ((looking-at dostart-re)
+(cond ((looking-at dostart-re)
-		   (setq count (1- count)))
+(setq count (1- count)))
 ;; Note labelled loop ends not considered.
-		  ((looking-at "end[ \t]*do\\b")
+((looking-at "end[ \t]*do\\b")
-		   (setq count (1+ count)))))
+(setq count (1+ count)))))
-	  (and (zerop count)
+(and (zerop count)
-	       ;; All pairs accounted for.
+;; All pairs accounted for.
-	       (point)))))))
+(point)))))))
 (defun fortran-mark-if ()
 "Put mark at end of Fortran IF-ENDIF construct, point at beginning.
 The marks are pushed."
 (interactive)
 (defun fortran-end-if ()
 "Search forwards for first unmatched ENDIF.
 Return point or nil."
 (let ((case-fold-search t))
 (if (save-excursion (beginning-of-line)
-			(skip-chars-forward " \t0-9")
+(skip-chars-forward " \t0-9")
-			(looking-at "end[ \t]*if\\b"))
+(looking-at "end[ \t]*if\\b"))
-	;; Sitting on one.
+;; Sitting on one.
-	(match-beginning 0)
+(match-beginning 0)
 ;; Search for one.  The point has been already been moved to first
 ;; letter on line but this should not cause troubles.
 (save-excursion
-	(let ((count 1))
+(let ((count 1))
-	  (while (and (not (zerop count))
+(while (and (not (zerop count))
-		      (not (eq (fortran-next-statement) 'last-statement))
+(not (eq (fortran-next-statement) 'last-statement))
-		      ;; Keep local to subprogram.
+;; Keep local to subprogram.
-		      (not (and (looking-at fortran-end-prog-re)
+(not (and (looking-at fortran-end-prog-re)
-				(fortran-check-end-prog-re))))
+(fortran-check-end-prog-re))))
-	    (skip-chars-forward " \t0-9")
+(skip-chars-forward " \t0-9")
-	    (cond ((looking-at "end[ \t]*if\\b")
+(cond ((looking-at "end[ \t]*if\\b")
-		   (setq count (1- count)))
+(setq count (1- count)))
-		  ((looking-at fortran-if-start-re)
+((looking-at fortran-if-start-re)
-		   (save-excursion
+(save-excursion
-		     (if (or
+(if (or
-			  (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]")
+(looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]")
-			  (let (then-test) ; multi-line if-then
+(let (then-test) ; multi-line if-then
-			    (while
+(while
-				(and
+(and
-				 (zerop (forward-line 1))
+(zerop (forward-line 1))
-				 ;; Search forward for then.
+;; Search forward for then.
-				 (looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]")
+(looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]")
-				 (not
+(not
-				  (setq then-test
+(setq then-test
-					(looking-at
+(looking-at
-					 ".*then\\b[ \t]*[^ \t(=a-z0-9]")))))
+".*then\\b[ \t]*[^ \t(=a-z0-9]")))))
-			    then-test))
+then-test))
-			 (setq count (1+ count)))))))
+(setq count (1+ count)))))))
-	  (and (zerop count)
+(and (zerop count)
-	       ;; All pairs accounted for.
+;; All pairs accounted for.
-	       (point)))))))
+(point)))))))
 (defun fortran-beginning-if ()
 "Search backwards for first unmatched IF-THEN.
 Return point or nil."
 (let ((case-fold-search t))
 (if (save-excursion
-	  ;; May be sitting on multi-line if-then statement, first
+;; May be sitting on multi-line if-then statement, first
-	  ;; move to beginning of current statement.  Note:
+;; move to beginning of current statement.  Note:
-	  ;; `fortran-previous-statement' moves to previous statement
+;; `fortran-previous-statement' moves to previous statement
-	  ;; *unless* current statement is first one.  Only move
+;; *unless* current statement is first one.  Only move
-	  ;; forward if not first-statement.
+;; forward if not first-statement.
-	  (if (not (eq (fortran-previous-statement) 'first-statement))
+(if (not (eq (fortran-previous-statement) 'first-statement))
-	      (fortran-next-statement))
+(fortran-next-statement))
-	  (skip-chars-forward " \t0-9")
+(skip-chars-forward " \t0-9")
-	  (and
+(and
-	   (looking-at fortran-if-start-re)
+(looking-at fortran-if-start-re)
-	   (save-match-data
+(save-match-data
-	     (or (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]")
+(or (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]")
-		 ;; Multi-line if-then.
+;; Multi-line if-then.
-		 (let (then-test)
+(let (then-test)
-		   (while
+(while
 (and (zerop (forward-line 1))
-			    ;; Search forward for then.
+;; Search forward for then.
-			    (looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]")
+(looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]")
-			    (not
+(not
-			     (setq then-test
+(setq then-test
-				   (looking-at
+(looking-at
-				    ".*then\\b[ \t]*[^ \t(=a-z0-9]")))))
+".*then\\b[ \t]*[^ \t(=a-z0-9]")))))
-		   then-test)))))
+then-test)))))
-	;; Sitting on one.
+;; Sitting on one.
-	(match-beginning 0)
+(match-beginning 0)
 ;; Search for one.
 (save-excursion
-	(let ((count 1))
+(let ((count 1))
-	  (while (and (not (zerop count))
+(while (and (not (zerop count))
-		      (not (eq (fortran-previous-statement) 'first-statement))
+(not (eq (fortran-previous-statement) 'first-statement))
-		      ;; Keep local to subprogram.
+;; Keep local to subprogram.
-		      (not (and (looking-at fortran-end-prog-re)
+(not (and (looking-at fortran-end-prog-re)
-				(fortran-check-end-prog-re))))
+(fortran-check-end-prog-re))))
-	    (skip-chars-forward " \t0-9")
+(skip-chars-forward " \t0-9")
-	    (cond ((looking-at fortran-if-start-re)
+(cond ((looking-at fortran-if-start-re)
-		   (save-excursion
+(save-excursion
-		     (if (or
+(if (or
-			  (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]")
+(looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]")
-			  (let (then-test) ; multi-line if-then
+(let (then-test) ; multi-line if-then
-			    (while
+(while
-				(and
+(and
-				 (zerop (forward-line 1))
+(zerop (forward-line 1))
-				 ;; Search forward for then.
+;; Search forward for then.
-				 (looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]")
+(looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]")
-				 (not
+(not
-				  (setq then-test
+(setq then-test
-					(looking-at
+(looking-at
-					 (concat ".*then\\b[ \t]*"
+(concat ".*then\\b[ \t]*"
-						 "[^ \t(=a-z0-9]"))))))
+"[^ \t(=a-z0-9]"))))))
-			    then-test))
+then-test))
-			 (setq count (1- count)))))
+(setq count (1- count)))))
-		  ((looking-at "end[ \t]*if\\b")
+((looking-at "end[ \t]*if\\b")
-		   (setq count (1+ count)))))
+(setq count (1+ count)))))
-	  (and (zerop count)
+(and (zerop count)
-	       ;; All pairs accounted for.
+;; All pairs accounted for.
-	       (point)))))))
+(point)))))))
 (defun fortran-indent-line ()
 "Indent current Fortran line based on its contents and on previous lines."
 (interactive "*")
 (let ((cfi (fortran-calculate-indent)))
 (save-excursion
 (beginning-of-line)
 (if (or (not (= cfi (fortran-current-line-indentation)))
-	      (and (re-search-forward "^[ \t]*[0-9]+" (+ (point) 4) t)
+(and (re-search-forward "^[ \t]*[0-9]+" (+ (point) 4) t)
-		   (not (fortran-line-number-indented-correctly-p))))
+(not (fortran-line-number-indented-correctly-p))))
-	  (fortran-indent-to-column cfi)
+(fortran-indent-to-column cfi)
-	(beginning-of-line)
+(beginning-of-line)
-	(if (fortran-find-comment-start-skip)
+(if (fortran-find-comment-start-skip)
-	    (fortran-indent-comment))))
+(fortran-indent-comment))))
 ;; Never leave point in left margin.
 (if (< (current-column) cfi)
-	(move-to-column cfi))
+(move-to-column cfi))
 (and auto-fill-function
 (> (save-excursion (end-of-line) (current-column))
 fill-column)
 (save-excursion
 (end-of-line)
 (defun fortran-auto-fill ()
 "Function to use for `normal-auto-fill-function' in Fortran mode."
 (if (> (current-column) (current-fill-column))
 (let ((cfi (fortran-calculate-indent)))
-	(save-excursion
+(save-excursion
-	  (beginning-of-line)
+(beginning-of-line)
-	  (if (or (not (= cfi (fortran-current-line-indentation)))
+(if (or (not (= cfi (fortran-current-line-indentation)))
-		  (and (re-search-forward "^[ \t]*[0-9]+"
+(and (re-search-forward "^[ \t]*[0-9]+"
-					  (+ (point) 4) t)
+(+ (point) 4) t)
-		       (not (fortran-line-number-indented-correctly-p))))
+(not (fortran-line-number-indented-correctly-p))))
-	      (fortran-indent-to-column cfi)
+(fortran-indent-to-column cfi)
-	    (beginning-of-line)
+(beginning-of-line)
-	    (if (fortran-find-comment-start-skip)
+(if (fortran-find-comment-start-skip)
-		(fortran-indent-comment))))
+(fortran-indent-comment))))
-	(fortran-fill)
+(fortran-fill)
-	;; Never leave point in left margin.
+;; Never leave point in left margin.
-	(if (< (current-column) cfi)
+(if (< (current-column) cfi)
-	    (move-to-column cfi)))))
+(move-to-column cfi)))))
 ;; Historically this was a separate function which advertised itself
 ;; as reindenting but only did so where `most likely to be necessary'.
 (defalias 'fortran-indent-new-line 'reindent-then-newline-and-indent)
 (message "Indenting subprogram...done."))
 (defun fortran-calculate-indent ()
 "Calculates the Fortran indent column based on previous lines."
 (let (icol first-statement (case-fold-search t)
-	     (fortran-minimum-statement-indent
+(fortran-minimum-statement-indent
-	      (if indent-tabs-mode
+(if indent-tabs-mode
-		  fortran-minimum-statement-indent-tab
+fortran-minimum-statement-indent-tab
-		fortran-minimum-statement-indent-fixed)))
+fortran-minimum-statement-indent-fixed)))
 (save-excursion
 (setq first-statement (fortran-previous-statement))
 (if first-statement
-	  (setq icol fortran-minimum-statement-indent)
+(setq icol fortran-minimum-statement-indent)
 (if (= (point) (point-min))
 (setq icol fortran-minimum-statement-indent)
 (setq icol (fortran-current-line-indentation)))
 (skip-chars-forward " \t0-9")
 (cond ((looking-at "\\(\\(\\sw\\|\\s_\\)+:[ \t]*\\)?if[ \t]*(")
 (if (or (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t_$(=a-z0-9]")
-(let (then-test)	; multi-line if-then
+(let (then-test) ; multi-line if-then
 (while (and (zerop (forward-line 1))
 ;; Search forward for then.
 (looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]")
 (not (setq then-test
 (looking-at
 (setq icol fortran-minimum-statement-indent)))))
 (save-excursion
 (beginning-of-line)
 (cond ((looking-at "[ \t]*$"))
 ;; Check for directive before comment, so as not to indent.
-	    ((looking-at fortran-directive-re)
+((looking-at fortran-directive-re)
-	     (setq fortran-minimum-statement-indent 0 icol 0))
+(setq fortran-minimum-statement-indent 0 icol 0))
-	    ((looking-at fortran-comment-line-start-skip)
+((looking-at fortran-comment-line-start-skip)
-	     (cond ((eq fortran-comment-indent-style 'relative)
+(cond ((eq fortran-comment-indent-style 'relative)
-		    (setq icol (+ icol fortran-comment-line-extra-indent)))
+(setq icol (+ icol fortran-comment-line-extra-indent)))
-		   ((eq fortran-comment-indent-style 'fixed)
+((eq fortran-comment-indent-style 'fixed)
-		    (setq icol (+ fortran-minimum-statement-indent
+(setq icol (+ fortran-minimum-statement-indent
-				  fortran-comment-line-extra-indent))))
+fortran-comment-line-extra-indent))))
-	     (setq fortran-minimum-statement-indent 0))
+(setq fortran-minimum-statement-indent 0))
-	    ((or (looking-at (concat "[ \t]*"
+((or (looking-at (concat "[ \t]*"
-				     (regexp-quote
+(regexp-quote
-				      fortran-continuation-string)))
+fortran-continuation-string)))
-		 (looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]"))
+(looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]"))
 (skip-chars-forward " \t")
 ;; Do not introduce extra whitespace into a broken string.
 (setq icol
 (if (fortran-is-in-string-p (point))
 6
 (+ icol fortran-continuation-indent))))
-	    (first-statement)
+(first-statement)
-	    ((and fortran-check-all-num-for-matching-do
+((and fortran-check-all-num-for-matching-do
-		  (looking-at "[ \t]*[0-9]+")
+(looking-at "[ \t]*[0-9]+")
-		  (fortran-check-for-matching-do))
+(fortran-check-for-matching-do))
-	     (setq icol (- icol fortran-do-indent)))
+(setq icol (- icol fortran-do-indent)))
-	    (t
+(t
-	     (skip-chars-forward " \t0-9")
+(skip-chars-forward " \t0-9")
-	     (cond ((looking-at "end[ \t]*\\(if\\|select\\|where\\)\\b")
+(cond ((looking-at "end[ \t]*\\(if\\|select\\|where\\)\\b")
-		    (setq icol (- icol fortran-if-indent)))
+(setq icol (- icol fortran-if-indent)))
-		   ((looking-at "else\\(if\\)?\\b")
+((looking-at "else\\(if\\)?\\b")
-		    (setq icol (- icol fortran-if-indent)))
+(setq icol (- icol fortran-if-indent)))
 ((looking-at "case[ \t]*\\((.*)\\|default\\>\\)")
-		    (setq icol (- icol fortran-if-indent)))
+(setq icol (- icol fortran-if-indent)))
-		   ((looking-at "\\(otherwise\\|else[ \t]*where\\)\\b")
+((looking-at "\\(otherwise\\|else[ \t]*where\\)\\b")
-		    (setq icol (- icol fortran-if-indent)))
+(setq icol (- icol fortran-if-indent)))
-		   ((and (looking-at "continue\\b")
+((and (looking-at "continue\\b")
-			 (fortran-check-for-matching-do))
+(fortran-check-for-matching-do))
-		    (setq icol (- icol fortran-do-indent)))
+(setq icol (- icol fortran-do-indent)))
-		   ((looking-at "end[ \t]*do\\b")
+((looking-at "end[ \t]*do\\b")
-		    (setq icol (- icol fortran-do-indent)))
+(setq icol (- icol fortran-do-indent)))
-		   ((looking-at "end[ \t]*\
+((looking-at "end[ \t]*\
 \\(structure\\|union\\|map\\|interface\\)\\b[ \t]*[^ \t=(a-z]")
-		    (setq icol (- icol fortran-structure-indent)))
+(setq icol (- icol fortran-structure-indent)))
-		   ((and (looking-at fortran-end-prog-re1)
+((and (looking-at fortran-end-prog-re1)
-			 (fortran-check-end-prog-re)
+(fortran-check-end-prog-re)
-			 (not (= icol fortran-minimum-statement-indent)))
+(not (= icol fortran-minimum-statement-indent)))
-		    (message "Warning: `end' not in column %d.  Probably\
+(message "Warning: `end' not in column %d.  Probably\
 an unclosed block." fortran-minimum-statement-indent))))))
 (max fortran-minimum-statement-indent icol)))
 (defun fortran-current-line-indentation ()
 For comment lines, returns indentation of the first
 non-indentation text within the comment."
 (save-excursion
 (beginning-of-line)
 (cond ((looking-at fortran-comment-line-start-skip)
-	   (goto-char (match-end 0))
+(goto-char (match-end 0))
-	   (skip-chars-forward
+(skip-chars-forward
-	    (if (stringp fortran-comment-indent-char)
+(if (stringp fortran-comment-indent-char)
-		fortran-comment-indent-char
+fortran-comment-indent-char
-	      (char-to-string fortran-comment-indent-char))))
+(char-to-string fortran-comment-indent-char))))
-	  ((or (looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]"))
+((or (looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]"))
-	   (goto-char (match-end 0)))
+(goto-char (match-end 0)))
-	  (t
+(t
-	   ;; Move past line number.
+;; Move past line number.
-	   (skip-chars-forward "[ \t0-9]")))
+(skip-chars-forward "[ \t0-9]")))
 ;; Move past whitespace.
 (skip-chars-forward " \t")
 (current-column)))
 (defun fortran-indent-to-column (col)
 non-whitespace character is a numbered line.
 4) A TAB followed by a digit indicates a continuation line."
 (save-excursion
 (beginning-of-line)
 (if (looking-at fortran-comment-line-start-skip)
-	(if fortran-comment-indent-style
+(if fortran-comment-indent-style
-	    (let* ((char (if (stringp fortran-comment-indent-char)
+(let* ((char (if (stringp fortran-comment-indent-char)
-			     (aref fortran-comment-indent-char 0)
+(aref fortran-comment-indent-char 0)
-			   fortran-comment-indent-char))
+fortran-comment-indent-char))
-		   (chars (string ?\s ?\t char)))
+(chars (string ?\s ?\t char)))
-	      (goto-char (match-end 0))
+(goto-char (match-end 0))
-	      (skip-chars-backward chars)
+(skip-chars-backward chars)
-	      (delete-region (point) (progn (skip-chars-forward chars)
+(delete-region (point) (progn (skip-chars-forward chars)
-					    (point)))
+(point)))
-	      (insert-char char (- col (current-column)))))
+(insert-char char (- col (current-column)))))
 (if (looking-at "\t[1-9]")
-	  (if indent-tabs-mode
+(if indent-tabs-mode
-	      (goto-char (match-end 0))
+(goto-char (match-end 0))
-	    (delete-char 2)
+(delete-char 2)
-	    (insert-char ?\s 5)
+(insert-char ?\s 5)
-	    (insert fortran-continuation-string))
+(insert fortran-continuation-string))
-	(if (looking-at " \\{5\\}[^ 0\n]")
+(if (looking-at " \\{5\\}[^ 0\n]")
-	    (if indent-tabs-mode
+(if indent-tabs-mode
-		(progn (delete-char 6)
+(progn (delete-char 6)
-		       (insert ?\t (fortran-numerical-continuation-char) 1))
+(insert ?\t (fortran-numerical-continuation-char) 1))
-	      (forward-char 6))
+(forward-char 6))
-	  (delete-horizontal-space)
+(delete-horizontal-space)
-	  ;; Put line number in columns 0-4, or
+;; Put line number in columns 0-4, or
 ;; continuation character in column 5.
-	  (cond ((eobp))
+(cond ((eobp))
-		((looking-at (regexp-quote fortran-continuation-string))
+((looking-at (regexp-quote fortran-continuation-string))
-		 (if indent-tabs-mode
+(if indent-tabs-mode
-		     (progn
+(progn
-		       (indent-to
+(indent-to
-			(if indent-tabs-mode
+(if indent-tabs-mode
-			    fortran-minimum-statement-indent-tab
+fortran-minimum-statement-indent-tab
-			  fortran-minimum-statement-indent-fixed))
+fortran-minimum-statement-indent-fixed))
-		       (delete-char 1)
+(delete-char 1)
-		       (insert-char (fortran-numerical-continuation-char) 1))
+(insert-char (fortran-numerical-continuation-char) 1))
-		   (indent-to 5)
+(indent-to 5)
-		   (forward-char 1)))
+(forward-char 1)))
-		((looking-at "[0-9]+")
+((looking-at "[0-9]+")
-		 (let ((extra-space (- 5 (- (match-end 0) (point)))))
+(let ((extra-space (- 5 (- (match-end 0) (point)))))
-		   (if (< extra-space 0)
+(if (< extra-space 0)
-		       (message "Warning: line number exceeds 5-digit limit.")
+(message "Warning: line number exceeds 5-digit limit.")
-		     (indent-to (min fortran-line-number-indent extra-space))))
+(indent-to (min fortran-line-number-indent extra-space))))
-		 (skip-chars-forward "0-9")))))
+(skip-chars-forward "0-9")))))
 ;; Point is now after any continuation character or line number.
 ;; Put body of statement where specified.
 (delete-horizontal-space)
 (indent-to col)
 ;; Indent any comment following code on the same line.
 Do not call if there is no line number."
 (save-excursion
 (beginning-of-line)
 (skip-chars-forward " \t")
 (and (<= (current-column) fortran-line-number-indent)
-	 (or (= (current-column) fortran-line-number-indent)
+(or (= (current-column) fortran-line-number-indent)
-	     (progn (skip-chars-forward "0-9")
+(progn (skip-chars-forward "0-9")
-		    (= (current-column) 5))))))
+(= (current-column) 5))))))
 (defun fortran-check-for-matching-do ()
 "When called from a numbered statement, return t if matching DO is found.
 Otherwise return nil."
 (let ((case-fold-search t)
-	charnum)
+charnum)
 (save-excursion
 (beginning-of-line)
 (when (looking-at "[ \t]*[0-9]+")
 (skip-chars-forward " \t")
-(skip-chars-forward "0")	; skip past leading zeros
+(skip-chars-forward "0")        ; skip past leading zeros
 (setq charnum
 (buffer-substring (point) (progn
 (skip-chars-forward "0-9")
 (point))))
 (beginning-of-line)
 If ALL is nil, only match comments that start in column > 0."
 ;; Hopefully at some point we can just use the line below!  -stef
 ;; (comment-search-forward (line-end-position) t))
 (when (or all comment-start-skip)
 (let ((pos (point))
-	  (css (if comment-start-skip
+(css (if comment-start-skip
-		   (concat fortran-comment-line-start-skip
+(concat fortran-comment-line-start-skip
-			   "\\|" comment-start-skip)
+"\\|" comment-start-skip)
-		 fortran-comment-line-start-skip)))
+fortran-comment-line-start-skip)))
 (when (re-search-forward css (line-end-position) t)
-	(if (and (or all (> (match-beginning 0) (line-beginning-position)))
+(if (and (or all (> (match-beginning 0) (line-beginning-position)))
-		 (or (save-match-data
+(or (save-match-data
-		       (not (fortran-is-in-string-p (match-beginning 0))))
+(not (fortran-is-in-string-p (match-beginning 0))))
-		     ;; Recurse for rest of line.
+;; Recurse for rest of line.
-		     (fortran-find-comment-start-skip all)))
+(fortran-find-comment-start-skip all)))
-	    (point)
+(point)
-	  (goto-char pos)
+(goto-char pos)
-	  nil)))))
+nil)))))
 ;; From: ralf@up3aud1.gwdg.de (Ralf Fassel)
 ;; Test if TAB format continuation lines work.
 (defun fortran-is-in-string-p (where)
 "Return non-nil if WHERE (a buffer position) is inside a Fortran string."
 (save-excursion
 (goto-char where)
 (cond
-((bolp) nil)			; bol is never inside a string
+((bolp) nil)                       ; bol is never inside a string
-((save-excursion			; comment lines too
+((save-excursion                   ; comment lines too
-	(beginning-of-line)
+(beginning-of-line)
-	(looking-at fortran-comment-line-start-skip)) nil)
+(looking-at fortran-comment-line-start-skip)) nil)
 (t (let ((parse-state '(0 nil nil nil nil nil 0))
-	      (quoted-comment-start (if comment-start
+(quoted-comment-start (if comment-start
-					(regexp-quote comment-start)))
+(regexp-quote comment-start)))
-	      (not-done t)
+(not-done t)
-	      parse-limit end-of-line)
+parse-limit end-of-line)
-	  ;; Move to start of current statement.
+;; Move to start of current statement.
-	  (fortran-next-statement)
+(fortran-next-statement)
-	  (fortran-previous-statement)
+(fortran-previous-statement)
-	  ;; Now parse up to WHERE.
+;; Now parse up to WHERE.
-	  (while not-done
+(while not-done
-	    (if (or ;; Skip to next line if:
+(if (or ;; Skip to next line if:
-		 ;; - comment line?
+;; - comment line?
-		 (looking-at fortran-comment-line-start-skip)
+(looking-at fortran-comment-line-start-skip)
-		 ;; - at end of line?
+;; - at end of line?
-		 (eolp)
+(eolp)
-		 ;; - not in a string and after comment-start?
+;; - not in a string and after comment-start?
-		 (and (not (nth 3 parse-state))
+(and (not (nth 3 parse-state))
-		      comment-start
+comment-start
-		      (equal comment-start
+(equal comment-start
-			     (char-to-string (preceding-char)))))
+(char-to-string (preceding-char)))))
-		(if (> (forward-line) 0)
+(if (> (forward-line) 0)
-		    (setq not-done nil))
+(setq not-done nil))
-	      ;; else:
+;; else:
-	      ;; If we are at beginning of code line, skip any
+;; If we are at beginning of code line, skip any
-	      ;; whitespace, labels and tab continuation markers.
+;; whitespace, labels and tab continuation markers.
-	      (if (bolp) (skip-chars-forward " \t0-9"))
+(if (bolp) (skip-chars-forward " \t0-9"))
-	      ;; If we are in column <= 5 now, check for continuation char.
+;; If we are in column <= 5 now, check for continuation char.
-	      (cond ((= 5 (current-column)) (forward-char 1))
+(cond ((= 5 (current-column)) (forward-char 1))
-		    ((and (< (current-column) 5)
+((and (< (current-column) 5)
-			  (equal fortran-continuation-string
+(equal fortran-continuation-string
-				 (char-to-string (following-char)))
+(char-to-string (following-char)))
-			  (forward-char 1))))
+(forward-char 1))))
-	      ;; Find out parse-limit from here.
+;; Find out parse-limit from here.
-	      (setq end-of-line (line-end-position))
+(setq end-of-line (line-end-position))
-	      (setq parse-limit (min where end-of-line))
+(setq parse-limit (min where end-of-line))
-	      ;; Parse max up to comment-start, if non-nil and in current line.
+;; Parse max up to comment-start, if non-nil and in current line.
-	      (if comment-start
+(if comment-start
-		  (save-excursion
+(save-excursion
-		    (if (re-search-forward quoted-comment-start end-of-line t)
+(if (re-search-forward quoted-comment-start end-of-line t)
-			(setq parse-limit (min (point) parse-limit)))))
+(setq parse-limit (min (point) parse-limit)))))
-	      ;; Now parse if still in limits.
+;; Now parse if still in limits.
-	      (if (< (point) where)
+(if (< (point) where)
-		  (setq parse-state (parse-partial-sexp
+(setq parse-state (parse-partial-sexp
-				     (point) parse-limit nil nil parse-state))
+(point) parse-limit nil nil parse-state))
-		(setq not-done nil))))
+(setq not-done nil))))
-	  ;; Result.
+;; Result.
-	  (nth 3 parse-state))))))
+(nth 3 parse-state))))))
 ;; From old version.
 (defalias 'fortran-auto-fill-mode 'auto-fill-mode)
 (defun fortran-fill ()
 "Fill the current line at an appropriate point(s)."
 (let* ((auto-fill-function #'fortran-auto-fill)
-	 (opoint (point))
+(opoint (point))
-	 (bol (line-beginning-position))
+(bol (line-beginning-position))
-	 (eol (line-end-position))
+(eol (line-end-position))
-	 (bos (min eol (+ bol (fortran-current-line-indentation))))
+(bos (min eol (+ bol (fortran-current-line-indentation))))
 ;; If in a string at fill-column, break it either before the
 ;; initial quote, or at fill-col (if string is too long).
-	 (quote
+(quote
-	  (save-excursion
+(save-excursion
-	    (goto-char bol)
+(goto-char bol)
-	    ;; OK to break quotes on comment lines.
+;; OK to break quotes on comment lines.
-	    (unless (looking-at fortran-comment-line-start-skip)
+(unless (looking-at fortran-comment-line-start-skip)
 (let (fcpoint start)
 (move-to-column fill-column)
 (when (fortran-is-in-string-p (setq fcpoint (point)))
 (save-excursion
 (re-search-backward "\\S\"\\s\"\\S\"?" bol t)
 ;; infinite loop).
 (if (> (- (point) start)
 (- fill-column 6 fortran-continuation-indent))
 fcpoint
 start))))))
-	 ;; Decide where to split the line. If a position for a quoted
+;; Decide where to split the line. If a position for a quoted
-	 ;; string was found above then use that, else break the line
+;; string was found above then use that, else break the line
-	 ;; before/after the last delimiter.
+;; before/after the last delimiter.
-	 (fill-point
+(fill-point
-	  (or quote
+(or quote
-	      (save-excursion
+(save-excursion
 ;; If f-b-b-d is t, have an extra column to play with,
 ;; since delimiter gets shifted to new line.
 (move-to-column (if fortran-break-before-delimiters
 (1+ fill-column)
 fill-column))
 (forward-char 1))
 (backward-char)
 (or (looking-at fortran-no-break-re)
 (forward-char)))))
 ;; Line indented beyond fill-column?
-		(when (<= (point) bos)
+(when (<= (point) bos)
 (move-to-column (1+ fill-column))
 ;; What is this doing???
 (or (re-search-forward "[\t\n,'+-/*)=]" eol t)
 (goto-char bol)))
-		(if (bolp)
+(if (bolp)
-		    (re-search-forward "[ \t]" opoint t))
+(re-search-forward "[ \t]" opoint t))
 (point)))))
 ;; If we are in an in-line comment, don't break unless the
 ;; line of code is longer than it should be. Otherwise
 ;; break the line at the column computed above.
 ;;
 ;; Need to use fortran-find-comment-start-skip to make sure that
 ;; quoted !'s don't prevent a break.
 (when (and (save-excursion
-		 (beginning-of-line)
+(beginning-of-line)
-		 (if (not (fortran-find-comment-start-skip))
+(if (not (fortran-find-comment-start-skip))
 t
-		   (goto-char (match-beginning 0))
+(goto-char (match-beginning 0))
-		   (>= (point) fill-point)))
+(>= (point) fill-point)))
-	       (save-excursion
+(save-excursion
-		 (goto-char fill-point)
+(goto-char fill-point)
-		 (not (bolp)))
+(not (bolp)))
-	       (> (save-excursion
+(> (save-excursion
-		    (goto-char opoint)
+(goto-char opoint)
-		    (current-column))
+(current-column))
-		  (min (1+ fill-column)
+(min (1+ fill-column)
-		       (+ (fortran-calculate-indent)
+(+ (fortran-calculate-indent)
-			  fortran-continuation-indent))))
+fortran-continuation-indent))))
 (goto-char fill-point)
 (fortran-break-line)
 (end-of-line))))
 (defun fortran-break-line ()
 "Call `fortran-split-line'.  Joins continuation lines first, then refills."
 (let ((bol (line-beginning-position))
-	(comment-string
+(comment-string
-	 (save-excursion
+(save-excursion
-	   (if (fortran-find-comment-start-skip)
+(if (fortran-find-comment-start-skip)
-	       (delete-and-extract-region
+(delete-and-extract-region
-		(match-beginning 0) (line-end-position))))))
+(match-beginning 0) (line-end-position))))))
 ;; Forward line 1 really needs to go to next non white line.
 (if (save-excursion (forward-line)
-			(looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]"))
+(looking-at " \\{5\\}[^ 0\n]\\|\t[1-9]"))
-	(progn
+(progn
-	  (end-of-line)
+(end-of-line)
-	  (delete-region (point) (match-end 0))
+(delete-region (point) (match-end 0))
-	  (delete-horizontal-space)
+(delete-horizontal-space)
-	  (fortran-fill))
+(fortran-fill))
 (fortran-split-line))
 (if comment-string
-	(save-excursion
+(save-excursion
-	  (goto-char bol)
+(goto-char bol)
-	  (end-of-line)
+(end-of-line)
-	  (delete-horizontal-space)
+(delete-horizontal-space)
-	  (indent-to (fortran-comment-indent))
+(indent-to (fortran-comment-indent))
-	  (insert comment-string)))))
+(insert comment-string)))))
 (defun fortran-analyze-file-format ()
 "Return nil if fixed format is used, t if TAB formatting is used.
 Use `fortran-tab-mode-default' if no non-comment statements are found
 before the end or in the first `fortran-analyze-depth' lines."
 (let ((i 0))
 (save-excursion
 (goto-char (point-min))
 (while (not (or
-		   (eobp)
+(eobp)
-		   (eq (char-after) ?\t)
+(eq (char-after) ?\t)
-		   (looking-at " \\{6\\}")
+(looking-at " \\{6\\}")
-		   (> i fortran-analyze-depth)))
+(> i fortran-analyze-depth)))
-	(forward-line)
+(forward-line)
-	(setq i (1+ i)))
+(setq i (1+ i)))
 (cond
 ((eq (char-after) ?\t) t)
 ((looking-at " \\{6\\}") nil)
 (t fortran-tab-mode-default)))))
 (defun fortran-current-defun ()
 "Function to use for `add-log-current-defun-function' in Fortran mode."
 (save-excursion
 ;; We must be inside function body for this to work.
 (fortran-beginning-of-subprogram)
-(let ((case-fold-search t))		; case-insensitive
+(let ((case-fold-search t))         ; case-insensitive
 ;; Search for fortran subprogram start.
 (if (re-search-forward
 (concat "^[ \t]*\\(program\\|subroutine\\|function"
 "\\|[ \ta-z0-9*()]*[ \t]+function\\|"
 "\\(block[ \t]*data\\)\\)")

Mercurial > emacs

comparison lisp/progmodes/fortran.el @ 85579:fb34ccab73f6