:group 'f90)
(defconst f90-xemacs-flag (string-match "XEmacs\\|Lucid" emacs-version)
- "Non-nil means f90-mode thinks it is running under XEmacs.")
+ "Non-nil means F90 mode thinks it is running under XEmacs.")
(defconst f90-keywords-re
(regexp-opt '("allocatable" "allocate" "assign" "assignment" "backspace"
(defconst f90-hpf-keywords-re
(regexp-opt
- ;; Intrinsic procedures
+ ;; Intrinsic procedures.
'("all_prefix" "all_scatter" "all_suffix" "any_prefix"
"any_scatter" "any_suffix" "copy_prefix" "copy_scatter"
"copy_suffix" "count_prefix" "count_scatter" "count_suffix"
"parity_prefix" "parity_scatter" "parity_suffix" "popcnt" "poppar"
"processors_shape" "product_prefix" "product_scatter"
"product_suffix" "sum_prefix" "sum_scatter" "sum_suffix"
- ;; Directives
+ ;; Directives.
"align" "distribute" "dynamic" "independent" "inherit" "processors"
"realign" "redistribute" "template"
- ;; Keywords
+ ;; Keywords.
"block" "cyclic" "extrinsic" "new" "onto" "pure" "with") 'words)
"Regexp for all HPF keywords, procedures and directives.")
-;; Highlighting patterns
+;; Highlighting patterns.
(defvar f90-font-lock-keywords-1
(list
- ;; Special highlighting of "module procedure foo-list"
+ ;; Special highlighting of "module procedure".
'("\\<\\(module[ \t]*procedure\\)\\>" (1 font-lock-keyword-face))
- ;; Highlight definition of new type
+ ;; Highlight declaration of derived type.
;;; '("\\<\\(type\\)[ \t]*\\(.*::[ \t]*\\|[ \t]+\\)\\(\\sw+\\)"
;;; (1 font-lock-keyword-face) (3 font-lock-function-name-face))
;; Other functions and declarations.
(append
f90-font-lock-keywords-1
(list
- ;; Variable declarations (avoid the real function call)
+ ;; Variable declarations (avoid the real function call).
'("^[ \t0-9]*\\(real\\|integer\\|c\\(haracter\\|omplex\\)\\|\
logical\\|type[ \t]*(\\sw+)\\)\\(.*::\\|[ \t]*(.*)\\)?\\([^!\n]*\\)"
(1 font-lock-type-face t) (4 font-lock-variable-name-face))
- ;; do, if, select, where, and forall constructs
+ ;; do, if, select, where, and forall constructs.
'("\\<\\(end[ \t]*\\(do\\|if\\|select\\|forall\\|where\\)\\)\\>\
\\([ \t]+\\(\\sw+\\)\\)?"
(1 font-lock-keyword-face) (3 font-lock-constant-face nil t))
'("^[ \t0-9]*\\(\\(\\sw+\\)[ \t]*:[ \t]*\\)?\\(\\(if\\|\
do\\([ \t]*while\\)?\\|select[ \t]*case\\|where\\|forall\\)\\)\\>"
(2 font-lock-constant-face nil t) (3 font-lock-keyword-face))
- ;; implicit declaration
+ ;; Implicit declaration.
'("\\<\\(implicit\\)[ \t]*\\(real\\|integer\\|c\\(haracter\\|omplex\\)\
\\|logical\\|type[ \t]*(\\sw+)\\|none\\)\\>"
(1 font-lock-keyword-face) (2 font-lock-type-face))
f90-keywords-level-3-re
f90-operators-re
(list f90-procedures-re '(1 font-lock-keyword-face keep))
- "\\<real\\>" ; Avoid overwriting real defs.
+ "\\<real\\>" ; avoid overwriting real defs
))
"Highlights all F90 keywords and intrinsic procedures.")
f90-font-lock-keywords-2
"*Default expressions to highlight in F90 mode.")
-;; syntax table
+
(defvar f90-mode-syntax-table nil
"Syntax table in use in F90 mode buffers.")
(unless f90-mode-syntax-table
(setq f90-mode-syntax-table (make-syntax-table))
- (modify-syntax-entry ?\! "<" f90-mode-syntax-table) ; beg. comment
- (modify-syntax-entry ?\n ">" f90-mode-syntax-table) ; end comment
- (modify-syntax-entry ?_ "w" f90-mode-syntax-table) ; underscore in names
+ (modify-syntax-entry ?\! "<" f90-mode-syntax-table) ; begin comment
+ (modify-syntax-entry ?\n ">" f90-mode-syntax-table) ; end comment
+ (modify-syntax-entry ?_ "w" f90-mode-syntax-table) ; underscore in names
(modify-syntax-entry ?\' "\"" f90-mode-syntax-table) ; string quote
(modify-syntax-entry ?\" "\"" f90-mode-syntax-table) ; string quote
- (modify-syntax-entry ?\` "w" f90-mode-syntax-table) ; for abbrevs
- (modify-syntax-entry ?\r " " f90-mode-syntax-table) ; return is whitespace
- (modify-syntax-entry ?+ "." f90-mode-syntax-table)
- (modify-syntax-entry ?- "." f90-mode-syntax-table)
- (modify-syntax-entry ?= "." f90-mode-syntax-table)
- (modify-syntax-entry ?* "." f90-mode-syntax-table)
- (modify-syntax-entry ?/ "." f90-mode-syntax-table)
+ (modify-syntax-entry ?\` "w" f90-mode-syntax-table) ; for abbrevs
+ (modify-syntax-entry ?\r " " f90-mode-syntax-table) ; return is whitespace
+ (modify-syntax-entry ?+ "." f90-mode-syntax-table) ; punctuation
+ (modify-syntax-entry ?- "." f90-mode-syntax-table)
+ (modify-syntax-entry ?= "." f90-mode-syntax-table)
+ (modify-syntax-entry ?* "." f90-mode-syntax-table)
+ (modify-syntax-entry ?/ "." f90-mode-syntax-table)
(modify-syntax-entry ?\\ "\\" f90-mode-syntax-table)) ; escape chars
-;; keys
+
(defvar f90-mode-map ()
"Keymap used in F90 mode.")
(define-key f90-mode-map "\C-j" 'f90-indent-new-line) ; LFD equals C-j
(define-key f90-mode-map "\r" 'newline)
(define-key f90-mode-map "\C-c\r" 'f90-break-line)
- ;; (define-key f90-mode-map [M-return] 'f90-break-line)
+;;; (define-key f90-mode-map [M-return] 'f90-break-line)
(define-key f90-mode-map "\C-c\C-d" 'f90-join-lines)
(define-key f90-mode-map "\C-c\C-f" 'f90-fill-region)
(define-key f90-mode-map "\C-c\C-p" 'f90-previous-statement)
(define-key f90-mode-map "/" 'f90-electric-insert))
-;; menus
(if f90-xemacs-flag
(defvar f90-xemacs-menu
'("F90"
["Insert Block End" f90-insert-end t]
"-----"
["Upcase Keywords (buffer)" f90-upcase-keywords t]
- ["Upcase Keywords (region)" f90-upcase-region-keywords
- t]
+ ["Upcase Keywords (region)" f90-upcase-region-keywords t]
["Capitalize Keywords (buffer)" f90-capitalize-keywords t]
- ["Capitalize Keywords (region)"
- f90-capitalize-region-keywords t]
+ ["Capitalize Keywords (region)" f90-capitalize-region-keywords t]
["Downcase Keywords (buffer)" f90-downcase-keywords t]
- ["Downcase Keywords (region)"
- f90-downcase-region-keywords t]
+ ["Downcase Keywords (region)" f90-downcase-region-keywords t]
"-----"
- ["Toggle abbrev-mode" abbrev-mode t]
- ["Toggle auto-fill" auto-fill-mode t])
+ ["Toggle abbrev-mode" abbrev-mode t]
+ ["Toggle auto-fill" auto-fill-mode t])
"XEmacs menu for F90 mode.")
- ;; Emacs
+ ;; Emacs.
(defvar f90-change-case-menu
(let ((map (make-sparse-keymap "Change Keyword Case")))
- (define-key map [dkr] (cons "Downcase Keywords (region)"
- 'f90-downcase-region-keywords))
+ (define-key map [dkr]
+ (cons "Downcase Keywords (region)" 'f90-downcase-region-keywords))
(put 'f90-downcase-region-keywords 'menu-enable 'mark-active)
- (define-key map [ckr] (cons "Capitalize Keywords (region)"
- 'f90-capitalize-region-keywords))
+ (define-key map [ckr]
+ (cons "Capitalize Keywords (region)" 'f90-capitalize-region-keywords))
(put 'f90-capitalize-region-keywords 'menu-enable 'mark-active)
- (define-key map [ukr] (cons "Upcase Keywords (region)"
- 'f90-upcase-region-keywords))
+ (define-key map [ukr]
+ (cons "Upcase Keywords (region)" 'f90-upcase-region-keywords))
(put 'f90-upcase-region-keywords 'menu-enable 'mark-active)
(define-key map [line] (list "-----------------"))
- (define-key map [dkb] (cons "Downcase Keywords (buffer)"
- 'f90-downcase-keywords))
- (define-key map [ckb] (cons "Capitalize Keywords (buffer)"
- 'f90-capitalize-keywords))
- (define-key map [ukb] (cons "Upcase Keywords (buffer)"
- 'f90-upcase-keywords))
+ (define-key map [dkb]
+ (cons "Downcase Keywords (buffer)" 'f90-downcase-keywords))
+ (define-key map [ckb]
+ (cons "Capitalize Keywords (buffer)" 'f90-capitalize-keywords))
+ (define-key map [ukb]
+ (cons "Upcase Keywords (buffer)" 'f90-upcase-keywords))
map)
"Submenu for change of case.")
(defalias 'f90-change-case-menu f90-change-case-menu)
- ;; font-lock-menu and function calls
+ ;; Font-lock-menu and function calls.
(defalias 'f90-font-lock-on 'font-lock-mode)
(defalias 'f90-font-lock-off 'font-lock-mode)
(put 'f90-font-lock-on 'menu-enable 'font-lock-mode)
(defvar f90-font-lock-menu
(let ((map (make-sparse-keymap "f90-font-lock-menu")))
- (define-key map [h4] (cons "Maximum highlighting (level 4)"
- 'f90-font-lock-4))
- (define-key map [h3] (cons "Heavy highlighting (level 3)"
- 'f90-font-lock-3))
- (define-key map [h2] (cons "Default highlighting (level 2)"
- 'f90-font-lock-2))
- (define-key map [h1] (cons "Light highlighting (level 1)"
- 'f90-font-lock-1))
+ (define-key map [h4]
+ (cons "Maximum highlighting (level 4)" 'f90-font-lock-4))
+ (define-key map [h3]
+ (cons "Heavy highlighting (level 3)" 'f90-font-lock-3))
+ (define-key map [h2]
+ (cons "Default highlighting (level 2)" 'f90-font-lock-2))
+ (define-key map [h1]
+ (cons "Light highlighting (level 1)" 'f90-font-lock-1))
(define-key map [line] (list "-----------------"))
- (define-key map [floff] (cons "Turn off font-lock-mode"
- 'f90-font-lock-on))
- (define-key map [flon] (cons "Turn on font-lock-mode"
- 'f90-font-lock-off))
+ (define-key map [floff]
+ (cons "Turn off font-lock-mode" 'f90-font-lock-on))
+ (define-key map [flon]
+ (cons "Turn on font-lock-mode" 'f90-font-lock-off))
map)
"Submenu for highlighting using font-lock-mode.")
+
(defalias 'f90-font-lock-menu f90-font-lock-menu)
(define-key f90-mode-map [menu-bar] (make-sparse-keymap))
'("Toggle abbrev-mode" . abbrev-mode))
(define-key f90-mode-map [menu-bar f90 auto-fill-mode]
'("Toggle auto-fill" . auto-fill-mode))
- (define-key f90-mode-map [menu-bar f90 line1]
- '("----"))
+ (define-key f90-mode-map [menu-bar f90 line1] '("----"))
(define-key f90-mode-map [menu-bar f90 f90-change-case-menu]
(cons "Change Keyword Case" 'f90-change-case-menu))
(define-key f90-mode-map [menu-bar f90 f90-font-lock-menu]
(cons "Highlighting" 'f90-font-lock-menu))
- (define-key f90-mode-map [menu-bar f90 line2]
- '("----"))
+ (define-key f90-mode-map [menu-bar f90 line2] '("----"))
(define-key f90-mode-map [menu-bar f90 f90-insert-end]
'("Insert Block End" . f90-insert-end))
(define-key f90-mode-map [menu-bar f90 f90-join-lines]
'("Join with Next Line" . f90-join-lines))
(define-key f90-mode-map [menu-bar f90 f90-break-line]
'("Break Line at Point" . f90-break-line))
- (define-key f90-mode-map [menu-bar f90 line3]
- '("----"))
+ (define-key f90-mode-map [menu-bar f90 line3] '("----"))
(define-key f90-mode-map [menu-bar f90 f90-fill-region]
'("Fill Region" . f90-fill-region))
(put 'f90-fill-region 'menu-enable 'mark-active)
(define-key f90-mode-map [menu-bar f90 f90-comment-region]
'("(Un)Comment Region" . f90-comment-region))
(put 'f90-comment-region 'menu-enable 'mark-active)
- (define-key f90-mode-map [menu-bar f90 line4]
- '("----"))
+ (define-key f90-mode-map [menu-bar f90 line4] '("----"))
(define-key f90-mode-map [menu-bar f90 f90-end-of-subprogram]
'("End of Subprogram" . f90-end-of-subprogram))
(define-key f90-mode-map [menu-bar f90 f90-beginning-of-subprogram]
;; Regexps for finding program structures.
(defconst f90-blocks-re
- "\\(block[ \t]*data\\|do\\|if\\|interface\\|function\\|module\\|\
-program\\|select\\|subroutine\\|type\\|where\\|forall\\)\\>")
+ (concat "\\(block[ \t]*data\\|"
+ (regexp-opt '("do" "if" "interface" "function" "module" "program"
+ "select" "subroutine" "type" "where" "forall"))
+ "\\)\\>")
+ "Regexp potentially indicating a \"block\" of F90 code.")
+
(defconst f90-program-block-re
- "\\(program\\|module\\|subroutine\\|function\\)")
+ (regexp-opt '("program" "module" "subroutine" "function") 'paren)
+ "Regexp used to locate the start/end of a \"subprogram\".")
+
(defconst f90-else-like-re
- "\\(else\\([ \t]*if\\|where\\)?\\|case[ \t]*\\(default\\|(\\)\\)")
+ "\\(else\\([ \t]*if\\|where\\)?\\|case[ \t]*\\(default\\|(\\)\\)"
+ "Regexp matching an ELSE IF, ELSEWHERE, CASE statement.")
+
(defconst f90-end-if-re
- "end[ \t]*\\(if\\|select\\|where\\|forall\\)\\>")
+ (concat "end[ \t]*"
+ (regexp-opt '("if" "select" "where" "forall") 'paren)
+ "\\>")
+ "Regexp matching the end of an IF, SELECT, WHERE, FORALL block.")
+
(defconst f90-end-type-re
- "end[ \t]*\\(type\\|interface\\|block[ \t]*data\\)")
+ "end[ \t]*\\(type\\|interface\\|block[ \t]*data\\)\\>"
+ "Regexp matching the end of a TYPE, INTERFACE, BLOCK DATA section.")
+
(defconst f90-type-def-re
- "\\<\\(type\\)\\([^(\n]*\\)\\(::\\)?[ \t]*\\b\\(\\sw+\\)")
-(defconst f90-no-break-re "\\(\\*\\*\\|//\\|=>\\)")
-;; A temporary position to make region operators faster
-(defvar f90-cache-position nil)
+ "\\<\\(type\\)\\([^(\n]*\\)\\(::\\)?[ \t]*\\b\\(\\sw+\\)"
+ "Regexp matching the declaration of a variable of derived type.")
+
+(defconst f90-no-break-re
+ (regexp-opt '("**" "//" "=>") 'paren)
+ "Regexp specifying where not to break lines when filling.")
+
+(defvar f90-cache-position nil
+ "Temporary position used to speed up region operations.")
(make-variable-buffer-local 'f90-cache-position)
-;; A flag to tell whether f90-imenu is turned on.
-(defvar f90-imenu nil)
-(make-variable-buffer-local 'f90-imenu)
+
+(defvar f90-imenu-flag nil
+ "Non-nil means this buffer already has an imenu.")
+(make-variable-buffer-local 'f90-imenu-flag)
\f
-;; Imenu support
+;; Imenu support.
(defvar f90-imenu-generic-expression
(let ((good-char "[^!\"\&\n \t]") (not-e "[^e!\n\"\& \t]")
(not-n "[^n!\n\"\& \t]") (not-d "[^d!\n\"\& \t]"))
(concat
"^[ \t0-9]*"
"\\("
- ;; At least three non-space characters before function/subroutine
- ;; Check that the last three non-space characters don't spell E N D
+ ;; At least three non-space characters before function/subroutine.
+ ;; Check that the last three non-space characters do not spell E N D.
"[^!\"\&\n]*\\("
not-e good-char good-char "\\|"
good-char not-n good-char "\\|"
good-char good-char not-d "\\)"
"\\|"
- ;; Less than three non-space characters before function/subroutine
+ ;; Less than three non-space characters before function/subroutine.
good-char "?" good-char "?"
"\\)"
"[ \t]*\\(function\\|subroutine\\)[ \t]+\\(\\sw+\\)")
(defun f90-add-imenu-menu ()
"Add an imenu menu to the menubar."
(interactive)
- (if f90-imenu
+ (if f90-imenu-flag
(message "%s" "F90-imenu already exists.")
(imenu-add-to-menubar "F90-imenu")
(redraw-frame (selected-frame))
- (setq f90-imenu t)))
+ (setq f90-imenu-flag t)))
-(put 'f90-add-imenu-menu 'menu-enable '(not f90-imenu))
+(put 'f90-add-imenu-menu 'menu-enable '(not f90-imenu-flag))
-;; When compiling under GNU Emacs, load imenu during compilation. If
-;; you have 19.22 or earlier, comment this out, or get imenu.
+;; When compiling under GNU Emacs, load imenu during compilation.
+;; If you have 19.22 or earlier, comment this out, or get imenu.
(or f90-xemacs-flag (eval-when-compile (require 'imenu)))
\f
-;; abbrevs have generally two letters, except standard types `c, `i, `r, `t
+;; Abbrevs have generally two letters, except standard types `c, `i, `r, `t.
(defvar f90-mode-abbrev-table nil)
(unless f90-mode-abbrev-table
(let ((ac abbrevs-changed))
(setq abbrevs-changed ac)))
\f
(defcustom f90-mode-hook nil
- "Hook run by F90 mode."
+ "Hook run when entering F90 mode."
:type 'hook
:options '(f90-add-imenu-menu)
:group 'f90)
(defun f90-mode ()
"Major mode for editing Fortran 90,95 code in free format.
-\\[f90-indent-new-line] corrects current indentation and creates new\
+\\[f90-indent-new-line] indents current line and creates a new\
indented line.
-\\[f90-indent-line] indents the current line correctly.
+\\[f90-indent-line] indents the current line.
\\[f90-indent-subprogram] indents the current subprogram.
Type `? or `\\[help-command] to display a list of built-in\
Variables controlling indentation style and extra features:
- `f90-do-indent'
- Extra indentation within do blocks. (default 3)
- `f90-if-indent'
- Extra indentation within if/select case/where/forall blocks. (default 3)
- `f90-type-indent'
- Extra indentation within type/interface/block-data blocks. (default 3)
- `f90-program-indent'
- Extra indentation within program/module/subroutine/function blocks.
- (default 2)
- `f90-continuation-indent'
- Extra indentation applied to continuation lines. (default 5)
- `f90-comment-region'
- String inserted by \\[f90-comment-region] at start of each line in
- region. (default \"!!!$\")
- `f90-indented-comment-re'
- Regexp determining the type of comment to be intended like code.
- (default \"!\")
- `f90-directive-comment-re'
- Regexp of comment-like directive like \"!HPF\\\\$\", not to be indented.
- (default \"!hpf\\\\$\")
- `f90-break-delimiters'
- Regexp holding list of delimiters at which lines may be broken.
- (default \"[-+*/><=,% \\t]\")
- `f90-break-before-delimiters'
- Non-nil causes `f90-do-auto-fill' to break lines before delimiters.
- (default t)
- `f90-beginning-ampersand'
- Automatic insertion of \& at beginning of continuation lines. (default t)
- `f90-smart-end'
- From an END statement, check and fill the end using matching block start.
- Allowed values are 'blink, 'no-blink, and nil, which determine
- whether to blink the matching beginning. (default 'blink)
- `f90-auto-keyword-case'
- Automatic change of case of keywords. (default nil)
- The possibilities are 'downcase-word, 'upcase-word, 'capitalize-word.
- `f90-leave-line-no'
- Do not left-justify line numbers. (default nil)
- `f90-keywords-re'
- List of keywords used for highlighting/upcase-keywords etc.
+`f90-do-indent'
+ Extra indentation within do blocks (default 3).
+`f90-if-indent'
+ Extra indentation within if/select case/where/forall blocks (default 3).
+`f90-type-indent'
+ Extra indentation within type/interface/block-data blocks (default 3).
+`f90-program-indent'
+ Extra indentation within program/module/subroutine/function blocks
+ (default 2).
+`f90-continuation-indent'
+ Extra indentation applied to continuation lines (default 5).
+`f90-comment-region'
+ String inserted by \\[f90-comment-region] at start of each line in
+ region (default \"!!!$\").
+`f90-indented-comment-re'
+ Regexp determining the type of comment to be intended like code
+ (default \"!\").
+`f90-directive-comment-re'
+ Regexp of comment-like directive like \"!HPF\\\\$\", not to be indented
+ (default \"!hpf\\\\$\").
+`f90-break-delimiters'
+ Regexp holding list of delimiters at which lines may be broken
+ (default \"[-+*/><=,% \\t]\").
+`f90-break-before-delimiters'
+ Non-nil causes `f90-do-auto-fill' to break lines before delimiters
+ (default t).
+`f90-beginning-ampersand'
+ Automatic insertion of \& at beginning of continuation lines (default t).
+`f90-smart-end'
+ From an END statement, check and fill the end using matching block start.
+ Allowed values are 'blink, 'no-blink, and nil, which determine
+ whether to blink the matching beginning (default 'blink).
+`f90-auto-keyword-case'
+ Automatic change of case of keywords (default nil).
+ The possibilities are 'downcase-word, 'upcase-word, 'capitalize-word.
+`f90-leave-line-no'
+ Do not left-justify line numbers (default nil).
+`f90-keywords-re'
+ List of keywords used for highlighting/upcase-keywords etc.
Turning on F90 mode calls the value of the variable `f90-mode-hook'
with no args, if that value is non-nil."
(make-local-variable 'normal-auto-fill-function)
(setq normal-auto-fill-function 'f90-do-auto-fill)
(setq indent-tabs-mode nil)
- ;; Setting up things for font-lock
+ ;; Setting up things for font-lock.
(when f90-xemacs-flag
(put 'f90-mode 'font-lock-keywords-case-fold-search t)
(when (and (featurep 'menubar)
(not (assoc "F90" current-menubar)))
(set-buffer-menubar (copy-sequence current-menubar))
(add-submenu nil f90-xemacs-menu)))
- ;; XEmacs: (Don't need a special case, since both emacsen work alike -sb)
+ ;; XEmacs: Does not need a special case, since both emacsen work alike -sb.
(make-local-variable 'font-lock-defaults)
(setq font-lock-defaults
'((f90-font-lock-keywords f90-font-lock-keywords-1
(set (make-local-variable 'add-log-current-defun-function)
#'f90-current-defun)
(run-hooks 'f90-mode-hook))
+
\f
-;; inline-functions
+;; Inline-functions.
(defsubst f90-in-string ()
"Return non-nil if point is inside a string.
-Checks from point-min, or f90-cache-position, if that is non-nil
+Checks from `point-min', or `f90-cache-position', if that is non-nil
and lies before point."
(let ((beg-pnt
(if (and f90-cache-position (> (point) f90-cache-position))
(defsubst f90-in-comment ()
"Return non-nil if point is inside a comment.
-Checks from point-min, or f90-cache-position, if that is non-nil
+Checks from `point-min', or `f90-cache-position', if that is non-nil
and lies before point."
(let ((beg-pnt
(if (and f90-cache-position (> (point) f90-cache-position))
type)))
(defsubst f90-equal-symbols (a b)
- "Compare strings neglecting case and allowing for nil value."
+ "Compare strings A and B neglecting case and allowing for nil value."
(let ((a-local (if a (downcase a) nil))
(b-local (if b (downcase b) nil)))
(equal a-local b-local)))
-;; XEmacs 19.11 & 19.12 gives back a single char when matching an empty regular
-;; expression. Therefore, the next 2 functions are longer than necessary.
-
+;; XEmacs 19.11 & 19.12 return a single char when matching an empty regexp.
+;; The next 2 functions are therefore longer than necessary.
(defsubst f90-looking-at-do ()
"Return (\"do\" NAME) if a do statement starts after point.
NAME is nil if the statement has no label."
(list (match-string 1) (match-string 3))))
(defsubst f90-comment-indent ()
+ "Return the indentation to be used for a comment starting at point.
+Used for `comment-indent-function' by F90 mode.
+\"!!!\", `f90-directive-comment-re', variable `f90-comment-region' return 0.
+`f90-indented-comment-re' (if not trailing code) calls `f90-calculate-indent'.
+Any other type return `comment-column', leaving at least one space after code."
(cond ((looking-at "!!!") 0)
((and f90-directive-comment-re
(looking-at f90-directive-comment-re)) 0)
(goto-char pnt)
(beginning-of-line)
(cond ((looking-at "[ \t]*$"))
- ((looking-at "[ \t]*#") ; Check for cpp directive.
+ ((looking-at "[ \t]*#") ; check for cpp directive
(setq icol 0))
(t
(skip-chars-forward " \t0-9")
))))
icol))
\f
-;; Statement = statement line, a line which is neither blank, nor a comment.
(defun f90-previous-statement ()
"Move point to beginning of the previous F90 statement.
-Return nil if no previous statement is found."
+Return nil if no previous statement is found.
+A statement is a line which is neither blank nor a comment."
(interactive)
(let (not-first-statement)
(beginning-of-line)
(defun f90-beginning-of-subprogram ()
"Move point to the beginning of subprogram.
-Return (type name) or nil if not found."
+Return (TYPE NAME), or nil if not found."
(interactive)
(let ((count 1) (case-fold-search t) matching-beg)
(beginning-of-line) (skip-chars-forward " \t0-9")
(beginning-of-line)
(if (zerop count)
matching-beg
- (message "No beginning-found.")
+ (message "No beginning found.")
nil)))
(defun f90-end-of-subprogram ()
"Move point to the end of subprogram.
-Return (type name) or nil if not found."
+Return (TYPE NAME), or nil if not found."
(interactive)
(let ((count 1) (case-fold-search t) matching-end)
(beginning-of-line) (skip-chars-forward " \t0-9")
(interactive)
(let (indent (no-line-number nil) (pos (make-marker)) (case-fold-search t))
(set-marker pos (point))
- (beginning-of-line) ; Digits after & \n are not line-no
+ (beginning-of-line) ; digits after & \n are not line-nos
(if (save-excursion (and (f90-previous-statement) (f90-line-continued)))
(progn (setq no-line-number t) (skip-chars-forward " \t"))
(f90-indent-line-no))
(interactive)
(let (string cont (case-fold-search t))
(if abbrev-mode (expand-abbrev))
- (beginning-of-line) ; Reindent where likely to be needed.
+ (beginning-of-line) ; reindent where likely to be needed
(f90-indent-line-no)
- (if (or (looking-at "\\(end\\|else\\|!\\)"))
- (f90-indent-line 'no-update))
+ (f90-indent-line 'no-update)
(end-of-line)
- (delete-horizontal-space) ;Destroy trailing whitespace
+ (delete-horizontal-space) ; destroy trailing whitespace
(setq string (f90-in-string))
(setq cont (f90-line-continued))
(if (and string (not cont)) (insert "&"))
struct beg-struct end-struct)
(set-marker end-region-mark end-region)
(goto-char beg-region)
- ;; first find a line which is not a continuation line or comment
+ ;; First find a line which is not a continuation line or comment.
(beginning-of-line)
(while (and (looking-at "[ \t]*[0-9]*\\(!\\|#\\|[ \t]*$\\)")
(progn (f90-indent-line 'no-update)
(while (and (or (eq cont 'middle) (eq cont 'end))
(f90-previous-statement))
(setq cont (f90-present-statement-cont)))
- ;; process present line for beginning of block
+ ;; Process present line for beginning of block.
(setq f90-cache-position (point))
(f90-indent-line 'no-update)
(setq ind-lev (f90-current-indentation))
(if struct (setq block-list (cons struct block-list)))
(while (and (f90-line-continued) (zerop (forward-line 1))
(< (point) end-region-mark))
- (if (not (zerop (- (current-indentation)
- (+ ind-curr f90-continuation-indent))))
- (f90-indent-to (+ ind-curr f90-continuation-indent) 'no-line-no)))
- ;; process all following lines
+ (if (looking-at "[ \t]*!")
+ (f90-indent-to (f90-comment-indent))
+ (if (not (zerop (- (current-indentation)
+ (+ ind-curr f90-continuation-indent))))
+ (f90-indent-to (+ ind-curr f90-continuation-indent) 'no-line-no))))
+ ;; Process all following lines.
(while (and (zerop (forward-line 1)) (< (point) end-region-mark))
(beginning-of-line)
(f90-indent-line-no)
block-list (cdr block-list))
(if f90-smart-end
(save-excursion
- (f90-block-match (car beg-struct)(car (cdr beg-struct))
- (car end-struct)(car (cdr end-struct)))))
+ (f90-block-match (car beg-struct) (car (cdr beg-struct))
+ (car end-struct) (car (cdr end-struct)))))
(setq ind-b
(cond ((looking-at f90-end-if-re) f90-if-indent)
((looking-at "end[ \t]*do\\>") f90-do-indent)
(if ind-b (setq ind-lev (- ind-lev ind-b)))
(setq ind-curr ind-lev))
(t (setq ind-curr ind-lev)))
- ;; do the indentation if necessary
+ ;; Do the indentation if necessary.
(if (not (zerop (- ind-curr (current-column))))
(f90-indent-to ind-curr))
(while (and (f90-line-continued) (zerop (forward-line 1))
(< (point) end-region-mark))
- (if (not (zerop (- (current-indentation)
- (+ ind-curr f90-continuation-indent))))
- (f90-indent-to (+ ind-curr f90-continuation-indent) 'no-line-no))))
- ;; restore point etc
+ (if (looking-at "[ \t]*!")
+ (f90-indent-to (f90-comment-indent))
+ (if (not (zerop (- (current-indentation)
+ (+ ind-curr f90-continuation-indent))))
+ (f90-indent-to
+ (+ ind-curr f90-continuation-indent) 'no-line-no)))))
+ ;; Restore point, etc.
(setq f90-cache-position nil)
(goto-char save-point)
(set-marker end-region-mark nil)
(deactivate-mark))))
(defun f90-indent-subprogram ()
- "Properly indent the subprogram which contains point."
+ "Properly indent the subprogram containing point."
(interactive)
(save-excursion
(let (program)
(indent-region (point) (mark) nil)
(message "Indenting the whole file...done")))))
-;; autofill and break-line
(defun f90-break-line (&optional no-update)
"Break line at point, insert continuation marker(s) and indent.
Unless in a string or comment, or if the optional argument NO-UPDATE
"Break line if non-white characters beyond `fill-column'.
Update keyword case first."
(interactive)
- ;; Break the line before or after the last delimiter (non-word char) if
+ ;; Break line before or after last delimiter (non-word char) if
;; position is beyond fill-column.
- ;; Will not break **, //, or => (specified by f90-no-break-re).
+ ;; Will not break **, //, or => (as specified by f90-no-break-re).
(f90-update-line)
(while (> (current-column) fill-column)
(let ((pos-mark (point-marker)))
(set-marker end-region-mark end-region)
(goto-char beg-region)
(while go-on
- ;; join as much as possible
+ ;; Join as much as possible.
(while (f90-join-lines))
- ;; chop the line if necessary
+ ;; Chop the line if necessary.
(while (> (save-excursion (end-of-line) (current-column))
fill-column)
(move-to-column fill-column)
\f
(defun f90-block-match (beg-block beg-name end-block end-name)
"Match end-struct with beg-struct and complete end-block if possible.
+BEG-BLOCK is the type of block as indicated at the start (e.g., do).
+BEG-NAME is the block start name (may be nil).
+END-BLOCK is the type of block as indicated at the end (may be nil).
+END-NAME is the block end name (may be nil).
Leave point at the end of line."
(search-forward "end" (line-end-position))
(catch 'no-match
(if (not (looking-at "[ \t]*!")) (delete-horizontal-space))))
(defun f90-match-end ()
- "From an end foo statement, find the corresponding foo including name."
+ "From an end block statement, find the corresponding block and name."
(interactive)
(let ((count 1) (top-of-window (window-start)) (matching-beg nil)
(end-point (point)) (case-fold-search t)
(insert "end")
(f90-indent-new-line)))
\f
-;; abbrevs and keywords
+;; Abbrevs and keywords.
(defun f90-abbrev-start ()
"Typing `\\[help-command] or `? lists all the F90 abbrevs.
(setq c (read-event))
(setq e (next-command-event)
c (event-to-character e)))
- ;; insert char if not equal to `?'
+ ;; Insert char if not equal to `?'.
(if (or (eq c ??) (eq c help-char))
(f90-abbrev-help)
(if f90-xemacs-flag
(message "Listing abbrev table...done"))
(defun f90-prepare-abbrev-list-buffer ()
+ "Create a buffer listing the F90 mode abbreviations."
(save-excursion
(set-buffer (get-buffer-create "*Abbrevs*"))
(erase-buffer)
;; Change the keywords according to argument.
(defun f90-change-keywords (change-word &optional beg end)
+ "Change the case of F90 keywords in the region (if specified) or buffer.
+CHANGE-WORD should be one of 'upcase-word, 'downcase-word, capitalize-word."
(save-excursion
(setq beg (if beg beg (point-min)))
(setq end (if end end (point-max)))
(unless (progn
(setq state (parse-partial-sexp ref-point (point)))
(or (nth 3 state) (nth 4 state)
- (save-excursion ; Check for cpp directive.
+ (save-excursion ; check for cpp directive
(beginning-of-line)
(skip-chars-forward " \t0-9")
(looking-at "#"))))
projects / emacs.git / commitdiff