;;; ada-mode.el --- major-mode for editing Ada sources
-;; Copyright (C) 1994-1995, 1997-2011 Free Software Foundation, Inc.
+;; Copyright (C) 1994-1995, 1997-2015 Free Software Foundation, Inc.
;; Author: Rolf Ebert <ebert@inf.enst.fr>
;; Markus Heritsch <Markus.Heritsch@studbox.uni-stuttgart.de>
;; independent from the GNU Ada compiler GNAT, distributed by Ada
;; Core Technologies. All the other files rely heavily on features
;; provided only by GNAT.
-;;
-;; Note: this mode will not work with Emacs 19. If you are on a VMS
-;; system, where the latest version of Emacs is 19.28, you will need
-;; another file, called ada-vms.el, that provides some required
-;; functions.
;;; Usage:
;; Emacs should enter Ada mode automatically when you load an Ada file.
;; should be loaded before the ada-mode, which will then setup some variables
;; to improve the support for Ada code.
;; Here is the list of these modes:
-;; `which-function-mode': Display the name of the subprogram the cursor is
-;; in in the mode line.
+;; `which-function-mode': Display in the mode line the name of the subprogram
+;; the cursor is in.
;; `outline-mode': Provides the capability to collapse or expand the code
;; for specific language constructs, for instance if you want to hide the
;; code corresponding to a subprogram
(defvar ispell-check-comments)
(defvar skeleton-further-elements)
+(define-error 'ada-mode-errors nil)
+
(defun ada-mode-version ()
"Return Ada mode version."
(interactive)
version-string)))
(defvar ada-mode-hook nil
- "*List of functions to call when Ada mode is invoked.
+ "List of functions to call when Ada mode is invoked.
This hook is automatically executed after the `ada-mode' is
fully loaded.
This is a good place to add Ada environment specific bindings.")
(defgroup ada nil
"Major mode for editing and compiling Ada source in Emacs."
:link '(custom-group-link :tag "Font Lock Faces group" font-lock-faces)
+ :link '(custom-manual "(ada-mode) Top")
+ :link '(emacs-commentary-link :tag "Commentary" "ada-mode.el")
:group 'languages)
(defcustom ada-auto-case t
- "*Non-nil means automatically change case of preceding word while typing.
+ "Non-nil means automatically change case of preceding word while typing.
Casing is done according to `ada-case-keyword', `ada-case-identifier'
and `ada-case-attribute'."
:type 'boolean :group 'ada)
(defcustom ada-broken-decl-indent 0
- "*Number of columns to indent a broken declaration.
+ "Number of columns to indent a broken declaration.
An example is :
declare
:type 'integer :group 'ada)
(defcustom ada-broken-indent 2
- "*Number of columns to indent the continuation of a broken line.
+ "Number of columns to indent the continuation of a broken line.
An example is :
My_Var : My_Type := (Field1 =>
:type 'integer :group 'ada)
(defcustom ada-continuation-indent ada-broken-indent
- "*Number of columns to indent the continuation of broken lines in parenthesis.
+ "Number of columns to indent the continuation of broken lines in parenthesis.
An example is :
Func (Param1,
:type 'integer :group 'ada)
(defcustom ada-case-attribute 'ada-capitalize-word
- "*Function to call to adjust the case of Ada attributes.
+ "Function to call to adjust the case of Ada attributes.
It may be `downcase-word', `upcase-word', `ada-loose-case-word',
`ada-capitalize-word' or `ada-no-auto-case'."
:type '(choice (const downcase-word)
(defcustom ada-case-exception-file
(list (convert-standard-filename' "~/.emacs_case_exceptions"))
- "*List of special casing exceptions dictionaries for identifiers.
+ "List of special casing exceptions dictionaries for identifiers.
The first file is the one where new exceptions will be saved by Emacs
when you call `ada-create-case-exception'.
:group 'ada)
(defcustom ada-case-keyword 'downcase-word
- "*Function to call to adjust the case of an Ada keywords.
+ "Function to call to adjust the case of an Ada keywords.
It may be `downcase-word', `upcase-word', `ada-loose-case-word' or
`ada-capitalize-word'."
:type '(choice (const downcase-word)
:group 'ada)
(defcustom ada-case-identifier 'ada-loose-case-word
- "*Function to call to adjust the case of an Ada identifier.
+ "Function to call to adjust the case of an Ada identifier.
It may be `downcase-word', `upcase-word', `ada-loose-case-word' or
`ada-capitalize-word'."
:type '(choice (const downcase-word)
:group 'ada)
(defcustom ada-clean-buffer-before-saving t
- "*Non-nil means remove trailing spaces and untabify the buffer before saving."
+ "Non-nil means remove trailing spaces and untabify the buffer before saving."
:type 'boolean :group 'ada)
(make-obsolete-variable 'ada-clean-buffer-before-saving
"use the `write-file-functions' hook."
(defcustom ada-indent 3
- "*Size of Ada indentation.
+ "Size of Ada indentation.
An example is :
procedure Foo is
:type 'integer :group 'ada)
(defcustom ada-indent-after-return t
- "*Non-nil means automatically indent after RET or LFD."
+ "Non-nil means automatically indent after RET or LFD."
:type 'boolean :group 'ada)
(defcustom ada-indent-align-comments t
- "*Non-nil means align comments on previous line comments, if any.
+ "Non-nil means align comments on previous line comments, if any.
If nil, indentation is calculated as usual.
Note that indentation is calculated only if `ada-indent-comment-as-code' is t.
:type 'boolean :group 'ada)
(defcustom ada-indent-comment-as-code t
- "*Non-nil means indent comment lines as code.
+ "Non-nil means indent comment lines as code.
A nil value means do not auto-indent comments."
:type 'boolean :group 'ada)
(defcustom ada-indent-handle-comment-special nil
- "*Non-nil if comment lines should be handled specially inside parenthesis.
+ "Non-nil if comment lines should be handled specially inside parenthesis.
By default, if the line that contains the open parenthesis has some
text following it, then the following lines will be indented in the
same column as this text. This will not be true if the first line is
:type 'boolean :group 'ada)
(defcustom ada-indent-is-separate t
- "*Non-nil means indent 'is separate' or 'is abstract' if on a single line."
+ "Non-nil means indent 'is separate' or 'is abstract' if on a single line."
:type 'boolean :group 'ada)
(defcustom ada-indent-record-rel-type 3
- "*Indentation for 'record' relative to 'type' or 'use'.
+ "Indentation for 'record' relative to 'type' or 'use'.
An example is:
type A is
:type 'integer :group 'ada)
(defcustom ada-indent-renames ada-broken-indent
- "*Indentation for renames relative to the matching function statement.
+ "Indentation for renames relative to the matching function statement.
If `ada-indent-return' is null or negative, the indentation is done relative to
the open parenthesis (if there is no parenthesis, `ada-broken-indent' is used).
:type 'integer :group 'ada)
(defcustom ada-indent-return 0
- "*Indentation for 'return' relative to the matching 'function' statement.
+ "Indentation for 'return' relative to the matching 'function' statement.
If `ada-indent-return' is null or negative, the indentation is done relative to
the open parenthesis (if there is no parenthesis, `ada-broken-indent' is used).
:type 'integer :group 'ada)
(defcustom ada-indent-to-open-paren t
- "*Non-nil means indent according to the innermost open parenthesis."
+ "Non-nil means indent according to the innermost open parenthesis."
:type 'boolean :group 'ada)
(defcustom ada-fill-comment-prefix "-- "
- "*Text inserted in the first columns when filling a comment paragraph.
+ "Text inserted in the first columns when filling a comment paragraph.
Note: if you modify this variable, you will have to invoke `ada-mode'
again to take account of the new value."
:type 'string :group 'ada)
(defcustom ada-fill-comment-postfix " --"
- "*Text inserted at the end of each line when filling a comment paragraph.
+ "Text inserted at the end of each line when filling a comment paragraph.
Used by `ada-fill-comment-paragraph-postfix'."
:type 'string :group 'ada)
(defcustom ada-label-indent -4
- "*Number of columns to indent a label.
+ "Number of columns to indent a label.
An example is:
procedure Foo is
:type 'integer :group 'ada)
(defcustom ada-language-version 'ada95
- "*Ada language version; one of `ada83', `ada95', `ada2005'."
+ "Ada language version; one of `ada83', `ada95', `ada2005'."
:type '(choice (const ada83) (const ada95) (const ada2005)) :group 'ada)
(defcustom ada-move-to-declaration nil
- "*Non-nil means `ada-move-to-start' moves to the subprogram declaration, not to 'begin'."
+ "Non-nil means `ada-move-to-start' moves to the subprogram declaration, not to 'begin'."
:type 'boolean :group 'ada)
(defcustom ada-popup-key '[down-mouse-3]
- "*Key used for binding the contextual menu.
+ "Key used for binding the contextual menu.
If nil, no contextual menu is available."
:type '(restricted-sexp :match-alternatives (stringp vectorp))
:group 'ada)
(split-string (or (getenv "ADA_INCLUDE_PATH") "") ":")
'("/usr/adainclude" "/usr/local/adainclude"
"/opt/gnu/adainclude"))
- "*Default list of directories to search for Ada files.
+ "Default list of directories to search for Ada files.
See the description for the `ff-search-directories' variable. This variable
is the initial value of `ada-search-directories-internal'."
:type '(repeat (choice :tag "Directory"
`ada-search-directories'.")
(defcustom ada-stmt-end-indent 0
- "*Number of columns to indent the end of a statement on a separate line.
+ "Number of columns to indent the end of a statement on a separate line.
An example is:
if A = B
:type 'integer :group 'ada)
(defcustom ada-tab-policy 'indent-auto
- "*Control the behavior of the TAB key.
+ "Control the behavior of the TAB key.
Must be one of :
`indent-rigidly' : always adds `ada-indent' blanks at the beginning of the line.
`indent-auto' : use indentation functions in this file.
:group 'ada)
(defcustom ada-use-indent ada-broken-indent
- "*Indentation for the lines in a 'use' statement.
+ "Indentation for the lines in a 'use' statement.
An example is:
use Ada.Text_IO,
:type 'integer :group 'ada)
(defcustom ada-when-indent 3
- "*Indentation for 'when' relative to 'exception' or 'case'.
+ "Indentation for 'when' relative to 'exception' or 'case'.
An example is:
case A is
:type 'integer :group 'ada)
(defcustom ada-with-indent ada-broken-indent
- "*Indentation for the lines in a 'with' statement.
+ "Indentation for the lines in a 'with' statement.
An example is:
with Ada.Text_IO,
:type 'integer :group 'ada)
(defcustom ada-which-compiler 'gnat
- "*Name of the compiler to use.
+ "Name of the compiler to use.
This will determine what features are made available through the Ada mode.
The possible choices are:
`gnat': Use Ada Core Technologies' GNAT compiler. Add some cross-referencing
(defvar ada-mode-extra-prefix "\C-c\C-q"
"Prefix key to access `ada-mode-extra-map' functions.")
-(defvar ada-mode-abbrev-table nil
+(define-abbrev-table 'ada-mode-abbrev-table ()
"Local abbrev table for Ada mode.")
-(define-abbrev-table 'ada-mode-abbrev-table ())
-
-(defvar ada-mode-syntax-table nil
- "Syntax table to be used for editing Ada source code.")
-
-(defvar ada-mode-symbol-syntax-table nil
- "Syntax table for Ada, where `_' is a word constituent.")
(eval-when-compile
;; These values are used in eval-when-compile expressions.
(defvar ada-case-exception-substring '()
"Alist of substrings (entities) that have special casing.
-The substrings are detected for word constituant when the word
+The substrings are detected for word constituent when the word
is not itself in `ada-case-exception', and only for substrings that
either are at the beginning or end of the word, or start after '_'.")
;; to be considered as part of a word or not.
;; Some characters may have multiple meanings depending on the context:
;; - ' is either the beginning of a constant character or an attribute
-;; - # is either part of a based litteral or a gnatprep statement.
+;; - # is either part of a based literal or a gnatprep statement.
;; - " starts a string, but not if inside a constant character.
;; - ( and ) should be ignored if inside a constant character.
;; Thus their syntax property is changed automatically, and we can still use
;; better is available on XEmacs.
;;-------------------------------------------------------------------------
-(defun ada-create-syntax-table ()
- "Create the two syntax tables use in the Ada mode.
-The standard table declares `_' as a symbol constituent, the second one
-declares it as a word constituent."
- (interactive)
- (setq ada-mode-syntax-table (make-syntax-table))
-
- ;; define string brackets (`%' is alternative string bracket, but
- ;; almost never used as such and throws font-lock and indentation
- ;; off the track.)
- (modify-syntax-entry ?% "$" ada-mode-syntax-table)
- (modify-syntax-entry ?\" "\"" ada-mode-syntax-table)
-
- (modify-syntax-entry ?: "." ada-mode-syntax-table)
- (modify-syntax-entry ?\; "." ada-mode-syntax-table)
- (modify-syntax-entry ?& "." ada-mode-syntax-table)
- (modify-syntax-entry ?\| "." ada-mode-syntax-table)
- (modify-syntax-entry ?+ "." ada-mode-syntax-table)
- (modify-syntax-entry ?* "." ada-mode-syntax-table)
- (modify-syntax-entry ?/ "." ada-mode-syntax-table)
- (modify-syntax-entry ?= "." ada-mode-syntax-table)
- (modify-syntax-entry ?< "." ada-mode-syntax-table)
- (modify-syntax-entry ?> "." ada-mode-syntax-table)
- (modify-syntax-entry ?$ "." ada-mode-syntax-table)
- (modify-syntax-entry ?\[ "." ada-mode-syntax-table)
- (modify-syntax-entry ?\] "." ada-mode-syntax-table)
- (modify-syntax-entry ?\{ "." ada-mode-syntax-table)
- (modify-syntax-entry ?\} "." ada-mode-syntax-table)
- (modify-syntax-entry ?. "." ada-mode-syntax-table)
- (modify-syntax-entry ?\\ "." ada-mode-syntax-table)
- (modify-syntax-entry ?\' "." ada-mode-syntax-table)
-
- ;; a single hyphen is punctuation, but a double hyphen starts a comment
- (modify-syntax-entry ?- ". 12" ada-mode-syntax-table)
-
- ;; See the comment above on grammar related function for the special
- ;; setup for '#'.
- (if (featurep 'xemacs)
- (modify-syntax-entry ?# "<" ada-mode-syntax-table)
- (modify-syntax-entry ?# "$" ada-mode-syntax-table))
-
- ;; and \f and \n end a comment
- (modify-syntax-entry ?\f "> " ada-mode-syntax-table)
- (modify-syntax-entry ?\n "> " ada-mode-syntax-table)
-
- ;; define what belongs in Ada symbols
- (modify-syntax-entry ?_ "_" ada-mode-syntax-table)
-
- ;; define parentheses to match
- (modify-syntax-entry ?\( "()" ada-mode-syntax-table)
- (modify-syntax-entry ?\) ")(" ada-mode-syntax-table)
-
- (setq ada-mode-symbol-syntax-table (copy-syntax-table ada-mode-syntax-table))
- (modify-syntax-entry ?_ "w" ada-mode-symbol-syntax-table)
- )
+(defvar ada-mode-syntax-table
+ (let ((st (make-syntax-table)))
+ ;; Define string brackets (`%' is alternative string bracket, but
+ ;; almost never used as such and throws font-lock and indentation
+ ;; off the track.)
+ (modify-syntax-entry ?% "$" st)
+ (modify-syntax-entry ?\" "\"" st)
+
+ (modify-syntax-entry ?: "." st)
+ (modify-syntax-entry ?\; "." st)
+ (modify-syntax-entry ?& "." st)
+ (modify-syntax-entry ?\| "." st)
+ (modify-syntax-entry ?+ "." st)
+ (modify-syntax-entry ?* "." st)
+ (modify-syntax-entry ?/ "." st)
+ (modify-syntax-entry ?= "." st)
+ (modify-syntax-entry ?< "." st)
+ (modify-syntax-entry ?> "." st)
+ (modify-syntax-entry ?$ "." st)
+ (modify-syntax-entry ?\[ "." st)
+ (modify-syntax-entry ?\] "." st)
+ (modify-syntax-entry ?\{ "." st)
+ (modify-syntax-entry ?\} "." st)
+ (modify-syntax-entry ?. "." st)
+ (modify-syntax-entry ?\\ "." st)
+ (modify-syntax-entry ?\' "." st)
+
+ ;; A single hyphen is punctuation, but a double hyphen starts a comment.
+ (modify-syntax-entry ?- ". 12" st)
+
+ ;; See the comment above on grammar related function for the special
+ ;; setup for '#'.
+ (modify-syntax-entry ?# (if (featurep 'xemacs) "<" "$") st)
+
+ ;; And \f and \n end a comment.
+ (modify-syntax-entry ?\f "> " st)
+ (modify-syntax-entry ?\n "> " st)
+
+ ;; Define what belongs in Ada symbols.
+ (modify-syntax-entry ?_ "_" st)
+
+ ;; Define parentheses to match.
+ (modify-syntax-entry ?\( "()" st)
+ (modify-syntax-entry ?\) ")(" st)
+ st)
+ "Syntax table to be used for editing Ada source code.")
+
+(defvar ada-mode-symbol-syntax-table
+ (let ((st (make-syntax-table ada-mode-syntax-table)))
+ (modify-syntax-entry ?_ "w" st)
+ st)
+ "Syntax table for Ada, where `_' is a word constituent.")
;; Support of special characters in XEmacs (see the comments at the beginning
;; of the section on Grammar related functions).
(unless modified
(restore-buffer-modified-p nil))))
-(defun ada-after-change-function (beg end old-len)
+(defun ada-after-change-function (beg end _old-len)
"Called when the region between BEG and END was changed in the buffer.
OLD-LEN indicates what the length of the replaced text was."
(save-excursion
(if ada-popup-key
(define-key ada-mode-map ada-popup-key 'ada-popup-menu))
- ;; Support for Abbreviations (the user still need to "M-x abbrev-mode"
+ ;; Support for Abbreviations (the user still needs to "M-x abbrev-mode").
(setq local-abbrev-table ada-mode-abbrev-table)
;; Support for which-function mode
(let ((lastk last-command-event))
(with-syntax-table ada-mode-symbol-syntax-table
- (cond ((or (eq lastk ?\n)
- (eq lastk ?\r))
- ;; horrible kludge
+ (cond ((memq lastk '(?\n ?\r))
+ ;; Horrible kludge.
(insert " ")
(ada-adjust-case)
;; horrible dekludge
'( ?` ?_ ?# ?% ?& ?* ?( ?) ?- ?= ?+
?| ?\; ?: ?' ?\" ?< ?, ?. ?> ?/ ?\n 32 ?\r )))
-(defun ada-loose-case-word (&optional arg)
+(defun ada-loose-case-word (&optional _arg)
"Upcase first letter and letters following `_' in the following word.
No other letter is modified.
ARG is ignored, and is there for compatibility with `capitalize-word' only."
(insert-char (upcase (following-char)) 1)
(delete-char 1)))))
-(defun ada-no-auto-case (&optional arg)
+(defun ada-no-auto-case (&optional _arg)
"Do nothing. ARG is ignored.
This function can be used for the auto-casing variables in Ada mode, to
-adapt to unusal auto-casing schemes. Since it does nothing, you can for
+adapt to unusual auto-casing schemes. Since it does nothing, you can for
instance use it for `ada-case-identifier' if you don't want any special
auto-casing for identifiers, whereas keywords have to be lower-cased.
See also `ada-auto-case' to disable auto casing altogether."
nil)
-(defun ada-capitalize-word (&optional arg)
+(defun ada-capitalize-word (&optional _arg)
"Upcase first letter and letters following '_', lower case other letters.
ARG is ignored, and is there for compatibility with `capitalize-word' only."
(interactive)
(let ((end (save-excursion (skip-syntax-forward "w") (point)))
(begin (save-excursion (skip-syntax-backward "w") (point))))
- (modify-syntax-entry ?_ "_")
- (capitalize-region begin end)
- (modify-syntax-entry ?_ "w")))
+ (capitalize-region begin end)))
(defun ada-adjust-case-region (from to)
"Adjust the case of all words in the region between FROM and TO.
;; `ada-insert-paramlist'.
;; Both steps are called from `ada-format-paramlist'.
;; Note: Comments inside the parameter list are lost.
-;; The syntax has to be correct, or the reformating will fail.
+;; The syntax has to be correct, or the reformatting will fail.
;;--------------------------------------------------------------
(defun ada-format-paramlist ()
(while command-line-args-left
(let ((source (car command-line-args-left)))
- (message "Formating %s" source)
+ (message "Formatting %s" source)
(find-file source)
(ada-indent-region (point-min) (point-max))
(ada-adjust-case-buffer)
(unwind-protect
(with-syntax-table ada-mode-symbol-syntax-table
- ;; This need to be done here so that the advice is not always
+ ;; This needs to be done here so that the advice is not always
;; activated (this might interact badly with other modes)
(if (featurep 'xemacs)
(ad-activate 'parse-partial-sexp t))
If BACKWARD is non-nil, jump to the beginning of the previous word.
Return the new position of point or nil if not found."
(let ((match-cons nil)
- (orgpoint (point))
- (old-syntax (char-to-string (char-syntax ?_))))
- (modify-syntax-entry ?_ "w")
+ (orgpoint (point)))
(unless backward
- (skip-syntax-forward "w"))
+ (skip-syntax-forward "w_"))
(if (setq match-cons
- (ada-search-ignore-string-comment "\\w" backward nil t))
+ (ada-search-ignore-string-comment "\\sw\\|\\s_" backward nil t))
;;
;; move to the beginning of the word found
;;
(progn
(goto-char (car match-cons))
- (skip-syntax-backward "w")
+ (skip-syntax-backward "w_")
(point))
;;
;; if not found, restore old position of point
;;
(goto-char orgpoint)
- 'nil)
- (modify-syntax-entry ?_ old-syntax))
- )
+ 'nil)))
(defun ada-check-matching-start (keyword)
;; processing them recursively avoids the need for any special
;; handling.
;; Nothing should be done if we have only the specs or a
- ;; generic instantion.
+ ;; generic instantiation.
((and (looking-at "\\<procedure\\|function\\>"))
(if first
((eq ada-tab-policy 'always-tab) (error "Not implemented"))
))
-(defun ada-untab (arg)
+(defun ada-untab (_arg)
"Delete leading indenting according to `ada-tab-policy'."
;; FIXME: ARG is ignored
(interactive "P")
(ada-goto-matching-end 1))
;; on first line of subprogram body
- ;; Do nothing for specs or generic instantion, since these are
+ ;; Do nothing for specs or generic instantiation, since these are
;; handled as the general case (find the enclosing block)
;; We also need to make sure that we ignore nested subprograms
((save-excursion
["Entry family" ada-entry-family t]
["Select" ada-select t]
["Accept" ada-accept t]
- ["Or accept" ada-or-accep t]
+ ["Or accept" ada-or-accept t]
["Or delay" ada-or-delay t]
["Or terminate" ada-or-terminate t]
["---" nil nil]
(re-search-backward ada-imenu-subprogram-menu-re nil t))
;; Get the function name, but not the properties, or this changes
- ;; the face in the modeline on Emacs 21
+ ;; the face in the mode line on Emacs 21
(setq func-name (match-string-no-properties 3))
(if (and (not (ada-in-comment-p))
(not (save-excursion
;; correctly highlight a with_clause that spans multiple lines.
(list (concat "\\<\\(goto\\|raise\\|use\\|with\\)"
"[ \t]+\\([a-zA-Z0-9_., \t]+\\)\\W")
- '(1 font-lock-keyword-face) '(2 font-lock-reference-face nil t))
+ '(1 font-lock-keyword-face) '(2 font-lock-constant-face nil t))
;;
;; Goto tags.
- '("<<\\(\\sw+\\)>>" 1 font-lock-reference-face)
+ '("<<\\(\\sw+\\)>>" 1 font-lock-constant-face)
;; Highlight based-numbers (R. Reagan <robin-reply@reagans.org>)
(list "\\([0-9]+#[0-9a-fA-F_]+#\\)" '(1 font-lock-constant-face t))
;; Support for narrow-to-region
;; ---------------------------------------------------------
-(defun ada-narrow-to-defun (&optional arg)
+(defun ada-narrow-to-defun (&optional _arg)
"Make text outside current subprogram invisible.
The subprogram visible is the one that contains or follow point.
Optional ARG is ignored.
(ada-create-keymap)
(ada-create-menu)
-;; Create the syntax tables, but do not activate them
-(ada-create-syntax-table)
-
;; Add the default extensions (and set up speedbar)
(ada-add-extensions ".ads" ".adb")
;; This two files are generated by GNAT when running with -gnatD