| blob | 130027137fadf7988e87e93ad240872828329f47 |
1 ;;; ada-mode.el --- major-mode for editing Ada sources
3 ;; Copyright (C) 1994-1995, 1997-2014 Free Software Foundation, Inc.
5 ;; Author: Rolf Ebert <ebert@inf.enst.fr>
6 ;; Markus Heritsch <Markus.Heritsch@studbox.uni-stuttgart.de>
7 ;; Emmanuel Briot <briot@gnat.com>
8 ;; Maintainer: Stephen Leake <stephen_leake@member.fsf.org>
9 ;; Keywords: languages ada
11 ;; This file is part of GNU Emacs.
13 ;; GNU Emacs is free software: you can redistribute it and/or modify
14 ;; it under the terms of the GNU General Public License as published by
15 ;; the Free Software Foundation, either version 3 of the License, or
16 ;; (at your option) any later version.
18 ;; GNU Emacs is distributed in the hope that it will be useful,
19 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 ;; GNU General Public License for more details.
23 ;; You should have received a copy of the GNU General Public License
24 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
26 ;;; Commentary:
27 ;; This mode is a major mode for editing Ada code. This is a major
28 ;; rewrite of the file packaged with Emacs-20. The Ada mode is
29 ;; composed of four Lisp files: ada-mode.el, ada-xref.el, ada-prj.el
30 ;; and ada-stmt.el. Only this file (ada-mode.el) is completely
31 ;; independent from the GNU Ada compiler GNAT, distributed by Ada
32 ;; Core Technologies. All the other files rely heavily on features
33 ;; provided only by GNAT.
34 ;;
35 ;; Note: this mode will not work with Emacs 19. If you are on a VMS
36 ;; system, where the latest version of Emacs is 19.28, you will need
37 ;; another file, called ada-vms.el, that provides some required
38 ;; functions.
40 ;;; Usage:
41 ;; Emacs should enter Ada mode automatically when you load an Ada file.
42 ;; By default, the valid extensions for Ada files are .ads, .adb or .ada
43 ;; If the ada-mode does not start automatically, then simply type the
44 ;; following command :
45 ;; M-x ada-mode
46 ;;
47 ;; By default, ada-mode is configured to take full advantage of the GNAT
48 ;; compiler (the menus will include the cross-referencing features,...).
49 ;; If you are using another compiler, you might want to set the following
50 ;; variable in your .emacs (Note: do not set this in the ada-mode-hook, it
51 ;; won't work) :
52 ;; (setq ada-which-compiler 'generic)
53 ;;
54 ;; This mode requires find-file.el to be present on your system.
56 ;;; History:
57 ;; The first Ada mode for GNU Emacs was written by V. Broman in
58 ;; 1985. He based his work on the already existing Modula-2 mode.
59 ;; This was distributed as ada.el in versions of Emacs prior to 19.29.
60 ;;
61 ;; Lynn Slater wrote an extensive Ada mode in 1989. It consisted of
62 ;; several files with support for dired commands and other nice
63 ;; things. It is currently available from the PAL
64 ;; (wuarchive.wustl.edu:/languages/ada) as ada-mode-1.06a.tar.Z.
65 ;;
66 ;; The probably very first Ada mode (called electric-ada.el) was
67 ;; written by Steven D. Litvintchouk and Steven M. Rosen for the
68 ;; Gosling Emacs. L. Slater based his development on ada.el and
69 ;; electric-ada.el.
70 ;;
71 ;; A complete rewrite by M. Heritsch and R. Ebert has been done.
72 ;; Some ideas from the Ada mode mailing list have been
73 ;; added. Some of the functionality of L. Slater's mode has not
74 ;; (yet) been recoded in this new mode. Perhaps you prefer sticking
75 ;; to his version.
76 ;;
77 ;; A complete rewrite for Emacs-20 / GNAT-3.11 has been done by Ada Core
78 ;; Technologies.
80 ;;; Credits:
81 ;; Many thanks to John McCabe <john@assen.demon.co.uk> for sending so
82 ;; many patches included in this package.
83 ;; Christian Egli <Christian.Egli@hcsd.hac.com>:
84 ;; ada-imenu-generic-expression
85 ;; Many thanks also to the following persons that have contributed
86 ;; to the ada-mode
87 ;; Philippe Waroquiers (PW) <philippe@cfmu.eurocontrol.be> in particular,
88 ;; woodruff@stc.llnl.gov (John Woodruff)
89 ;; jj@ddci.dk (Jesper Joergensen)
90 ;; gse@ocsystems.com (Scott Evans)
91 ;; comar@gnat.com (Cyrille Comar)
92 ;; stephen.leake@gsfc.nasa.gov (Stephen Leake)
93 ;; robin-reply@reagans.org
94 ;; and others for their valuable hints.
96 ;;; Code:
97 ;; Note: Every function in this package is compiler-independent.
98 ;; The names start with ada-
99 ;; The variables that the user can edit can all be modified through
100 ;; the customize mode. They are sorted in alphabetical order in this
101 ;; file.
103 ;; Supported packages.
104 ;; This package supports a number of other Emacs modes. These other modes
105 ;; should be loaded before the ada-mode, which will then setup some variables
106 ;; to improve the support for Ada code.
107 ;; Here is the list of these modes:
108 ;; `which-function-mode': Display in the mode line the name of the subprogram
109 ;; the cursor is in.
110 ;; `outline-mode': Provides the capability to collapse or expand the code
111 ;; for specific language constructs, for instance if you want to hide the
112 ;; code corresponding to a subprogram
113 ;; `align': This mode is now provided with Emacs 21, but can also be
114 ;; installed manually for older versions of Emacs. It provides the
115 ;; capability to automatically realign the selected region (for instance
116 ;; all ':=', ':' and '--' will be aligned on top of each other.
117 ;; `imenu': Provides a menu with the list of entities defined in the current
118 ;; buffer, and an easy way to jump to any of them
119 ;; `speedbar': Provides a separate file browser, and the capability for each
120 ;; file to see the list of entities defined in it and to jump to them
121 ;; easily
122 ;; `abbrev-mode': Provides the capability to define abbreviations, which
123 ;; are automatically expanded when you type them. See the Emacs manual.
136 "Return Ada mode version."
141 version-string)))
144 "List of functions to call when Ada mode is invoked.
145 This hook is automatically executed after the `ada-mode' is
146 fully loaded.
150 "Major mode for editing and compiling Ada source in Emacs."
155 "Non-nil means automatically change case of preceding word while typing.
156 Casing is done according to `ada-case-keyword', `ada-case-identifier'
157 and `ada-case-attribute'."
161 "Number of columns to indent a broken declaration.
163 An example is :
164 declare
165 A,
166 >>>>>B : Integer;"
170 "Number of columns to indent the continuation of a broken line.
172 An example is :
173 My_Var : My_Type := (Field1 =>
174 >>>>>>>>>Value);"
178 "Number of columns to indent the continuation of broken lines in parenthesis.
180 An example is :
181 Func (Param1,
182 >>>>>Param2);"
186 "Function to call to adjust the case of Ada attributes.
187 It may be `downcase-word', `upcase-word', `ada-loose-case-word',
188 `ada-capitalize-word' or `ada-no-auto-case'."
198 "List of special casing exceptions dictionaries for identifiers.
199 The first file is the one where new exceptions will be saved by Emacs
200 when you call `ada-create-case-exception'.
202 These files should contain one word per line, that gives the casing
203 to be used for that word in Ada files. If the line starts with the
204 character *, then the exception will be used for substrings that either
205 start at the beginning of a word or after a _ character, and end either
206 at the end of the word or at a _ character. Each line can be terminated
207 by a comment."
212 "Function to call to adjust the case of an Ada keywords.
213 It may be `downcase-word', `upcase-word', `ada-loose-case-word' or
214 `ada-capitalize-word'."
223 "Function to call to adjust the case of an Ada identifier.
224 It may be `downcase-word', `upcase-word', `ada-loose-case-word' or
225 `ada-capitalize-word'."
234 "Non-nil means remove trailing spaces and untabify the buffer before saving."
237 "use the `write-file-functions' hook."
242 "Size of Ada indentation.
244 An example is :
245 procedure Foo is
246 begin
247 >>>>>>>>>>null;"
251 "Non-nil means automatically indent after RET or LFD."
255 "Non-nil means align comments on previous line comments, if any.
256 If nil, indentation is calculated as usual.
257 Note that indentation is calculated only if `ada-indent-comment-as-code' is t.
259 For instance:
260 A := 1; -- A multi-line comment
261 -- aligned if `ada-indent-align-comments' is t"
265 "Non-nil means indent comment lines as code.
266 A nil value means do not auto-indent comments."
270 "Non-nil if comment lines should be handled specially inside parenthesis.
271 By default, if the line that contains the open parenthesis has some
272 text following it, then the following lines will be indented in the
273 same column as this text. This will not be true if the first line is
274 a comment and `ada-indent-handle-comment-special' is t.
276 type A is
277 ( Value_1, -- common behavior, when not a comment
278 Value_2);
280 type A is
281 ( -- `ada-indent-handle-comment-special' is nil
282 Value_1,
283 Value_2);
285 type A is
286 ( -- `ada-indent-handle-comment-special' is non-nil
287 Value_1,
288 Value_2);"
292 "Non-nil means indent 'is separate' or 'is abstract' if on a single line."
296 "Indentation for 'record' relative to 'type' or 'use'.
298 An example is:
299 type A is
300 >>>>>>>>>>>record"
304 "Indentation for renames relative to the matching function statement.
305 If `ada-indent-return' is null or negative, the indentation is done relative to
306 the open parenthesis (if there is no parenthesis, `ada-broken-indent' is used).
308 An example is:
309 function A (B : Integer)
310 return C;
311 >>>renames Foo;"
315 "Indentation for 'return' relative to the matching 'function' statement.
316 If `ada-indent-return' is null or negative, the indentation is done relative to
317 the open parenthesis (if there is no parenthesis, `ada-broken-indent' is used).
319 An example is:
320 function A (B : Integer)
321 >>>>>return C;"
325 "Non-nil means indent according to the innermost open parenthesis."
329 "Text inserted in the first columns when filling a comment paragraph.
330 Note: if you modify this variable, you will have to invoke `ada-mode'
331 again to take account of the new value."
335 "Text inserted at the end of each line when filling a comment paragraph.
336 Used by `ada-fill-comment-paragraph-postfix'."
340 "Number of columns to indent a label.
342 An example is:
343 procedure Foo is
344 begin
345 >>>>Label:
347 This is also used for <<..>> labels"
351 "Ada language version; one of `ada83', `ada95', `ada2005'."
355 "Non-nil means `ada-move-to-start' moves to the subprogram declaration, not to 'begin'."
359 "Key used for binding the contextual menu.
360 If nil, no contextual menu is available."
369 "Default list of directories to search for Ada files.
370 See the description for the `ff-search-directories' variable. This variable
371 is the initial value of `ada-search-directories-internal'."
378 "Internal version of `ada-search-directories'.
379 Its value is the concatenation of the search path as read in the project file
380 and the standard runtime location, and the value of the user-defined
384 "Number of columns to indent the end of a statement on a separate line.
386 An example is:
387 if A = B
388 >>>>then"
392 "Control the behavior of the TAB key.
393 Must be one of :
394 `indent-rigidly' : always adds `ada-indent' blanks at the beginning of the line.
395 `indent-auto' : use indentation functions in this file.
396 `always-tab' : do `indent-relative'."
403 "Indentation for the lines in a 'use' statement.
405 An example is:
406 use Ada.Text_IO,
407 >>>>Ada.Numerics;"
411 "Indentation for 'when' relative to 'exception' or 'case'.
413 An example is:
414 case A is
415 >>>>when B =>"
419 "Indentation for the lines in a 'with' statement.
421 An example is:
422 with Ada.Text_IO,
423 >>>>Ada.Numerics;"
427 "Name of the compiler to use.
428 This will determine what features are made available through the Ada mode.
429 The possible choices are:
430 `gnat': Use Ada Core Technologies' GNAT compiler. Add some cross-referencing
431 features.
432 `generic': Use a generic compiler."
438 ;;; ---- end of user configurable variables
439 \f
442 "List of possible suffixes for Ada body files.
446 "List of possible suffixes for Ada spec files.
458 ;; default is C-c C-q because it's free in ada-mode-map
466 ;; These values are used in eval-when-compile expressions.
476 "List of Ada 83 keywords.
481 "List of keywords new in Ada 95.
486 "List of keywords new in Ada 2005.
496 "Alist of substrings (entities) that have special casing.
497 The substrings are detected for word constituent when the word
498 is not itself in `ada-case-exception', and only for substrings that
505 "Variable used by `find-file' to find the name of the other package.
513 "Ada support for align.el <= 2.2.
514 This variable provides regular expressions on which to align different lines.
533 )
534 "Ada support for align.el >= 2.8.
555 "when"
559 ;;; ---- Below are the regexp used in this package for parsing
570 ada-95-string-keywords
578 ada-2005-string-keywords
579 ada-83-string-keywords
585 ;; FIXME: make this customizable
589 ;; [:alnum:] matches any multibyte word constituent, as well as
590 ;; Latin-1 letters and numbers. This allows __ and trailing _;
591 ;; someone (emacs bug#1919) proposed [^\W_] to fix that, but \W does
592 ;; _not_ mean "not word constituent" inside a character alternative.
601 "Regexp matching a block label.
608 ;; "with" needs to be included in the regexp, to match generic subprogram parameters
609 ;; Similarly, we put '[not] overriding' on the same line with 'procedure' etc.
612 "^[ \t]*\\(with[ \t]+\\)?\\(\\(not[ \t]+\\)?overriding[ \t]+\\)?\\(procedure\\|function\\|task\\)[ \t\n]+"
614 ;; subprogram name: operator ("[+/=*]")
618 ;; subprogram name: name
622 "Regexp matching Ada subprogram start.
631 "Regexp matching start of package.
639 ;;; ---- regexps for indentation functions
663 "Regexp of possible ends for a non-broken statement.
689 "Position of point just before displaying the menu.
690 This is a list (point buffer).
691 Since `ada-popup-menu' moves the point where the user clicked, the region
692 is modified. Therefore no command from the menu knows what the user selected
693 before displaying the contextual menu.
694 To get the original region, restore the point to this position before
695 calling `region-end' and `region-beginning'.
699 "Menu to use when the user presses the right mouse button.
700 The variable `ada-contextual-menu-on-identifier' will be set to t before
701 displaying the menu if point was on an identifier."
716 \f
717 ;;------------------------------------------------------------------
718 ;; Support for imenu (see imenu.el)
719 ;;------------------------------------------------------------------
726 ada-imenu-comment-re
746 "Imenu generic expression for Ada mode.
747 See `imenu-generic-expression'. This variable will create several submenus for
750 \f
751 ;;------------------------------------------------------------
752 ;; Support for compile.el
753 ;;------------------------------------------------------------
756 "Mouse interface for `ada-compile-goto-error'."
760 )
763 "Replace `compile-goto-error' from compile.el.
764 If POS is on a file and line location, go to this position. It adds
765 to compile.el the capacity to go to a reference in an error message.
766 For instance, on these lines:
767 foo.adb:61:11: [...] in call to size declared at foo.ads:11
768 foo.adb:61:11: [...] in call to local declared at line 20
769 the 4 file locations can be clicked on and jumped to."
775 ;; special case: looking at a filename:line not at the beginning of a line
776 ;; or a simple line reference "at line ..."
786 )
793 source)
795 ;; set source marker
808 ))
810 ;; otherwise, default behavior
813 )
816 \f
817 ;;-------------------------------------------------------------------------
818 ;; Grammar related function
819 ;; The functions below work with the syntax class of the characters in an Ada
820 ;; buffer. Two syntax tables are created, depending on whether we want '_'
821 ;; to be considered as part of a word or not.
822 ;; Some characters may have multiple meanings depending on the context:
823 ;; - ' is either the beginning of a constant character or an attribute
824 ;; - # is either part of a based literal or a gnatprep statement.
825 ;; - " starts a string, but not if inside a constant character.
826 ;; - ( and ) should be ignored if inside a constant character.
827 ;; Thus their syntax property is changed automatically, and we can still use
828 ;; the standard Emacs functions for sexp (see `ada-in-string-p')
829 ;;
830 ;; On Emacs, this is done through the `syntax-table' text property. The
831 ;; corresponding action is applied automatically each time the buffer
832 ;; changes via syntax-propertize-function.
833 ;;
834 ;; on XEmacs, the `syntax-table' property does not exist and we have to use a
835 ;; slow advice to `parse-partial-sexp' to do the same thing.
836 ;; When executing parse-partial-sexp, we simply modify the strings before and
837 ;; after, so that the special constants '"', '(' and ')' do not interact
838 ;; with parse-partial-sexp.
839 ;; Note: this code is slow and needs to be rewritten as soon as something
840 ;; better is available on XEmacs.
841 ;;-------------------------------------------------------------------------
845 ;; Define string brackets (`%' is alternative string bracket, but
846 ;; almost never used as such and throws font-lock and indentation
847 ;; off the track.)
870 ;; A single hyphen is punctuation, but a double hyphen starts a comment.
873 ;; See the comment above on grammar related function for the special
874 ;; setup for '#'.
877 ;; And \f and \n end a comment.
881 ;; Define what belongs in Ada symbols.
884 ;; Define parentheses to match.
887 st)
893 st)
896 ;; Support of special characters in XEmacs (see the comments at the beginning
897 ;; of the section on Grammar related functions).
901 "Handles special character constants and gnatprep statements."
910 1
912 change))
919 change))
921 ad-do-it
930 ;; Before `syntax-propertize', we had to use font-lock to apply syntax-table
931 ;; properties, and in some cases we even had to do it manually (in
932 ;; `ada-after-change-function'). `ada-handle-syntax-table-properties'
933 ;; decides which method to use.
936 "Assign `syntax-table' properties in accessible part of buffer.
937 In particular, character constants are said to be strings, #...#
938 are treated as numbers instead of gnatprep comments."
947 ;; The following regexp was adapted from
948 ;; `ada-font-lock-syntactic-keywords'.
950 nil t)
962 "Called when the region between BEG and END was changed in the buffer.
963 OLD-LEN indicates what the length of the replaced text was."
973 "Assign `syntax-table' properties in current buffer."
982 "Handle `syntax-table' properties."
984 ;; `font-lock-mode' will take care of `syntax-table' properties.
986 ;; Take care of `syntax-table' properties manually.
991 ;;------------------------------------------------------------------
992 ;; Testing the grammatical context
993 ;;------------------------------------------------------------------
996 "Return t if inside a comment.
997 If PARSE-RESULT is non-nil, use it instead of calling `parse-partial-sexp'."
1003 "Return t if point is inside a string.
1004 If PARSE-RESULT is non-nil, use it instead of calling `parse-partial-sexp'."
1010 "Return t if inside a comment or string.
1011 If PARSE-RESULT is non-nil, use it instead of calling `parse-partial-sexp'."
1018 "Return t if point is after a prefix of a numeric literal."
1021 ;;------------------------------------------------------------------
1022 ;; Contextual menus
1023 ;; The Ada mode comes with contextual menus, bound by default to the right
1024 ;; mouse button.
1025 ;; Add items to this menu by modifying `ada-contextual-menu'. Note that the
1026 ;; variable `ada-contextual-menu-on-identifier' is set automatically to t
1027 ;; if the mouse button was pressed on an identifier.
1028 ;;------------------------------------------------------------------
1031 "Execute FUNCTION when called from the contextual menu.
1032 It forces Emacs to change the cursor position."
1039 "Pops up a contextual menu, depending on where the user clicked.
1040 POSITION is the location the mouse was clicked on.
1041 Sets `ada-contextual-menu-last-point' to the current position before
1042 displaying the menu. When a function from the menu is called, the
1043 point is where the mouse button was clicked."
1046 ;; declare this as a local variable, so that the function called
1047 ;; in the contextual menu does not hide the region in
1048 ;; transient-mark-mode.
1061 ))
1071 ))
1074 ;;------------------------------------------------------------------
1075 ;; Misc functions
1076 ;;------------------------------------------------------------------
1078 ;;;###autoload
1080 "Define SPEC and BODY as being valid extensions for Ada files.
1081 Going from body to spec with `ff-find-other-file' used these
1082 extensions.
1083 SPEC and BODY are two regular expressions that must match against
1084 the file name."
1105 ;; Support for speedbar (Specifies that we want to see these files in
1106 ;; speedbar)
1110 spec)
1112 body))))
1116 ;;;###autoload
1118 "Ada mode is the major mode for editing Ada code."
1120 ;; Set the paragraph delimiters so that one can select a whole block
1121 ;; simply with M-h
1125 ;; comment end must be set because it may hold a wrong value if
1126 ;; this buffer had been in another mode before. RE
1129 ;; used by autofill and indent-new-comment-line
1132 ;; used by autofill to break a comment line and continue it on another line.
1133 ;; The reason we need this one is that the default behavior does not work
1134 ;; correctly with the definition of paragraph-start above when the comment
1135 ;; is right after a multi-line subprogram declaration (the comments are
1136 ;; aligned under the latest parameter, not under the declaration start).
1146 ;; Emacs 20.3 defines a comment-padding to insert spaces between
1147 ;; the comment and the text. We do not want any, this is already
1148 ;; included in comment-start
1161 ;; Support for compile.el
1162 ;; We just substitute our own functions to go to the error.
1165 ;; FIXME: This has global impact! -stef
1173 ;; font-lock support :
1177 nil t
1179 beginning-of-line))
1185 ada-font-lock-syntactic-keywords))
1187 ;; Set up support for find-file.el.
1199 ;; Top level child package declaration; go to the parent package.
1206 ada-search-directories-internal
1208 ada-spec-suffixes)))
1210 ;; A "separate" clause.
1214 ada-search-directories-internal
1216 ada-spec-suffixes)))
1218 ;; A "with" clause.
1222 ada-search-directories-internal
1224 ada-spec-suffixes)))
1225 ))
1227 ;; Support for outline-minor-mode
1229 "\\([ \t]*\\(procedure\\|function\\|package\\|if\\|while\\|for\\|declare\\|case\\|end\\|begin\\|loop\\)\\|--\\)")
1232 ;; Support for imenu : We want a sorted index
1237 ;; Support for ispell : Check only comments
1240 ;; Support for align
1245 ;; Exclude comments alone on line from alignment.
1284 ;; Set up the contextual menu
1288 ;; Support for Abbreviations (the user still needs to "M-x abbrev-mode").
1291 ;; Support for which-function mode
1294 ;; Support for indent-new-comment-line (Especially for XEmacs)
1297 ;; Support for add-log
1308 ;; To be run after the hook, in case the user modified
1309 ;; ada-fill-comment-prefix
1315 ;; Run this after the hook to give the users a chance
1316 ;; to activate font-lock-mode.
1324 ;; FIXME: ada-language-version might be set in the mode
1325 ;; hook or it might even be set later on via file-local
1326 ;; vars, so ada-keywords should be set lazily.
1339 "Adjust the case of the text inserted by a skeleton."
1347 "Should we operate on an active region?"
1351 \f
1352 ;;-----------------------------------------------------------------
1353 ;; auto-casing
1354 ;; Since Ada is case-insensitive, the Ada mode provides an extensive set of
1355 ;; functions to auto-case identifiers, keywords, ...
1356 ;; The basic rules for autocasing are defined through the variables
1357 ;; `ada-case-attribute', `ada-case-keyword' and `ada-case-identifier'. These
1358 ;; are references to the functions that will do the actual casing.
1359 ;;
1360 ;; However, in most cases, the user will want to define some exceptions to
1361 ;; these casing rules. This is done through a list of files, that contain
1362 ;; one word per line. These files are stored in `ada-case-exception-file'.
1363 ;; For backward compatibility, this variable can also be a string.
1364 ;;-----------------------------------------------------------------
1367 "Save the casing exception lists to the file FILE-NAME.
1368 Casing exception lists are `ada-case-exception' and `ada-case-exception-substring'."
1379 )
1382 "Define WORD as an exception for the casing system.
1383 If WORD is not given, then the current word in the buffer is used instead.
1384 The new word is added to the first file in `ada-case-exception-file'.
1385 The standard casing rules will no longer apply to this word."
1389 ada-case-exception-file)
1403 ;; Reread the exceptions file, in case it was modified by some other,
1406 ;; If the word is already in the list, even with a different casing
1407 ;; we simply want to replace it.
1416 "Define the substring WORD as an exception for the casing system.
1417 If WORD is not given, then the current word in the buffer is used instead,
1418 or the selected region if any is active.
1419 The new word is added to the first file in `ada-case-exception-file'.
1420 When auto-casing a word, this substring will be special-cased, unless the
1421 word itself has a special casing."
1425 ada-case-exception-file)
1432 ;; Find the substring to define as an exception. Order is: the parameter,
1433 ;; if any, or the selected region, or the word under the cursor
1454 ;; Reread the exceptions file, in case it was modified by some other,
1457 ;; If the word is already in the list, even with a different casing
1458 ;; we simply want to replace it.
1463 )
1470 "Read the content of the casing exception file FILE-NAME."
1479 ;; If the item is already in the list, even with an other casing,
1480 ;; do not add it again. This way, the user can easily decide which
1481 ;; priority should be applied to each casing exception
1485 ;; Handling a substring ?
1497 )
1500 "Read all the casing exception files from `ada-case-exception-file'."
1503 ;; Reinitialize the casing exception list
1505 ada-case-exception-substring '())
1512 ada-case-exception-file))))
1515 "Adjust case of substrings in the previous word."
1521 re)
1537 )
1538 )
1540 )))
1543 "Adjust case of the previous identifier.
1544 The auto-casing is done according to the value of `ada-case-identifier'
1545 and the exceptions defined in `ada-case-exception-file'."
1557 match)
1558 ;; If we have an exception, replace the word by the correct casing
1560 ada-case-exception t))
1566 ;; Else simply re-case the word
1571 "Return t if cursor is after a keyword that is not an attribute."
1580 "Adjust the case of the word before the character just typed.
1581 If FORCE-IDENTIFIER is non-nil then also adjust keyword as identifier."
1586 ;; or if at the end of a character constant
1589 ;; or if the previous character was not part of a word
1591 ;; if in a string or a comment
1593 ;; if in a numeric literal
1595 )
1608 ))
1609 )
1612 "Adjust the case of the previous word, and process the character just typed.
1621 ;; Horrible kludge.
1624 ;; horrible dekludge
1626 ;; some special keys and their bindings
1633 ;; Else just insert the character
1635 ;; if there is a keyword in front of the underscore
1636 ;; then it should be part of an identifier (MH)
1641 ;; Else, no auto-casing
1651 ;; FIXME: Use post-self-insert-hook instead of changing key bindings.
1652 "Modify the key bindings for all the keys that should readjust the casing."
1654 ;; Save original key-bindings to allow swapping ret/lfd
1655 ;; when casing is activated.
1656 ;; The 'or ...' is there to be sure that the value will not
1657 ;; be changed again when Ada mode is called more than once
1661 ;; Call case modifying function after certain keys.
1663 ada-mode-map
1667 ?| ?\; ?: ?' ?\" ?< ?, ?. ?> ?/ ?\n 32 ?\r )))
1670 "Upcase first letter and letters following `_' in the following word.
1671 No other letter is modified.
1672 ARG is ignored, and is there for compatibility with `capitalize-word' only."
1686 "Do nothing. ARG is ignored.
1687 This function can be used for the auto-casing variables in Ada mode, to
1688 adapt to unusual auto-casing schemes. Since it does nothing, you can for
1689 instance use it for `ada-case-identifier' if you don't want any special
1690 auto-casing for identifiers, whereas keywords have to be lower-cased.
1691 See also `ada-auto-case' to disable auto casing altogether."
1692 nil)
1695 "Upcase first letter and letters following '_', lower case other letters.
1696 ARG is ignored, and is there for compatibility with `capitalize-word' only."
1703 "Adjust the case of all words in the region between FROM and TO.
1704 Attention: This function might take very long for big regions!"
1714 ;;
1715 ;; loop: look for all identifiers, keywords, and attributes
1716 ;;
1725 ;; do nothing if it is a string or comment
1728 ;;
1729 ;; get the identifier or keyword or attribute
1730 ;;
1734 ;;
1735 ;; casing according to user-option
1736 ;;
1746 "Adjust the case of all words in the whole buffer.
1747 ATTENTION: This function might take very long for big buffers!"
1751 \f
1752 ;;--------------------------------------------------------------
1753 ;; Format Parameter Lists
1754 ;; Some special algorithms are provided to indent the parameter lists in
1755 ;; subprogram declarations. This is done in two steps:
1756 ;; - First parses the parameter list. The returned list has the following
1757 ;; format:
1758 ;; ( (<Param_Name> in? out? access? <Type_Name> <Default_Expression>)
1759 ;; ... )
1760 ;; This is done in `ada-scan-paramlist'.
1761 ;; - Delete and recreate the parameter list in function
1762 ;; `ada-insert-paramlist'.
1763 ;; Both steps are called from `ada-format-paramlist'.
1764 ;; Note: Comments inside the parameter list are lost.
1765 ;; The syntax has to be correct, or the reformatting will fail.
1766 ;;--------------------------------------------------------------
1769 "Reformat the parameter list point is in."
1777 ;; check if really inside parameter list
1781 ;; find start of current parameter-list
1788 ;; find end of parameter-list
1794 ;; find end of last parameter-declaration
1798 ;; build a list of all elements of the parameter-list
1801 ;; delete the original parameter-list
1804 ;; insert the new parameter-list
1809 "Scan the parameter list found in between BEGIN and END.
1810 Return the equivalent internal parameter list."
1821 ;; loop until end of last parameter
1824 ;; find first character of parameter-declaration
1828 ;; find last character of parameter-declaration
1836 ;; read name(s) of parameter(s)
1843 ;; look for 'in'
1852 ;; look for 'out'
1861 ;; look for 'access'
1870 ;; skip 'in'/'out'/'access'
1877 ;; read type of parameter
1878 ;; We accept spaces in the name, since some software like Rose
1879 ;; generates something like: "A : B 'Class"
1885 ;; read default-expression, if there is one
1894 nil))))
1896 ;; add this parameter-declaration to the list
1899 ;; check if it was the last parameter
1903 )
1907 "Insert a formatted PARAMLIST in the buffer."
1917 ;; loop until last parameter
1921 ;; get max length of parameter-name
1924 ;; get max length of type-name
1927 ;; is there any 'in' ?
1930 ;; is there any 'out' ?
1933 ;; is there any 'access' ?
1935 )
1937 ;; does paramlist already start on a separate line ?
1941 ;; yes => re-indent it
1948 ;; no => insert it where we are after removing any whitespace
1964 ;; loop until last parameter
1969 ;; insert parameter-name, space and colon
1975 ;; insert 'in' or space
1980 accessp)
1984 ;; insert 'out' or space
1989 accessp)
1993 ;; insert 'access'
1999 ;; insert type-name and, if necessary, space and default-expression
2006 ;; check if it was the last parameter
2009 ;; no => insert ';' and newline and indent
2013 )
2015 ;; if anything follows, except semicolon, newline, is or return
2016 ;; put it in a new line and indent it
2019 ))
2022 \f
2023 ;;;----------------------------------------------------------------
2024 ;; Indentation Engine
2025 ;; All indentations are indicated as a two-element string:
2026 ;; - position of reference in the buffer
2027 ;; - offset to indent from this position (can also be a symbol or a list
2028 ;; that are evaluated)
2029 ;; Thus the total indentation for a line is the column number of the reference
2030 ;; position plus whatever value the evaluation of the second element provides.
2031 ;; This mechanism is used so that the Ada mode can "explain" how the
2032 ;; indentation was calculated, by showing which variables were used.
2033 ;;
2034 ;; The indentation itself is done in only one pass: first we try to guess in
2035 ;; what context we are by looking at the following keyword or punctuation
2036 ;; sign. If nothing remarkable is found, just try to guess the indentation
2037 ;; based on previous lines.
2038 ;;
2039 ;; The relevant functions for indentation are:
2040 ;; - `ada-indent-region': Re-indent a region of text
2041 ;; - `ada-justified-indent-current': Re-indent the current line and shows the
2042 ;; calculation that were done
2043 ;; - `ada-indent-current': Re-indent the current line
2044 ;; - `ada-get-current-indent': Calculate the indentation for the current line,
2045 ;; based on the context (see above).
2046 ;; - `ada-get-indent-*': Calculate the indentation in a specific context.
2047 ;; For efficiency, these functions do not check they are in the correct
2048 ;; context.
2049 ;;;----------------------------------------------------------------
2052 "Indent the region between BEG end END."
2060 ;; catch errors while indenting
2074 "Indent the current line, insert a newline and then indent the new line."
2081 "Insert a newline and indent it.
2082 The original line is re-indented if `ada-indent-after-return' is non-nil."
2084 ;; If at end of buffer (entering brand new code), some indentation
2085 ;; fails. For example, a block label requires whitespace following
2086 ;; the : to be recognized. So we do the newline first, then
2087 ;; go back and indent the original line.
2097 "Indent the current line and explain how the calculation was done."
2116 ))
2124 "Re-indent and re-case all the files found on the command line.
2125 This function should be used from the command line, with a
2126 command like:
2127 emacs -batch -l ada-mode -f ada-batch-reformat file1 file2 ..."
2141 "Move point to the beginning of the previous word of Ada code.
2142 Return the new position of point or nil if not found."
2146 "Indent current line as Ada code.
2147 Return the calculation that was done, including the reference point
2148 and the offset."
2151 cur-indent tmp-indent
2152 prev-indent)
2157 ;; This needs to be done here so that the advice is not always
2158 ;; activated (this might interact badly with other modes)
2165 ;; Not First line in the buffer ?
2171 ;; first line in the buffer
2174 ;; Evaluate the list to get the column to indent to
2175 ;; prev-indent contains the column to indent to
2188 )
2191 ;; only re-indent if indentation is different then the current
2193 nil
2197 ;;
2198 ;; restore position of point
2199 ;;
2207 cur-indent))
2210 "Return the indentation to use for the current line."
2212 pos
2213 match-cons
2214 result
2224 ;;-----------------------------
2225 ;; in open parenthesis, but not in parameter-list
2226 ;;-----------------------------
2232 ;; check if we have something like this (Table_Component_Type =>
2233 ;; Source_File_Record)
2236 ;; Align the closing parenthesis on the opening one
2247 ;; ??? Could use a different variable
2250 ;; We want all continuation lines to be indented the same
2251 ;; (ada-broken-line from the opening parenthesis. However, in
2252 ;; parameter list, each new parameter should be indented at the
2253 ;; column as the opening parenthesis.
2255 ;; A special case to handle nested boolean expressions, as in
2256 ;; ((B
2257 ;; and then C) -- indented by ada-broken-indent
2258 ;; or else D) -- indenting this line.
2259 ;; ??? This is really a hack, we should have a proper way to go to
2260 ;; ??? the beginning of the statement
2268 )))))
2270 ;;---------------------------
2271 ;; at end of buffer
2272 ;;---------------------------
2277 ;;---------------------------
2278 ;; starting with e
2279 ;;---------------------------
2284 ;; ------- end ------
2288 limit)
2292 ;;
2293 ;; found 'loop' => skip back to 'while' or 'for'
2294 ;; if 'loop' is not on a separate line
2295 ;; Stop the search for 'while' and 'for' when a ';' is encountered.
2296 ;;
2315 ;; found 'record' =>
2316 ;; if the keyword is found at the beginning of a line (or just
2317 ;; after limited, we indent on it, otherwise we indent on the
2318 ;; beginning of the type declaration)
2319 ;; type A is (B : Integer;
2320 ;; C : Integer) is record
2321 ;; end record; -- This is badly indented otherwise
2331 ;; Else keep the same indentation as the beginning statement
2334 ;; ------ exception ----
2341 ;; else
2351 ;; elsif
2358 ))
2360 ;;---------------------------
2361 ;; starting with w (when)
2362 ;;---------------------------
2371 ;;---------------------------
2372 ;; starting with t (then)
2373 ;;---------------------------
2381 ;; Select has been added for the statement: "select ... then abort"
2387 ;;---------------------------
2388 ;; starting with l (loop)
2389 ;;---------------------------
2401 nil pos))
2406 ;;----------------------------
2407 ;; starting with l (limited) or r (record)
2408 ;;----------------------------
2424 ;;---------------------------
2425 ;; starting with b (begin)
2426 ;;---------------------------
2435 ;;---------------------------
2436 ;; starting with i (is)
2437 ;;---------------------------
2456 ;;---------------------------
2457 ;; starting with r (return, renames)
2458 ;;---------------------------
2465 ;; If looking at a renames, skip the 'return' statement too
2480 ;; If there is a parameter list, and we have a function declaration
2481 ;; or a access to subprogram declaration
2493 ;; The indentation depends of the value of ada-indent-return
2497 var))
2499 ;; Else there is no parameter list, but we have a function
2500 ;; Only do something special if the user want to indent
2501 ;; relative to the "function" keyword
2507 ;; Else...
2510 ;;--------------------------------
2511 ;; starting with 'o' or 'p'
2512 ;; 'or' as statement-start
2513 ;; 'private' as statement-start
2514 ;;--------------------------------
2521 ;; ??? Wasn't this done already in ada-looking-at-semi-or ?
2525 ;;--------------------------------
2526 ;; starting with 'd' (do)
2527 ;;--------------------------------
2535 ;;--------------------------------
2536 ;; starting with '-' (comment)
2537 ;;--------------------------------
2542 ;; Indent comments on previous line comments if required
2543 ;; We must use a search-forward (even if the code is more complex),
2544 ;; since we want to find the beginning of the comment.
2555 pos))
2558 ;; Else always on previous line
2561 ;; Else same indentation as the previous line
2564 ;;--------------------------------
2565 ;; starting with '#' (preprocessor line)
2566 ;;--------------------------------
2573 ;;--------------------------------
2574 ;; starting with ')' (end of a parameter list)
2575 ;;--------------------------------
2583 ;;---------------------------------
2584 ;; new/abstract/separate
2585 ;;---------------------------------
2590 ;;---------------------------------
2591 ;; package/function/procedure
2592 ;;---------------------------------
2597 ;; Go up until we find either a generic section, or the end of the
2598 ;; previous subprogram/package, or 'overriding' for this function/procedure
2604 ;; avoid "with procedure"... in generic parts
2616 ;;---------------------------------
2617 ;; label
2618 ;;---------------------------------
2622 ;; ada-block-label-re matches variable declarations
2627 ))
2629 ;;---------------------------------
2630 ;; Other syntaxes
2631 ;;---------------------------------
2635 "Calculate the indentation for the new line after ORGPOINT.
2636 The result list is based on the previous lines in the buffer.
2637 If NOMOVE is nil, moves point to the beginning of the current statement.
2638 if INITIAL-POS is non-nil, moves point to INITIAL-POS before calculation."
2643 ;; Is inside a parameter-list ?
2647 ;; Move to beginning of current statement. If already at a
2648 ;; statement start, move to beginning of enclosing statement.
2652 ;; no beginning found => don't change indentation
2658 ;;
2660 ada-indent-to-open-paren
2663 ;;
2666 ;;
2669 ;;
2672 ;;
2675 ;;
2678 ;;
2681 ;;
2684 ;;
2685 ;; "then" has to be included in the case of "select...then abort"
2686 ;; statements, since (goto-stmt-start) at the beginning of
2687 ;; the current function would leave the cursor on that position
2690 ;;
2693 ;;
2696 ;;
2699 ;;
2701 ;; Are we still in that statement, or are we in fact looking at
2702 ;; the previous one ?
2706 'ada-with-indent
2708 ;;
2711 ))
2714 "Calculate the indentation when point is behind an unclosed parenthesis."
2718 "Return the current indentation of the previous line."
2725 "Calculate the indentation when point is inside a parameter list."
2729 ;; in front of the first parameter
2734 ;; in front of another parameter
2740 ;; After an affectation (default parameter value in subprogram
2741 ;; declaration)
2746 ;; inside a parameter declaration
2753 "Calculate the indentation when point is just before an end statement.
2754 ORGPOINT is the limit position used in the calculation."
2758 ;; is the line already terminated by ';' ?
2763 ;; yes, look what's following 'end'
2768 ;;
2769 ;; loop/select/if/case/return
2770 ;;
2775 ;;
2776 ;; record
2777 ;;
2781 ;; we are now looking at the matching "record" statement
2784 ;; now on the matching type declaration, or use clause
2788 ;;
2789 ;; a named block end
2790 ;;
2797 ;;
2798 ;; a block-end without name
2799 ;;
2808 indent))
2810 )))
2811 ;;
2812 ;; anything else - should maybe signal an error ?
2813 ;;
2822 "Calculate the indentation when point is just before a case statement.
2823 ORGPOINT is the limit position used in the calculation."
2827 ;;
2828 ;; case..is..when..=>
2829 ;;
2832 ;; the `=>' must be after the keyword `is'.
2842 ;;
2843 ;; case..is..when
2844 ;;
2850 ;;
2851 ;; case..is
2852 ;;
2857 ;;
2858 ;; incomplete case
2859 ;;
2865 "Calculate the indentation when point is just before a when statement.
2866 ORGPOINT is the limit position used in the calculation."
2873 "Calculate the indentation when point is just before an if statement.
2874 ORGPOINT is the limit position used in the calculation."
2877 ;;
2878 ;; Move to the correct then (ignore all "and then")
2879 ;;
2882 nil orgpoint))
2884 ;; If "then" was found (we are looking at it)
2887 ;;
2888 ;; 'then' first in separate line ?
2889 ;; => indent according to 'then',
2890 ;; => else indent according to 'if'
2891 ;;
2896 ;; skip 'then'
2903 "Calculate the indentation when point is at the start of a block.
2904 ORGPOINT is the limit position used in the calculation."
2914 ;; Special case for record types, for instance for:
2915 ;; type A is (B : Integer;
2916 ;; C : Integer) is record
2917 ;; null; -- This is badly indented otherwise
2920 ;; If record is at the beginning of the line, indent from there
2926 ;; else indent relative to the type command
2931 ;; Special case for label:
2935 ;; nothing follows the block-start
2940 "Calculate the indentation when point is just before a subprogram.
2941 ORGPOINT is the limit position used in the calculation."
2945 ;;
2946 ;; is there an 'is' in front of point ?
2947 ;;
2952 ;;
2953 ;; yes, then skip to its end
2954 ;;
2958 ;;
2959 ;; no, then goto next non-ws, if there is one in front of point
2960 ;;
2966 ;;
2967 ;; nothing follows 'is'
2968 ;;
2970 foundis
2975 ;;
2976 ;; is abstract/separate/new ...
2977 ;;
2979 foundis
2984 nil orgpoint))))
2988 ;;
2989 ;; something follows 'is'
2990 ;;
2992 foundis
2996 ;;
2997 ;; no 'is' but ';'
2998 ;;
3002 ;;
3003 ;; no 'is' or ';'
3004 ;;
3009 "Calculate the indentation when point is just before a 'noindent stmt'.
3010 ORGPOINT is the limit position used in the calculation."
3017 ;; This one is called when indenting a line preceded by a multi-line
3018 ;; subprogram declaration (in that case, we are at this point inside
3019 ;; the parameter declaration list)
3024 ;; This one is called when indenting the second line of a multi-line
3025 ;; declaration section, in a declare block or a record declaration
3030 ;; This one is called in every other case when indenting a line at the
3031 ;; top level
3038 ;; "with private" or "null record" cases
3063 "Calculate the indentation when before a label or variable declaration.
3064 ORGPOINT is the limit position used in the calculation."
3069 ;; loop label
3072 ada-loop-start-re nil orgpoint)))
3076 ;; declare label
3083 ;; variable declaration
3090 ;; nothing follows colon
3095 "Calculate the indentation when at a goto label."
3099 ;; labeled statement is the one we need to indent
3101 ;; else indentation is indent for labeled statement
3105 "Calculate the indentation when just before a loop or a for ... use.
3106 ORGPOINT is the limit position used in the calculation."
3110 ;; If looking at a named block, skip the label
3119 ;;
3120 ;; statement complete
3121 ;;
3126 ;;
3127 ;; simple loop
3128 ;;
3132 pos
3135 ;;
3136 ;; 'for'- loop (or also a for ... use statement)
3137 ;;
3140 ;;
3141 ;; for ... use
3142 ;;
3151 ;;
3152 ;; check if there is a 'record' before point
3153 ;;
3157 t)))
3163 )
3165 ;;
3166 ;; for..loop
3167 ;;
3172 ;;
3173 ;; indent according to 'loop', if it's first in the line;
3174 ;; otherwise to 'for'
3175 ;;
3182 ;;
3183 ;; for-statement is broken
3184 ;;
3189 ;;
3190 ;; 'while'-loop
3191 ;;
3193 ;;
3194 ;; while..loop ?
3195 ;;
3202 ;;
3203 ;; indent according to 'loop', if it's first in the line;
3204 ;; otherwise to 'while'.
3205 ;;
3217 "Calculate the indentation when before a type statement.
3218 ORGPOINT is the limit position used in the calculation."
3221 ;;
3222 ;; complete record declaration
3223 ;;
3235 ;;
3236 ;; record type
3237 ;;
3243 ;;
3244 ;; complete type declaration
3245 ;;
3250 ;;
3251 ;; "type ... is", but not "type ... is ...", which is broken
3252 ;;
3259 ;;
3260 ;; broken statement
3261 ;;
3266 \f
3267 ;; -----------------------------------------------------------
3268 ;; -- searching and matching
3269 ;; -----------------------------------------------------------
3272 "Move point to the beginning of the statement that point is in or after.
3273 Return the new position of point.
3274 As a special case, if we are looking at a closing parenthesis, skip to the
3275 open parenthesis."
3282 ;;
3283 ;; found a previous end-statement => check if anything follows
3284 ;;
3290 ;;
3291 ;; nothing follows => it's the end-statement directly in
3292 ;; front of point => search again
3293 ;;
3295 ;;
3296 ;; if found the correct end-statement => goto next non-ws
3297 ;;
3301 ))
3303 ;;
3304 ;; no previous end-statement => we are at the beginning of the
3305 ;; accessible part of the buffer
3306 ;;
3309 ;;
3310 ;; skip to the very first statement, if there is one
3311 ;;
3318 "Move point to previous end statement.
3319 Return a cons cell whose car is the beginning and whose cdr
3320 is the end of the match."
3324 ;; search until found or beginning-of-buffer
3329 ada-end-stmt-re t)))
3350 ;; words that can go after an 'is'
3366 )))
3369 match-dat
3370 nil)))
3373 "Skip to next non-whitespace character.
3374 Skips spaces, newlines and comments, and possibly goto labels.
3375 Return `point' if moved, nil if not.
3376 Stop the search at LIMIT.
3377 Do not call this function from within a string."
3390 t)))))
3393 nil)
3394 )
3398 "Move point to the end of the statement that point is in or before.
3399 Return the new position of point or nil if not found.
3400 Stop the search at LIMIT."
3403 nil))
3407 "Move point to the beginning of the next word of Ada code.
3408 If BACKWARD is non-nil, jump to the beginning of the previous word.
3409 Return the new position of point or nil if not found."
3416 ;;
3417 ;; move to the beginning of the word found
3418 ;;
3423 ;;
3424 ;; if not found, restore old position of point
3425 ;;
3431 "Signal an error if matching block start is not KEYWORD.
3432 Moves point to the matching block start."
3439 "Check if the name of the matching defun really is DEFUN-NAME.
3440 Assumes point to be already positioned by `ada-goto-matching-start'.
3441 Moves point to the beginning of the declaration."
3443 ;; named block without a `declare'; ada-goto-matching-start leaves
3444 ;; point at start of 'begin' for a block.
3448 t ; name matches
3449 ;; else
3450 ;;
3451 ;; 'accept' or 'package' ?
3452 ;;
3455 ;;
3456 ;; 'begin' of 'procedure'/'function'/'task' or 'declare'
3457 ;;
3459 ;;
3460 ;; a named 'declare'-block ? => jump to the label
3461 ;;
3466 ;;
3467 ;; no, => 'procedure'/'function'/'task'/'protected'
3468 ;;
3472 ;;
3473 ;; skip 'body' 'type'
3474 ;;
3479 ;;
3480 ;; should be looking-at the correct name
3481 ;;
3488 "Move point to the declaration start of the current construct.
3489 If NOERROR is non-nil, return nil if no match was found;
3490 otherwise throw error."
3498 ;; first should be set to t if we should stop at the first
3499 ;; "begin" we encounter.
3503 )
3505 ;; Ignore "when" most of the time, except if we are looking at the
3506 ;; beginning of a block (structure: case .. is
3507 ;; when ... =>
3508 ;; begin ...
3509 ;; exception ... )
3521 ;; search backward for interesting keywords
3525 ;;
3526 ;; calculate nest-depth
3527 ;;
3529 ;;
3533 ;; In some case, two begin..end block can follow each other closely,
3534 ;; which we have to detect, as in
3535 ;; procedure P is
3536 ;; procedure Q is
3537 ;; begin
3538 ;; end;
3539 ;; begin -- here we should go to procedure, not begin
3540 ;; end
3546 ;; If begin was just there as the beginning of a block
3547 ;; (with no declare) then do nothing, otherwise just
3548 ;; register that we have to find the statement that
3549 ;; required the begin
3553 t)
3561 ))
3562 )))
3563 ;;
3569 ;;
3578 ;;
3582 ;;
3584 ;; look for things to ignore
3587 ;; generic formal parameter
3590 ;; A type definition, or a case statement. Note that the
3591 ;; goto-matching-start above on 'end record' leaves us at
3592 ;; 'record', not at 'type'.
3593 ;;
3594 ;; We get to a case statement here by calling
3595 ;; 'ada-move-to-end' from inside a case statement; then
3596 ;; we are not ignoring 'when'.
3598 ;; Skip type discriminants or case argument function call param list
3606 ))
3607 ;; skip type or case argument name
3611 ;; if it's a protected type, it's the decl start we
3612 ;; are looking for; since we didn't see the 'end'
3613 ;; above, we are inside it.
3620 ;; null procedure declaration
3623 ;; skip this construct
3624 nil
3625 ;; this is the right "is"
3629 ;;
3635 ;;
3639 ;;
3647 ))))
3648 ;;
3651 ;;
3658 ;; check if declaration-start is really found
3664 t
3667 ))
3670 "Move point to the beginning of a block-start.
3671 Which block depends on the value of NEST-LEVEL, which defaults to zero.
3672 If NOERROR is non-nil, it only returns nil if no matching start was found.
3673 If GOTOTHEN is non-nil, point moves to the 'then' following 'if'."
3678 ;; List all keywords encountered while traversing
3679 ;; something like '("end" "end" "begin")
3680 ;; This is removed from the list when "package", "procedure",...
3681 ;; are seen. The goal is to find whether a package has an elaboration
3682 ;; part
3686 ;; search backward for interesting keywords
3696 ;; calculate nest-depth
3698 ;; found block end => increase nest depth
3703 ;; found loop/select/record/case/if => check if it starts or
3704 ;; ends a block
3708 ;; check if keyword follows 'end'
3712 ;; it ends a block => increase nest depth
3717 ;; it starts a block => decrease nest depth
3720 ;; Some nested "begin .. end" blocks with no "declare"?
3721 ;; => remove those entries
3726 ))
3728 )
3730 ;; found package start => check if it really is a block
3733 ;; ignore if this is just a renames statement
3740 "No matching 'is' or 'renames' for 'package' at"
3741 " line "
3747 ;; ignore it if it is only a declaration with 'new'
3748 ;; We could have package Foo is new ....
3749 ;; or package Foo is separate;
3750 ;; or package Foo is begin null; end Foo
3751 ;; for elaboration code (elaboration)
3757 )
3758 ;; found task start => check if it has a body
3766 ;; In that case, do nothing if there is a "is"
3770 ;; Do nothing if we are simply looking at a simple
3771 ;; "task type name;" statement with no block
3774 ;; Skip the parameters
3785 ;; Check if that task declaration had a block attached to
3786 ;; it (i.e do nothing if we have just "task name;")
3791 )
3794 ;; remove entry for begin and end (include nested begin..end
3795 ;; groups)
3803 )))
3806 ;; Ignore if this is just a declaration
3813 ;; remove entry for end
3819 ;; Ignore if this is just a declaration
3826 ;; remove entry for begin and end
3828 )
3830 ;; all the other block starts
3835 )
3837 ;; match is found, if nest-depth is zero
3843 ;;
3844 ;; match found => is there anything else to do ?
3845 ;;
3848 ;;
3849 ;; found 'if' => skip to 'then', if it's on a separate line
3850 ;; and GOTOTHEN is non-nil
3851 ;;
3853 gotothen
3862 ;;
3863 ;; found 'do' => skip back to 'accept' or 'return'
3864 ;;
3872 nil
3877 "Move point to the end of a block.
3878 Which block depends on the value of NEST-LEVEL, which defaults to zero.
3879 If NOERROR is non-nil, it only returns nil if no matching start found."
3887 found
3888 pos
3890 ;; First is used for subprograms: they are generally handled
3891 ;; recursively, but of course we do not want to do that the
3892 ;; first time (see comment below about subprograms)
3895 ;; If we are already looking at one of the keywords, this shouldn't count
3896 ;; in the nesting loop below, so we just make sure we don't count it.
3897 ;; "declare" is a special case because we need to look after the "begin"
3898 ;; keyword
3902 ;;
3903 ;; search forward for interesting keywords
3904 ;;
3909 ;;
3910 ;; calculate nest-depth
3911 ;;
3914 ;; procedures and functions need to be processed recursively, in
3915 ;; case they are defined in a declare/begin block, as in:
3916 ;; declare -- NL 0 (nested level)
3917 ;; A : Boolean;
3918 ;; procedure B (C : D) is
3919 ;; begin -- NL 1
3920 ;; null;
3921 ;; end B; -- NL 0, and we would exit
3922 ;; begin
3923 ;; end; -- we should exit here
3924 ;; processing them recursively avoids the need for any special
3925 ;; handling.
3926 ;; Nothing should be done if we have only the specs or a
3927 ;; generic instantiation.
3943 ;; found block end => decrease nest depth
3947 ;; skip the following keyword
3954 ;; found package start => check if it really starts a block, and is not
3955 ;; in fact a generic instantiation for instance
3960 ;; ignore and skip it if it is only a 'new' package
3966 ;; all the other block starts
3976 t
3978 nil
3980 ))
3985 "Regexp-search for SEARCH-RE, ignoring comments, strings.
3986 Returns a cons cell of begin and end of match data or nil, if not found.
3987 If BACKWARD is non-nil, search backward; search forward otherwise.
3988 The search stops at pos LIMIT.
3989 If PARAMLISTS is nil, ignore parameter lists.
3990 The search is done using SEARCH-FUNC. SEARCH-FUNC can be optimized
3991 in case we are searching for a constant string.
3992 Point is moved at the beginning of the SEARCH-RE."
3994 begin
3995 end
3996 parse-result)
3998 ;; FIXME: need to pass BACKWARD to search-func!
4002 ;;
4003 ;; search until found or end-of-buffer
4004 ;; We have to test that we do not look further than limit
4005 ;;
4016 ;;
4017 ;; If inside a string, skip it (and the following comments)
4018 ;;
4024 ;;
4025 ;; If inside a comment, skip it (and the following comments)
4026 ;; There is a special code for comments at the end of the file
4027 ;;
4036 ;; at the end of the file, it is not possible to skip a comment
4037 ;; so we just go at the end of the line
4043 ;;
4044 ;; directly in front of a comment => skip it, if searching forward
4045 ;;
4049 ;;
4050 ;; found a parameter-list but should ignore it => skip it
4051 ;;
4056 ;;
4057 ;; found what we were looking for
4058 ;;
4064 nil)))
4066 ;; -------------------------------------------------------
4067 ;; -- Testing the position of the cursor
4068 ;; -------------------------------------------------------
4071 "Return t if point is inside a declarative part.
4072 Assumes point to be at the end of a statement."
4079 "Return t if looking at an 'or' following a semicolon."
4089 "Return t if looking at the start of a private section in a package.
4090 Return nil if the private is part of the package name, as in
4091 'private package A is...' (this can only happen at top level)."
4096 ;; Make sure this is the start of a private section (ie after
4097 ;; a semicolon or just after the package declaration, but not
4098 ;; after a 'type ... is private' or 'is new ... with private'
4099 ;;
4100 ;; Note that a 'private' statement at the beginning of the buffer
4101 ;; does not indicate a private section, since this is instead a
4102 ;; 'private procedure ...'
4111 "Return t if point is inside the parameter-list of a declaration, but not a subprogram call or aggregate."
4115 ;; inside parentheses ?
4118 ;; We could be looking at two things here:
4119 ;; operator definition: function "." (
4120 ;; subprogram definition: procedure .... (
4121 ;; Let's skip back over the first one
4127 t)
4129 ;; and now over the second one
4132 ;; We should ignore the case when the reserved keyword is in a
4133 ;; comment (for instance, when we have:
4134 ;; -- .... package
4135 ;; Test (A)
4136 ;; we should return nil
4140 ;; right keyword two words before parenthesis ?
4141 ;; Type is in this list because of discriminants
4142 ;; pragma is not, because the syntax is that of a subprogram call.
4152 "Search for REGEXP, ignoring comments, strings, 'and then', 'or else'.
4153 If BACKWARDP is non-nil, search backward; search forward otherwise."
4158 result))
4161 "Non-nil if in an open parenthesis.
4162 Return value is the position of the first non-ws behind the last unclosed
4163 parenthesis, or nil."
4169 t))
4176 ;; Skip blanks, if they are not followed by a comment
4177 ;; See:
4178 ;; type A is ( Value_0,
4179 ;; Value_1);
4180 ;; type B is ( -- comment
4181 ;; Value_2);
4189 \f
4190 ;; -----------------------------------------------------------
4191 ;; -- Behavior Of TAB Key
4192 ;; -----------------------------------------------------------
4195 "Do indenting or tabbing according to `ada-tab-policy'.
4196 In Transient Mark mode, if the mark is active, operate on the contents
4197 of the region. Otherwise, operate only on the current line."
4205 ))
4208 "Delete leading indenting according to `ada-tab-policy'."
4209 ;; FIXME: ARG is ignored
4214 ))
4217 "Ada mode version of the `indent-line-function'."
4225 ))
4228 "Indent current line to next tab stop."
4236 "Indent current line to previous tab stop."
4240 \f
4241 ;; ------------------------------------------------------------
4242 ;; -- Miscellaneous
4243 ;; ------------------------------------------------------------
4245 ;; Not needed any more for Emacs 21.2, but still needed for backward
4246 ;; compatibility
4248 "Remove trailing spaces in the whole buffer."
4259 "Clean up comments, `(' and `,' for GNAT style checking switch."
4263 ;; The \n is required, or the line after an empty comment line is
4264 ;; simply ignored.
4293 ;; Make sure there is a space after a ','.
4294 ;; Always go back to the beginning of the match, since otherwise
4295 ;; a statement like ('F','D','E') is incorrectly modified.
4303 ;; Operators should be surrounded by spaces.
4307 nil t)
4326 ))
4329 \f
4330 ;; -------------------------------------------------------------
4331 ;; -- Moving To Procedures/Packages/Statements
4332 ;; -------------------------------------------------------------
4335 "Move point to the matching start of the current Ada structure."
4341 ;;
4342 ;; do nothing if in string or comment or not on 'end ...;'
4343 ;; or if an error occurs during processing
4344 ;;
4357 ;;
4358 ;; on 'begin' => go on, according to user option
4359 ;;
4360 ada-move-to-declaration
4367 ;; now really move to the found position
4371 "Move point to the end of the block around point.
4372 Moves to 'begin' if in a declarative part."
4375 decl-start)
4381 ;; Go to the beginning of the current word, and check if we are
4382 ;; directly on 'begin'
4388 ;; on first line of subprogram body
4389 ;; Do nothing for specs or generic instantiation, since these are
4390 ;; handled as the general case (find the enclosing block)
4391 ;; We also need to make sure that we ignore nested subprograms
4397 ))
4401 ;; on first line of task declaration
4410 ;; accept block start
4415 ;; package start
4421 ;; On a "declare" keyword
4427 ;; inside a 'begin' ... 'end' block
4432 ;; (hopefully ;-) everything else
4436 )
4438 ;; now really move to the position found
4442 "Move point to next procedure."
4450 "Move point to previous procedure."
4458 "Move point to next package."
4466 "Move point to previous package."
4473 \f
4474 ;; ------------------------------------------------------------
4475 ;; -- Define keymap and menus for Ada
4476 ;; -------------------------------------------------------------
4479 "Create the keymap associated with the Ada mode."
4481 ;; All non-standard keys go into ada-mode-extra-map
4484 ;; Indentation and Formatting
4492 ;; We don't want to make meta-characters case-specific.
4494 ;; Movement
4500 ;; Compilation
4504 ;; Casing
4510 ;; On XEmacs, you can easily specify whether DEL should deletes
4511 ;; one character forward or one character backward. Take this into
4512 ;; account
4515 'backward-delete-char-untabify)
4517 ;; Make body
4518 (define-key ada-mode-map "\C-c\C-n" 'ada-make-subprogram-body)
4520 ;; Use predefined function of Emacs19 for comments (RE)
4521 (define-key ada-mode-map "\C-c;" 'comment-region)
4522 (define-key ada-mode-map "\C-c:" 'ada-uncomment-region)
4524 ;; The following keys are bound to functions defined in ada-xref.el or
4525 ;; ada-prj,el., However, RMS rightly thinks that the code should be shared,
4526 ;; and activated only if the right compiler is used
4528 (define-key ada-mode-map (if (featurep 'xemacs) '(shift button3) [S-mouse-3])
4529 'ada-point-and-xref)
4530 (define-key ada-mode-map [(control tab)] 'ada-complete-identifier)
4532 (define-key ada-mode-extra-map "o" 'ff-find-other-file)
4533 (define-key ada-mode-map "\C-c5\C-d" 'ada-goto-declaration-other-frame)
4534 (define-key ada-mode-map "\C-c\C-d" 'ada-goto-declaration)
4535 (define-key ada-mode-map "\C-c\C-s" 'ada-xref-goto-previous-reference)
4536 (define-key ada-mode-map "\C-c\C-c" 'ada-compile-application)
4537 (define-key ada-mode-extra-map "c" 'ada-change-prj)
4538 (define-key ada-mode-extra-map "d" 'ada-set-default-project-file)
4539 (define-key ada-mode-extra-map "g" 'ada-gdb-application)
4540 (define-key ada-mode-map "\C-c\C-m" 'ada-set-main-compile-application)
4541 (define-key ada-mode-extra-map "r" 'ada-run-application)
4542 (define-key ada-mode-map "\C-c\C-o" 'ada-goto-parent)
4543 (define-key ada-mode-map "\C-c\C-r" 'ada-find-references)
4544 (define-key ada-mode-extra-map "l" 'ada-find-local-references)
4545 (define-key ada-mode-map "\C-c\C-v" 'ada-check-current)
4546 (define-key ada-mode-extra-map "f" 'ada-find-file)
4548 (define-key ada-mode-extra-map "u" 'ada-prj-edit)
4550 (define-key ada-mode-map "\C-xnd" 'ada-narrow-to-defun); override narrow-to-defun
4552 ;; The templates, defined in ada-stmt.el
4554 (let ((map (make-sparse-keymap)))
4555 (define-key map "h" 'ada-header)
4556 (define-key map "\C-a" 'ada-array)
4557 (define-key map "b" 'ada-exception-block)
4558 (define-key map "d" 'ada-declare-block)
4559 (define-key map "c" 'ada-case)
4560 (define-key map "\C-e" 'ada-elsif)
4561 (define-key map "e" 'ada-else)
4562 (define-key map "\C-k" 'ada-package-spec)
4563 (define-key map "k" 'ada-package-body)
4564 (define-key map "\C-p" 'ada-procedure-spec)
4565 (define-key map "p" 'ada-subprogram-body)
4566 (define-key map "\C-f" 'ada-function-spec)
4567 (define-key map "f" 'ada-for-loop)
4568 (define-key map "i" 'ada-if)
4569 (define-key map "l" 'ada-loop)
4570 (define-key map "\C-r" 'ada-record)
4571 (define-key map "\C-s" 'ada-subtype)
4572 (define-key map "S" 'ada-tabsize)
4573 (define-key map "\C-t" 'ada-task-spec)
4574 (define-key map "t" 'ada-task-body)
4575 (define-key map "\C-y" 'ada-type)
4576 (define-key map "\C-v" 'ada-private)
4577 (define-key map "u" 'ada-use)
4578 (define-key map "\C-u" 'ada-with)
4579 (define-key map "\C-w" 'ada-when)
4580 (define-key map "w" 'ada-while-loop)
4581 (define-key map "\C-x" 'ada-exception)
4582 (define-key map "x" 'ada-exit)
4583 (define-key ada-mode-extra-map "t" map))
4584 )
4587 (defun ada-create-menu ()
4588 "Create the Ada menu as shown in the menu bar."
4589 (let ((m '("Ada"
4590 ("Help"
4591 ["Ada Mode" (info "ada-mode") t]
4592 ["GNAT User's Guide" (info "gnat_ugn")
4593 (eq ada-which-compiler 'gnat)]
4594 ["GNAT Reference Manual" (info "gnat_rm")
4595 (eq ada-which-compiler 'gnat)]
4596 ["Gcc Documentation" (info "gcc")
4597 (eq ada-which-compiler 'gnat)]
4598 ["Gdb Documentation" (info "gdb")
4599 (eq ada-which-compiler 'gnat)]
4600 ["Ada95 Reference Manual" (info "arm95") t])
4601 ("Options" :included (derived-mode-p 'ada-mode)
4602 ["Auto Casing" (setq ada-auto-case (not ada-auto-case))
4603 :style toggle :selected ada-auto-case]
4604 ["Auto Indent After Return"
4605 (setq ada-indent-after-return (not ada-indent-after-return))
4606 :style toggle :selected ada-indent-after-return]
4607 ["Automatically Recompile For Cross-references"
4608 (setq ada-xref-create-ali (not ada-xref-create-ali))
4609 :style toggle :selected ada-xref-create-ali
4610 :included (eq ada-which-compiler 'gnat)]
4611 ["Confirm Commands"
4612 (setq ada-xref-confirm-compile (not ada-xref-confirm-compile))
4613 :style toggle :selected ada-xref-confirm-compile
4614 :included (eq ada-which-compiler 'gnat)]
4615 ["Show Cross-references In Other Buffer"
4616 (setq ada-xref-other-buffer (not ada-xref-other-buffer))
4617 :style toggle :selected ada-xref-other-buffer
4618 :included (eq ada-which-compiler 'gnat)]
4619 ["Tight Integration With GNU Visual Debugger"
4620 (setq ada-tight-gvd-integration (not ada-tight-gvd-integration))
4621 :style toggle :selected ada-tight-gvd-integration
4622 :included (string-match "gvd" ada-prj-default-debugger)])
4623 ["Customize" (customize-group 'ada)
4624 :included (fboundp 'customize-group)]
4625 ["Check file" ada-check-current t]
4626 ["Compile file" ada-compile-current t]
4627 ["Set main and Build" ada-set-main-compile-application t]
4628 ["Show main" ada-show-current-main t]
4629 ["Build" ada-compile-application t]
4630 ["Run" ada-run-application t]
4631 ["Debug" ada-gdb-application (eq ada-which-compiler 'gnat)]
4632 ["------" nil nil]
4633 ("Project"
4634 ["Show project" ada-show-current-project t]
4635 ["Load..." ada-set-default-project-file t]
4636 ["New..." ada-prj-new t]
4637 ["Edit..." ada-prj-edit t])
4638 ("Goto" :included (derived-mode-p 'ada-mode)
4639 ["Goto Declaration/Body" ada-goto-declaration
4640 (eq ada-which-compiler 'gnat)]
4641 ["Goto Body" ada-goto-body
4642 (eq ada-which-compiler 'gnat)]
4643 ["Goto Declaration Other Frame"
4644 ada-goto-declaration-other-frame
4645 (eq ada-which-compiler 'gnat)]
4646 ["Goto Previous Reference" ada-xref-goto-previous-reference
4647 (eq ada-which-compiler 'gnat)]
4648 ["List Local References" ada-find-local-references
4649 (eq ada-which-compiler 'gnat)]
4650 ["List References" ada-find-references
4651 (eq ada-which-compiler 'gnat)]
4652 ["Goto Reference To Any Entity" ada-find-any-references
4653 (eq ada-which-compiler 'gnat)]
4654 ["Goto Parent Unit" ada-goto-parent
4655 (eq ada-which-compiler 'gnat)]
4656 ["--" nil nil]
4657 ["Next compilation error" next-error t]
4658 ["Previous Package" ada-previous-package t]
4659 ["Next Package" ada-next-package t]
4660 ["Previous Procedure" ada-previous-procedure t]
4661 ["Next Procedure" ada-next-procedure t]
4662 ["Goto Start Of Statement" ada-move-to-start t]
4663 ["Goto End Of Statement" ada-move-to-end t]
4664 ["-" nil nil]
4665 ["Other File" ff-find-other-file t]
4666 ["Other File Other Window" ada-ff-other-window t])
4667 ("Edit" :included (derived-mode-p 'ada-mode)
4668 ["Search File On Source Path" ada-find-file t]
4669 ["------" nil nil]
4670 ["Complete Identifier" ada-complete-identifier t]
4671 ["-----" nil nil]
4672 ["Indent Line" ada-indent-current-function t]
4673 ["Justify Current Indentation" ada-justified-indent-current t]
4674 ["Indent Lines in Selection" ada-indent-region t]
4675 ["Indent Lines in File"
4676 (ada-indent-region (point-min) (point-max)) t]
4677 ["Format Parameter List" ada-format-paramlist t]
4678 ["-" nil nil]
4679 ["Comment Selection" comment-region t]
4680 ["Uncomment Selection" ada-uncomment-region t]
4681 ["--" nil nil]
4682 ["Fill Comment Paragraph" fill-paragraph t]
4683 ["Fill Comment Paragraph Justify"
4684 ada-fill-comment-paragraph-justify t]
4685 ["Fill Comment Paragraph Postfix"
4686 ada-fill-comment-paragraph-postfix t]
4687 ["---" nil nil]
4688 ["Adjust Case Selection" ada-adjust-case-region t]
4689 ["Adjust Case in File" ada-adjust-case-buffer t]
4690 ["Create Case Exception" ada-create-case-exception t]
4691 ["Create Case Exception Substring"
4692 ada-create-case-exception-substring t]
4693 ["Reload Case Exceptions" ada-case-read-exceptions t]
4694 ["----" nil nil]
4695 ["Make body for subprogram" ada-make-subprogram-body t]
4696 ["-----" nil nil]
4697 ["Narrow to subprogram" ada-narrow-to-defun t])
4698 ("Templates"
4699 :included (derived-mode-p 'ada-mode)
4700 ["Header" ada-header t]
4701 ["-" nil nil]
4702 ["Package Body" ada-package-body t]
4703 ["Package Spec" ada-package-spec t]
4704 ["Function Spec" ada-function-spec t]
4705 ["Procedure Spec" ada-procedure-spec t]
4706 ["Proc/func Body" ada-subprogram-body t]
4707 ["Task Body" ada-task-body t]
4708 ["Task Spec" ada-task-spec t]
4709 ["Declare Block" ada-declare-block t]
4710 ["Exception Block" ada-exception-block t]
4711 ["--" nil nil]
4712 ["Entry" ada-entry t]
4713 ["Entry family" ada-entry-family t]
4714 ["Select" ada-select t]
4715 ["Accept" ada-accept t]
4716 ["Or accept" ada-or-accept t]
4717 ["Or delay" ada-or-delay t]
4718 ["Or terminate" ada-or-terminate t]
4719 ["---" nil nil]
4720 ["Type" ada-type t]
4721 ["Private" ada-private t]
4722 ["Subtype" ada-subtype t]
4723 ["Record" ada-record t]
4724 ["Array" ada-array t]
4725 ["----" nil nil]
4726 ["If" ada-if t]
4727 ["Else" ada-else t]
4728 ["Elsif" ada-elsif t]
4729 ["Case" ada-case t]
4730 ["-----" nil nil]
4731 ["While Loop" ada-while-loop t]
4732 ["For Loop" ada-for-loop t]
4733 ["Loop" ada-loop t]
4734 ["------" nil nil]
4735 ["Exception" ada-exception t]
4736 ["Exit" ada-exit t]
4737 ["When" ada-when t])
4738 )))
4740 (easy-menu-define ada-mode-menu ada-mode-map "Menu keymap for Ada mode" m)
4741 (if (featurep 'xemacs)
4742 (progn
4743 (define-key ada-mode-map [menu-bar] ada-mode-menu)
4744 (setq mode-popup-menu (cons "Ada mode" ada-mode-menu))))))
4746 \f
4747 ;; -------------------------------------------------------
4748 ;; Commenting/Uncommenting code
4749 ;; The following two calls are provided to enhance the standard
4750 ;; comment-region function, which only allows uncommenting if the
4751 ;; comment is at the beginning of a line. If the line have been re-indented,
4752 ;; we are unable to use comment-region, which makes no sense.
4753 ;;
4754 ;; In addition, we provide an interface to the standard comment handling
4755 ;; function for justifying the comments.
4756 ;; -------------------------------------------------------
4758 (defadvice comment-region (before ada-uncomment-anywhere disable)
4759 (if (and (consp arg) ;; a prefix with \C-u is of the form '(4), whereas
4760 ;; \C-u 2 sets arg to '2' (fixed by S.Leake)
4761 (derived-mode-p 'ada-mode))
4762 (save-excursion
4764 (goto-char beg)
4765 (while (re-search-forward cs end t)
4766 (replace-match comment-start))
4767 ))))
4769 (defun ada-uncomment-region (beg end &optional arg)
4770 "Uncomment region BEG .. END.
4771 ARG gives number of comment characters."
4774 ;; This advice is not needed anymore with Emacs21. However, for older
4775 ;; versions, as well as for XEmacs, we still need to enable it.
4776 (if (or (<= emacs-major-version 20) (featurep 'xemacs))
4777 (progn
4778 (ad-activate 'comment-region)
4779 (comment-region beg end (- (or arg 2)))
4780 (ad-deactivate 'comment-region))
4781 (comment-region beg end (list (- (or arg 2))))
4782 (ada-indent-region beg end)))
4784 (defun ada-fill-comment-paragraph-justify ()
4785 "Fill current comment paragraph and justify each line as well."
4786 (interactive)
4787 (ada-fill-comment-paragraph 'full))
4789 (defun ada-fill-comment-paragraph-postfix ()
4790 "Fill current comment paragraph and justify each line as well.
4791 Adds `ada-fill-comment-postfix' at the end of each line."
4792 (interactive)
4793 (ada-fill-comment-paragraph 'full t))
4795 (defun ada-fill-comment-paragraph (&optional justify postfix)
4796 "Fill the current comment paragraph.
4797 If JUSTIFY is non-nil, each line is justified as well.
4798 If POSTFIX and JUSTIFY are non-nil, `ada-fill-comment-postfix' is appended
4799 to each line filled and justified.
4800 The paragraph is indented on the first line."
4801 (interactive "P")
4803 ;; check if inside comment or just in front a comment
4804 (if (and (not (ada-in-comment-p))
4806 (error "Not inside comment"))
4808 (let* (indent from to
4809 (opos (point-marker))
4811 ;; Sets this variable to nil, otherwise it prevents
4812 ;; fill-region-as-paragraph to work on Emacs <= 20.2
4813 (parse-sexp-lookup-properties nil)
4815 fill-prefix
4816 (fill-column (current-fill-column)))
4818 ;; Find end of paragraph
4819 (back-to-indentation)
4821 (forward-line 1)
4823 ;; If we were at the last line in the buffer, create a dummy empty
4824 ;; line at the end of the buffer.
4825 (if (eobp)
4827 (back-to-indentation)))
4828 (beginning-of-line)
4829 (setq to (point-marker))
4830 (goto-char opos)
4832 ;; Find beginning of paragraph
4833 (back-to-indentation)
4835 (forward-line -1)
4836 (back-to-indentation))
4838 ;; We want one line above the first one, unless we are at the beginning
4839 ;; of the buffer
4840 (unless (bobp)
4841 (forward-line 1))
4842 (beginning-of-line)
4843 (setq from (point-marker))
4845 ;; Calculate the indentation we will need for the paragraph
4846 (back-to-indentation)
4847 (setq indent (current-column))
4848 ;; unindent the first line of the paragraph
4849 (delete-region from (point))
4851 ;; Remove the old postfixes
4852 (goto-char from)
4856 (goto-char (1- to))
4857 (setq to (point-marker))
4859 ;; Indent and justify the paragraph
4860 (setq fill-prefix ada-fill-comment-prefix)
4861 (set-left-margin from to indent)
4862 (if postfix
4863 (setq fill-column (- fill-column (length ada-fill-comment-postfix))))
4865 (fill-region-as-paragraph from to justify)
4867 ;; Add the postfixes if required
4868 (if postfix
4869 (save-restriction
4870 (goto-char from)
4871 (narrow-to-region from to)
4872 (while (not (eobp))
4873 (end-of-line)
4874 (insert-char ? (- fill-column (current-column)))
4875 (insert ada-fill-comment-postfix)
4876 (forward-line))
4877 ))
4879 ;; In Emacs <= 20.2 and XEmacs <=20.4, there is a bug, and a newline is
4880 ;; inserted at the end. Delete it
4881 (if (or (featurep 'xemacs)
4882 (<= emacs-major-version 19)
4883 (and (= emacs-major-version 20)
4884 (<= emacs-minor-version 2)))
4885 (progn
4886 (goto-char to)
4887 (end-of-line)
4888 (delete-char 1)))
4890 (goto-char opos)))
4893 ;; ---------------------------------------------------
4894 ;; support for find-file.el
4895 ;; These functions are used by find-file to guess the file names from
4896 ;; unit names, and to find the other file (spec or body) from the current
4897 ;; file (body or spec).
4898 ;; It is also used to find in which function we are, so as to put the
4899 ;; cursor at the correct position.
4900 ;; Standard Ada does not force any relation between unit names and file names,
4901 ;; so some of these functions can only be a good approximation. However, they
4902 ;; are also overridden in `ada-xref'.el when we know that the user is using
4903 ;; GNAT.
4904 ;; ---------------------------------------------------
4906 ;; Overridden when we work with GNAT, to use gnatkrunch
4907 (defun ada-make-filename-from-adaname (adaname)
4908 "Determine the filename in which ADANAME is found.
4909 This matches the GNAT default naming convention, except for
4910 pre-defined units."
4912 (setq adaname (replace-match "-" t t adaname)))
4913 (downcase adaname)
4914 )
4916 (defun ada-other-file-name ()
4917 "Return the name of the other file.
4918 The name returned is the body if `current-buffer' is the spec,
4919 or the spec otherwise."
4921 (let ((is-spec nil)
4922 (is-body nil)
4923 (suffixes ada-spec-suffixes)
4924 (name (buffer-file-name)))
4926 ;; Guess whether we have a spec or a body, and get the basename of the
4927 ;; file. Since the extension may not start with '.', we can not use
4928 ;; file-name-extension
4929 (while (and (not is-spec)
4930 suffixes)
4932 (setq is-spec t
4933 name (match-string 1 name)))
4934 (setq suffixes (cdr suffixes)))
4936 (if (not is-spec)
4937 (progn
4938 (setq suffixes ada-body-suffixes)
4939 (while (and (not is-body)
4940 suffixes)
4942 (setq is-body t
4943 name (match-string 1 name)))
4944 (setq suffixes (cdr suffixes)))))
4946 ;; If this wasn't in either list, return name itself
4947 (if (not (or is-spec is-body))
4948 name
4950 ;; Else find the other possible names
4951 (if is-spec
4952 (setq suffixes ada-body-suffixes)
4953 (setq suffixes ada-spec-suffixes))
4954 (setq is-spec name)
4956 (while suffixes
4958 ;; If we are using project file, search for the other file in all
4959 ;; the possible src directories.
4961 (if (fboundp 'ada-find-src-file-in-dir)
4962 (let ((other
4963 (ada-find-src-file-in-dir
4964 (file-name-nondirectory (concat name (car suffixes))))))
4965 (if other
4966 (setq is-spec other)))
4968 ;; Else search in the current directory
4969 (if (file-exists-p (concat name (car suffixes)))
4970 (setq is-spec (concat name (car suffixes)))))
4971 (setq suffixes (cdr suffixes)))
4973 is-spec)))
4975 (defun ada-which-function-are-we-in ()
4976 "Return the name of the function whose definition/declaration point is in.
4977 Used in `ff-pre-load-hook'."
4978 (setq ff-function-name nil)
4979 (save-excursion
4980 (end-of-line);; make sure we get the complete name
4981 (or (if (re-search-backward ada-procedure-start-regexp nil t)
4982 (setq ff-function-name (match-string 5)))
4983 (if (re-search-backward ada-package-start-regexp nil t)
4984 (setq ff-function-name (match-string 4))))
4985 ))
4988 (defvar ada-last-which-function-line -1
4989 "Last line on which `ada-which-function' was called.")
4990 (defvar ada-last-which-function-subprog 0
4991 "Last subprogram name returned by `ada-which-function'.")
4992 (make-variable-buffer-local 'ada-last-which-function-subprog)
4993 (make-variable-buffer-local 'ada-last-which-function-line)
4996 (defun ada-which-function ()
4997 "Return the name of the function whose body the point is in.
4998 This function works even in the case of nested subprograms, whereas the
4999 standard Emacs function `which-function' does not.
5000 Since the search can be long, the results are cached."
5002 (let ((line (count-lines 1 (point)))
5003 (pos (point))
5004 end-pos
5005 func-name indent
5006 found)
5008 ;; If this is the same line as before, simply return the same result
5009 (if (= line ada-last-which-function-line)
5010 ada-last-which-function-subprog
5012 (save-excursion
5013 ;; In case the current line is also the beginning of the body
5014 (end-of-line)
5019 (condition-case nil
5020 (up-list 1)
5021 (error nil))
5024 (if (looking-at "return")
5025 (progn
5026 (forward-word 1)
5028 (skip-chars-forward "a-zA-Z0-9_'")))
5030 ;; Can't simply do forward-word, in case the "is" is not on the
5031 ;; same line as the closing parenthesis
5034 ;; No look for the closest subprogram body that has not ended yet.
5035 ;; Not that we expect all the bodies to be finished by "end <name>",
5036 ;; or a simple "end;" indented in the same column as the start of
5037 ;; the subprogram. The goal is to be as efficient as possible.
5039 (while (and (not found)
5040 (re-search-backward ada-imenu-subprogram-menu-re nil t))
5042 ;; Get the function name, but not the properties, or this changes
5043 ;; the face in the mode line on Emacs 21
5044 (setq func-name (match-string-no-properties 3))
5045 (if (and (not (ada-in-comment-p))
5046 (not (save-excursion
5047 (goto-char (match-end 0))
5049 (save-excursion
5050 (back-to-indentation)
5051 (setq indent (current-column))
5052 (if (ada-search-ignore-string-comment
5054 (make-string indent ? ) "end;"))
5055 (setq end-pos (point))
5056 (setq end-pos (point-max)))
5057 (if (>= end-pos pos)
5058 (setq found func-name))))
5059 )
5060 (setq ada-last-which-function-line line
5061 ada-last-which-function-subprog found)
5062 found))))
5064 (defun ada-ff-other-window ()
5065 "Find other file in other window using `ff-find-other-file'."
5066 (interactive)
5067 (and (fboundp 'ff-find-other-file)
5068 (ff-find-other-file t)))
5070 (defun ada-set-point-accordingly ()
5071 "Move to the function declaration that was set by `ff-which-function-are-we-in'."
5072 (if ff-function-name
5073 (progn
5074 (goto-char (point-min))
5075 (unless (ada-search-ignore-string-comment
5077 (goto-char (point-min))))))
5079 (defun ada-get-body-name (&optional spec-name)
5080 "Return the file name for the body of SPEC-NAME.
5081 If SPEC-NAME is nil, return the body for the current package.
5082 Return nil if no body was found."
5083 (interactive)
5085 (unless spec-name (setq spec-name (buffer-file-name)))
5087 ;; Remove the spec extension. We can not simply remove the file extension,
5088 ;; but we need to take into account the specific non-GNAT extensions that the
5089 ;; user might have specified.
5091 (let ((suffixes ada-spec-suffixes)
5092 end)
5093 (while suffixes
5094 (setq end (- (length spec-name) (length (car suffixes))))
5095 (if (string-equal (car suffixes) (substring spec-name end))
5096 (setq spec-name (substring spec-name 0 end)))
5097 (setq suffixes (cdr suffixes))))
5099 ;; If find-file.el was available, use its functions
5100 (if (fboundp 'ff-get-file-name)
5101 (ff-get-file-name ada-search-directories-internal
5102 (ada-make-filename-from-adaname
5103 (file-name-nondirectory
5104 (file-name-sans-extension spec-name)))
5105 ada-body-suffixes)
5106 ;; Else emulate it very simply
5107 (concat (ada-make-filename-from-adaname
5108 (file-name-nondirectory
5109 (file-name-sans-extension spec-name)))
5110 ".adb")))
5112 \f
5113 ;; ---------------------------------------------------
5114 ;; support for font-lock.el
5115 ;; Strings are a real pain in Ada because a single quote character is
5116 ;; overloaded as a string quote and type/instance delimiter. By default, a
5117 ;; single quote is given punctuation syntax in `ada-mode-syntax-table'.
5118 ;; So, for Font Lock mode purposes, we mark single quotes as having string
5119 ;; syntax when the gods that created Ada determine them to be.
5120 ;;
5121 ;; This only works in Emacs. See the comments before the grammar functions
5122 ;; at the beginning of this file for how this is done with XEmacs.
5123 ;; ----------------------------------------------------
5125 (defconst ada-font-lock-syntactic-keywords
5126 ;; Mark single quotes as having string quote syntax in 'c' instances.
5127 ;; We used to explicitly avoid ''' as a special case for fear the buffer
5128 ;; be highlighted as a string, but it seems this fear is unfounded.
5129 ;;
5130 ;; This sets the properties of the characters, so that ada-in-string-p
5131 ;; correctly handles '"' too...
5135 (defvar ada-font-lock-keywords
5136 (eval-when-compile
5137 (list
5138 ;;
5139 ;; handle "type T is access function return S;"
5142 ;; preprocessor line
5145 ;;
5146 ;; accept, entry, function, package (body), protected (body|type),
5147 ;; pragma, procedure, task (body) plus name.
5148 (list (concat
5162 "task"
5165 '(1 font-lock-keyword-face) '(2 font-lock-function-name-face nil t))
5166 ;;
5167 ;; Optional keywords followed by a type name.
5169 "\\<\\(access[ \t]+all\\|access[ \t]+constant\\|access\\|constant\\|in[ \t]+reverse\\|\\|in[ \t]+out\\|in\\|out\\)\\>"
5172 '(1 font-lock-keyword-face nil t) '(2 font-lock-type-face nil t))
5174 ;;
5175 ;; Main keywords, except those treated specially below.
5177 (regexp-opt
5178 '("abort" "abs" "abstract" "accept" "access" "aliased" "all"
5179 "and" "array" "at" "begin" "case" "declare" "delay" "delta"
5180 "digits" "do" "else" "elsif" "entry" "exception" "exit" "for"
5181 "generic" "if" "in" "interface" "is" "limited" "loop" "mod" "not"
5182 "null" "or" "others" "overriding" "private" "protected" "raise"
5183 "range" "record" "rem" "renames" "requeue" "return" "reverse"
5184 "select" "separate" "synchronized" "tagged" "task" "terminate"
5185 "then" "until" "when" "while" "with" "xor") t)
5187 ;;
5188 ;; Anything following end and not already fontified is a body name.
5190 (1 font-lock-keyword-face) (3 font-lock-function-name-face nil t))
5191 ;;
5192 ;; Keywords followed by a type or function name.
5196 '(1 font-lock-keyword-face)
5197 '(2 (if (match-beginning 4)
5198 font-lock-function-name-face
5199 font-lock-type-face) nil t))
5200 ;;
5201 ;; Keywords followed by a (comma separated list of) reference.
5202 ;; Note that font-lock only works on single lines, thus we can not
5203 ;; correctly highlight a with_clause that spans multiple lines.
5206 '(1 font-lock-keyword-face) '(2 font-lock-constant-face nil t))
5208 ;;
5209 ;; Goto tags.
5212 ;; Highlight based-numbers (R. Reagan <robin-reply@reagans.org>)
5215 ;; Ada unnamed numerical constants
5218 ))
5219 "Default expressions to highlight in Ada mode.")
5222 ;; ---------------------------------------------------------
5223 ;; Support for outline.el
5224 ;; ---------------------------------------------------------
5226 (defun ada-outline-level ()
5227 "This is so that `current-column' DTRT in otherwise-hidden text."
5228 ;; patch from Dave Love <fx@gnu.org>
5229 (let (buffer-invisibility-spec)
5230 (save-excursion
5231 (back-to-indentation)
5232 (current-column))))
5234 ;; ---------------------------------------------------------
5235 ;; Support for narrow-to-region
5236 ;; ---------------------------------------------------------
5238 (defun ada-narrow-to-defun (&optional _arg)
5239 "Make text outside current subprogram invisible.
5240 The subprogram visible is the one that contains or follow point.
5241 Optional ARG is ignored.
5244 (interactive)
5245 (save-excursion
5246 (let (end)
5247 (widen)
5248 (forward-line 1)
5249 (ada-previous-procedure)
5250 (setq end (point-at-bol))
5251 (ada-move-to-end)
5252 (end-of-line)
5253 (narrow-to-region end (point))
5254 (message
5255 "Use M-x widen to get back to full visibility in the buffer"))))
5257 ;; ---------------------------------------------------------
5258 ;; Automatic generation of code
5259 ;; The Ada mode has a set of function to automatically generate a subprogram
5260 ;; or package body from its spec.
5261 ;; These function only use a primary and basic algorithm, this could use a
5262 ;; lot of improvement.
5263 ;; When the user is using GNAT, we rather use gnatstub to generate an accurate
5264 ;; body.
5265 ;; ----------------------------------------------------------
5267 (defun ada-gen-treat-proc (match)
5268 "Make dummy body of a procedure/function specification.
5269 MATCH is a cons cell containing the start and end locations of the last search
5270 for `ada-procedure-start-regexp'."
5271 (goto-char (car match))
5272 (let (func-found procname functype)
5273 (cond
5276 ;; treat it as a proc/func
5277 (forward-word 2)
5278 (forward-word -1)
5279 (setq procname (buffer-substring (point) (cdr match))) ; store proc name
5281 ;; goto end of procname
5282 (goto-char (cdr match))
5284 ;; skip over parameterlist
5286 (forward-sexp))
5288 ;; if function, skip over 'return' and result type.
5289 (if func-found
5290 (progn
5291 (forward-word 1)
5293 (setq functype (buffer-substring (point)
5294 (progn
5295 (skip-chars-forward
5296 "a-zA-Z0-9_\.")
5297 (point))))))
5298 ;; look for next non WS
5299 (cond
5301 (delete-region (match-beginning 0) (match-end 0));; delete the ';'
5302 (ada-indent-newline-indent)
5303 (insert "is")
5304 (ada-indent-newline-indent)
5305 (if func-found
5306 (progn
5307 (insert "Result : " functype ";")
5308 (ada-indent-newline-indent)))
5309 (insert "begin")
5310 (ada-indent-newline-indent)
5311 (if func-found
5312 (insert "return Result;")
5313 (insert "null;"))
5314 (ada-indent-newline-indent)
5315 (insert "end " procname ";")
5316 (ada-indent-newline-indent)
5317 )
5320 ;; do nothing
5321 )
5324 ;; do nothing
5325 )
5327 (t
5328 (message "unknown syntax"))))
5329 (t
5331 (progn
5332 (message "Task conversion is not yet implemented")
5333 (forward-word 2)
5335 (forward-line)
5336 (ada-move-to-end))
5337 ))))))
5339 (defun ada-make-body ()
5340 "Create an Ada package body in the current buffer.
5341 The spec must be the previously visited buffer.
5342 This function typically is to be hooked into `ff-file-created-hook'."
5343 (delete-region (point-min) (point-max))
5344 (insert-buffer-substring (car (cdr (buffer-list))))
5345 (goto-char (point-min))
5346 (ada-mode)
5348 (let (found ada-procedure-or-package-start-regexp)
5349 (if (setq found
5350 (ada-search-ignore-string-comment ada-package-start-regexp nil))
5351 (progn (goto-char (cdr found))
5352 (insert " body")
5353 )
5354 (error "No package"))
5356 (setq ada-procedure-or-package-start-regexp
5357 (concat ada-procedure-start-regexp
5359 ada-package-start-regexp))
5361 (while (setq found
5362 (ada-search-ignore-string-comment
5363 ada-procedure-or-package-start-regexp nil))
5364 (progn
5365 (goto-char (car found))
5366 (if (looking-at ada-package-start-regexp)
5367 (progn (goto-char (cdr found))
5368 (insert " body"))
5369 (ada-gen-treat-proc found))))))
5372 (defun ada-make-subprogram-body ()
5373 "Create a dummy subprogram body in package body file from spec surrounding point."
5374 (interactive)
5375 (let* ((found (re-search-backward ada-procedure-start-regexp nil t))
5376 (spec (match-beginning 0))
5377 body-file)
5378 (if found
5379 (progn
5380 (goto-char spec)
5382 (= (char-before) ?\())
5383 (progn
5384 (ada-search-ignore-string-comment ")" nil)
5385 (ada-search-ignore-string-comment ";" nil)))
5386 (setq spec (buffer-substring spec (point)))
5388 ;; If find-file.el was available, use its functions
5389 (setq body-file (ada-get-body-name))
5390 (if body-file
5391 (find-file body-file)
5392 (error "No body found for the package. Create it first"))
5394 (save-restriction
5395 (widen)
5396 (goto-char (point-max))
5397 (forward-comment -10000)
5399 ;; Move to the beginning of the elaboration part, if any
5400 (re-search-backward "^begin" nil t)
5401 (newline)
5402 (forward-char -1)
5403 (insert spec)
5404 (re-search-backward ada-procedure-start-regexp nil t)
5405 (ada-gen-treat-proc (cons (match-beginning 0) (match-end 0)))
5406 ))
5407 (error "Not in subprogram spec"))))
5409 ;; --------------------------------------------------------
5410 ;; Global initializations
5411 ;; --------------------------------------------------------
5413 ;; Create the keymap once and for all. If we do that in ada-mode,
5414 ;; the keys changed in the user's .emacs have to be modified
5415 ;; every time
5416 (ada-create-keymap)
5417 (ada-create-menu)
5419 ;; Add the default extensions (and set up speedbar)
5420 (ada-add-extensions ".ads" ".adb")
5421 ;; This two files are generated by GNAT when running with -gnatD
5422 (if (equal ada-which-compiler 'gnat)
5423 (ada-add-extensions ".ads.dg" ".adb.dg"))
5425 ;; Read the special cases for exceptions
5426 (ada-case-read-exceptions)
5428 ;; Setup auto-loading of the other Ada mode files.
5429 (autoload 'ada-change-prj "ada-xref" nil t)
5430 (autoload 'ada-check-current "ada-xref" nil t)
5431 (autoload 'ada-compile-application "ada-xref" nil t)
5432 (autoload 'ada-compile-current "ada-xref" nil t)
5433 (autoload 'ada-complete-identifier "ada-xref" nil t)
5434 (autoload 'ada-find-file "ada-xref" nil t)
5435 (autoload 'ada-find-any-references "ada-xref" nil t)
5436 (autoload 'ada-find-src-file-in-dir "ada-xref" nil t)
5437 (autoload 'ada-find-local-references "ada-xref" nil t)
5438 (autoload 'ada-find-references "ada-xref" nil t)
5439 (autoload 'ada-gdb-application "ada-xref" nil t)
5440 (autoload 'ada-goto-declaration "ada-xref" nil t)
5441 (autoload 'ada-goto-declaration-other-frame "ada-xref" nil t)
5442 (autoload 'ada-goto-parent "ada-xref" nil t)
5443 (autoload 'ada-make-body-gnatstub "ada-xref" nil t)
5444 (autoload 'ada-point-and-xref "ada-xref" nil t)
5445 (autoload 'ada-reread-prj-file "ada-xref" nil t)
5446 (autoload 'ada-run-application "ada-xref" nil t)
5447 (autoload 'ada-set-default-project-file "ada-xref" nil t)
5448 (autoload 'ada-xref-goto-previous-reference "ada-xref" nil t)
5449 (autoload 'ada-set-main-compile-application "ada-xref" nil t)
5450 (autoload 'ada-show-current-main "ada-xref" nil t)
5452 (autoload 'ada-customize "ada-prj" nil t)
5453 (autoload 'ada-prj-edit "ada-prj" nil t)
5454 (autoload 'ada-prj-new "ada-prj" nil t)
5455 (autoload 'ada-prj-save "ada-prj" nil t)
5457 (autoload 'ada-array "ada-stmt" nil t)
5458 (autoload 'ada-case "ada-stmt" nil t)
5459 (autoload 'ada-declare-block "ada-stmt" nil t)
5460 (autoload 'ada-else "ada-stmt" nil t)
5461 (autoload 'ada-elsif "ada-stmt" nil t)
5462 (autoload 'ada-exception "ada-stmt" nil t)
5463 (autoload 'ada-exception-block "ada-stmt" nil t)
5464 (autoload 'ada-exit "ada-stmt" nil t)
5465 (autoload 'ada-for-loop "ada-stmt" nil t)
5466 (autoload 'ada-function-spec "ada-stmt" nil t)
5467 (autoload 'ada-header "ada-stmt" nil t)
5468 (autoload 'ada-if "ada-stmt" nil t)
5469 (autoload 'ada-loop "ada-stmt" nil t)
5470 (autoload 'ada-package-body "ada-stmt" nil t)
5471 (autoload 'ada-package-spec "ada-stmt" nil t)
5472 (autoload 'ada-private "ada-stmt" nil t)
5473 (autoload 'ada-procedure-spec "ada-stmt" nil t)
5474 (autoload 'ada-record "ada-stmt" nil t)
5475 (autoload 'ada-subprogram-body "ada-stmt" nil t)
5476 (autoload 'ada-subtype "ada-stmt" nil t)
5477 (autoload 'ada-tabsize "ada-stmt" nil t)
5478 (autoload 'ada-task-body "ada-stmt" nil t)
5479 (autoload 'ada-task-spec "ada-stmt" nil t)
5480 (autoload 'ada-type "ada-stmt" nil t)
5481 (autoload 'ada-use "ada-stmt" nil t)
5482 (autoload 'ada-when "ada-stmt" nil t)
5483 (autoload 'ada-while-loop "ada-stmt" nil t)
5484 (autoload 'ada-with "ada-stmt" nil t)
5486 ;;; provide ourselves
5487 (provide 'ada-mode)
5489 ;;; ada-mode.el ends here