| blob | d7e1ecb67e1479f3c71ec4a4e1ffee2d72c46955 |
1 ;;; ada-mode.el --- major-mode for editing Ada sources
3 ;; Copyright (C) 1994, 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 ;; 2005, 2006 Free Software Foundation, Inc.
6 ;; Author: Rolf Ebert <ebert@inf.enst.fr>
7 ;; Markus Heritsch <Markus.Heritsch@studbox.uni-stuttgart.de>
8 ;; Emmanuel Briot <briot@gnat.com>
9 ;; Maintainer: Emmanuel Briot <briot@gnat.com>
10 ;; Ada Core Technologies's version: Revision: 1.188
11 ;; Keywords: languages ada
13 ;; This file is part of GNU Emacs.
15 ;; GNU Emacs is free software; you can redistribute it and/or modify
16 ;; it under the terms of the GNU General Public License as published by
17 ;; the Free Software Foundation; either version 2, or (at your option)
18 ;; any later version.
20 ;; GNU Emacs is distributed in the hope that it will be useful,
21 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
22 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 ;; GNU General Public License for more details.
25 ;; You should have received a copy of the GNU General Public License
26 ;; along with GNU Emacs; see the file COPYING. If not, write to the
27 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
28 ;; Boston, MA 02110-1301, USA.
30 ;;; Commentary:
31 ;;; This mode is a major mode for editing Ada83 and Ada95 source code.
32 ;;; This is a major rewrite of the file packaged with Emacs-20. The
33 ;;; ada-mode is composed of four lisp files, ada-mode.el, ada-xref.el,
34 ;;; ada-prj.el and ada-stmt.el. Only this file (ada-mode.el) is
35 ;;; completely independent from the GNU Ada compiler Gnat, distributed
36 ;;; by Ada Core Technologies. All the other files rely heavily on
37 ;;; features provided only by Gnat.
38 ;;;
39 ;;; Note: this mode will not work with Emacs 19. If you are on a VMS
40 ;;; system, where the latest version of Emacs is 19.28, you will need
41 ;;; another file, called ada-vms.el, that provides some required
42 ;;; functions.
44 ;;; Usage:
45 ;;; Emacs should enter Ada mode automatically when you load an Ada file.
46 ;;; By default, the valid extensions for Ada files are .ads, .adb or .ada
47 ;;; If the ada-mode does not start automatically, then simply type the
48 ;;; following command :
49 ;;; M-x ada-mode
50 ;;;
51 ;;; By default, ada-mode is configured to take full advantage of the GNAT
52 ;;; compiler (the menus will include the cross-referencing features,...).
53 ;;; If you are using another compiler, you might want to set the following
54 ;;; variable in your .emacs (Note: do not set this in the ada-mode-hook, it
55 ;;; won't work) :
56 ;;; (setq ada-which-compiler 'generic)
57 ;;;
58 ;;; This mode requires find-file.el to be present on your system.
60 ;;; History:
61 ;;; The first Ada mode for GNU Emacs was written by V. Broman in
62 ;;; 1985. He based his work on the already existing Modula-2 mode.
63 ;;; This was distributed as ada.el in versions of Emacs prior to 19.29.
64 ;;;
65 ;;; Lynn Slater wrote an extensive Ada mode in 1989. It consisted of
66 ;;; several files with support for dired commands and other nice
67 ;;; things. It is currently available from the PAL
68 ;;; (wuarchive.wustl.edu:/languages/ada) as ada-mode-1.06a.tar.Z.
69 ;;;
70 ;;; The probably very first Ada mode (called electric-ada.el) was
71 ;;; written by Steven D. Litvintchouk and Steven M. Rosen for the
72 ;;; Gosling Emacs. L. Slater based his development on ada.el and
73 ;;; electric-ada.el.
74 ;;;
75 ;;; A complete rewrite by M. Heritsch and R. Ebert has been done.
76 ;;; Some ideas from the Ada mode mailing list have been
77 ;;; added. Some of the functionality of L. Slater's mode has not
78 ;;; (yet) been recoded in this new mode. Perhaps you prefer sticking
79 ;;; to his version.
80 ;;;
81 ;;; A complete rewrite for Emacs-20 / Gnat-3.11 has been done by Ada Core
82 ;;; Technologies. Please send bugs to briot@gnat.com
84 ;;; Credits:
85 ;;; Many thanks to John McCabe <john@assen.demon.co.uk> for sending so
86 ;;; many patches included in this package.
87 ;;; Christian Egli <Christian.Egli@hcsd.hac.com>:
88 ;;; ada-imenu-generic-expression
89 ;;; Many thanks also to the following persons that have contributed one day
90 ;;; to the ada-mode
91 ;;; Philippe Waroquiers (PW) <philippe@cfmu.eurocontrol.be> in particular,
92 ;;; woodruff@stc.llnl.gov (John Woodruff)
93 ;;; jj@ddci.dk (Jesper Joergensen)
94 ;;; gse@ocsystems.com (Scott Evans)
95 ;;; comar@gnat.com (Cyrille Comar)
96 ;;; stephen.leake@gsfc.nasa.gov (Stephen Leake)
97 ;;; robin-reply@reagans.org
98 ;;; and others for their valuable hints.
100 ;;; Code:
101 ;;; Note: Every function in this package is compiler-independent.
102 ;;; The names start with ada-
103 ;;; The variables that the user can edit can all be modified through
104 ;;; the customize mode. They are sorted in alphabetical order in this
105 ;;; file.
107 ;;; Supported packages.
108 ;;; This package supports a number of other Emacs modes. These other modes
109 ;;; should be loaded before the ada-mode, which will then setup some variables
110 ;;; to improve the support for Ada code.
111 ;;; Here is the list of these modes:
112 ;;; `which-function-mode': Display the name of the subprogram the cursor is
113 ;;; in in the mode line.
114 ;;; `outline-mode': Provides the capability to collapse or expand the code
115 ;;; for specific language constructs, for instance if you want to hide the
116 ;;; code corresponding to a subprogram
117 ;;; `align': This mode is now provided with Emacs 21, but can also be
118 ;;; installed manually for older versions of Emacs. It provides the
119 ;;; capability to automatically realign the selected region (for instance
120 ;;; all ':=', ':' and '--' will be aligned on top of each other.
121 ;;; `imenu': Provides a menu with the list of entities defined in the current
122 ;;; buffer, and an easy way to jump to any of them
123 ;;; `speedbar': Provides a separate file browser, and the capability for each
124 ;;; file to see the list of entities defined in it and to jump to them
125 ;;; easily
126 ;;; `abbrev-mode': Provides the capability to define abbreviations, which
127 ;;; are automatically expanded when you type them. See the Emacs manual.
139 ;; this function is needed at compile time
142 "Return t if Emacs's version is greater or equal to MAJOR.MINOR.
143 If IS-XEMACS is non-nil, check for XEmacs instead of Emacs."
153 ;; This call should not be made in the release that is done for the
154 ;; official Emacs, since it does nothing useful for the latest version
155 ;;(if (not (ada-check-emacs-version 21 1))
156 ;; (require 'ada-support))
159 "*List of functions to call when Ada mode is invoked.
160 This hook is automatically executed after the `ada-mode' is
161 fully loaded.
165 "Major mode for editing Ada source in Emacs."
170 "*Non-nil means automatically change case of preceding word while typing.
171 Casing is done according to `ada-case-keyword', `ada-case-identifier'
172 and `ada-case-attribute'."
176 "*Number of columns to indent a broken declaration.
178 An example is :
179 declare
180 A,
181 >>>>>B : Integer; -- from ada-broken-decl-indent"
185 "*Number of columns to indent the continuation of a broken line.
187 An example is :
188 My_Var : My_Type := (Field1 =>
189 >>>>>>>>>Value); -- from ada-broken-indent"
193 "*Number of columns to indent the continuation of broken lines in parenthesis.
195 An example is :
196 Func (Param1,
197 >>>>>Param2);"
201 "*Function to call to adjust the case of Ada attributes.
202 It may be `downcase-word', `upcase-word', `ada-loose-case-word',
203 `ada-capitalize-word' or `ada-no-auto-case'."
213 "*List of special casing exceptions dictionaries for identifiers.
214 The first file is the one where new exceptions will be saved by Emacs
215 when you call `ada-create-case-exception'.
217 These files should contain one word per line, that gives the casing
218 to be used for that word in Ada files. If the line starts with the
219 character *, then the exception will be used for substrings that either
220 start at the beginning of a word or after a _ character, and end either
221 at the end of the word or at a _ character. Each line can be terminated by
222 a comment."
227 "*Function to call to adjust the case of an Ada keywords.
228 It may be `downcase-word', `upcase-word', `ada-loose-case-word' or
229 `ada-capitalize-word'."
238 "*Function to call to adjust the case of an Ada identifier.
239 It may be `downcase-word', `upcase-word', `ada-loose-case-word' or
240 `ada-capitalize-word'."
249 "*Non-nil means remove trailing spaces and untabify the buffer before saving."
253 "*Size of Ada indentation.
255 An example is :
256 procedure Foo is
257 begin
258 >>>>>>>>>>null; -- from ada-indent"
262 "*Non-nil means automatically indent after RET or LFD."
266 "*Non-nil means align comments on previous line comments, if any.
267 If nil, indentation is calculated as usual.
268 Note that indentation is calculated only if `ada-indent-comment-as-code' is t.
270 For instance:
271 A := 1; -- A multi-line comment
272 -- aligned if ada-indent-align-comments is t"
276 "*Non-nil means indent comment lines as code.
277 A nil value means do not auto-indent comments."
281 "*Non-nil if comment lines should be handled specially inside parenthesis.
282 By default, if the line that contains the open parenthesis has some
283 text following it, then the following lines will be indented in the
284 same column as this text. This will not be true if the first line is
285 a comment and `ada-indent-handle-comment-special' is t.
287 type A is
288 ( Value_1, -- common behavior, when not a comment
289 Value_2);
291 type A is
292 ( -- `ada-indent-handle-comment-special' is nil
293 Value_1,
294 Value_2);
296 type A is
297 ( -- `ada-indent-handle-comment-special' is non-nil
298 Value_1,
299 Value_2);"
303 "*Non-nil means indent 'is separate' or 'is abstract' if on a single line."
307 "*Indentation for 'record' relative to 'type' or 'use'.
309 An example is:
310 type A is
311 >>>>>>>>>>>record -- from ada-indent-record-rel-type"
315 "*Indentation for renames 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; -- from ada-indent-return
322 >>>renames Foo; -- from ada-indent-renames"
326 "*Indentation for 'return' relative to the matching 'function' statement.
327 If `ada-indent-return' is null or negative, the indentation is done relative to
328 the open parenthesis (if there is no parenthesis, `ada-broken-indent' is used).
330 An example is:
331 function A (B : Integer)
332 >>>>>return C; -- from ada-indent-return"
336 "*Non-nil means indent according to the innermost open parenthesis."
340 "*Text inserted in the first columns when filling a comment paragraph.
341 Note: if you modify this variable, you will have to invoke `ada-mode'
342 again to take account of the new value."
346 "*Text inserted at the end of each line when filling a comment paragraph.
347 Used by `ada-fill-comment-paragraph-postfix'."
351 "*Number of columns to indent a label.
353 An example is:
354 procedure Foo is
355 begin
356 >>>>>>>>>>>>Label: -- from ada-label-indent
358 This is also used for <<..>> labels"
362 "*Do we program in `ada83' or `ada95'?"
366 "*Non-nil means `ada-move-to-start' moves point to the subprogram declaration,
367 not to 'begin'."
371 "*Key used for binding the contextual menu.
372 If nil, no contextual menu is available."
381 "*List of directories to search for Ada files.
382 See the description for the `ff-search-directories' variable. This variable
383 is the initial value of this variable, and is copied and modified in
384 `ada-search-directories-internal'."
391 "Internal version of `ada-search-directories'.
392 Its value is the concatenation of the search path as read in the project file
393 and the standard runtime location, and the value of the user-defined
397 "*Number of columns to indent the end of a statement on a separate line.
399 An example is:
400 if A = B
401 >>>>>>>>>>>then -- from ada-stmt-end-indent"
405 "*Control the behavior of the TAB key.
406 Must be one of :
407 `indent-rigidly' : always adds `ada-indent' blanks at the beginning of the line.
408 `indent-auto' : use indentation functions in this file.
409 `always-tab' : do indent-relative."
416 "*Indentation for the lines in a 'use' statement.
418 An example is:
419 use Ada.Text_IO,
420 >>>>>Ada.Numerics; -- from ada-use-indent"
424 "*Indentation for 'when' relative to 'exception' or 'case'.
426 An example is:
427 case A is
428 >>>>>>>>when B => -- from ada-when-indent"
432 "*Indentation for the lines in a 'with' statement.
434 An example is:
435 with Ada.Text_IO,
436 >>>>>Ada.Numerics; -- from ada-with-indent"
440 "*Name of the compiler to use.
441 This will determine what features are made available through the ada-mode.
442 The possible choices are :
443 `gnat': Use Ada Core Technologies' Gnat compiler. Add some cross-referencing
444 features
445 `generic': Use a generic compiler"
451 ;;; ---- end of user configurable variables
452 \f
455 "List of possible suffixes for Ada body files.
459 "List of possible suffixes for Ada spec files.
487 "List of Ada keywords.
497 "Alist of substrings (entities) that have special casing.
498 The substrings are detected for word constituant when the word
499 is not itself in `ada-case-exception', and only for substrings that
506 "Variable used by `find-file' to find the name of the other package.
514 "Ada support for align.el <= 2.2
515 This variable provides regular expressions on which to align different lines.
534 )
535 "Ada support for align.el >= 2.8
555 "when"
559 ;;; ---- Below are the regexp used in this package for parsing
582 ;; "with" needs to be included in the regexp, so that we can insert new lines
583 ;; after the declaration of the parameter for a generic.
588 ;; subprogram name: operator ("[+/=*]")
592 ;; subprogram name: name
603 ;;; ---- regexps for indentation functions
626 "Regexp of possible ends for a non-broken statement.
664 "Position of point just before displaying the menu.
665 This is a list (point buffer).
666 Since `ada-popup-menu' moves the point where the user clicked, the region
667 is modified. Therefore no command from the menu knows what the user selected
668 before displaying the contextual menu.
669 To get the original region, restore the point to this position before
670 calling `region-end' and `region-beginning'.
674 "Menu to use when the user presses the right mouse button.
675 The variable `ada-contextual-menu-on-identifier' will be set to t before
676 displaying the menu if point was on an identifier."
691 \f
692 ;;------------------------------------------------------------------
693 ;; Support for imenu (see imenu.el)
694 ;;------------------------------------------------------------------
701 ada-imenu-comment-re
721 "Imenu generic expression for Ada mode.
722 See `imenu-generic-expression'. This variable will create several submenus for
725 \f
726 ;;------------------------------------------------------------
727 ;; Support for compile.el
728 ;;------------------------------------------------------------
731 "Mouse interface for ada-compile-goto-error."
735 )
738 "Replace `compile-goto-error' from compile.el.
739 If POS is on a file and line location, go to this position. It adds
740 to compile.el the capacity to go to a reference in an error message.
741 For instance, on this line:
742 foo.adb:61:11: [...] in call to size declared at foo.ads:11
743 both file locations can be clicked on and jumped to."
749 ;; special case: looking at a filename:line not at the beginning of a line
754 file
756 source)
760 ;; Use funcall so as to prevent byte-compiler warnings
761 ;; `ada-find-file' is not defined if ada-xref wasn't loaded. But
762 ;; if we can find it, we should use it instead of
763 ;; `compilation-find-file', since the latter doesn't know anything
764 ;; about source path.
779 ))
781 ;; otherwise, default behavior
784 )
787 \f
788 ;;-------------------------------------------------------------------------
789 ;; Grammar related function
790 ;; The functions below work with the syntax class of the characters in an Ada
791 ;; buffer. Two syntax tables are created, depending on whether we want '_'
792 ;; to be considered as part of a word or not.
793 ;; Some characters may have multiple meanings depending on the context:
794 ;; - ' is either the beginning of a constant character or an attribute
795 ;; - # is either part of a based litteral or a gnatprep statement.
796 ;; - " starts a string, but not if inside a constant character.
797 ;; - ( and ) should be ignored if inside a constant character.
798 ;; Thus their syntax property is changed automatically, and we can still use
799 ;; the standard Emacs functions for sexp (see `ada-in-string-p')
800 ;;
801 ;; On Emacs, this is done through the `syntax-table' text property. The
802 ;; modification is done automatically each time the user as typed a new
803 ;; character. This is already done in `font-lock-mode' (in
804 ;; `font-lock-syntactic-keywords', so we take advantage of the existing
805 ;; mechanism. If font-lock-mode is not activated, we do it by hand in
806 ;; `ada-after-change-function', thanks to `ada-deactivate-properties' and
807 ;; `ada-initialize-properties'.
808 ;;
809 ;; on XEmacs, the `syntax-table' property does not exist and we have to use a
810 ;; slow advice to `parse-partial-sexp' to do the same thing.
811 ;; When executing parse-partial-sexp, we simply modify the strings before and
812 ;; after, so that the special constants '"', '(' and ')' do not interact
813 ;; with parse-partial-sexp.
814 ;; Note: this code is slow and needs to be rewritten as soon as something
815 ;; better is available on XEmacs.
816 ;;-------------------------------------------------------------------------
819 "Create the two syntax tables use in the Ada mode.
820 The standard table declares `_' as a symbol constituent, the second one
821 declares it as a word constituent."
826 ;; define string brackets (`%' is alternative string bracket, but
827 ;; almost never used as such and throws font-lock and indentation
828 ;; off the track.)
851 ;; a single hyphen is punctuation, but a double hyphen starts a comment
854 ;; See the comment above on grammar related function for the special
855 ;; setup for '#'.
860 ;; and \f and \n end a comment
864 ;; define what belongs in Ada symbols
867 ;; define parentheses to match
873 )
875 ;; Support of special characters in XEmacs (see the comments at the beginning
876 ;; of the section on Grammar related functions).
880 "Handles special character constants and gnatprep statements."
889 1
891 change))
898 change))
900 ad-do-it
909 "Deactivate ada-mode's properties handling.
910 This would be a duplicate of font-lock if both are used at the same time."
914 "Initialize some special text properties in the whole buffer.
915 In particular, character constants are said to be strings, #...# are treated
916 as numbers instead of gnatprep comments."
930 ;; Setting this only if font-lock is not set won't work
931 ;; if the user activates or deactivates font-lock-mode,
932 ;; but will make things faster most of the time
934 )))
937 "Called when the region between BEG and END was changed in the buffer.
938 OLD-LEN indicates what the length of the replaced text was."
953 ;;------------------------------------------------------------------
954 ;; Testing the grammatical context
955 ;;------------------------------------------------------------------
958 "Return t if inside a comment."
964 "Return t if point is inside a string.
965 If parse-result is non-nil, use is instead of calling `parse-partial-sexp'."
971 "Return t if inside a comment or string."
978 ;;------------------------------------------------------------------
979 ;; Contextual menus
980 ;; The Ada-mode comes with contextual menus, bound by default to the right
981 ;; mouse button.
982 ;; Add items to this menu by modifying `ada-contextual-menu'. Note that the
983 ;; variable `ada-contextual-menu-on-identifier' is set automatically to t
984 ;; if the mouse button was pressed on an identifier.
985 ;;------------------------------------------------------------------
988 "Execute FUNCTION when called from the contextual menu.
989 It forces Emacs to change the cursor position."
996 "Pops up a contextual menu, depending on where the user clicked.
997 POSITION is the location the mouse was clicked on.
998 Sets `ada-contextual-menu-last-point' to the current position before
999 displaying the menu. When a function from the menu is called, the
1000 point is where the mouse button was clicked."
1003 ;; declare this as a local variable, so that the function called
1004 ;; in the contextual menu does not hide the region in
1005 ;; transient-mark-mode.
1018 ))
1028 ))
1031 ;;------------------------------------------------------------------
1032 ;; Misc functions
1033 ;;------------------------------------------------------------------
1035 ;;;###autoload
1037 "Define SPEC and BODY as being valid extensions for Ada files.
1038 Going from body to spec with `ff-find-other-file' used these
1039 extensions.
1040 SPEC and BODY are two regular expressions that must match against
1041 the file name."
1062 ;; Support for speedbar (Specifies that we want to see these files in
1063 ;; speedbar)
1067 spec)
1069 body)))
1070 )
1073 ;;;###autoload
1075 "Ada mode is the major mode for editing Ada code.
1077 Bindings are as follows: (Note: 'LFD' is control-j.)
1091 Next func/proc/task '\\[ada-next-procedure]' Previous func/proc/task '\\[ada-previous-procedure]'
1097 Comments are handled using standard GNU Emacs conventions, including:
1103 If you use imenu.el:
1106 If you use find-file.el:
1111 If you use this function in a spec and no body is available, it gets created with body stubs.
1113 If you use ada-xref.el:
1123 ;; Set the paragraph delimiters so that one can select a whole block
1124 ;; simply with M-h
1128 ;; comment end must be set because it may hold a wrong value if
1129 ;; this buffer had been in another mode before. RE
1132 ;; used by autofill and indent-new-comment-line
1135 ;; used by autofill to break a comment line and continue it on another line.
1136 ;; The reason we need this one is that the default behavior does not work
1137 ;; correctly with the definition of paragraph-start above when the comment
1138 ;; is right after a multi-line subprogram declaration (the comments are
1139 ;; aligned under the latest parameter, not under the declaration start).
1149 ;; Emacs 20.3 defines a comment-padding to insert spaces between
1150 ;; the comment and the text. We do not want any, this is already
1151 ;; included in comment-start
1159 ))
1169 ada-imenu-generic-expression)
1171 ;; Support for compile.el
1172 ;; We just substitute our own functions to go to the error.
1176 ;; FIXME: This has global impact! -stef
1184 ;; font-lock support :
1185 ;; We need to set some properties for XEmacs, and define some variables
1186 ;; for Emacs
1189 ;; XEmacs
1193 ;; Emacs
1196 nil t
1198 beginning-of-line
1200 )
1202 ;; Set up support for find-file.el.
1211 ;; Some special constructs for find-file.el
1212 ;; We do not need to add the construction for 'with', which is in the
1213 ;; standard find-file.el
1216 ;; Go to the parent package :
1226 ada-search-directories-internal
1229 ada-spec-suffixes)))))))
1230 ;; Another special construct for find-file.el : when in a separate clause,
1231 ;; go to the correct package.
1238 ada-search-directories-internal
1241 ada-spec-suffixes)))))))
1243 ;; Another special construct, that redefines the one in find-file.el. The
1244 ;; old one can handle only one possible type of extension for Ada files
1245 ;; remove from the list the standard "with..." that is put by find-file.el,
1246 ;; since it uses the old ada-spec-suffix variable
1247 ;; This one needs to replace the standard one defined in find-file.el (with
1248 ;; Emacs <= 20.4), since that one uses the old variable ada-spec-suffix
1256 ada-search-directories-internal
1259 ada-spec-suffixes)))))))
1264 new-cdr))))
1266 ;; Support for outline-minor-mode
1268 "\\([ \t]*\\(procedure\\|function\\|package\\|if\\|while\\|for\\|declare\\|case\\|end\\|begin\\|loop\\)\\|--\\)")
1271 ;; Support for imenu : We want a sorted index
1274 ;; Support for ispell : Check only comments
1277 ;; Support for align.el <= 2.2, if present
1278 ;; align.el is distributed with Emacs 21, but not with earlier versions.
1282 ;; Support for align.el >= 2.8, if present
1288 ada-align-region-separate)
1290 ;; Exclude comments alone on line from alignment.
1329 ))
1331 ;; Set up the contextual menu
1335 ;; Support for Abbreviations (the user still need to "M-x abbrev-mode"
1339 ;; Support for which-function mode
1340 ;; which-function-mode does not work with nested subprograms, since it is
1341 ;; based only on the regexps generated by imenu, and thus can only detect the
1342 ;; beginning of subprograms, not the end.
1343 ;; Fix is: redefine a new function ada-which-function, and call it when the
1344 ;; major-mode is ada-mode.
1349 ;; Support for indent-new-comment-line (Especially for XEmacs)
1363 ;; remove all spaces at the end of lines in the whole buffer.
1365 ;; convert all tabs to the correct number of spaces.
1376 ;; To be run after the hook, in case the user modified
1377 ;; ada-fill-comment-prefix
1383 ;; Run this after the hook to give the users a chance to activate
1384 ;; font-lock-mode
1391 ;; the following has to be done after running the ada-mode-hook
1392 ;; because users might want to set the values of these variable
1393 ;; inside the hook (MH)
1404 "Adjust the case of the text inserted by a skeleton."
1411 ;; transient-mark-mode and mark-active are not defined in XEmacs
1413 "Return t if a region has been selected by the user and is still active."
1419 \f
1420 ;;-----------------------------------------------------------------
1421 ;; auto-casing
1422 ;; Since Ada is case-insensitive, the Ada-mode provides an extensive set of
1423 ;; functions to auto-case identifiers, keywords, ...
1424 ;; The basic rules for autocasing are defined through the variables
1425 ;; `ada-case-attribute', `ada-case-keyword' and `ada-case-identifier'. These
1426 ;; are references to the functions that will do the actual casing.
1427 ;;
1428 ;; However, in most cases, the user will want to define some exceptions to
1429 ;; these casing rules. This is done through a list of files, that contain
1430 ;; one word per line. These files are stored in `ada-case-exception-file'.
1431 ;; For backward compatibility, this variable can also be a string.
1432 ;;-----------------------------------------------------------------
1435 "Save the exception lists `ada-case-exception' and
1436 `ada-case-exception-substring' to the file FILE-NAME."
1438 ;; Save the list in the file
1449 )
1452 "Define WORD as an exception for the casing system.
1453 If WORD is not given, then the current word in the buffer is used instead.
1454 The new words is added to the first file in `ada-case-exception-file'.
1455 The standard casing rules will no longer apply to this word."
1458 file-name
1459 )
1477 ;; Reread the exceptions file, in case it was modified by some other,
1480 ;; If the word is already in the list, even with a different casing
1481 ;; we simply want to replace it.
1486 )
1489 ))
1492 "Define the substring WORD as an exception for the casing system.
1493 If WORD is not given, then the current word in the buffer is used instead,
1494 or the selected region if any is active.
1495 The new word is added to the first file in `ada-case-exception-file'.
1496 When auto-casing a word, this substring will be special-cased, unless the
1497 word itself has a special casing."
1501 ada-case-exception-file)
1508 ;; Find the substring to define as an exception. Order is: the parameter,
1509 ;; if any, or the selected region, or the word under the cursor
1530 ;; Reread the exceptions file, in case it was modified by some other,
1533 ;; If the word is already in the list, even with a different casing
1534 ;; we simply want to replace it.
1539 )
1546 "Read the content of the casing exception file FILE-NAME."
1555 ;; If the item is already in the list, even with an other casing,
1556 ;; do not add it again. This way, the user can easily decide which
1557 ;; priority should be applied to each casing exception
1561 ;; Handling a substring ?
1573 )
1576 "Read all the casing exception files from `ada-case-exception-file'."
1579 ;; Reinitialize the casing exception list
1581 ada-case-exception-substring '())
1588 ada-case-exception-file))))
1591 "Adjust case of substrings in the previous word."
1597 re)
1613 )
1614 )
1616 )))
1619 "Adjust case of the previous identifier.
1620 The auto-casing is done according to the value of `ada-case-identifier' and
1621 the exceptions defined in `ada-case-exception-file'."
1633 match)
1634 ;; If we have an exception, replace the word by the correct casing
1636 ada-case-exception t))
1642 ;; Else simply re-case the word
1647 "Return t if cursor is after a keyword that is not an attribute."
1656 "Adjust the case of the word before the character just typed.
1657 If FORCE-IDENTIFIER is non-nil then also adjust keyword as identifier."
1662 ;; or if at the end of a character constant
1665 ;; or if the previous character was not part of a word
1667 ;; if in a string or a comment
1669 )
1682 ))
1683 )
1686 "Adjust the case of the previous word, and process the character just typed.
1699 ;; horrible kludge
1702 ;; horrible dekludge
1704 ;; some special keys and their bindings
1711 ;; Else just insert the character
1713 ;; if there is a keyword in front of the underscore
1714 ;; then it should be part of an identifier (MH)
1718 )
1719 ;; Restore the syntax table
1721 )
1723 ;; Else, no auto-casing
1731 ))
1734 "Modify the key bindings for all the keys that should readjust the casing."
1736 ;; Save original key-bindings to allow swapping ret/lfd
1737 ;; when casing is activated.
1738 ;; The 'or ...' is there to be sure that the value will not
1739 ;; be changed again when Ada mode is called more than once
1743 ;; Call case modifying function after certain keys.
1745 ada-mode-map
1749 ?| ?\; ?: ?' ?\" ?< ?, ?. ?> ?/ ?\n 32 ?\r )))
1752 "Upcase first letter and letters following `_' in the following word.
1753 No other letter is modified.
1754 ARG is ignored, and is there for compatibility with `capitalize-word' only."
1768 "Do nothing.
1769 This function can be used for the auto-casing variables in the ada-mode, to
1770 adapt to unusal auto-casing schemes. Since it does nothing, you can for
1771 instance use it for `ada-case-identifier' if you don't want any special
1772 auto-casing for identifiers, whereas keywords have to be lower-cased.
1773 See also `ada-auto-case' to disable auto casing altogether."
1774 )
1777 "Upcase first letter and letters following '_', lower case other letters.
1778 ARG is ignored, and is there for compatibility with `capitalize-word' only."
1787 "Adjust the case of all words in the region between FROM and TO.
1788 Attention: This function might take very long for big regions!"
1800 ;;
1801 ;; loop: look for all identifiers, keywords, and attributes
1802 ;;
1811 ;; do nothing if it is a string or comment
1814 ;;
1815 ;; get the identifier or keyword or attribute
1816 ;;
1820 ;;
1821 ;; casing according to user-option
1822 ;;
1833 "Adjusts the case of all words in the whole buffer.
1834 ATTENTION: This function might take very long for big buffers!"
1838 \f
1839 ;;--------------------------------------------------------------
1840 ;; Format Parameter Lists
1841 ;; Some special algorithms are provided to indent the parameter lists in
1842 ;; subprogram declarations. This is done in two steps:
1843 ;; - First parses the parameter list. The returned list has the following
1844 ;; format:
1845 ;; ( (<Param_Name> in? out? access? <Type_Name> <Default_Expression>)
1846 ;; ... )
1847 ;; This is done in `ada-scan-paramlist'.
1848 ;; - Delete and recreate the parameter list in function
1849 ;; `ada-insert-paramlist'.
1850 ;; Both steps are called from `ada-format-paramlist'.
1851 ;; Note: Comments inside the parameter list are lost.
1852 ;; The syntax has to be correct, or the reformating will fail.
1853 ;;--------------------------------------------------------------
1856 "Reformat the parameter list point is in."
1867 ;; check if really inside parameter list
1871 ;; find start of current parameter-list
1878 ;; find end of parameter-list
1884 ;; find end of last parameter-declaration
1888 ;; build a list of all elements of the parameter-list
1891 ;; delete the original parameter-list
1894 ;; insert the new parameter-list
1898 ;; restore syntax-table
1900 )))
1903 "Scan the parameter list found in between BEGIN and END.
1904 Return the equivalent internal parameter list."
1915 ;; loop until end of last parameter
1918 ;; find first character of parameter-declaration
1922 ;; find last character of parameter-declaration
1930 ;; read name(s) of parameter(s)
1937 ;; look for 'in'
1946 ;; look for 'out'
1955 ;; look for 'access'
1964 ;; skip 'in'/'out'/'access'
1971 ;; read type of parameter
1972 ;; We accept spaces in the name, since some software like Rose
1973 ;; generates something like: "A : B 'Class"
1979 ;; read default-expression, if there is one
1988 nil))))
1990 ;; add this parameter-declaration to the list
1993 ;; check if it was the last parameter
1997 )
2001 "Insert a formatted PARAMLIST in the buffer."
2011 ;; loop until last parameter
2015 ;; get max length of parameter-name
2018 ;; get max length of type-name
2021 ;; is there any 'in' ?
2024 ;; is there any 'out' ?
2027 ;; is there any 'access' ?
2029 )
2031 ;; does paramlist already start on a separate line ?
2035 ;; yes => re-indent it
2042 ;; no => insert it where we are after removing any whitespace
2058 ;; loop until last parameter
2063 ;; insert parameter-name, space and colon
2069 ;; insert 'in' or space
2074 accessp)
2078 ;; insert 'out' or space
2083 accessp)
2087 ;; insert 'access'
2093 ;; insert type-name and, if necessary, space and default-expression
2100 ;; check if it was the last parameter
2103 ;; no => insert ';' and newline and indent
2107 )
2109 ;; if anything follows, except semicolon, newline, is or return
2110 ;; put it in a new line and indent it
2113 ))
2116 \f
2117 ;;;----------------------------------------------------------------
2118 ;; Indentation Engine
2119 ;; All indentations are indicated as a two-element string:
2120 ;; - position of reference in the buffer
2121 ;; - offset to indent from this position (can also be a symbol or a list
2122 ;; that are evaluated)
2123 ;; Thus the total indentation for a line is the column number of the reference
2124 ;; position plus whatever value the evaluation of the second element provides.
2125 ;; This mechanism is used so that the ada-mode can "explain" how the
2126 ;; indentation was calculated, by showing which variables were used.
2127 ;;
2128 ;; The indentation itself is done in only one pass: first we try to guess in
2129 ;; what context we are by looking at the following keyword or punctuation
2130 ;; sign. If nothing remarkable is found, just try to guess the indentation
2131 ;; based on previous lines.
2132 ;;
2133 ;; The relevant functions for indentation are:
2134 ;; - `ada-indent-region': Re-indent a region of text
2135 ;; - `ada-justified-indent-current': Re-indent the current line and shows the
2136 ;; calculation that were done
2137 ;; - `ada-indent-current': Re-indent the current line
2138 ;; - `ada-get-current-indent': Calculate the indentation for the current line,
2139 ;; based on the context (see above).
2140 ;; - `ada-get-indent-*': Calculate the indentation in a specific context.
2141 ;; For efficiency, these functions do not check they are in the correct
2142 ;; context.
2143 ;;;----------------------------------------------------------------
2146 "Indent the region between BEG end END."
2154 ;; catch errors while indenting
2168 "Indent the current line, insert a newline and then indent the new line."
2175 "Insert a newline and indent it.
2176 The original line is indented first if `ada-indent-after-return' is non-nil.
2177 This function is intended to be bound to the C-m and C-j keys."
2184 "Indent the current line and explain how the calculation was done."
2203 ))
2211 "Re-indent and re-case all the files found on the command line.
2212 This function should be used from the Unix/Windows command line, with a
2213 command like:
2214 emacs -batch -l ada-mode -f ada-batch-reformat file1 file2 ..."
2228 "Move point to the beginning of the previous word of Ada code.
2229 Return the new position of point or nil if not found."
2233 "Indent current line as Ada code.
2234 Return the calculation that was done, including the reference point and the
2235 offset."
2239 cur-indent tmp-indent
2240 prev-indent)
2246 ;; This need to be done here so that the advice is not always
2247 ;; activated (this might interact badly with other modes)
2254 ;; Not First line in the buffer ?
2260 ;; first line in the buffer
2263 ;; Evaluate the list to get the column to indent to
2264 ;; prev-indent contains the column to indent to
2277 )
2280 ;; only re-indent if indentation is different then the current
2282 nil
2286 ;;
2287 ;; restore position of point
2288 ;;
2293 ;; restore syntax-table
2297 )
2299 cur-indent
2300 ))
2303 "Return the indentation to use for the current line."
2305 pos
2306 match-cons
2307 result
2317 ;;-----------------------------
2318 ;; in open parenthesis, but not in parameter-list
2319 ;;-----------------------------
2325 ;; check if we have something like this (Table_Component_Type =>
2326 ;; Source_File_Record)
2329 ;; Align the closing parenthesis on the opening one
2340 ;; ??? Could use a different variable
2343 ;; We want all continuation lines to be indented the same
2344 ;; (ada-broken-line from the opening parenthesis. However, in
2345 ;; parameter list, each new parameter should be indented at the
2346 ;; column as the opening parenthesis.
2348 ;; A special case to handle nested boolean expressions, as in
2349 ;; ((B
2350 ;; and then C) -- indented by ada-broken-indent
2351 ;; or else D) -- indenting this line.
2352 ;; ??? This is really a hack, we should have a proper way to go to
2353 ;; ??? the beginning of the statement
2361 )))))
2363 ;;---------------------------
2364 ;; at end of buffer
2365 ;;---------------------------
2370 ;;---------------------------
2371 ;; starting with e
2372 ;;---------------------------
2377 ;; ------- end ------
2381 limit)
2385 ;;
2386 ;; found 'loop' => skip back to 'while' or 'for'
2387 ;; if 'loop' is not on a separate line
2388 ;; Stop the search for 'while' and 'for' when a ';' is encountered.
2389 ;;
2408 ;; found 'record' =>
2409 ;; if the keyword is found at the beginning of a line (or just
2410 ;; after limited, we indent on it, otherwise we indent on the
2411 ;; beginning of the type declaration)
2412 ;; type A is (B : Integer;
2413 ;; C : Integer) is record
2414 ;; end record; -- This is badly indented otherwise
2424 ;; Else keep the same indentation as the beginning statement
2427 ;; ------ exception ----
2434 ;; else
2444 ;; elsif
2451 ))
2453 ;;---------------------------
2454 ;; starting with w (when)
2455 ;;---------------------------
2464 ;;---------------------------
2465 ;; starting with t (then)
2466 ;;---------------------------
2474 ;; Select has been added for the statement: "select ... then abort"
2480 ;;---------------------------
2481 ;; starting with l (loop)
2482 ;;---------------------------
2494 nil pos))
2499 ;;----------------------------
2500 ;; starting with l (limited) or r (record)
2501 ;;----------------------------
2517 ;;---------------------------
2518 ;; starting with b (begin)
2519 ;;---------------------------
2528 ;;---------------------------
2529 ;; starting with i (is)
2530 ;;---------------------------
2550 ;;---------------------------
2551 ;; starting with r (return, renames)
2552 ;;---------------------------
2559 ;; If looking at a renames, skip the 'return' statement too
2574 ;; If there is a parameter list, and we have a function declaration
2575 ;; or a access to subprogram declaration
2587 ;; The indentation depends of the value of ada-indent-return
2591 var))
2593 ;; Else there is no parameter list, but we have a function
2594 ;; Only do something special if the user want to indent
2595 ;; relative to the "function" keyword
2601 ;; Else...
2604 ;;--------------------------------
2605 ;; starting with 'o' or 'p'
2606 ;; 'or' as statement-start
2607 ;; 'private' as statement-start
2608 ;;--------------------------------
2615 ;; ??? Wasn't this done already in ada-looking-at-semi-or ?
2619 ;;--------------------------------
2620 ;; starting with 'd' (do)
2621 ;;--------------------------------
2629 ;;--------------------------------
2630 ;; starting with '-' (comment)
2631 ;;--------------------------------
2636 ;; Indent comments on previous line comments if required
2637 ;; We must use a search-forward (even if the code is more complex),
2638 ;; since we want to find the beginning of the comment.
2649 t))
2652 pos))
2655 ;; Else always on previous line
2658 ;; Else same indentation as the previous line
2661 ;;--------------------------------
2662 ;; starting with '#' (preprocessor line)
2663 ;;--------------------------------
2670 ;;--------------------------------
2671 ;; starting with ')' (end of a parameter list)
2672 ;;--------------------------------
2680 ;;---------------------------------
2681 ;; new/abstract/separate
2682 ;;---------------------------------
2687 ;;---------------------------------
2688 ;; package/function/procedure
2689 ;;---------------------------------
2694 ;; Go up until we find either a generic section, or the end of the
2695 ;; previous subprogram/package
2701 ;; avoid "with procedure"... in generic parts
2710 ;;---------------------------------
2711 ;; label
2712 ;;---------------------------------
2720 ))
2722 ;;---------------------------------
2723 ;; Other syntaxes
2724 ;;---------------------------------
2728 "Calculate the indentation for the new line after ORGPOINT.
2729 The result list is based on the previous lines in the buffer.
2730 If NOMOVE is nil, moves point to the beginning of the current statement.
2731 if INITIAL-POS is non-nil, moves point to INITIAL-POS before calculation."
2736 ;; Is inside a parameter-list ?
2740 ;; move to beginning of current statement
2744 ;; no beginning found => don't change indentation
2750 ;;
2752 ada-indent-to-open-paren
2755 ;;
2758 ;;
2761 ;;
2764 ;;
2767 ;;
2770 ;;
2771 ;; "then" has to be included in the case of "select...then abort"
2772 ;; statements, since (goto-stmt-start) at the beginning of
2773 ;; the current function would leave the cursor on that position
2776 ;;
2779 ;;
2782 ;;
2785 ;;
2789 ;; A label
2794 ;;
2796 ;; Are we still in that statement, or are we in fact looking at
2797 ;; the previous one ?
2801 'ada-with-indent
2803 ;;
2806 ))
2809 "Calculate the indentation when point is behind an unclosed parenthesis."
2813 "Return the current indentation of the previous line."
2820 "Calculate the indentation when point is inside a parameter list."
2824 ;; in front of the first parameter
2829 ;; in front of another parameter
2835 ;; After an affectation (default parameter value in subprogram
2836 ;; declaration)
2841 ;; inside a parameter declaration
2848 "Calculate the indentation when point is just before an end statement.
2849 ORGPOINT is the limit position used in the calculation."
2853 ;; is the line already terminated by ';' ?
2858 ;; yes, look what's following 'end'
2867 ;;
2868 ;; loop/select/if/case/record/select
2869 ;;
2873 ;; we are now looking at the matching "record" statement
2876 ;; now on the matching type declaration, or use clause
2880 ;;
2881 ;; a named block end
2882 ;;
2889 ;;
2890 ;; a block-end without name
2891 ;;
2900 indent))
2902 )))
2903 ;;
2904 ;; anything else - should maybe signal an error ?
2905 ;;
2914 "Calculate the indentation when point is just before a case statement.
2915 ORGPOINT is the limit position used in the calculation."
2919 ;;
2920 ;; case..is..when..=>
2921 ;;
2924 ;; the `=>' must be after the keyword `is'.
2934 ;;
2935 ;; case..is..when
2936 ;;
2942 ;;
2943 ;; case..is
2944 ;;
2949 ;;
2950 ;; incomplete case
2951 ;;
2957 "Calculate the indentation when point is just before a when statement.
2958 ORGPOINT is the limit position used in the calculation."
2965 "Calculate the indentation when point is just before an if statement.
2966 ORGPOINT is the limit position used in the calculation."
2969 ;;
2970 ;; Move to the correct then (ignore all "and then")
2971 ;;
2974 nil orgpoint))
2976 ;; If "then" was found (we are looking at it)
2979 ;;
2980 ;; 'then' first in separate line ?
2981 ;; => indent according to 'then',
2982 ;; => else indent according to 'if'
2983 ;;
2988 ;; skip 'then'
2995 "Calculate the indentation when point is at the start of a block.
2996 ORGPOINT is the limit position used in the calculation."
3006 ;; Special case for record types, for instance for:
3007 ;; type A is (B : Integer;
3008 ;; C : Integer) is record
3009 ;; null; -- This is badly indented otherwise
3012 ;; If record is at the beginning of the line, indent from there
3018 ;; else indent relative to the type command
3023 ;; nothing follows the block-start
3028 "Calculate the indentation when point is just before a subprogram.
3029 ORGPOINT is the limit position used in the calculation."
3033 ;;
3034 ;; is there an 'is' in front of point ?
3035 ;;
3040 ;;
3041 ;; yes, then skip to its end
3042 ;;
3046 ;;
3047 ;; no, then goto next non-ws, if there is one in front of point
3048 ;;
3054 ;;
3055 ;; nothing follows 'is'
3056 ;;
3058 foundis
3063 ;;
3064 ;; is abstract/separate/new ...
3065 ;;
3067 foundis
3072 nil orgpoint))))
3076 ;;
3077 ;; something follows 'is'
3078 ;;
3080 foundis
3084 ;;
3085 ;; no 'is' but ';'
3086 ;;
3090 ;;
3091 ;; no 'is' or ';'
3092 ;;
3097 "Calculate the indentation when point is just before a 'noindent stmt'.
3098 ORGPOINT is the limit position used in the calculation."
3105 ;; This one is called when indenting a line preceded by a multi-line
3106 ;; subprogram declaration (in that case, we are at this point inside
3107 ;; the parameter declaration list)
3112 ;; This one is called when indenting the second line of a multi-line
3113 ;; declaration section, in a declare block or a record declaration
3118 ;; This one is called in every over case when indenting a line at the
3119 ;; top level
3126 ;; "with private" or "null record" cases
3151 "Calculate the indentation when before a label or variable declaration.
3152 ORGPOINT is the limit position used in the calculation."
3157 ;; loop label
3160 ada-loop-start-re nil orgpoint)))
3164 ;; declare label
3171 ;; variable declaration
3178 ;; nothing follows colon
3183 "Calculate the indentation when just before a loop or a for ... use.
3184 ORGPOINT is the limit position used in the calculation."
3188 ;; If looking at a named block, skip the label
3197 ;;
3198 ;; statement complete
3199 ;;
3204 ;;
3205 ;; simple loop
3206 ;;
3210 pos
3213 ;;
3214 ;; 'for'- loop (or also a for ... use statement)
3215 ;;
3218 ;;
3219 ;; for ... use
3220 ;;
3229 ;;
3230 ;; check if there is a 'record' before point
3231 ;;
3235 t)))
3241 )
3243 ;;
3244 ;; for..loop
3245 ;;
3250 ;;
3251 ;; indent according to 'loop', if it's first in the line;
3252 ;; otherwise to 'for'
3253 ;;
3260 ;;
3261 ;; for-statement is broken
3262 ;;
3267 ;;
3268 ;; 'while'-loop
3269 ;;
3271 ;;
3272 ;; while..loop ?
3273 ;;
3280 ;;
3281 ;; indent according to 'loop', if it's first in the line;
3282 ;; otherwise to 'while'.
3283 ;;
3295 "Calculate the indentation when before a type statement.
3296 ORGPOINT is the limit position used in the calculation."
3299 ;;
3300 ;; complete record declaration
3301 ;;
3313 ;;
3314 ;; record type
3315 ;;
3321 ;;
3322 ;; complete type declaration
3323 ;;
3328 ;;
3329 ;; "type ... is", but not "type ... is ...", which is broken
3330 ;;
3337 ;;
3338 ;; broken statement
3339 ;;
3344 \f
3345 ;; -----------------------------------------------------------
3346 ;; -- searching and matching
3347 ;; -----------------------------------------------------------
3350 "Move point to the beginning of the statement that point is in or after.
3351 Return the new position of point.
3352 As a special case, if we are looking at a closing parenthesis, skip to the
3353 open parenthesis."
3360 ;;
3361 ;; found a previous end-statement => check if anything follows
3362 ;;
3368 ;;
3369 ;; nothing follows => it's the end-statement directly in
3370 ;; front of point => search again
3371 ;;
3373 ;;
3374 ;; if found the correct end-statement => goto next non-ws
3375 ;;
3379 ))
3381 ;;
3382 ;; no previous end-statement => we are at the beginning of the
3383 ;; accessible part of the buffer
3384 ;;
3387 ;;
3388 ;; skip to the very first statement, if there is one
3389 ;;
3396 "Move point to previous end statement.
3397 Return a cons cell whose car is the beginning and whose cdr
3398 is the end of the match."
3402 ;; search until found or beginning-of-buffer
3407 ada-end-stmt-re t)))
3428 ;; words that can go after an 'is'
3439 )))
3442 match-dat
3443 nil)))
3447 "Skip white spaces, newlines and comments to next non-ws character.
3448 Stop the search at LIMIT.
3449 Do not call this function from within a string."
3460 nil)
3461 )
3465 "Move point to the end of the statement that point is in or before.
3466 Return the new position of point or nil if not found.
3467 Stop the search at LIMIT."
3470 nil))
3474 "Move point to the beginning of the next word of Ada code.
3475 If BACKWARD is non-nil, jump to the beginning of the previous word.
3476 Return the new position of point or nil if not found."
3487 ;;
3488 ;; move to the beginning of the word found
3489 ;;
3494 ;;
3495 ;; if not found, restore old position of point
3496 ;;
3500 )
3504 "Signal an error if matching block start is not KEYWORD.
3505 Moves point to the matching block start."
3512 "Check if the name of the matching defun really is DEFUN-NAME.
3513 Assumes point to be already positioned by `ada-goto-matching-start'.
3514 Moves point to the beginning of the declaration."
3516 ;; named block without a `declare'
3520 t ; do nothing
3521 ;;
3522 ;; 'accept' or 'package' ?
3523 ;;
3526 ;;
3527 ;; 'begin' of 'procedure'/'function'/'task' or 'declare'
3528 ;;
3530 ;;
3531 ;; a named 'declare'-block ?
3532 ;;
3535 ;;
3536 ;; no, => 'procedure'/'function'/'task'/'protected'
3537 ;;
3541 ;;
3542 ;; skip 'body' 'type'
3543 ;;
3548 ;;
3549 ;; should be looking-at the correct name
3550 ;;
3557 "Move point to the matching declaration start of the current 'begin'.
3558 If NOERROR is non-nil, it only returns nil if no match was found."
3561 ;; first should be set to t if we should stop at the first
3562 ;; "begin" we encounter.
3566 )
3568 ;; Ignore "when" most of the time, except if we are looking at the
3569 ;; beginning of a block (structure: case .. is
3570 ;; when ... =>
3571 ;; begin ...
3572 ;; exception ... )
3584 ;; search backward for interesting keywords
3588 ;;
3589 ;; calculate nest-depth
3590 ;;
3592 ;;
3596 ;; In some case, two begin..end block can follow each other closely,
3597 ;; which we have to detect, as in
3598 ;; procedure P is
3599 ;; procedure Q is
3600 ;; begin
3601 ;; end;
3602 ;; begin -- here we should go to procedure, not begin
3603 ;; end
3609 ;; If begin was just there as the beginning of a block
3610 ;; (with no declare) then do nothing, otherwise just
3611 ;; register that we have to find the statement that
3612 ;; required the begin
3616 t)
3620 ;; (ada-goto-matching-decl-start noerror t)
3625 ))
3626 )))
3627 ;;
3633 ;;
3642 ;;
3646 ;;
3648 ;; check if it is only a type definition, but not a protected
3649 ;; type definition, which should be handled like a procedure.
3655 ;; Detect if we have a closing parenthesis (Could be
3656 ;; either the end of subprogram parameters or (<>)
3657 ;; in a type definition
3663 ))
3677 ;;
3683 ;;
3687 ;;
3695 ))))
3696 ;;
3699 ;;
3706 ;; check if declaration-start is really found
3712 t
3715 ))
3718 "Move point to the beginning of a block-start.
3719 Which block depends on the value of NEST-LEVEL, which defaults to zero.
3720 If NOERROR is non-nil, it only returns nil if no matching start was found.
3721 If GOTOTHEN is non-nil, point moves to the 'then' following 'if'."
3726 ;;
3727 ;; search backward for interesting keywords
3728 ;;
3738 ;;
3739 ;; calculate nest-depth
3740 ;;
3742 ;; found block end => increase nest depth
3746 ;; found loop/select/record/case/if => check if it starts or
3747 ;; ends a block
3751 ;;
3752 ;; check if keyword follows 'end'
3753 ;;
3756 ;; it ends a block => increase nest depth
3760 ;; it starts a block => decrease nest depth
3764 ;; found package start => check if it really is a block
3767 ;; ignore if this is just a renames statement
3774 "No matching 'is' or 'renames' for 'package' at"
3775 " line "
3781 ;; ignore it if it is only a declaration with 'new'
3782 ;; We could have package Foo is new ....
3783 ;; or package Foo is separate;
3784 ;; or package Foo is begin null; end Foo
3785 ;; for elaboration code (elaboration)
3788 ;; found task start => check if it has a body
3796 ;; In that case, do nothing if there is a "is"
3800 ;; Do nothing if we are simply looking at a simple
3801 ;; "task type name;" statement with no block
3804 ;; Skip the parameters
3815 ;; Check if that task declaration had a block attached to
3816 ;; it (i.e do nothing if we have just "task name;")
3820 ;; all the other block starts
3824 ;; match is found, if nest-depth is zero
3825 ;;
3831 ;;
3832 ;; match found => is there anything else to do ?
3833 ;;
3836 ;;
3837 ;; found 'if' => skip to 'then', if it's on a separate line
3838 ;; and GOTOTHEN is non-nil
3839 ;;
3841 gotothen
3850 ;;
3851 ;; found 'do' => skip back to 'accept'
3852 ;;
3855 "accept" t nil nil
3861 nil
3866 "Move point to the end of a block.
3867 Which block depends on the value of NEST-LEVEL, which defaults to zero.
3868 If NOERROR is non-nil, it only returns nil if found no matching start."
3876 found
3877 pos
3879 ;; First is used for subprograms: they are generally handled
3880 ;; recursively, but of course we do not want to do that the
3881 ;; first time (see comment below about subprograms)
3884 ;; If we are already looking at one of the keywords, this shouldn't count
3885 ;; in the nesting loop below, so we just make sure we don't count it.
3886 ;; "declare" is a special case because we need to look after the "begin"
3887 ;; keyword
3891 ;;
3892 ;; search forward for interesting keywords
3893 ;;
3898 ;;
3899 ;; calculate nest-depth
3900 ;;
3903 ;; procedures and functions need to be processed recursively, in
3904 ;; case they are defined in a declare/begin block, as in:
3905 ;; declare -- NL 0 (nested level)
3906 ;; A : Boolean;
3907 ;; procedure B (C : D) is
3908 ;; begin -- NL 1
3909 ;; null;
3910 ;; end B; -- NL 0, and we would exit
3911 ;; begin
3912 ;; end; -- we should exit here
3913 ;; processing them recursively avoids the need for any special
3914 ;; handling.
3915 ;; Nothing should be done if we have only the specs or a
3916 ;; generic instantion.
3932 ;; found block end => decrease nest depth
3936 ;; skip the following keyword
3943 ;; found package start => check if it really starts a block, and is not
3944 ;; in fact a generic instantiation for instance
3949 ;; ignore and skip it if it is only a 'new' package
3955 ;; all the other block starts
3965 t
3967 nil
3969 ))
3974 "Regexp-search for SEARCH-RE, ignoring comments, strings.
3975 If PARAMLISTS is nil, ignore parameter lists. Returns a cons cell of
3976 begin and end of match data or nil, if not found.
3977 The search is done using SEARCH-FUNC, which should search backward if
3978 BACKWARD is non-nil, forward otherwise. SEARCH-FUNC can be optimized
3979 in case we are searching for a constant string.
3980 The search stops at pos LIMIT.
3981 Point is moved at the beginning of the SEARCH-RE."
3983 begin
3984 end
3985 parse-result
3991 ;;
3992 ;; search until found or end-of-buffer
3993 ;; We have to test that we do not look further than limit
3994 ;;
4009 ;;
4010 ;; If inside a string, skip it (and the following comments)
4011 ;;
4017 ;;
4018 ;; If inside a comment, skip it (and the following comments)
4019 ;; There is a special code for comments at the end of the file
4020 ;;
4029 ;; at the end of the file, it is not possible to skip a comment
4030 ;; so we just go at the end of the line
4036 ;;
4037 ;; directly in front of a comment => skip it, if searching forward
4038 ;;
4042 ;;
4043 ;; found a parameter-list but should ignore it => skip it
4044 ;;
4049 ;;
4050 ;; found what we were looking for
4051 ;;
4059 nil)))
4061 ;; -------------------------------------------------------
4062 ;; -- Testing the position of the cursor
4063 ;; -------------------------------------------------------
4066 "Return t if point is inside a declarative part.
4067 Assumes point to be at the end of a statement."
4074 "Return t if looking at an 'or' following a semicolon."
4084 "Return t if looking at the start of a private section in a package.
4085 Returns nil if the private is part of the package name, as in
4086 'private package A is...' (this can only happen at top level)."
4091 ;; Make sure this is the start of a private section (ie after
4092 ;; a semicolon or just after the package declaration, but not
4093 ;; after a 'type ... is private' or 'is new ... with private'
4094 ;;
4095 ;; Note that a 'private' statement at the beginning of the buffer
4096 ;; does not indicate a private section, since this is instead a
4097 ;; 'private procedure ...'
4106 "Return t if point is inside a parameter-list."
4110 ;; inside parentheses ?
4113 ;; We could be looking at two things here:
4114 ;; operator definition: function "." (
4115 ;; subprogram definition: procedure .... (
4116 ;; Let's skip back over the first one
4122 t)
4124 ;; and now over the second one
4127 ;; We should ignore the case when the reserved keyword is in a
4128 ;; comment (for instance, when we have:
4129 ;; -- .... package
4130 ;; Test (A)
4131 ;; we should return nil
4135 ;; right keyword two words before parenthesis ?
4136 ;; Type is in this list because of discriminants
4147 "Like `ada-search-ignore-string-comment', except that it also ignores
4148 boolean expressions 'and then' and 'or else'."
4153 result))
4156 "Return the position of the first non-ws behind the last unclosed
4157 parenthesis, or nil."
4163 t))
4170 ;; Skip blanks, if they are not followed by a comment
4171 ;; See:
4172 ;; type A is ( Value_0,
4173 ;; Value_1);
4174 ;; type B is ( -- comment
4175 ;; Value_2);
4183 \f
4184 ;; -----------------------------------------------------------
4185 ;; -- Behavior Of TAB Key
4186 ;; -----------------------------------------------------------
4189 "Do indenting or tabbing according to `ada-tab-policy'.
4190 In Transient Mark mode, if the mark is active, operate on the contents
4191 of the region. Otherwise, operate only on the current line."
4199 ))
4202 "Delete leading indenting according to `ada-tab-policy'."
4207 ))
4210 "Ada mode version of the `indent-line-function'."
4218 ))
4221 "Indent current line to next tab stop."
4230 "Indent current line to previous tab stop."
4237 \f
4238 ;; ------------------------------------------------------------
4239 ;; -- Miscellaneous
4240 ;; ------------------------------------------------------------
4242 ;; Not needed any more for Emacs 21.2, but still needed for backward
4243 ;; compatibility
4245 "Remove trailing spaces in the whole buffer."
4256 "Clean up comments, `(' and `,' for GNAT style checking switch."
4260 ;; The \n is required, or the line after an empty comment line is
4261 ;; simply ignored.
4290 ;; Make sure there is a space after a ','.
4291 ;; Always go back to the beginning of the match, since otherwise
4292 ;; a statement like ('F','D','E') is incorrectly modified.
4300 ;; Operators should be surrounded by spaces.
4304 nil t)
4323 ))
4326 \f
4327 ;; -------------------------------------------------------------
4328 ;; -- Moving To Procedures/Packages/Statements
4329 ;; -------------------------------------------------------------
4332 "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
4370 ;; restore syntax-table
4374 "Move point to the matching end of the block around point.
4375 Moves to 'begin' if in a declarative part."
4378 decl-start
4387 ;; Go to the beginning of the current word, and check if we are
4388 ;; directly on 'begin'
4393 )
4395 ;; on first line of subprogram body
4396 ;; Do nothing for specs or generic instantion, since these are
4397 ;; handled as the general case (find the enclosing block)
4398 ;; We also need to make sure that we ignore nested subprograms
4404 ))
4408 ;; on first line of task declaration
4417 ;; accept block start
4422 ;; package start
4428 ;; On a "declare" keyword
4434 ;; inside a 'begin' ... 'end' block
4439 ;; (hopefully ;-) everything else
4443 )
4445 ;; now really move to the position found
4448 ;; restore syntax-table
4452 "Move point to next procedure."
4460 "Move point to previous procedure."
4468 "Move point to next package."
4476 "Move point to previous package."
4483 \f
4484 ;; ------------------------------------------------------------
4485 ;; -- Define keymap and menus for Ada
4486 ;; -------------------------------------------------------------
4489 "Create the keymap associated with the Ada mode."
4491 ;; Indentation and Formatting
4501 ;; We don't want to make meta-characters case-specific.
4503 ;; Movement
4509 ;; Compilation
4513 ;; Casing
4519 ;; On XEmacs, you can easily specify whether DEL should deletes
4520 ;; one character forward or one character backward. Take this into
4521 ;; account
4526 ;; Make body
4527 (define-key ada-mode-map "\C-c\C-n" 'ada-make-subprogram-body)
4529 ;; Use predefined function of Emacs19 for comments (RE)
4530 (define-key ada-mode-map "\C-c;" 'comment-region)
4531 (define-key ada-mode-map "\C-c:" 'ada-uncomment-region)
4533 ;; The following keys are bound to functions defined in ada-xref.el or
4534 ;; ada-prj,el., However, RMS rightly thinks that the code should be shared,
4535 ;; and activated only if the right compiler is used
4536 (if (featurep 'xemacs)
4537 (progn
4538 (define-key ada-mode-map '(shift button3) 'ada-point-and-xref)
4539 (define-key ada-mode-map '(control tab) 'ada-complete-identifier))
4540 (define-key ada-mode-map [C-tab] 'ada-complete-identifier)
4541 (define-key ada-mode-map [S-mouse-3] 'ada-point-and-xref))
4543 (define-key ada-mode-map "\C-co" 'ff-find-other-file)
4544 (define-key ada-mode-map "\C-c5\C-d" 'ada-goto-declaration-other-frame)
4545 (define-key ada-mode-map "\C-c\C-d" 'ada-goto-declaration)
4546 (define-key ada-mode-map "\C-c\C-s" 'ada-xref-goto-previous-reference)
4547 (define-key ada-mode-map "\C-c\C-c" 'ada-compile-application)
4548 (define-key ada-mode-map "\C-cc" 'ada-change-prj)
4549 (define-key ada-mode-map "\C-cd" 'ada-set-default-project-file)
4550 (define-key ada-mode-map "\C-cg" 'ada-gdb-application)
4551 (define-key ada-mode-map "\C-cr" 'ada-run-application)
4552 (define-key ada-mode-map "\C-c\C-o" 'ada-goto-parent)
4553 (define-key ada-mode-map "\C-c\C-r" 'ada-find-references)
4554 (define-key ada-mode-map "\C-cl" 'ada-find-local-references)
4555 (define-key ada-mode-map "\C-c\C-v" 'ada-check-current)
4556 (define-key ada-mode-map "\C-cf" 'ada-find-file)
4558 (define-key ada-mode-map "\C-cu" 'ada-prj-edit)
4560 ;; The templates, defined in ada-stmt.el
4562 (let ((map (make-sparse-keymap)))
4563 (define-key map "h" 'ada-header)
4564 (define-key map "\C-a" 'ada-array)
4565 (define-key map "b" 'ada-exception-block)
4566 (define-key map "d" 'ada-declare-block)
4567 (define-key map "c" 'ada-case)
4568 (define-key map "\C-e" 'ada-elsif)
4569 (define-key map "e" 'ada-else)
4570 (define-key map "\C-k" 'ada-package-spec)
4571 (define-key map "k" 'ada-package-body)
4572 (define-key map "\C-p" 'ada-procedure-spec)
4573 (define-key map "p" 'ada-subprogram-body)
4574 (define-key map "\C-f" 'ada-function-spec)
4575 (define-key map "f" 'ada-for-loop)
4576 (define-key map "i" 'ada-if)
4577 (define-key map "l" 'ada-loop)
4578 (define-key map "\C-r" 'ada-record)
4579 (define-key map "\C-s" 'ada-subtype)
4580 (define-key map "S" 'ada-tabsize)
4581 (define-key map "\C-t" 'ada-task-spec)
4582 (define-key map "t" 'ada-task-body)
4583 (define-key map "\C-y" 'ada-type)
4584 (define-key map "\C-v" 'ada-private)
4585 (define-key map "u" 'ada-use)
4586 (define-key map "\C-u" 'ada-with)
4587 (define-key map "\C-w" 'ada-when)
4588 (define-key map "w" 'ada-while-loop)
4589 (define-key map "\C-x" 'ada-exception)
4590 (define-key map "x" 'ada-exit)
4591 (define-key ada-mode-map "\C-ct" map))
4592 )
4595 (defun ada-create-menu ()
4596 "Create the Ada menu as shown in the menu bar."
4597 (let ((m '("Ada"
4598 ("Help"
4599 ["Ada Mode" (info "ada-mode") t]
4600 ["GNAT User's Guide" (info "gnat_ugn")
4601 (eq ada-which-compiler 'gnat)]
4602 ["GNAT Reference Manual" (info "gnat_rm")
4603 (eq ada-which-compiler 'gnat)]
4604 ["Gcc Documentation" (info "gcc")
4605 (eq ada-which-compiler 'gnat)]
4606 ["Gdb Documentation" (info "gdb")
4607 (eq ada-which-compiler 'gnat)]
4608 ["Ada95 Reference Manual" (info "arm95")
4609 (eq ada-which-compiler 'gnat)])
4610 ("Options" :included (eq major-mode 'ada-mode)
4611 ["Auto Casing" (setq ada-auto-case (not ada-auto-case))
4612 :style toggle :selected ada-auto-case]
4613 ["Auto Indent After Return"
4614 (setq ada-indent-after-return (not ada-indent-after-return))
4615 :style toggle :selected ada-indent-after-return]
4616 ["Automatically Recompile For Cross-references"
4617 (setq ada-xref-create-ali (not ada-xref-create-ali))
4618 :style toggle :selected ada-xref-create-ali
4619 :included (eq ada-which-compiler 'gnat)]
4620 ["Confirm Commands"
4621 (setq ada-xref-confirm-compile (not ada-xref-confirm-compile))
4622 :style toggle :selected ada-xref-confirm-compile
4623 :included (eq ada-which-compiler 'gnat)]
4624 ["Show Cross-references In Other Buffer"
4625 (setq ada-xref-other-buffer (not ada-xref-other-buffer))
4626 :style toggle :selected ada-xref-other-buffer
4627 :included (eq ada-which-compiler 'gnat)]
4628 ["Tight Integration With GNU Visual Debugger"
4629 (setq ada-tight-gvd-integration (not ada-tight-gvd-integration))
4630 :style toggle :selected ada-tight-gvd-integration
4631 :included (string-match "gvd" ada-prj-default-debugger)])
4632 ["Customize" (customize-group 'ada)
4633 :included (fboundp 'customize-group)]
4634 ["Check file" ada-check-current (eq ada-which-compiler 'gnat)]
4635 ["Compile file" ada-compile-current (eq ada-which-compiler 'gnat)]
4636 ["Build" ada-compile-application
4637 (eq ada-which-compiler 'gnat)]
4638 ["Run" ada-run-application t]
4639 ["Debug" ada-gdb-application (eq ada-which-compiler 'gnat)]
4640 ["------" nil nil]
4641 ("Project"
4642 :included (eq ada-which-compiler 'gnat)
4643 ["Load..." ada-set-default-project-file t]
4644 ["New..." ada-prj-new t]
4645 ["Edit..." ada-prj-edit t])
4646 ("Goto" :included (eq major-mode 'ada-mode)
4647 ["Goto Declaration/Body" ada-goto-declaration
4648 (eq ada-which-compiler 'gnat)]
4649 ["Goto Body" ada-goto-body
4650 (eq ada-which-compiler 'gnat)]
4651 ["Goto Declaration Other Frame"
4652 ada-goto-declaration-other-frame
4653 (eq ada-which-compiler 'gnat)]
4654 ["Goto Previous Reference" ada-xref-goto-previous-reference
4655 (eq ada-which-compiler 'gnat)]
4656 ["List Local References" ada-find-local-references
4657 (eq ada-which-compiler 'gnat)]
4658 ["List References" ada-find-references
4659 (eq ada-which-compiler 'gnat)]
4660 ["Goto Reference To Any Entity" ada-find-any-references
4661 (eq ada-which-compiler 'gnat)]
4662 ["Goto Parent Unit" ada-goto-parent
4663 (eq ada-which-compiler 'gnat)]
4664 ["--" nil nil]
4665 ["Next compilation error" next-error t]
4666 ["Previous Package" ada-previous-package t]
4667 ["Next Package" ada-next-package t]
4668 ["Previous Procedure" ada-previous-procedure t]
4669 ["Next Procedure" ada-next-procedure t]
4670 ["Goto Start Of Statement" ada-move-to-start t]
4671 ["Goto End Of Statement" ada-move-to-end t]
4672 ["-" nil nil]
4673 ["Other File" ff-find-other-file t]
4674 ["Other File Other Window" ada-ff-other-window t])
4675 ("Edit" :included (eq major-mode 'ada-mode)
4676 ["Search File On Source Path" ada-find-file t]
4677 ["------" nil nil]
4678 ["Complete Identifier" ada-complete-identifier t]
4679 ["-----" nil nil]
4680 ["Indent Line" ada-indent-current-function t]
4681 ["Justify Current Indentation" ada-justified-indent-current t]
4682 ["Indent Lines in Selection" ada-indent-region t]
4683 ["Indent Lines in File"
4684 (ada-indent-region (point-min) (point-max)) t]
4685 ["Format Parameter List" ada-format-paramlist t]
4686 ["-" nil nil]
4687 ["Comment Selection" comment-region t]
4688 ["Uncomment Selection" ada-uncomment-region t]
4689 ["--" nil nil]
4690 ["Fill Comment Paragraph" fill-paragraph t]
4691 ["Fill Comment Paragraph Justify"
4692 ada-fill-comment-paragraph-justify t]
4693 ["Fill Comment Paragraph Postfix"
4694 ada-fill-comment-paragraph-postfix t]
4695 ["---" nil nil]
4696 ["Adjust Case Selection" ada-adjust-case-region t]
4697 ["Adjust Case in File" ada-adjust-case-buffer t]
4698 ["Create Case Exception" ada-create-case-exception t]
4699 ["Create Case Exception Substring"
4700 ada-create-case-exception-substring t]
4701 ["Reload Case Exceptions" ada-case-read-exceptions t]
4702 ["----" nil nil]
4703 ["Make body for subprogram" ada-make-subprogram-body t]
4704 ["-----" nil nil]
4705 ["Narrow to subprogram" ada-narrow-to-defun t])
4706 ("Templates"
4707 :included (eq major-mode 'ada-mode)
4708 ["Header" ada-header t]
4709 ["-" nil nil]
4710 ["Package Body" ada-package-body t]
4711 ["Package Spec" ada-package-spec t]
4712 ["Function Spec" ada-function-spec t]
4713 ["Procedure Spec" ada-procedure-spec t]
4714 ["Proc/func Body" ada-subprogram-body t]
4715 ["Task Body" ada-task-body t]
4716 ["Task Spec" ada-task-spec t]
4717 ["Declare Block" ada-declare-block t]
4718 ["Exception Block" ada-exception-block t]
4719 ["--" nil nil]
4720 ["Entry" ada-entry t]
4721 ["Entry family" ada-entry-family t]
4722 ["Select" ada-select t]
4723 ["Accept" ada-accept t]
4724 ["Or accept" ada-or-accep t]
4725 ["Or delay" ada-or-delay t]
4726 ["Or terminate" ada-or-terminate t]
4727 ["---" nil nil]
4728 ["Type" ada-type t]
4729 ["Private" ada-private t]
4730 ["Subtype" ada-subtype t]
4731 ["Record" ada-record t]
4732 ["Array" ada-array t]
4733 ["----" nil nil]
4734 ["If" ada-if t]
4735 ["Else" ada-else t]
4736 ["Elsif" ada-elsif t]
4737 ["Case" ada-case t]
4738 ["-----" nil nil]
4739 ["While Loop" ada-while-loop t]
4740 ["For Loop" ada-for-loop t]
4741 ["Loop" ada-loop t]
4742 ["------" nil nil]
4743 ["Exception" ada-exception t]
4744 ["Exit" ada-exit t]
4745 ["When" ada-when t])
4746 )))
4748 (easy-menu-define ada-mode-menu ada-mode-map "Menu keymap for Ada mode" m)
4749 (if (featurep 'xemacs)
4750 (progn
4751 (define-key ada-mode-map [menu-bar] ada-mode-menu)
4752 (set 'mode-popup-menu (cons "Ada mode" ada-mode-menu))))))
4754 \f
4755 ;; -------------------------------------------------------
4756 ;; Commenting/Uncommenting code
4757 ;; The following two calls are provided to enhance the standard
4758 ;; comment-region function, which only allows uncommenting if the
4759 ;; comment is at the beginning of a line. If the line have been re-indented,
4760 ;; we are unable to use comment-region, which makes no sense.
4761 ;;
4762 ;; In addition, we provide an interface to the standard comment handling
4763 ;; function for justifying the comments.
4764 ;; -------------------------------------------------------
4766 (defadvice comment-region (before ada-uncomment-anywhere disable)
4767 (if (and arg
4768 (listp arg) ;; a prefix with \C-u is of the form '(4), whereas
4769 ;; \C-u 2 sets arg to '2' (fixed by S.Leake)
4770 (string= mode-name "Ada"))
4771 (save-excursion
4773 (goto-char beg)
4774 (while (re-search-forward cs end t)
4775 (replace-match comment-start))
4776 ))))
4778 (defun ada-uncomment-region (beg end &optional arg)
4779 "Delete `comment-start' at the beginning of a line in the region."
4782 ;; This advice is not needed anymore with Emacs21. However, for older
4783 ;; versions, as well as for XEmacs, we still need to enable it.
4784 (if (or (<= emacs-major-version 20) (featurep 'xemacs))
4785 (progn
4786 (ad-activate 'comment-region)
4787 (comment-region beg end (- (or arg 2)))
4788 (ad-deactivate 'comment-region))
4789 (comment-region beg end (list (- (or arg 2))))
4790 (ada-indent-region beg end)))
4792 (defun ada-fill-comment-paragraph-justify ()
4793 "Fill current comment paragraph and justify each line as well."
4794 (interactive)
4795 (ada-fill-comment-paragraph 'full))
4797 (defun ada-fill-comment-paragraph-postfix ()
4798 "Fill current comment paragraph and justify each line as well.
4799 Adds `ada-fill-comment-postfix' at the end of each line."
4800 (interactive)
4801 (ada-fill-comment-paragraph 'full t))
4803 (defun ada-fill-comment-paragraph (&optional justify postfix)
4804 "Fill the current comment paragraph.
4805 If JUSTIFY is non-nil, each line is justified as well.
4806 If POSTFIX and JUSTIFY are non-nil, `ada-fill-comment-postfix' is appended
4807 to each line filled and justified.
4808 The paragraph is indented on the first line."
4809 (interactive "P")
4811 ;; check if inside comment or just in front a comment
4812 (if (and (not (ada-in-comment-p))
4814 (error "Not inside comment"))
4816 (let* (indent from to
4817 (opos (point-marker))
4819 ;; Sets this variable to nil, otherwise it prevents
4820 ;; fill-region-as-paragraph to work on Emacs <= 20.2
4821 (parse-sexp-lookup-properties nil)
4823 fill-prefix
4824 (fill-column (current-fill-column)))
4826 ;; Find end of paragraph
4827 (back-to-indentation)
4829 (forward-line 1)
4831 ;; If we were at the last line in the buffer, create a dummy empty
4832 ;; line at the end of the buffer.
4833 (if (eobp)
4835 (back-to-indentation)))
4836 (beginning-of-line)
4837 (setq to (point-marker))
4838 (goto-char opos)
4840 ;; Find beginning of paragraph
4841 (back-to-indentation)
4843 (forward-line -1)
4844 (back-to-indentation))
4846 ;; We want one line above the first one, unless we are at the beginning
4847 ;; of the buffer
4848 (unless (bobp)
4849 (forward-line 1))
4850 (beginning-of-line)
4851 (setq from (point-marker))
4853 ;; Calculate the indentation we will need for the paragraph
4854 (back-to-indentation)
4855 (setq indent (current-column))
4856 ;; unindent the first line of the paragraph
4857 (delete-region from (point))
4859 ;; Remove the old postfixes
4860 (goto-char from)
4864 (goto-char (1- to))
4865 (setq to (point-marker))
4867 ;; Indent and justify the paragraph
4868 (setq fill-prefix ada-fill-comment-prefix)
4869 (set-left-margin from to indent)
4870 (if postfix
4871 (setq fill-column (- fill-column (length ada-fill-comment-postfix))))
4873 (fill-region-as-paragraph from to justify)
4875 ;; Add the postfixes if required
4876 (if postfix
4877 (save-restriction
4878 (goto-char from)
4879 (narrow-to-region from to)
4880 (while (not (eobp))
4881 (end-of-line)
4882 (insert-char ? (- fill-column (current-column)))
4883 (insert ada-fill-comment-postfix)
4884 (forward-line))
4885 ))
4887 ;; In Emacs <= 20.2 and XEmacs <=20.4, there is a bug, and a newline is
4888 ;; inserted at the end. Delete it
4889 (if (or (featurep 'xemacs)
4890 (<= emacs-major-version 19)
4891 (and (= emacs-major-version 20)
4892 (<= emacs-minor-version 2)))
4893 (progn
4894 (goto-char to)
4895 (end-of-line)
4896 (delete-char 1)))
4898 (goto-char opos)))
4901 ;; ---------------------------------------------------
4902 ;; support for find-file.el
4903 ;; These functions are used by find-file to guess the file names from
4904 ;; unit names, and to find the other file (spec or body) from the current
4905 ;; file (body or spec).
4906 ;; It is also used to find in which function we are, so as to put the
4907 ;; cursor at the correct position.
4908 ;; Standard Ada does not force any relation between unit names and file names,
4909 ;; so some of these functions can only be a good approximation. However, they
4910 ;; are also overriden in `ada-xref'.el when we know that the user is using
4911 ;; GNAT.
4912 ;; ---------------------------------------------------
4914 ;; Overriden when we work with GNAT, to use gnatkrunch
4915 (defun ada-make-filename-from-adaname (adaname)
4916 "Determine the filename in which ADANAME is found.
4917 This is a generic function, independent from any compiler."
4919 (setq adaname (replace-match "-" t t adaname)))
4920 (downcase adaname)
4921 )
4923 (defun ada-other-file-name ()
4924 "Return the name of the other file.
4925 The name returned is the body if `current-buffer' is the spec,
4926 or the spec otherwise."
4928 (let ((is-spec nil)
4929 (is-body nil)
4930 (suffixes ada-spec-suffixes)
4931 (name (buffer-file-name)))
4933 ;; Guess whether we have a spec or a body, and get the basename of the
4934 ;; file. Since the extension may not start with '.', we can not use
4935 ;; file-name-extension
4936 (while (and (not is-spec)
4937 suffixes)
4939 (setq is-spec t
4940 name (match-string 1 name)))
4941 (setq suffixes (cdr suffixes)))
4943 (if (not is-spec)
4944 (progn
4945 (setq suffixes ada-body-suffixes)
4946 (while (and (not is-body)
4947 suffixes)
4949 (setq is-body t
4950 name (match-string 1 name)))
4951 (setq suffixes (cdr suffixes)))))
4953 ;; If this wasn't in either list, return name itself
4954 (if (not (or is-spec is-body))
4955 name
4957 ;; Else find the other possible names
4958 (if is-spec
4959 (setq suffixes ada-body-suffixes)
4960 (setq suffixes ada-spec-suffixes))
4961 (setq is-spec name)
4963 (while suffixes
4965 ;; If we are using project file, search for the other file in all
4966 ;; the possible src directories.
4968 (if (fboundp 'ada-find-src-file-in-dir)
4969 (let ((other
4970 (ada-find-src-file-in-dir
4971 (file-name-nondirectory (concat name (car suffixes))))))
4972 (if other
4973 (set 'is-spec other)))
4975 ;; Else search in the current directory
4976 (if (file-exists-p (concat name (car suffixes)))
4977 (setq is-spec (concat name (car suffixes)))))
4978 (setq suffixes (cdr suffixes)))
4980 is-spec)))
4982 (defun ada-which-function-are-we-in ()
4983 "Return the name of the function whose definition/declaration point is in.
4984 Redefines the function `ff-which-function-are-we-in'."
4985 (setq ff-function-name nil)
4986 (save-excursion
4987 (end-of-line);; make sure we get the complete name
4988 (if (or (re-search-backward ada-procedure-start-regexp nil t)
4989 (re-search-backward ada-package-start-regexp nil t))
4990 (setq ff-function-name (match-string 0)))
4991 ))
4994 (defvar ada-last-which-function-line -1
4995 "Last on which `ada-which-function' was called.")
4996 (defvar ada-last-which-function-subprog 0
4997 "Last subprogram name returned by `ada-which-function'.")
4998 (make-variable-buffer-local 'ada-last-which-function-subprog)
4999 (make-variable-buffer-local 'ada-last-which-function-line)
5002 (defun ada-which-function ()
5003 "Return the name of the function whose body the point is in.
5004 This function works even in the case of nested subprograms, whereas the
5005 standard Emacs function `which-function' does not.
5006 Since the search can be long, the results are cached."
5008 (let ((line (count-lines 1 (point)))
5009 (pos (point))
5010 end-pos
5011 func-name indent
5012 found)
5014 ;; If this is the same line as before, simply return the same result
5015 (if (= line ada-last-which-function-line)
5016 ada-last-which-function-subprog
5018 (save-excursion
5019 ;; In case the current line is also the beginning of the body
5020 (end-of-line)
5025 (condition-case nil
5026 (up-list 1)
5027 (error nil))
5030 (if (looking-at "return")
5031 (progn
5032 (forward-word 1)
5034 (skip-chars-forward "a-zA-Z0-9_'")))
5036 ;; Can't simply do forward-word, in case the "is" is not on the
5037 ;; same line as the closing parenthesis
5040 ;; No look for the closest subprogram body that has not ended yet.
5041 ;; Not that we expect all the bodies to be finished by "end <name>",
5042 ;; or a simple "end;" indented in the same column as the start of
5043 ;; the subprogram. The goal is to be as efficient as possible.
5045 (while (and (not found)
5046 (re-search-backward ada-imenu-subprogram-menu-re nil t))
5048 ;; Get the function name, but not the properties, or this changes
5049 ;; the face in the modeline on Emacs 21
5050 (setq func-name (match-string-no-properties 2))
5051 (if (and (not (ada-in-comment-p))
5052 (not (save-excursion
5053 (goto-char (match-end 0))
5055 (save-excursion
5056 (back-to-indentation)
5057 (setq indent (current-column))
5058 (if (ada-search-ignore-string-comment
5060 (make-string indent ? ) "end;"))
5061 (setq end-pos (point))
5062 (setq end-pos (point-max)))
5063 (if (>= end-pos pos)
5064 (setq found func-name))))
5065 )
5066 (setq ada-last-which-function-line line
5067 ada-last-which-function-subprog found)
5068 found))))
5070 (defun ada-ff-other-window ()
5071 "Find other file in other window using `ff-find-other-file'."
5072 (interactive)
5073 (and (fboundp 'ff-find-other-file)
5074 (ff-find-other-file t)))
5076 (defun ada-set-point-accordingly ()
5077 "Move to the function declaration that was set by
5078 `ff-which-function-are-we-in'."
5079 (if ff-function-name
5080 (progn
5081 (goto-char (point-min))
5082 (unless (ada-search-ignore-string-comment
5084 (goto-char (point-min))))))
5086 (defun ada-get-body-name (&optional spec-name)
5087 "Return the file name for the body of SPEC-NAME.
5088 If SPEC-NAME is nil, return the body for the current package.
5089 Returns nil if no body was found."
5090 (interactive)
5092 (unless spec-name (setq spec-name (buffer-file-name)))
5094 ;; Remove the spec extension. We can not simply remove the file extension,
5095 ;; but we need to take into account the specific non-GNAT extensions that the
5096 ;; user might have specified.
5098 (let ((suffixes ada-spec-suffixes)
5099 end)
5100 (while suffixes
5101 (setq end (- (length spec-name) (length (car suffixes))))
5102 (if (string-equal (car suffixes) (substring spec-name end))
5103 (setq spec-name (substring spec-name 0 end)))
5104 (setq suffixes (cdr suffixes))))
5106 ;; If find-file.el was available, use its functions
5107 (if (fboundp 'ff-get-file-name)
5108 (ff-get-file-name ada-search-directories-internal
5109 (ada-make-filename-from-adaname
5110 (file-name-nondirectory
5111 (file-name-sans-extension spec-name)))
5112 ada-body-suffixes)
5113 ;; Else emulate it very simply
5114 (concat (ada-make-filename-from-adaname
5115 (file-name-nondirectory
5116 (file-name-sans-extension spec-name)))
5117 ".adb")))
5119 \f
5120 ;; ---------------------------------------------------
5121 ;; support for font-lock.el
5122 ;; Strings are a real pain in Ada because a single quote character is
5123 ;; overloaded as a string quote and type/instance delimiter. By default, a
5124 ;; single quote is given punctuation syntax in `ada-mode-syntax-table'.
5125 ;; So, for Font Lock mode purposes, we mark single quotes as having string
5126 ;; syntax when the gods that created Ada determine them to be.
5127 ;;
5128 ;; This only works in Emacs. See the comments before the grammar functions
5129 ;; at the beginning of this file for how this is done with XEmacs.
5130 ;; ----------------------------------------------------
5132 (defconst ada-font-lock-syntactic-keywords
5133 ;; Mark single quotes as having string quote syntax in 'c' instances.
5134 ;; As a special case, ''' will not be highlighted, but if we do not
5135 ;; set this special case, then the rest of the buffer is highlighted as
5136 ;; a string
5137 ;; This sets the properties of the characters, so that ada-in-string-p
5138 ;; correctly handles '"' too...
5141 ))
5143 (defvar ada-font-lock-keywords
5144 (eval-when-compile
5145 (list
5146 ;;
5147 ;; handle "type T is access function return S;"
5150 ;; preprocessor line
5153 ;;
5154 ;; accept, entry, function, package (body), protected (body|type),
5155 ;; pragma, procedure, task (body) plus name.
5156 (list (concat
5170 "task"
5173 '(1 font-lock-keyword-face) '(2 font-lock-function-name-face nil t))
5174 ;;
5175 ;; Optional keywords followed by a type name.
5177 "\\<\\(access[ \t]+all\\|access[ \t]+constant\\|access\\|constant\\|in[ \t]+reverse\\|\\|in[ \t]+out\\|in\\|out\\)\\>"
5180 '(1 font-lock-keyword-face nil t) '(2 font-lock-type-face nil t))
5182 ;;
5183 ;; Main keywords, except those treated specially below.
5185 (regexp-opt
5186 '("abort" "abs" "abstract" "accept" "access" "aliased" "all"
5187 "and" "array" "at" "begin" "case" "declare" "delay" "delta"
5188 "digits" "do" "else" "elsif" "entry" "exception" "exit" "for"
5189 "generic" "if" "in" "is" "limited" "loop" "mod" "not"
5190 "null" "or" "others" "private" "protected" "raise"
5191 "range" "record" "rem" "renames" "requeue" "return" "reverse"
5192 "select" "separate" "tagged" "task" "terminate" "then" "until"
5193 "when" "while" "with" "xor") t)
5195 ;;
5196 ;; Anything following end and not already fontified is a body name.
5198 (1 font-lock-keyword-face) (3 font-lock-function-name-face nil t))
5199 ;;
5200 ;; Keywords followed by a type or function name.
5204 '(1 font-lock-keyword-face)
5205 '(2 (if (match-beginning 4)
5206 font-lock-function-name-face
5207 font-lock-type-face) nil t))
5208 ;;
5209 ;; Keywords followed by a (comma separated list of) reference.
5210 ;; Note that font-lock only works on single lines, thus we can not
5211 ;; correctly highlight a with_clause that spans multiple lines.
5214 '(1 font-lock-keyword-face) '(2 font-lock-reference-face nil t))
5216 ;;
5217 ;; Goto tags.
5220 ;; Highlight based-numbers (R. Reagan <robin-reply@reagans.org>)
5223 ;; Ada unnamed numerical constants
5226 ))
5227 "Default expressions to highlight in Ada mode.")
5230 ;; ---------------------------------------------------------
5231 ;; Support for outline.el
5232 ;; ---------------------------------------------------------
5234 (defun ada-outline-level ()
5235 "This is so that `current-column' DTRT in otherwise-hidden text."
5236 ;; patch from Dave Love <fx@gnu.org>
5237 (let (buffer-invisibility-spec)
5238 (save-excursion
5239 (back-to-indentation)
5240 (current-column))))
5242 ;; ---------------------------------------------------------
5243 ;; Support for narrow-to-region
5244 ;; ---------------------------------------------------------
5246 (defun ada-narrow-to-defun (&optional arg)
5247 "Make text outside current subprogram invisible.
5248 The subprogram visible is the one that contains or follow point.
5249 Optional ARG is ignored.
5250 Use `M-x widen' to go back to the full visibility for the buffer."
5252 (interactive)
5253 (save-excursion
5254 (let (end)
5255 (widen)
5256 (forward-line 1)
5257 (ada-previous-procedure)
5259 (save-excursion
5260 (beginning-of-line)
5261 (setq end (point)))
5263 (ada-move-to-end)
5264 (end-of-line)
5265 (narrow-to-region end (point))
5266 (message
5267 "Use M-x widen to get back to full visibility in the buffer"))))
5269 ;; ---------------------------------------------------------
5270 ;; Automatic generation of code
5271 ;; The Ada-mode has a set of function to automatically generate a subprogram
5272 ;; or package body from its spec.
5273 ;; These function only use a primary and basic algorithm, this could use a
5274 ;; lot of improvement.
5275 ;; When the user is using GNAT, we rather use gnatstub to generate an accurate
5276 ;; body.
5277 ;; ----------------------------------------------------------
5279 (defun ada-gen-treat-proc (match)
5280 "Make dummy body of a procedure/function specification.
5281 MATCH is a cons cell containing the start and end locations of the last search
5282 for `ada-procedure-start-regexp'."
5283 (goto-char (car match))
5284 (let (func-found procname functype)
5285 (cond
5288 ;; treat it as a proc/func
5289 (forward-word 2)
5290 (forward-word -1)
5291 (setq procname (buffer-substring (point) (cdr match))) ; store proc name
5293 ;; goto end of procname
5294 (goto-char (cdr match))
5296 ;; skip over parameterlist
5298 (forward-sexp))
5300 ;; if function, skip over 'return' and result type.
5301 (if func-found
5302 (progn
5303 (forward-word 1)
5305 (setq functype (buffer-substring (point)
5306 (progn
5307 (skip-chars-forward
5308 "a-zA-Z0-9_\.")
5309 (point))))))
5310 ;; look for next non WS
5311 (cond
5313 (delete-region (match-beginning 0) (match-end 0));; delete the ';'
5314 (ada-indent-newline-indent)
5315 (insert "is")
5316 (ada-indent-newline-indent)
5317 (if func-found
5318 (progn
5319 (insert "Result : " functype ";")
5320 (ada-indent-newline-indent)))
5321 (insert "begin")
5322 (ada-indent-newline-indent)
5323 (if func-found
5324 (insert "return Result;")
5325 (insert "null;"))
5326 (ada-indent-newline-indent)
5327 (insert "end " procname ";")
5328 (ada-indent-newline-indent)
5329 )
5330 ;; else
5332 ;; do nothing
5333 )
5335 ;; do nothing
5336 )
5337 (t
5338 (message "unknown syntax"))))
5339 (t
5341 (progn
5342 (message "Task conversion is not yet implemented")
5343 (forward-word 2)
5345 (forward-line)
5346 (ada-move-to-end))
5347 ))))))
5349 (defun ada-make-body ()
5350 "Create an Ada package body in the current buffer.
5351 The potential old buffer contents is deleted first, then we copy the
5352 spec buffer in here and modify it to make it a body.
5353 This function typically is to be hooked into `ff-file-created-hooks'."
5354 (interactive)
5355 (delete-region (point-min) (point-max))
5356 (insert-buffer-substring (car (cdr (buffer-list))))
5357 (goto-char (point-min))
5358 (ada-mode)
5360 (let (found ada-procedure-or-package-start-regexp)
5361 (if (setq found
5362 (ada-search-ignore-string-comment ada-package-start-regexp nil))
5363 (progn (goto-char (cdr found))
5364 (insert " body")
5365 )
5366 (error "No package"))
5368 (setq ada-procedure-or-package-start-regexp
5369 (concat ada-procedure-start-regexp
5371 ada-package-start-regexp))
5373 (while (setq found
5374 (ada-search-ignore-string-comment
5375 ada-procedure-or-package-start-regexp nil))
5376 (progn
5377 (goto-char (car found))
5378 (if (looking-at ada-package-start-regexp)
5379 (progn (goto-char (cdr found))
5380 (insert " body"))
5381 (ada-gen-treat-proc found))))))
5384 (defun ada-make-subprogram-body ()
5385 "Make one dummy subprogram body from spec surrounding point."
5386 (interactive)
5387 (let* ((found (re-search-backward ada-procedure-start-regexp nil t))
5388 (spec (match-beginning 0))
5389 body-file)
5390 (if found
5391 (progn
5392 (goto-char spec)
5394 (= (char-before) ?\())
5395 (progn
5396 (ada-search-ignore-string-comment ")" nil)
5397 (ada-search-ignore-string-comment ";" nil)))
5398 (setq spec (buffer-substring spec (point)))
5400 ;; If find-file.el was available, use its functions
5401 (setq body-file (ada-get-body-name))
5402 (if body-file
5403 (find-file body-file)
5404 (error "No body found for the package. Create it first"))
5406 (save-restriction
5407 (widen)
5408 (goto-char (point-max))
5409 (forward-comment -10000)
5411 ;; Move to the beginning of the elaboration part, if any
5412 (re-search-backward "^begin" nil t)
5413 (newline)
5414 (forward-char -1)
5415 (insert spec)
5416 (re-search-backward ada-procedure-start-regexp nil t)
5417 (ada-gen-treat-proc (cons (match-beginning 0) (match-end 0)))
5418 ))
5419 (error "Not in subprogram spec"))))
5421 ;; --------------------------------------------------------
5422 ;; Global initializations
5423 ;; --------------------------------------------------------
5425 ;; Create the keymap once and for all. If we do that in ada-mode,
5426 ;; the keys changed in the user's .emacs have to be modified
5427 ;; every time
5428 (ada-create-keymap)
5429 (ada-create-menu)
5431 ;; Create the syntax tables, but do not activate them
5432 (ada-create-syntax-table)
5434 ;; Add the default extensions (and set up speedbar)
5435 (ada-add-extensions ".ads" ".adb")
5436 ;; This two files are generated by GNAT when running with -gnatD
5437 (if (equal ada-which-compiler 'gnat)
5438 (ada-add-extensions ".ads.dg" ".adb.dg"))
5440 ;; Read the special cases for exceptions
5441 (ada-case-read-exceptions)
5443 ;; Setup auto-loading of the other ada-mode files.
5444 (if (equal ada-which-compiler 'gnat)
5445 (progn
5446 (autoload 'ada-change-prj "ada-xref" nil t)
5447 (autoload 'ada-check-current "ada-xref" nil t)
5448 (autoload 'ada-compile-application "ada-xref" nil t)
5449 (autoload 'ada-compile-current "ada-xref" nil t)
5450 (autoload 'ada-complete-identifier "ada-xref" nil t)
5451 (autoload 'ada-find-file "ada-xref" nil t)
5452 (autoload 'ada-find-any-references "ada-xref" nil t)
5453 (autoload 'ada-find-src-file-in-dir "ada-xref" nil t)
5454 (autoload 'ada-find-local-references "ada-xref" nil t)
5455 (autoload 'ada-find-references "ada-xref" nil t)
5456 (autoload 'ada-gdb-application "ada-xref" nil t)
5457 (autoload 'ada-goto-declaration "ada-xref" nil t)
5458 (autoload 'ada-goto-declaration-other-frame "ada-xref" nil t)
5459 (autoload 'ada-goto-parent "ada-xref" nil t)
5460 (autoload 'ada-make-body-gnatstub "ada-xref" nil t)
5461 (autoload 'ada-point-and-xref "ada-xref" nil t)
5462 (autoload 'ada-reread-prj-file "ada-xref" nil t)
5463 (autoload 'ada-run-application "ada-xref" nil t)
5464 (autoload 'ada-set-default-project-file "ada-xref" nil nil)
5465 (autoload 'ada-set-default-project-file "ada-xref" nil t)
5466 (autoload 'ada-xref-goto-previous-reference "ada-xref" nil t)
5468 (autoload 'ada-customize "ada-prj" nil t)
5469 (autoload 'ada-prj-edit "ada-prj" nil t)
5470 (autoload 'ada-prj-new "ada-prj" nil t)
5471 (autoload 'ada-prj-save "ada-prj" nil t)
5472 ))
5474 (autoload 'ada-array "ada-stmt" nil t)
5475 (autoload 'ada-case "ada-stmt" nil t)
5476 (autoload 'ada-declare-block "ada-stmt" nil t)
5477 (autoload 'ada-else "ada-stmt" nil t)
5478 (autoload 'ada-elsif "ada-stmt" nil t)
5479 (autoload 'ada-exception "ada-stmt" nil t)
5480 (autoload 'ada-exception-block "ada-stmt" nil t)
5481 (autoload 'ada-exit "ada-stmt" nil t)
5482 (autoload 'ada-for-loop "ada-stmt" nil t)
5483 (autoload 'ada-function-spec "ada-stmt" nil t)
5484 (autoload 'ada-header "ada-stmt" nil t)
5485 (autoload 'ada-if "ada-stmt" nil t)
5486 (autoload 'ada-loop "ada-stmt" nil t)
5487 (autoload 'ada-package-body "ada-stmt" nil t)
5488 (autoload 'ada-package-spec "ada-stmt" nil t)
5489 (autoload 'ada-private "ada-stmt" nil t)
5490 (autoload 'ada-procedure-spec "ada-stmt" nil t)
5491 (autoload 'ada-record "ada-stmt" nil t)
5492 (autoload 'ada-subprogram-body "ada-stmt" nil t)
5493 (autoload 'ada-subtype "ada-stmt" nil t)
5494 (autoload 'ada-tabsize "ada-stmt" nil t)
5495 (autoload 'ada-task-body "ada-stmt" nil t)
5496 (autoload 'ada-task-spec "ada-stmt" nil t)
5497 (autoload 'ada-type "ada-stmt" nil t)
5498 (autoload 'ada-use "ada-stmt" nil t)
5499 (autoload 'ada-when "ada-stmt" nil t)
5500 (autoload 'ada-while-loop "ada-stmt" nil t)
5501 (autoload 'ada-with "ada-stmt" nil t)
5503 ;;; provide ourselves
5504 (provide 'ada-mode)
5506 ;;; arch-tag: 1b7d45ec-1698-43b5-8d4a-e479ea023270
5507 ;;; ada-mode.el ends here