|
2
|
1 ;;; ada-mode.el --- An Emacs major-mode for editing Ada source.
|
|
189
|
2
|
|
|
3 ;; Copyright (C) 1994, 1995, 1997 Free Software Foundation, Inc.
|
|
|
4
|
|
|
5 ;; Authors: Rolf Ebert <ebert@inf.enst.fr>
|
|
|
6 ;; Markus Heritsch <Markus.Heritsch@studbox.uni-stuttgart.de>
|
|
|
7 ;; Keywords: languages oop ada
|
|
|
8 ;; Rolf Ebert's version: 2.27
|
|
|
9
|
|
|
10 ;; This file is part of XEmacs
|
|
|
11
|
|
|
12 ;; XEmacs is free software; you can redistribute it and/or modify
|
|
|
13 ;; it under the terms of the GNU General Public License as published by
|
|
0
|
14 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
15 ;; any later version.
|
|
|
16
|
|
189
|
17 ;; XEmacs is distributed in the hope that it will be useful,
|
|
|
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
20 ;; GNU General Public License for more details.
|
|
0
|
21
|
|
|
22 ;; You should have received a copy of the GNU General Public License
|
|
189
|
23 ;; along with XEmacs; see the file COPYING. If not, write to the
|
|
|
24 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
25 ;; Boston, MA 02111-1307, USA.
|
|
0
|
26
|
|
|
27 ;;; This mode is a complete rewrite of a major mode for editing Ada 83
|
|
|
28 ;;; and Ada 95 source code under Emacs-19. It contains completely new
|
|
|
29 ;;; indenting code and support for code browsing (see ada-xref).
|
|
|
30
|
|
189
|
31 ;;; Synched up with: FSF 20.1
|
|
0
|
32
|
|
|
33 ;;; USAGE
|
|
|
34 ;;; =====
|
|
189
|
35 ;;; Emacs should enter Ada mode when you load an Ada source (*.ad[abs]).
|
|
0
|
36 ;;;
|
|
|
37 ;;; When you have entered ada-mode, you may get more info by pressing
|
|
|
38 ;;; C-h m. You may also get online help describing various functions by:
|
|
|
39 ;;; C-h d <Name of function you want described>
|
|
|
40
|
|
|
41
|
|
|
42 ;;; HISTORY
|
|
|
43 ;;; =======
|
|
|
44 ;;; The first Ada mode for GNU Emacs was written by V. Broman in
|
|
|
45 ;;; 1985. He based his work on the already existing Modula-2 mode.
|
|
|
46 ;;; This was distributed as ada.el in versions of Emacs prior to 19.29.
|
|
|
47 ;;;
|
|
|
48 ;;; Lynn Slater wrote an extensive Ada mode in 1989. It consisted of
|
|
|
49 ;;; several files with support for dired commands and other nice
|
|
|
50 ;;; things. It is currently available from the PAL
|
|
|
51 ;;; (wuarchive.wustl.edu:/languages/ada) as ada-mode-1.06a.tar.Z.
|
|
|
52 ;;;
|
|
|
53 ;;; The probably very first Ada mode (called electric-ada.el) was
|
|
|
54 ;;; written by Steven D. Litvintchouk and Steven M. Rosen for the
|
|
|
55 ;;; Gosling Emacs. L. Slater based his development on ada.el and
|
|
|
56 ;;; electric-ada.el.
|
|
|
57 ;;;
|
|
|
58 ;;; The current Ada mode is a complete rewrite by M. Heritsch and
|
|
189
|
59 ;;; R. Ebert. Some ideas from the Ada mode mailing list have been
|
|
0
|
60 ;;; added. Some of the functionality of L. Slater's mode has not
|
|
|
61 ;;; (yet) been recoded in this new mode. Perhaps you prefer sticking
|
|
|
62 ;;; to his version.
|
|
|
63
|
|
|
64
|
|
|
65 ;;; KNOWN BUGS
|
|
|
66 ;;; ==========
|
|
|
67 ;;;
|
|
|
68 ;;; In the presence of comments and/or incorrect syntax
|
|
|
69 ;;; ada-format-paramlist produces weird results.
|
|
2
|
70 ;;; -------------------
|
|
189
|
71 ;;; Character constants with otherwise syntactic relevant characters
|
|
|
72 ;;; like `(' or `"' throw indentation off the track. Fontification
|
|
|
73 ;;; should work now in Emacs-19.35
|
|
|
74 ;;; C : constant Character := Character'('"');
|
|
0
|
75 ;;; -------------------
|
|
189
|
76
|
|
|
77
|
|
|
78 ;;; TODO
|
|
|
79 ;;; ====
|
|
|
80 ;;;
|
|
|
81 ;;; o bodify-single-subprogram
|
|
|
82 ;;; o make a function "separate" and put it in the corresponding file.
|
|
0
|
83
|
|
|
84
|
|
|
85
|
|
|
86 ;;; CREDITS
|
|
|
87 ;;; =======
|
|
|
88 ;;;
|
|
|
89 ;;; Many thanks to
|
|
2
|
90 ;;; Philippe Waroquiers (PW) <philippe@cfmu.eurocontrol.be> in particular,
|
|
0
|
91 ;;; woodruff@stc.llnl.gov (John Woodruff)
|
|
|
92 ;;; jj@ddci.dk (Jesper Joergensen)
|
|
|
93 ;;; gse@ocsystems.com (Scott Evans)
|
|
|
94 ;;; comar@LANG8.CS.NYU.EDU (Cyrille Comar)
|
|
|
95 ;;; and others for their valuable hints.
|
|
|
96
|
|
|
97 ;;;--------------------
|
|
|
98 ;;; USER OPTIONS
|
|
|
99 ;;;--------------------
|
|
|
100
|
|
189
|
101
|
|
|
102 ;; ---- customize support
|
|
|
103
|
|
|
104 (defgroup ada nil
|
|
|
105 "Major mode for editing Ada source in Emacs"
|
|
|
106 :group 'languages)
|
|
|
107
|
|
0
|
108 ;; ---- configure indentation
|
|
|
109
|
|
189
|
110 (defcustom ada-indent 3
|
|
|
111 "*Defines the size of Ada indentation."
|
|
|
112 :type 'integer
|
|
|
113 :group 'ada)
|
|
|
114
|
|
|
115 (defcustom ada-broken-indent 2
|
|
|
116 "*# of columns to indent the continuation of a broken line."
|
|
|
117 :type 'integer
|
|
|
118 :group 'ada)
|
|
|
119
|
|
|
120 (defcustom ada-label-indent -4
|
|
|
121 "*# of columns to indent a label."
|
|
|
122 :type 'integer
|
|
|
123 :group 'ada)
|
|
|
124
|
|
|
125 (defcustom ada-stmt-end-indent 0
|
|
0
|
126 "*# of columns to indent a statement end keyword in a separate line.
|
|
189
|
127 Examples are 'is', 'loop', 'record', ..."
|
|
|
128 :type 'integer
|
|
|
129 :group 'ada)
|
|
|
130
|
|
|
131 (defcustom ada-when-indent 3
|
|
|
132 "*Defines the indentation for 'when' relative to 'exception' or 'case'."
|
|
|
133 :type 'integer
|
|
|
134 :group 'ada)
|
|
|
135
|
|
|
136 (defcustom ada-indent-record-rel-type 3
|
|
|
137 "*Defines the indentation for 'record' relative to 'type' or 'use'."
|
|
|
138 :type 'integer
|
|
|
139 :group 'ada)
|
|
|
140
|
|
|
141 (defcustom ada-indent-comment-as-code t
|
|
|
142 "*If non-nil, comment-lines get indented as Ada code."
|
|
|
143 :type 'boolean
|
|
|
144 :group 'ada)
|
|
|
145
|
|
|
146 (defcustom ada-indent-is-separate t
|
|
|
147 "*If non-nil, 'is separate' or 'is abstract' on a single line are indented."
|
|
|
148 :type 'boolean
|
|
|
149 :group 'ada)
|
|
|
150
|
|
|
151 (defcustom ada-indent-to-open-paren t
|
|
|
152 "*If non-nil, indent according to the innermost open parenthesis."
|
|
|
153 :type 'boolean
|
|
|
154 :group 'ada)
|
|
|
155
|
|
|
156 (defcustom ada-search-paren-char-count-limit 3000
|
|
|
157 "*Search that many characters for an open parenthesis."
|
|
|
158 :type 'integer
|
|
|
159 :group 'ada)
|
|
0
|
160
|
|
|
161
|
|
|
162 ;; ---- other user options
|
|
|
163
|
|
189
|
164 (defcustom ada-tab-policy 'indent-auto
|
|
0
|
165 "*Control behaviour of the TAB key.
|
|
2
|
166 Must be one of `indent-rigidly', `indent-auto', `gei', `indent-af'
|
|
|
167 or `always-tab'.
|
|
|
168
|
|
|
169 `indent-rigidly' : always adds ada-indent blanks at the beginning of the line.
|
|
|
170 `indent-auto' : use indentation functions in this file.
|
|
|
171 `gei' : use David Kågedal's Generic Indentation Engine.
|
|
|
172 `indent-af' : use Gary E. Barnes' ada-format.el
|
|
189
|
173 `always-tab' : do indent-relative."
|
|
|
174 :type '(choice (const indent-auto)
|
|
|
175 (const indent-rigidly)
|
|
|
176 (const gei)
|
|
|
177 (const indent-af)
|
|
|
178 (const always-tab))
|
|
|
179 :group 'ada)
|
|
|
180
|
|
|
181 (defcustom ada-move-to-declaration nil
|
|
2
|
182 "*If non-nil, `ada-move-to-start' moves point to the subprog declaration,
|
|
189
|
183 not to 'begin'."
|
|
|
184 :type 'boolean
|
|
|
185 :group 'ada)
|
|
|
186
|
|
|
187 (defcustom ada-spec-suffix ".ads"
|
|
|
188 "*Suffix of Ada specification files."
|
|
|
189 :type 'string
|
|
|
190 :group 'ada)
|
|
|
191
|
|
|
192 (defcustom ada-body-suffix ".adb"
|
|
|
193 "*Suffix of Ada body files."
|
|
|
194 :type 'string
|
|
|
195 :group 'ada)
|
|
|
196
|
|
|
197 (defcustom ada-spec-suffix-as-regexp "\\.ads$"
|
|
|
198 "*Regexp to find Ada specification files."
|
|
|
199 :type 'string
|
|
|
200 :group 'ada)
|
|
|
201
|
|
|
202 (defcustom ada-body-suffix-as-regexp "\\.adb$"
|
|
|
203 "*Regexp to find Ada body files."
|
|
|
204 :type 'string
|
|
|
205 :group 'ada)
|
|
|
206
|
|
|
207 (defvar ada-other-file-alist
|
|
|
208 (list
|
|
|
209 (list ada-spec-suffix-as-regexp (list ada-body-suffix))
|
|
|
210 (list ada-body-suffix-as-regexp (list ada-spec-suffix))
|
|
|
211 )
|
|
|
212 "*Alist of extensions to find given the current file's extension.
|
|
|
213
|
|
|
214 This list should contain the most used extensions before the others,
|
|
|
215 since the search algorithm searches sequentially through each directory
|
|
|
216 specified in `ada-search-directories'. If a file is not found, a new one
|
|
|
217 is created with the first matching extension (`.adb' yields `.ads').")
|
|
|
218
|
|
|
219 (defcustom ada-search-directories
|
|
|
220 '("." "/usr/adainclude" "/usr/local/adainclude" "/opt/gnu/adainclude")
|
|
|
221 "*List of directories to search for Ada files.
|
|
|
222 See the description for the `ff-search-directories' variable."
|
|
|
223 :type '(repeat (choice :tag "Directory"
|
|
|
224 (const :tag "default" nil)
|
|
|
225 (directory :format "%v")))
|
|
|
226 :group 'ada)
|
|
|
227
|
|
|
228 (defcustom ada-language-version 'ada95
|
|
|
229 "*Do we program in `ada83' or `ada95'?"
|
|
|
230 :type '(choice (const ada83)
|
|
|
231 (const ada95))
|
|
|
232 :group 'ada)
|
|
|
233
|
|
|
234 (defcustom ada-case-keyword 'downcase-word
|
|
2
|
235 "*Function to call to adjust the case of Ada keywords.
|
|
189
|
236 It may be `downcase-word', `upcase-word', `ada-loose-case-word' or
|
|
|
237 `capitalize-word'."
|
|
|
238 :type '(choice (const downcase-word)
|
|
|
239 (const upcase-word)
|
|
|
240 (const capitalize-word)
|
|
|
241 (const ada-loose-case-word))
|
|
|
242 :group 'ada)
|
|
|
243
|
|
|
244 (defcustom ada-case-identifier 'ada-loose-case-word
|
|
2
|
245 "*Function to call to adjust the case of an Ada identifier.
|
|
189
|
246 It may be `downcase-word', `upcase-word', `ada-loose-case-word' or
|
|
|
247 `capitalize-word'."
|
|
|
248 :type '(choice (const downcase-word)
|
|
|
249 (const upcase-word)
|
|
|
250 (const capitalize-word)
|
|
|
251 (const ada-loose-case-word))
|
|
|
252 :group 'ada)
|
|
|
253
|
|
|
254 (defcustom ada-case-attribute 'capitalize-word
|
|
2
|
255 "*Function to call to adjust the case of Ada attributes.
|
|
189
|
256 It may be `downcase-word', `upcase-word', `ada-loose-case-word' or
|
|
|
257 `capitalize-word'."
|
|
|
258 :type '(choice (const downcase-word)
|
|
|
259 (const upcase-word)
|
|
|
260 (const capitalize-word)
|
|
|
261 (const ada-loose-case-word))
|
|
|
262 :group 'ada)
|
|
|
263
|
|
|
264 (defcustom ada-auto-case t
|
|
2
|
265 "*Non-nil automatically changes case of preceding word while typing.
|
|
|
266 Casing is done according to `ada-case-keyword', `ada-case-identifier'
|
|
189
|
267 and `ada-case-attribute'."
|
|
|
268 :type 'boolean
|
|
|
269 :group 'ada)
|
|
|
270
|
|
|
271 (defcustom ada-clean-buffer-before-saving t
|
|
|
272 "*If non-nil, `remove-trailing-spaces' and `untabify' buffer before saving."
|
|
|
273 :type 'boolean
|
|
|
274 :group 'ada)
|
|
0
|
275
|
|
|
276 (defvar ada-mode-hook nil
|
|
189
|
277 "*List of functions to call when Ada mode is invoked.
|
|
0
|
278 This is a good place to add Ada environment specific bindings.")
|
|
|
279
|
|
189
|
280 (defcustom ada-external-pretty-print-program "aimap"
|
|
|
281 "*External pretty printer to call from within Ada mode."
|
|
|
282 :type 'string
|
|
|
283 :group 'ada)
|
|
|
284
|
|
|
285 (defcustom ada-tmp-directory "/tmp/"
|
|
|
286 "*Directory to store the temporary file for the Ada pretty printer."
|
|
|
287 :type 'string
|
|
|
288 :group 'ada)
|
|
|
289
|
|
|
290 (defcustom ada-compile-options "-c"
|
|
|
291 "*Buffer local options passed to the Ada compiler.
|
|
|
292 These options are used when the compiler is invoked on the current buffer."
|
|
|
293 :type 'string
|
|
|
294 :group 'ada)
|
|
|
295 (make-variable-buffer-local 'ada-compile-options)
|
|
|
296
|
|
|
297 (defcustom ada-make-options "-c"
|
|
|
298 "*Buffer local options passed to `ada-compiler-make' (usually `gnatmake').
|
|
|
299 These options are used when `gnatmake' is invoked on the current buffer."
|
|
|
300 :type 'string
|
|
|
301 :group 'ada)
|
|
|
302 (make-variable-buffer-local 'ada-make-options)
|
|
|
303
|
|
|
304 (defcustom ada-compiler-syntax-check "gcc -c -gnats"
|
|
|
305 "*Compiler command with options for syntax checking."
|
|
|
306 :type 'string
|
|
|
307 :group 'ada)
|
|
|
308
|
|
|
309 (defcustom ada-compiler-make "gnatmake"
|
|
|
310 "*The `make' command for the given compiler."
|
|
|
311 :type 'string
|
|
|
312 :group 'ada)
|
|
|
313
|
|
|
314 (defcustom ada-fill-comment-prefix "-- "
|
|
|
315 "*This is inserted in the first columns when filling a comment paragraph."
|
|
|
316 :type 'string
|
|
|
317 :group 'ada)
|
|
|
318
|
|
|
319 (defcustom ada-fill-comment-postfix " --"
|
|
|
320 "*This is inserted at the end of each line when filling a comment paragraph.
|
|
|
321 with `ada-fill-comment-paragraph-postfix'."
|
|
|
322 :type 'string
|
|
|
323 :group 'ada)
|
|
|
324
|
|
|
325 (defcustom ada-krunch-args "0"
|
|
|
326 "*Argument of gnatkr, a string containing the max number of characters.
|
|
|
327 Set to 0, if you don't use crunched filenames."
|
|
|
328 :type 'string
|
|
|
329 :group 'ada)
|
|
0
|
330
|
|
|
331 ;;; ---- end of user configurable variables
|
|
|
332
|
|
|
333
|
|
|
334 (defvar ada-mode-abbrev-table nil
|
|
189
|
335 "Abbrev table used in Ada mode.")
|
|
0
|
336 (define-abbrev-table 'ada-mode-abbrev-table ())
|
|
|
337
|
|
|
338 (defvar ada-mode-map ()
|
|
189
|
339 "Local keymap used for Ada mode.")
|
|
0
|
340
|
|
|
341 (defvar ada-mode-syntax-table nil
|
|
|
342 "Syntax table to be used for editing Ada source code.")
|
|
|
343
|
|
|
344 (defvar ada-mode-symbol-syntax-table nil
|
|
|
345 "Syntax table for Ada, where `_' is a word constituent.")
|
|
|
346
|
|
|
347 (defconst ada-83-keywords
|
|
|
348 "\\<\\(abort\\|abs\\|accept\\|access\\|all\\|and\\|array\\|\
|
|
|
349 at\\|begin\\|body\\|case\\|constant\\|declare\\|delay\\|delta\\|\
|
|
|
350 digits\\|do\\|else\\|elsif\\|end\\|entry\\|exception\\|exit\\|for\\|\
|
|
|
351 function\\|generic\\|goto\\|if\\|in\\|is\\|limited\\|loop\\|mod\\|\
|
|
|
352 new\\|not\\|null\\|of\\|or\\|others\\|out\\|package\\|pragma\\|\
|
|
|
353 private\\|procedure\\|raise\\|range\\|record\\|rem\\|renames\\|\
|
|
|
354 return\\|reverse\\|select\\|separate\\|subtype\\|task\\|terminate\\|\
|
|
|
355 then\\|type\\|use\\|when\\|while\\|with\\|xor\\)\\>"
|
|
2
|
356 ; "\\<\\(a\\(b\\(ort\\|s\\)\\|cce\\(pt\\|ss\\)\\|ll\\|nd\\|rray\\|t\\)\\|\
|
|
|
357 ;b\\(egin\\|ody\\)\\|c\\(ase\\|onstant\\)\\|\
|
|
|
358 ;d\\(e\\(clare\\|l\\(ay\\|ta\\)\\)\\|igits\\|o\\)\\|\
|
|
|
359 ;e\\(ls\\(e\\|if\\)\\|n\\(d\\|try\\)\\|x\\(ception\\|it\\)\\)\\|\
|
|
|
360 ;f\\(or\\|unction\\)\\|g\\(eneric\\|oto\\)\\|i[fns]\\|l\\(imited\\|oop\\)\\|\
|
|
|
361 ;mod\\|n\\(ew\\|ot\\|ull\\)\\|o\\([fr]\\|thers\\|ut\\)\\|\
|
|
|
362 ;p\\(ackage\\|r\\(agma\\|ivate\\|ocedure\\)\\)\\|\
|
|
|
363 ;r\\(a\\(ise\\|nge\\)\\|e\\(cord\\|m\\|names\\|turn\\|verse\\)\\)\\|\
|
|
|
364 ;s\\(e\\(lect\\|parate\\)\\|ubtype\\)\\|use\\|
|
|
|
365 ;t\\(ask\\|erminate\\|hen\\|ype\\)\\|w\\(h\\(en\\|ile\\)\\|ith\\)\\|xor\\)\\>"
|
|
|
366 "Regular expression for looking at Ada83 keywords.")
|
|
0
|
367
|
|
|
368 (defconst ada-95-keywords
|
|
|
369 "\\<\\(abort\\|abs\\|abstract\\|accept\\|access\\|aliased\\|\
|
|
|
370 all\\|and\\|array\\|at\\|begin\\|body\\|case\\|constant\\|declare\\|\
|
|
|
371 delay\\|delta\\|digits\\|do\\|else\\|elsif\\|end\\|entry\\|\
|
|
|
372 exception\\|exit\\|for\\|function\\|generic\\|goto\\|if\\|in\\|\
|
|
|
373 is\\|limited\\|loop\\|mod\\|new\\|not\\|null\\|of\\|or\\|others\\|\
|
|
|
374 out\\|package\\|pragma\\|private\\|procedure\\|protected\\|raise\\|\
|
|
|
375 range\\|record\\|rem\\|renames\\|requeue\\|return\\|reverse\\|\
|
|
|
376 select\\|separate\\|subtype\\|tagged\\|task\\|terminate\\|then\\|\
|
|
|
377 type\\|until\\|use\\|when\\|while\\|with\\|xor\\)\\>"
|
|
2
|
378 "Regular expression for looking at Ada95 keywords.")
|
|
0
|
379
|
|
|
380 (defvar ada-keywords ada-95-keywords
|
|
2
|
381 "Regular expression for looking at Ada keywords.")
|
|
0
|
382
|
|
|
383 (defvar ada-ret-binding nil
|
|
|
384 "Variable to save key binding of RET when casing is activated.")
|
|
|
385
|
|
|
386 (defvar ada-lfd-binding nil
|
|
|
387 "Variable to save key binding of LFD when casing is activated.")
|
|
|
388
|
|
|
389 ;;; ---- Regexps to find procedures/functions/packages
|
|
|
390
|
|
|
391 (defconst ada-ident-re
|
|
|
392 "[a-zA-Z0-9_\\.]+"
|
|
2
|
393 "Regexp matching Ada (qualified) identifiers.")
|
|
0
|
394
|
|
|
395 (defvar ada-procedure-start-regexp
|
|
|
396 "^[ \t]*\\(procedure\\|function\\|task\\)[ \t\n]+\\([a-zA-Z0-9_\\.]+\\)"
|
|
|
397 "Regexp used to find Ada procedures/functions.")
|
|
|
398
|
|
|
399 (defvar ada-package-start-regexp
|
|
|
400 "^[ \t]*\\(package\\)"
|
|
|
401 "Regexp used to find Ada packages")
|
|
|
402
|
|
|
403
|
|
|
404 ;;; ---- regexps for indentation functions
|
|
|
405
|
|
|
406 (defvar ada-block-start-re
|
|
|
407 "\\<\\(begin\\|select\\|declare\\|private\\|or\\|generic\\|\
|
|
|
408 exception\\|loop\\|else\\|\
|
|
|
409 \\(\\(limited\\|abstract\\|tagged\\)[ \t]+\\)*record\\)\\>"
|
|
2
|
410 "Regexp for keywords starting Ada blocks.")
|
|
0
|
411
|
|
|
412 (defvar ada-end-stmt-re
|
|
|
413 "\\(;\\|=>\\|^[ \t]*separate[ \t]+([a-zA-Z0-9_\\.]+)\\|\
|
|
189
|
414 \\<\\(begin\\|else\\|record\\|loop\\|select\\|do\\|then\\|\
|
|
2
|
415 declare\\|generic\\|private\\)\\>\\|\
|
|
189
|
416 ^[ \t]*\\(package\\|procedure\\|function\\)\\>[ \ta-zA-Z0-9_\\.]+\\<is\\>\\|\
|
|
2
|
417 ^[ \t]*exception\\>\\)"
|
|
0
|
418 "Regexp of possible ends for a non-broken statement.
|
|
2
|
419 A new statement starts after these.")
|
|
0
|
420
|
|
|
421 (defvar ada-loop-start-re
|
|
|
422 "\\<\\(for\\|while\\|loop\\)\\>"
|
|
|
423 "Regexp for the start of a loop.")
|
|
|
424
|
|
|
425 (defvar ada-subprog-start-re
|
|
2
|
426 "\\<\\(procedure\\|protected\\|package\\|function\\|\
|
|
0
|
427 task\\|accept\\|entry\\)\\>"
|
|
|
428 "Regexp for the start of a subprogram.")
|
|
|
429
|
|
189
|
430 (defvar ada-named-block-re
|
|
|
431 "[ \t]*[a-zA-Z_0-9]+ *:[^=]"
|
|
|
432 "Regexp of the name of a block or loop.")
|
|
|
433
|
|
0
|
434
|
|
2
|
435 ;; Written by Christian Egli <Christian.Egli@hcsd.hac.com>
|
|
|
436 ;;
|
|
|
437 (defvar ada-imenu-generic-expression
|
|
189
|
438 '((nil "^\\s-*\\(procedure\\|function\\)\\s-+\\([A-Za-z0-9_]+\\)" 2)
|
|
|
439 ("Type Defs" "^\\s-*\\(sub\\)?type\\s-+\\([A-Za-z0-9_]+\\)" 2))
|
|
2
|
440
|
|
|
441 "Imenu generic expression for Ada mode. See `imenu-generic-expression'.")
|
|
|
442
|
|
0
|
443 ;;;-------------
|
|
|
444 ;;; functions
|
|
|
445 ;;;-------------
|
|
|
446
|
|
|
447 (defun ada-xemacs ()
|
|
|
448 (or (string-match "Lucid" emacs-version)
|
|
|
449 (string-match "XEmacs" emacs-version)))
|
|
|
450
|
|
|
451 (defun ada-create-syntax-table ()
|
|
189
|
452 "Create the syntax table for Ada mode."
|
|
0
|
453 ;; There are two different syntax-tables. The standard one declares
|
|
2
|
454 ;; `_' as a symbol constituent, in the second one, it is a word
|
|
0
|
455 ;; constituent. For some search and replacing routines we
|
|
|
456 ;; temporarily switch between the two.
|
|
|
457 (setq ada-mode-syntax-table (make-syntax-table))
|
|
|
458 (set-syntax-table ada-mode-syntax-table)
|
|
|
459
|
|
189
|
460 ;; define string brackets (`%' is alternative string bracket, but
|
|
|
461 ;; almost never used as such and throws font-lock and indentation
|
|
|
462 ;; off the track.)
|
|
|
463 (modify-syntax-entry ?% "$" ada-mode-syntax-table)
|
|
0
|
464 (modify-syntax-entry ?\" "\"" ada-mode-syntax-table)
|
|
|
465
|
|
|
466 (modify-syntax-entry ?\# "$" ada-mode-syntax-table)
|
|
|
467
|
|
|
468 (modify-syntax-entry ?: "." ada-mode-syntax-table)
|
|
|
469 (modify-syntax-entry ?\; "." ada-mode-syntax-table)
|
|
|
470 (modify-syntax-entry ?& "." ada-mode-syntax-table)
|
|
|
471 (modify-syntax-entry ?\| "." ada-mode-syntax-table)
|
|
|
472 (modify-syntax-entry ?+ "." ada-mode-syntax-table)
|
|
|
473 (modify-syntax-entry ?* "." ada-mode-syntax-table)
|
|
|
474 (modify-syntax-entry ?/ "." ada-mode-syntax-table)
|
|
|
475 (modify-syntax-entry ?= "." ada-mode-syntax-table)
|
|
|
476 (modify-syntax-entry ?< "." ada-mode-syntax-table)
|
|
|
477 (modify-syntax-entry ?> "." ada-mode-syntax-table)
|
|
|
478 (modify-syntax-entry ?$ "." ada-mode-syntax-table)
|
|
|
479 (modify-syntax-entry ?\[ "." ada-mode-syntax-table)
|
|
|
480 (modify-syntax-entry ?\] "." ada-mode-syntax-table)
|
|
|
481 (modify-syntax-entry ?\{ "." ada-mode-syntax-table)
|
|
|
482 (modify-syntax-entry ?\} "." ada-mode-syntax-table)
|
|
|
483 (modify-syntax-entry ?. "." ada-mode-syntax-table)
|
|
|
484 (modify-syntax-entry ?\\ "." ada-mode-syntax-table)
|
|
|
485 (modify-syntax-entry ?\' "." ada-mode-syntax-table)
|
|
|
486
|
|
|
487 ;; a single hyphen is punctuation, but a double hyphen starts a comment
|
|
|
488 (modify-syntax-entry ?- ". 12" ada-mode-syntax-table)
|
|
|
489
|
|
|
490 ;; and \f and \n end a comment
|
|
|
491 (modify-syntax-entry ?\f "> " ada-mode-syntax-table)
|
|
|
492 (modify-syntax-entry ?\n "> " ada-mode-syntax-table)
|
|
|
493
|
|
189
|
494 ;; define what belongs in Ada symbols
|
|
0
|
495 (modify-syntax-entry ?_ "_" ada-mode-syntax-table)
|
|
|
496
|
|
|
497 ;; define parentheses to match
|
|
|
498 (modify-syntax-entry ?\( "()" ada-mode-syntax-table)
|
|
|
499 (modify-syntax-entry ?\) ")(" ada-mode-syntax-table)
|
|
|
500
|
|
|
501 (setq ada-mode-symbol-syntax-table (copy-syntax-table ada-mode-syntax-table))
|
|
|
502 (modify-syntax-entry ?_ "w" ada-mode-symbol-syntax-table)
|
|
|
503 )
|
|
|
504
|
|
|
505
|
|
|
506 ;;;###autoload
|
|
|
507 (defun ada-mode ()
|
|
189
|
508 "Ada mode is the major mode for editing Ada code.
|
|
0
|
509
|
|
|
510 Bindings are as follows: (Note: 'LFD' is control-j.)
|
|
|
511
|
|
|
512 Indent line '\\[ada-tab]'
|
|
|
513 Indent line, insert newline and indent the new line. '\\[newline-and-indent]'
|
|
|
514
|
|
|
515 Re-format the parameter-list point is in '\\[ada-format-paramlist]'
|
|
|
516 Indent all lines in region '\\[ada-indent-region]'
|
|
|
517 Call external pretty printer program '\\[ada-call-pretty-printer]'
|
|
|
518
|
|
|
519 Adjust case of identifiers and keywords in region '\\[ada-adjust-case-region]'
|
|
|
520 Adjust case of identifiers and keywords in buffer '\\[ada-adjust-case-buffer]'
|
|
|
521
|
|
|
522 Call EXTERNAL pretty printer (if you have one) '\\[ada-call-pretty-printer]'
|
|
|
523
|
|
|
524 Fill comment paragraph '\\[ada-fill-comment-paragraph]'
|
|
|
525 Fill comment paragraph and justify each line '\\[ada-fill-comment-paragraph-justify]'
|
|
|
526 Fill comment paragraph, justify and append postfix '\\[ada-fill-comment-paragraph-postfix]'
|
|
|
527
|
|
189
|
528 Next func/proc/task '\\[ada-next-procedure]' Previous func/proc/task '\\[ada-previous-procedure]'
|
|
0
|
529 Next package '\\[ada-next-package]' Previous package '\\[ada-previous-package]'
|
|
|
530
|
|
|
531 Goto matching start of current 'end ...;' '\\[ada-move-to-start]'
|
|
|
532 Goto end of current block '\\[ada-move-to-end]'
|
|
|
533
|
|
|
534 Comments are handled using standard GNU Emacs conventions, including:
|
|
|
535 Start a comment '\\[indent-for-comment]'
|
|
|
536 Comment region '\\[comment-region]'
|
|
|
537 Uncomment region '\\[ada-uncomment-region]'
|
|
|
538 Continue comment on next line '\\[indent-new-comment-line]'
|
|
|
539
|
|
|
540 If you use imenu.el:
|
|
|
541 Display index-menu of functions & procedures '\\[imenu]'
|
|
|
542
|
|
|
543 If you use find-file.el:
|
|
|
544 Switch to other file (Body <-> Spec) '\\[ff-find-other-file]'
|
|
|
545 or '\\[ff-mouse-find-other-file]
|
|
|
546 Switch to other file in other window '\\[ada-ff-other-window]'
|
|
|
547 or '\\[ff-mouse-find-other-file-other-window]
|
|
|
548 If you use this function in a spec and no body is available, it gets created
|
|
|
549 with body stubs.
|
|
|
550
|
|
|
551 If you use ada-xref.el:
|
|
|
552 Goto declaration: '\\[ada-point-and-xref]' on the identifier
|
|
|
553 or '\\[ada-goto-declaration]' with point on the identifier
|
|
|
554 Complete identifier: '\\[ada-complete-identifier]'
|
|
|
555 Execute Gnatf: '\\[ada-gnatf-current]'"
|
|
|
556
|
|
|
557 (interactive)
|
|
|
558 (kill-all-local-variables)
|
|
|
559
|
|
|
560 (make-local-variable 'require-final-newline)
|
|
|
561 (setq require-final-newline t)
|
|
|
562
|
|
|
563 (make-local-variable 'comment-start)
|
|
|
564 (setq comment-start "-- ")
|
|
|
565
|
|
|
566 ;; comment end must be set because it may hold a wrong value if
|
|
|
567 ;; this buffer had been in another mode before. RE
|
|
|
568 (make-local-variable 'comment-end)
|
|
|
569 (setq comment-end "")
|
|
|
570
|
|
|
571 (make-local-variable 'comment-start-skip) ;; used by autofill
|
|
|
572 (setq comment-start-skip "--+[ \t]*")
|
|
|
573
|
|
|
574 (make-local-variable 'indent-line-function)
|
|
|
575 (setq indent-line-function 'ada-indent-current-function)
|
|
|
576
|
|
|
577 (make-local-variable 'fill-column)
|
|
|
578 (setq fill-column 75)
|
|
|
579
|
|
|
580 (make-local-variable 'comment-column)
|
|
|
581 (setq comment-column 40)
|
|
|
582
|
|
|
583 (make-local-variable 'parse-sexp-ignore-comments)
|
|
|
584 (setq parse-sexp-ignore-comments t)
|
|
|
585
|
|
|
586 (make-local-variable 'case-fold-search)
|
|
|
587 (setq case-fold-search t)
|
|
|
588
|
|
189
|
589 (make-local-variable 'outline-regexp)
|
|
|
590 (setq outline-regexp "[^\n\^M]")
|
|
|
591 (make-local-variable 'outline-level)
|
|
|
592 (setq outline-level 'ada-outline-level)
|
|
|
593
|
|
0
|
594 (make-local-variable 'fill-paragraph-function)
|
|
|
595 (setq fill-paragraph-function 'ada-fill-comment-paragraph)
|
|
189
|
596 ;;(make-local-variable 'adaptive-fill-regexp)
|
|
0
|
597
|
|
2
|
598 (make-local-variable 'imenu-generic-expression)
|
|
|
599 (setq imenu-generic-expression ada-imenu-generic-expression)
|
|
|
600
|
|
189
|
601 (if (ada-xemacs) nil ; XEmacs uses properties
|
|
|
602 (make-local-variable 'font-lock-defaults)
|
|
|
603 (setq font-lock-defaults
|
|
|
604 '((ada-font-lock-keywords
|
|
|
605 ada-font-lock-keywords-1 ada-font-lock-keywords-2)
|
|
|
606 nil t
|
|
|
607 ((?\_ . "w")(?\. . "w"))
|
|
|
608 beginning-of-line
|
|
|
609 (font-lock-syntactic-keywords . ada-font-lock-syntactic-keywords)))
|
|
|
610
|
|
|
611 ;; Set up support for find-file.el.
|
|
|
612 (make-variable-buffer-local 'ff-other-file-alist)
|
|
|
613 (make-variable-buffer-local 'ff-search-directories)
|
|
|
614 (setq ff-other-file-alist 'ada-other-file-alist
|
|
|
615 ff-search-directories 'ada-search-directories
|
|
|
616 ff-pre-load-hooks 'ff-which-function-are-we-in
|
|
|
617 ff-post-load-hooks 'ff-set-point-accordingly
|
|
|
618 ff-file-created-hooks 'ada-make-body))
|
|
2
|
619
|
|
0
|
620 (setq major-mode 'ada-mode)
|
|
|
621 (setq mode-name "Ada")
|
|
|
622
|
|
|
623 (use-local-map ada-mode-map)
|
|
|
624
|
|
|
625 (if ada-mode-syntax-table
|
|
|
626 (set-syntax-table ada-mode-syntax-table)
|
|
|
627 (ada-create-syntax-table))
|
|
|
628
|
|
|
629 (if ada-clean-buffer-before-saving
|
|
|
630 (progn
|
|
|
631 ;; remove all spaces at the end of lines in the whole buffer.
|
|
|
632 (add-hook 'local-write-file-hooks 'ada-remove-trailing-spaces)
|
|
|
633 ;; convert all tabs to the correct number of spaces.
|
|
|
634 (add-hook 'local-write-file-hooks 'ada-untabify-buffer)))
|
|
|
635
|
|
|
636
|
|
|
637 ;; add menu 'Ada' to the menu bar
|
|
|
638 (ada-add-ada-menu)
|
|
|
639
|
|
|
640 (run-hooks 'ada-mode-hook)
|
|
|
641
|
|
|
642 ;; the following has to be done after running the ada-mode-hook
|
|
|
643 ;; because users might want to set the values of these variable
|
|
|
644 ;; inside the hook (MH)
|
|
|
645
|
|
|
646 (cond ((eq ada-language-version 'ada83)
|
|
|
647 (setq ada-keywords ada-83-keywords))
|
|
|
648 ((eq ada-language-version 'ada95)
|
|
|
649 (setq ada-keywords ada-95-keywords)))
|
|
|
650
|
|
|
651 (if ada-auto-case
|
|
|
652 (ada-activate-keys-for-case)))
|
|
|
653
|
|
|
654
|
|
|
655 ;;;--------------------------
|
|
189
|
656 ;;; Compile support
|
|
|
657 ;;;--------------------------
|
|
|
658
|
|
|
659 (defun ada-check-syntax ()
|
|
|
660 "Check syntax of the current buffer.
|
|
|
661 Uses the function `compile' to execute `ada-compiler-syntax-check'."
|
|
|
662 (interactive)
|
|
|
663 (let ((old-compile-command compile-command))
|
|
|
664 (setq compile-command (concat ada-compiler-syntax-check
|
|
|
665 (if (eq ada-language-version 'ada83)
|
|
|
666 "-gnat83 ")
|
|
|
667 " " ada-compile-options " "
|
|
|
668 (buffer-name)))
|
|
|
669 (setq compile-command (read-from-minibuffer
|
|
|
670 "enter command for syntax check: "
|
|
|
671 compile-command))
|
|
|
672 (compile compile-command)
|
|
|
673 ;; restore old compile-command
|
|
|
674 (setq compile-command old-compile-command)))
|
|
|
675
|
|
|
676 (defun ada-make-local ()
|
|
|
677 "Bring current Ada unit up-to-date.
|
|
|
678 Uses the function `compile' to execute `ada-compile-make'."
|
|
|
679 (interactive)
|
|
|
680 (let ((old-compile-command compile-command))
|
|
|
681 (setq compile-command (concat ada-compiler-make
|
|
|
682 " " ada-make-options " "
|
|
|
683 (buffer-name)))
|
|
|
684 (setq compile-command (read-from-minibuffer
|
|
|
685 "enter command for local make: "
|
|
|
686 compile-command))
|
|
|
687 (compile compile-command)
|
|
|
688 ;; restore old compile-command
|
|
|
689 (setq compile-command old-compile-command)))
|
|
|
690
|
|
|
691
|
|
|
692
|
|
|
693
|
|
|
694 ;;;--------------------------
|
|
0
|
695 ;;; Fill Comment Paragraph
|
|
|
696 ;;;--------------------------
|
|
|
697
|
|
|
698 (defun ada-fill-comment-paragraph-justify ()
|
|
|
699 "Fills current comment paragraph and justifies each line as well."
|
|
|
700 (interactive)
|
|
|
701 (ada-fill-comment-paragraph t))
|
|
|
702
|
|
|
703
|
|
|
704 (defun ada-fill-comment-paragraph-postfix ()
|
|
|
705 "Fills current comment paragraph and justifies each line as well.
|
|
|
706 Prompts for a postfix to be appended to each line."
|
|
|
707 (interactive)
|
|
|
708 (ada-fill-comment-paragraph t t))
|
|
|
709
|
|
|
710
|
|
|
711 (defun ada-fill-comment-paragraph (&optional justify postfix)
|
|
|
712 "Fills the current comment paragraph.
|
|
|
713 If JUSTIFY is non-nil, each line is justified as well.
|
|
2
|
714 If POSTFIX and JUSTIFY are non-nil, `ada-fill-comment-postfix' is appended
|
|
0
|
715 to each filled and justified line.
|
|
2
|
716 If `ada-indent-comment-as-code' is non-nil, the paragraph is idented."
|
|
0
|
717 (interactive "P")
|
|
|
718 (let ((opos (point-marker))
|
|
|
719 (begin nil)
|
|
|
720 (end nil)
|
|
|
721 (end-2 nil)
|
|
|
722 (indent nil)
|
|
|
723 (ada-fill-comment-old-postfix "")
|
|
|
724 (fill-prefix nil))
|
|
|
725
|
|
|
726 ;; check if inside comment
|
|
|
727 (if (not (ada-in-comment-p))
|
|
|
728 (error "not inside comment"))
|
|
|
729
|
|
|
730 ;; prompt for postfix if wanted
|
|
|
731 (if (and justify
|
|
|
732 postfix)
|
|
|
733 (setq ada-fill-comment-postfix
|
|
|
734 (read-from-minibuffer "enter new postfix string: "
|
|
|
735 ada-fill-comment-postfix)))
|
|
|
736
|
|
|
737 ;; prompt for old postfix to remove if necessary
|
|
|
738 (if (and justify
|
|
|
739 postfix)
|
|
|
740 (setq ada-fill-comment-old-postfix
|
|
|
741 (read-from-minibuffer "enter already existing postfix string: "
|
|
|
742 ada-fill-comment-postfix)))
|
|
|
743
|
|
|
744 ;;
|
|
|
745 ;; find limits of paragraph
|
|
|
746 ;;
|
|
|
747 (message "filling comment paragraph ...")
|
|
|
748 (save-excursion
|
|
|
749 (back-to-indentation)
|
|
|
750 ;; find end of paragraph
|
|
|
751 (while (and (looking-at "--.*$")
|
|
|
752 (not (looking-at "--[ \t]*$")))
|
|
|
753 (forward-line 1)
|
|
|
754 (back-to-indentation))
|
|
|
755 (beginning-of-line)
|
|
|
756 (setq end (point-marker))
|
|
|
757 (goto-char opos)
|
|
|
758 ;; find begin of paragraph
|
|
|
759 (back-to-indentation)
|
|
|
760 (while (and (looking-at "--.*$")
|
|
|
761 (not (looking-at "--[ \t]*$")))
|
|
|
762 (forward-line -1)
|
|
|
763 (back-to-indentation))
|
|
|
764 (forward-line 1)
|
|
|
765 ;; get indentation to calculate width for filling
|
|
|
766 (ada-indent-current)
|
|
|
767 (back-to-indentation)
|
|
|
768 (setq indent (current-column))
|
|
|
769 (setq begin (point-marker)))
|
|
|
770
|
|
|
771 ;; delete old postfix if necessary
|
|
|
772 (if (and justify
|
|
|
773 postfix)
|
|
|
774 (save-excursion
|
|
|
775 (goto-char begin)
|
|
|
776 (while (re-search-forward (concat ada-fill-comment-old-postfix
|
|
|
777 "\n")
|
|
|
778 end t)
|
|
|
779 (replace-match "\n"))))
|
|
|
780
|
|
|
781 ;; delete leading whitespace and uncomment
|
|
|
782 (save-excursion
|
|
|
783 (goto-char begin)
|
|
|
784 (beginning-of-line)
|
|
|
785 (while (re-search-forward "^[ \t]*--[ \t]*" end t)
|
|
|
786 (replace-match "")))
|
|
|
787
|
|
|
788 ;; calculate fill width
|
|
|
789 (setq fill-column (- fill-column indent
|
|
|
790 (length ada-fill-comment-prefix)
|
|
|
791 (if postfix
|
|
|
792 (length ada-fill-comment-postfix)
|
|
|
793 0)))
|
|
|
794 ;; fill paragraph
|
|
|
795 (fill-region begin (1- end) justify)
|
|
|
796 (setq fill-column (+ fill-column indent
|
|
|
797 (length ada-fill-comment-prefix)
|
|
|
798 (if postfix
|
|
|
799 (length ada-fill-comment-postfix)
|
|
|
800 0)))
|
|
|
801 ;; find end of second last line
|
|
|
802 (save-excursion
|
|
|
803 (goto-char end)
|
|
|
804 (forward-line -2)
|
|
|
805 (end-of-line)
|
|
|
806 (setq end-2 (point-marker)))
|
|
|
807
|
|
|
808 ;; re-comment and re-indent region
|
|
|
809 (save-excursion
|
|
|
810 (goto-char begin)
|
|
|
811 (indent-to indent)
|
|
|
812 (insert ada-fill-comment-prefix)
|
|
|
813 (while (re-search-forward "\n" (1- end-2) t)
|
|
|
814 (replace-match (concat "\n" ada-fill-comment-prefix))
|
|
|
815 (beginning-of-line)
|
|
|
816 (indent-to indent)))
|
|
|
817
|
|
|
818 ;; append postfix if wanted
|
|
|
819 (if (and justify
|
|
|
820 postfix
|
|
|
821 ada-fill-comment-postfix)
|
|
|
822 (progn
|
|
|
823 ;; append postfix up to there
|
|
|
824 (save-excursion
|
|
|
825 (goto-char begin)
|
|
|
826 (while (re-search-forward "\n" (1- end-2) t)
|
|
|
827 (replace-match (concat ada-fill-comment-postfix "\n")))
|
|
|
828
|
|
|
829 ;; fill last line and append postfix
|
|
|
830 (end-of-line)
|
|
|
831 (insert-char ?
|
|
|
832 (- fill-column
|
|
|
833 (current-column)
|
|
|
834 (length ada-fill-comment-postfix)))
|
|
|
835 (insert ada-fill-comment-postfix))))
|
|
|
836
|
|
|
837 ;; delete the extra line that gets inserted somehow(??)
|
|
|
838 (save-excursion
|
|
|
839 (goto-char (1- end))
|
|
|
840 (end-of-line)
|
|
|
841 (delete-char 1))
|
|
|
842
|
|
|
843 (message "filling comment paragraph ... done")
|
|
|
844 (goto-char opos))
|
|
|
845 t)
|
|
|
846
|
|
|
847
|
|
|
848 ;;;--------------------------------;;;
|
|
|
849 ;;; Call External Pretty Printer ;;;
|
|
|
850 ;;;--------------------------------;;;
|
|
|
851
|
|
|
852 (defun ada-call-pretty-printer ()
|
|
|
853 "Calls the external Pretty Printer.
|
|
2
|
854 The name is specified in `ada-external-pretty-print-program'. Saves the
|
|
|
855 current buffer in a directory specified by `ada-tmp-directory',
|
|
189
|
856 starts the pretty printer as external process on that file and then
|
|
2
|
857 reloads the beautified program in the buffer and cleans up
|
|
|
858 `ada-tmp-directory'."
|
|
0
|
859 (interactive)
|
|
|
860 (let ((filename-with-path buffer-file-name)
|
|
|
861 (curbuf (current-buffer))
|
|
|
862 (orgpos (point))
|
|
|
863 (mesgbuf nil) ;; for byte-compiling
|
|
|
864 (file-path (file-name-directory buffer-file-name))
|
|
|
865 (filename-without-path (file-name-nondirectory buffer-file-name))
|
|
|
866 (tmp-file-with-directory
|
|
|
867 (concat ada-tmp-directory
|
|
|
868 (file-name-nondirectory buffer-file-name))))
|
|
|
869 ;;
|
|
|
870 ;; save buffer in temporary file
|
|
|
871 ;;
|
|
|
872 (message "saving current buffer to temporary file ...")
|
|
|
873 (write-file tmp-file-with-directory)
|
|
|
874 (auto-save-mode nil)
|
|
|
875 (message "saving current buffer to temporary file ... done")
|
|
|
876 ;;
|
|
|
877 ;; call external pretty printer program
|
|
|
878 ;;
|
|
|
879
|
|
|
880 (message "running external pretty printer ...")
|
|
|
881 ;; create a temporary buffer for messages of pretty printer
|
|
|
882 (setq mesgbuf (get-buffer-create "Pretty Printer Messages"))
|
|
|
883 ;; execute pretty printer on temporary file
|
|
|
884 (call-process ada-external-pretty-print-program
|
|
|
885 nil mesgbuf t
|
|
|
886 tmp-file-with-directory)
|
|
|
887 ;; display messages if there are some
|
|
|
888 (if (buffer-modified-p mesgbuf)
|
|
|
889 ;; show the message buffer
|
|
|
890 (display-buffer mesgbuf t)
|
|
|
891 ;; kill the message buffer
|
|
|
892 (kill-buffer mesgbuf))
|
|
|
893 (message "running external pretty printer ... done")
|
|
|
894 ;;
|
|
|
895 ;; kill current buffer and load pretty printer output
|
|
|
896 ;; or restore old buffer
|
|
|
897 ;;
|
|
|
898 (if (y-or-n-p
|
|
|
899 "Really replace current buffer with pretty printer output ? ")
|
|
|
900 (progn
|
|
|
901 (set-buffer-modified-p nil)
|
|
|
902 (kill-buffer curbuf)
|
|
|
903 (find-file tmp-file-with-directory))
|
|
|
904 (message "old buffer contents restored"))
|
|
|
905 ;;
|
|
|
906 ;; delete temporary file and restore information of current buffer
|
|
|
907 ;;
|
|
|
908 (delete-file tmp-file-with-directory)
|
|
|
909 (set-visited-file-name filename-with-path)
|
|
|
910 (auto-save-mode t)
|
|
|
911 (goto-char orgpos)))
|
|
|
912
|
|
|
913
|
|
|
914 ;;;---------------
|
|
|
915 ;;; auto-casing
|
|
|
916 ;;;---------------
|
|
|
917
|
|
|
918 ;; from Philippe Waroquiers <philippe@cfmu.eurocontrol.be>
|
|
189
|
919 ;; modified by RE and MH
|
|
0
|
920
|
|
|
921 (defun ada-after-keyword-p ()
|
|
|
922 ;; returns t if cursor is after a keyword.
|
|
|
923 (save-excursion
|
|
|
924 (forward-word -1)
|
|
|
925 (and (save-excursion
|
|
|
926 (or
|
|
|
927 (= (point) (point-min))
|
|
|
928 (backward-char 1))
|
|
|
929 (not (looking-at "_"))) ; (MH)
|
|
|
930 (looking-at (concat ada-keywords "[^_]")))))
|
|
|
931
|
|
189
|
932 (defun ada-in-char-const-p ()
|
|
|
933 ;; Returns t if point is inside a character constant.
|
|
|
934 ;; We assume to be in a constant if the previous and the next character
|
|
|
935 ;; are "'".
|
|
0
|
936 (save-excursion
|
|
189
|
937 (if (> (point) 1)
|
|
|
938 (and
|
|
|
939 (progn
|
|
|
940 (forward-char 1)
|
|
|
941 (looking-at "'"))
|
|
|
942 (progn
|
|
|
943 (forward-char -2)
|
|
|
944 (looking-at "'")))
|
|
0
|
945 nil)))
|
|
|
946
|
|
|
947
|
|
|
948 (defun ada-adjust-case (&optional force-identifier)
|
|
2
|
949 "Adjust the case of the word before the just typed character.
|
|
|
950 Respect options `ada-case-keyword', `ada-case-identifier', and
|
|
|
951 `ada-case-attribute'.
|
|
|
952 If FORCE-IDENTIFIER is non-nil then also adjust keyword as identifier." ; (MH)
|
|
0
|
953 (forward-char -1)
|
|
|
954 (if (and (> (point) 1) (not (or (ada-in-string-p)
|
|
|
955 (ada-in-comment-p)
|
|
189
|
956 (ada-in-char-const-p))))
|
|
0
|
957 (if (eq (char-syntax (char-after (1- (point)))) ?w)
|
|
|
958 (if (save-excursion
|
|
|
959 (forward-word -1)
|
|
|
960 (or (= (point) (point-min))
|
|
|
961 (backward-char 1))
|
|
|
962 (looking-at "'"))
|
|
|
963 (funcall ada-case-attribute -1)
|
|
|
964 (if (and
|
|
|
965 (not force-identifier) ; (MH)
|
|
|
966 (ada-after-keyword-p))
|
|
|
967 (funcall ada-case-keyword -1)
|
|
|
968 (funcall ada-case-identifier -1)))))
|
|
|
969 (forward-char 1))
|
|
|
970
|
|
|
971
|
|
|
972 (defun ada-adjust-case-interactive (arg)
|
|
|
973 (interactive "P")
|
|
|
974 (let ((lastk last-command-char))
|
|
|
975 (cond ((or (eq lastk ?\n)
|
|
|
976 (eq lastk ?\r))
|
|
|
977 ;; horrible kludge
|
|
|
978 (insert " ")
|
|
|
979 (ada-adjust-case)
|
|
|
980 ;; horrible dekludge
|
|
|
981 (delete-backward-char 1)
|
|
|
982 ;; some special keys and their bindings
|
|
|
983 (cond
|
|
|
984 ((eq lastk ?\n)
|
|
|
985 (funcall ada-lfd-binding))
|
|
|
986 ((eq lastk ?\r)
|
|
|
987 (funcall ada-ret-binding))))
|
|
|
988 ((eq lastk ?\C-i) (ada-tab))
|
|
|
989 ((self-insert-command (prefix-numeric-value arg))))
|
|
|
990 ;; if there is a keyword in front of the underscore
|
|
|
991 ;; then it should be part of an identifier (MH)
|
|
|
992 (if (eq lastk ?_)
|
|
|
993 (ada-adjust-case t)
|
|
|
994 (ada-adjust-case))))
|
|
|
995
|
|
|
996
|
|
|
997 (defun ada-activate-keys-for-case ()
|
|
|
998 ;; save original keybindings to allow swapping ret/lfd
|
|
|
999 ;; when casing is activated
|
|
|
1000 ;; the 'or ...' is there to be sure that the value will not
|
|
189
|
1001 ;; be changed again when Ada mode is called more than once (MH)
|
|
0
|
1002 (or ada-ret-binding
|
|
|
1003 (setq ada-ret-binding (key-binding "\C-M")))
|
|
|
1004 (or ada-lfd-binding
|
|
|
1005 (setq ada-lfd-binding (key-binding "\C-j")))
|
|
|
1006 ;; call case modifying function after certain keys.
|
|
|
1007 (mapcar (function (lambda(key) (define-key
|
|
|
1008 ada-mode-map
|
|
|
1009 (char-to-string key)
|
|
|
1010 'ada-adjust-case-interactive)))
|
|
|
1011 '( ?` ?~ ?! ?@ ?# ?$ ?% ?^ ?& ?* ?( ?) ?- ?= ?+ ?[ ?{ ?] ?}
|
|
|
1012 ?_ ?\\ ?| ?\; ?: ?' ?\" ?< ?, ?. ?> ?? ?/ ?\n 32 ?\r )))
|
|
|
1013 ;; deleted ?\t from above list
|
|
|
1014
|
|
|
1015 ;;
|
|
|
1016 ;; added by MH
|
|
|
1017 ;;
|
|
|
1018 (defun ada-loose-case-word (&optional arg)
|
|
189
|
1019 "Capitalizes the first letter and the letters following `_'.
|
|
0
|
1020 ARG is ignored, it's there to fit the standard casing functions' style."
|
|
|
1021 (let ((pos (point))
|
|
|
1022 (first t))
|
|
|
1023 (skip-chars-backward "a-zA-Z0-9_")
|
|
|
1024 (while (or first
|
|
|
1025 (search-forward "_" pos t))
|
|
|
1026 (and first
|
|
|
1027 (setq first nil))
|
|
|
1028 (insert-char (upcase (following-char)) 1)
|
|
|
1029 (delete-char 1))
|
|
|
1030 (goto-char pos)))
|
|
|
1031
|
|
|
1032
|
|
|
1033 ;;
|
|
|
1034 ;; added by MH
|
|
189
|
1035 ;; modified by JSH to handle attributes
|
|
0
|
1036 ;;
|
|
|
1037 (defun ada-adjust-case-region (from to)
|
|
2
|
1038 "Adjusts the case of all words in the region.
|
|
|
1039 Attention: This function might take very long for big regions !"
|
|
0
|
1040 (interactive "*r")
|
|
|
1041 (let ((begin nil)
|
|
|
1042 (end nil)
|
|
|
1043 (keywordp nil)
|
|
189
|
1044 (attribp nil))
|
|
0
|
1045 (unwind-protect
|
|
|
1046 (save-excursion
|
|
|
1047 (set-syntax-table ada-mode-symbol-syntax-table)
|
|
|
1048 (goto-char to)
|
|
|
1049 ;;
|
|
189
|
1050 ;; loop: look for all identifiers, keywords, and attributes
|
|
0
|
1051 ;;
|
|
|
1052 (while (re-search-backward
|
|
|
1053 "[^a-zA-Z0-9_]\\([a-zA-Z0-9_]+\\)[^a-zA-Z0-9_]"
|
|
|
1054 from
|
|
|
1055 t)
|
|
|
1056 ;;
|
|
|
1057 ;; print status message
|
|
|
1058 ;;
|
|
189
|
1059 (message "adjusting case ... %5d characters left" (- (point) from))
|
|
|
1060 (setq attribp (looking-at "'[a-zA-Z0-9_]+[^']"))
|
|
0
|
1061 (forward-char 1)
|
|
|
1062 (or
|
|
|
1063 ;; do nothing if it is a string or comment
|
|
|
1064 (ada-in-string-or-comment-p)
|
|
|
1065 (progn
|
|
|
1066 ;;
|
|
189
|
1067 ;; get the identifier or keyword or attribute
|
|
0
|
1068 ;;
|
|
|
1069 (setq begin (point))
|
|
|
1070 (setq keywordp (looking-at (concat ada-keywords "[^_]")))
|
|
|
1071 (skip-chars-forward "a-zA-Z0-9_")
|
|
|
1072 ;;
|
|
|
1073 ;; casing according to user-option
|
|
|
1074 ;;
|
|
|
1075 (if keywordp
|
|
|
1076 (funcall ada-case-keyword -1)
|
|
189
|
1077 (if attribp
|
|
|
1078 (funcall ada-case-attribute -1)
|
|
|
1079 (funcall ada-case-identifier -1)))
|
|
0
|
1080 (goto-char begin))))
|
|
|
1081 (message "adjusting case ... done"))
|
|
|
1082 (set-syntax-table ada-mode-syntax-table))))
|
|
|
1083
|
|
|
1084
|
|
|
1085 ;;
|
|
|
1086 ;; added by MH
|
|
|
1087 ;;
|
|
|
1088 (defun ada-adjust-case-buffer ()
|
|
2
|
1089 "Adjusts the case of all words in the whole buffer.
|
|
189
|
1090 ATTENTION: This function might take very long for big buffers !"
|
|
0
|
1091 (interactive "*")
|
|
|
1092 (ada-adjust-case-region (point-min) (point-max)))
|
|
|
1093
|
|
|
1094
|
|
|
1095 ;;;------------------------;;;
|
|
|
1096 ;;; Format Parameter Lists ;;;
|
|
|
1097 ;;;------------------------;;;
|
|
|
1098
|
|
|
1099 (defun ada-format-paramlist ()
|
|
189
|
1100 "Reformats a parameter list.
|
|
|
1101 ATTENTION: 1) Comments inside the list are killed !
|
|
0
|
1102 2) If the syntax is not correct (especially, if there are
|
|
|
1103 semicolons missing), it can get totally confused !
|
|
2
|
1104 In such a case, use `undo', correct the syntax and try again."
|
|
0
|
1105
|
|
|
1106 (interactive)
|
|
|
1107 (let ((begin nil)
|
|
|
1108 (end nil)
|
|
|
1109 (delend nil)
|
|
|
1110 (paramlist nil))
|
|
|
1111 (unwind-protect
|
|
|
1112 (progn
|
|
|
1113 (set-syntax-table ada-mode-symbol-syntax-table)
|
|
|
1114
|
|
|
1115 ;; check if really inside parameter list
|
|
|
1116 (or (ada-in-paramlist-p)
|
|
|
1117 (error "not in parameter list"))
|
|
|
1118 ;;
|
|
|
1119 ;; find start of current parameter-list
|
|
|
1120 ;;
|
|
|
1121 (ada-search-ignore-string-comment
|
|
189
|
1122 (concat ada-subprog-start-re "\\|\\<body\\>" ) t nil)
|
|
0
|
1123 (ada-search-ignore-string-comment "(" nil nil t)
|
|
|
1124 (backward-char 1)
|
|
|
1125 (setq begin (point))
|
|
|
1126
|
|
|
1127 ;;
|
|
|
1128 ;; find end of parameter-list
|
|
|
1129 ;;
|
|
|
1130 (forward-sexp 1)
|
|
|
1131 (setq delend (point))
|
|
|
1132 (delete-char -1)
|
|
|
1133
|
|
|
1134 ;;
|
|
|
1135 ;; find end of last parameter-declaration
|
|
|
1136 ;;
|
|
|
1137 (ada-search-ignore-string-comment "[^ \t\n]" t nil t)
|
|
|
1138 (forward-char 1)
|
|
|
1139 (setq end (point))
|
|
|
1140
|
|
|
1141 ;;
|
|
|
1142 ;; build a list of all elements of the parameter-list
|
|
|
1143 ;;
|
|
|
1144 (setq paramlist (ada-scan-paramlist (1+ begin) end))
|
|
|
1145
|
|
|
1146 ;;
|
|
|
1147 ;; delete the original parameter-list
|
|
|
1148 ;;
|
|
|
1149 (delete-region begin (1- delend))
|
|
|
1150
|
|
|
1151 ;;
|
|
|
1152 ;; insert the new parameter-list
|
|
|
1153 ;;
|
|
|
1154 (goto-char begin)
|
|
|
1155 (ada-insert-paramlist paramlist))
|
|
|
1156
|
|
|
1157 ;;
|
|
|
1158 ;; restore syntax-table
|
|
|
1159 ;;
|
|
|
1160 (set-syntax-table ada-mode-syntax-table)
|
|
|
1161 )))
|
|
|
1162
|
|
|
1163
|
|
|
1164 (defun ada-scan-paramlist (begin end)
|
|
|
1165 ;; Scans a parameter-list between BEGIN and END and returns a list
|
|
|
1166 ;; of its contents.
|
|
|
1167 ;; The list has the following format:
|
|
|
1168 ;;
|
|
2
|
1169 ;; Name of Param in? out? access? Name of Type Default-Exp or nil
|
|
0
|
1170 ;;
|
|
|
1171 ;; ( ('Name_Param_1' t nil t Type_Param_1 ':= expression')
|
|
|
1172 ;; ('Name_Param_2' nil nil t Type_Param_2 nil) )
|
|
|
1173
|
|
|
1174 (let ((paramlist (list))
|
|
|
1175 (param (list))
|
|
|
1176 (notend t)
|
|
|
1177 (apos nil)
|
|
|
1178 (epos nil)
|
|
|
1179 (semipos nil)
|
|
|
1180 (match-cons nil))
|
|
|
1181
|
|
|
1182 (goto-char begin)
|
|
|
1183 ;;
|
|
|
1184 ;; loop until end of last parameter
|
|
|
1185 ;;
|
|
|
1186 (while notend
|
|
|
1187
|
|
|
1188 ;;
|
|
|
1189 ;; find first character of parameter-declaration
|
|
|
1190 ;;
|
|
|
1191 (ada-goto-next-non-ws)
|
|
|
1192 (setq apos (point))
|
|
|
1193
|
|
|
1194 ;;
|
|
|
1195 ;; find last character of parameter-declaration
|
|
|
1196 ;;
|
|
|
1197 (if (setq match-cons
|
|
|
1198 (ada-search-ignore-string-comment "[ \t\n]*;" nil end t))
|
|
|
1199 (progn
|
|
|
1200 (setq epos (car match-cons))
|
|
|
1201 (setq semipos (cdr match-cons)))
|
|
|
1202 (setq epos end))
|
|
|
1203
|
|
|
1204 ;;
|
|
|
1205 ;; read name(s) of parameter(s)
|
|
|
1206 ;;
|
|
|
1207 (goto-char apos)
|
|
|
1208 (looking-at "\\([a-zA-Z0-9_, \t\n]*[a-zA-Z0-9_]\\)[ \t\n]*:[^=]")
|
|
|
1209
|
|
|
1210 (setq param (list (buffer-substring (match-beginning 1)
|
|
|
1211 (match-end 1))))
|
|
|
1212 (ada-search-ignore-string-comment ":" nil epos t)
|
|
|
1213
|
|
|
1214 ;;
|
|
|
1215 ;; look for 'in'
|
|
|
1216 ;;
|
|
|
1217 (setq apos (point))
|
|
|
1218 (setq param
|
|
|
1219 (append param
|
|
|
1220 (list
|
|
|
1221 (consp
|
|
|
1222 (ada-search-ignore-string-comment "\\<in\\>"
|
|
|
1223 nil
|
|
|
1224 epos
|
|
|
1225 t)))))
|
|
|
1226
|
|
|
1227 ;;
|
|
|
1228 ;; look for 'out'
|
|
|
1229 ;;
|
|
|
1230 (goto-char apos)
|
|
|
1231 (setq param
|
|
|
1232 (append param
|
|
|
1233 (list
|
|
|
1234 (consp
|
|
|
1235 (ada-search-ignore-string-comment "\\<out\\>"
|
|
|
1236 nil
|
|
|
1237 epos
|
|
|
1238 t)))))
|
|
|
1239
|
|
|
1240 ;;
|
|
2
|
1241 ;; look for 'access'
|
|
0
|
1242 ;;
|
|
|
1243 (goto-char apos)
|
|
|
1244 (setq param
|
|
|
1245 (append param
|
|
|
1246 (list
|
|
|
1247 (consp
|
|
2
|
1248 (ada-search-ignore-string-comment "\\<access\\>"
|
|
0
|
1249 nil
|
|
|
1250 epos
|
|
|
1251 t)))))
|
|
|
1252
|
|
|
1253 ;;
|
|
2
|
1254 ;; skip 'in'/'out'/'access'
|
|
0
|
1255 ;;
|
|
|
1256 (goto-char apos)
|
|
|
1257 (ada-goto-next-non-ws)
|
|
2
|
1258 (while (looking-at "\\<\\(in\\|out\\|access\\)\\>")
|
|
0
|
1259 (forward-word 1)
|
|
|
1260 (ada-goto-next-non-ws))
|
|
|
1261
|
|
|
1262 ;;
|
|
189
|
1263 ;; read type of parameter
|
|
0
|
1264 ;;
|
|
189
|
1265 (looking-at "\\<[a-zA-Z0-9_\\.\\']+\\>")
|
|
0
|
1266 (setq param
|
|
|
1267 (append param
|
|
|
1268 (list
|
|
|
1269 (buffer-substring (match-beginning 0)
|
|
|
1270 (match-end 0)))))
|
|
|
1271
|
|
|
1272 ;;
|
|
|
1273 ;; read default-expression, if there is one
|
|
|
1274 ;;
|
|
|
1275 (goto-char (setq apos (match-end 0)))
|
|
|
1276 (setq param
|
|
|
1277 (append param
|
|
|
1278 (list
|
|
|
1279 (if (setq match-cons
|
|
|
1280 (ada-search-ignore-string-comment ":="
|
|
|
1281 nil
|
|
|
1282 epos
|
|
|
1283 t))
|
|
|
1284 (buffer-substring (car match-cons)
|
|
|
1285 epos)
|
|
|
1286 nil))))
|
|
|
1287 ;;
|
|
|
1288 ;; add this parameter-declaration to the list
|
|
|
1289 ;;
|
|
|
1290 (setq paramlist (append paramlist (list param)))
|
|
|
1291
|
|
|
1292 ;;
|
|
|
1293 ;; check if it was the last parameter
|
|
|
1294 ;;
|
|
|
1295 (if (eq epos end)
|
|
|
1296 (setq notend nil)
|
|
|
1297 (goto-char semipos))
|
|
|
1298
|
|
|
1299 ) ; end of loop
|
|
|
1300
|
|
|
1301 (reverse paramlist)))
|
|
|
1302
|
|
|
1303
|
|
|
1304 (defun ada-insert-paramlist (paramlist)
|
|
|
1305 ;; Inserts a formatted PARAMLIST in the buffer.
|
|
2
|
1306 ;; See doc of `ada-scan-paramlist' for the format.
|
|
0
|
1307 (let ((i (length paramlist))
|
|
|
1308 (parlen 0)
|
|
|
1309 (typlen 0)
|
|
|
1310 (temp 0)
|
|
|
1311 (inp nil)
|
|
|
1312 (outp nil)
|
|
2
|
1313 (accessp nil)
|
|
0
|
1314 (column nil)
|
|
|
1315 (orgpoint 0)
|
|
|
1316 (firstcol nil))
|
|
|
1317
|
|
|
1318 ;;
|
|
|
1319 ;; loop until last parameter
|
|
|
1320 ;;
|
|
|
1321 (while (not (zerop i))
|
|
|
1322 (setq i (1- i))
|
|
|
1323
|
|
|
1324 ;;
|
|
|
1325 ;; get max length of parameter-name
|
|
|
1326 ;;
|
|
|
1327 (setq parlen
|
|
|
1328 (if (<= parlen (setq temp
|
|
|
1329 (length (nth 0 (nth i paramlist)))))
|
|
|
1330 temp
|
|
|
1331 parlen))
|
|
|
1332
|
|
|
1333 ;;
|
|
|
1334 ;; get max length of type-name
|
|
|
1335 ;;
|
|
|
1336 (setq typlen
|
|
|
1337 (if (<= typlen (setq temp
|
|
|
1338 (length (nth 4 (nth i paramlist)))))
|
|
|
1339 temp
|
|
|
1340 typlen))
|
|
|
1341
|
|
|
1342 ;;
|
|
|
1343 ;; is there any 'in' ?
|
|
|
1344 ;;
|
|
|
1345 (setq inp
|
|
|
1346 (or inp
|
|
|
1347 (nth 1 (nth i paramlist))))
|
|
|
1348
|
|
|
1349 ;;
|
|
|
1350 ;; is there any 'out' ?
|
|
|
1351 ;;
|
|
|
1352 (setq outp
|
|
|
1353 (or outp
|
|
|
1354 (nth 2 (nth i paramlist))))
|
|
|
1355
|
|
|
1356 ;;
|
|
2
|
1357 ;; is there any 'access' ?
|
|
0
|
1358 ;;
|
|
2
|
1359 (setq accessp
|
|
|
1360 (or accessp
|
|
0
|
1361 (nth 3 (nth i paramlist))))) ; end of loop
|
|
|
1362
|
|
|
1363 ;;
|
|
|
1364 ;; does paramlist already start on a separate line ?
|
|
|
1365 ;;
|
|
|
1366 (if (save-excursion
|
|
|
1367 (re-search-backward "^.\\|[^ \t]" nil t)
|
|
|
1368 (looking-at "^."))
|
|
|
1369 ;; yes => re-indent it
|
|
|
1370 (ada-indent-current)
|
|
|
1371 ;;
|
|
|
1372 ;; no => insert newline and indent it
|
|
|
1373 ;;
|
|
|
1374 (progn
|
|
|
1375 (ada-indent-current)
|
|
|
1376 (newline)
|
|
|
1377 (delete-horizontal-space)
|
|
|
1378 (setq orgpoint (point))
|
|
|
1379 (setq column (save-excursion
|
|
|
1380 (funcall (ada-indent-function) orgpoint)))
|
|
|
1381 (indent-to column)
|
|
|
1382 ))
|
|
|
1383
|
|
|
1384 (insert "(")
|
|
|
1385
|
|
|
1386 (setq firstcol (current-column))
|
|
|
1387 (setq i (length paramlist))
|
|
|
1388
|
|
|
1389 ;;
|
|
|
1390 ;; loop until last parameter
|
|
|
1391 ;;
|
|
|
1392 (while (not (zerop i))
|
|
|
1393 (setq i (1- i))
|
|
|
1394 (setq column firstcol)
|
|
|
1395
|
|
|
1396 ;;
|
|
|
1397 ;; insert parameter-name, space and colon
|
|
|
1398 ;;
|
|
|
1399 (insert (nth 0 (nth i paramlist)))
|
|
|
1400 (indent-to (+ column parlen 1))
|
|
|
1401 (insert ": ")
|
|
|
1402 (setq column (current-column))
|
|
|
1403
|
|
|
1404 ;;
|
|
|
1405 ;; insert 'in' or space
|
|
|
1406 ;;
|
|
|
1407 (if (nth 1 (nth i paramlist))
|
|
|
1408 (insert "in ")
|
|
|
1409 (if (and
|
|
|
1410 (or inp
|
|
2
|
1411 accessp)
|
|
0
|
1412 (not (nth 3 (nth i paramlist))))
|
|
|
1413 (insert " ")))
|
|
|
1414
|
|
|
1415 ;;
|
|
|
1416 ;; insert 'out' or space
|
|
|
1417 ;;
|
|
|
1418 (if (nth 2 (nth i paramlist))
|
|
|
1419 (insert "out ")
|
|
|
1420 (if (and
|
|
|
1421 (or outp
|
|
2
|
1422 accessp)
|
|
0
|
1423 (not (nth 3 (nth i paramlist))))
|
|
|
1424 (insert " ")))
|
|
|
1425
|
|
|
1426 ;;
|
|
2
|
1427 ;; insert 'access'
|
|
0
|
1428 ;;
|
|
|
1429 (if (nth 3 (nth i paramlist))
|
|
2
|
1430 (insert "access "))
|
|
0
|
1431
|
|
|
1432 (setq column (current-column))
|
|
|
1433
|
|
|
1434 ;;
|
|
|
1435 ;; insert type-name and, if necessary, space and default-expression
|
|
|
1436 ;;
|
|
|
1437 (insert (nth 4 (nth i paramlist)))
|
|
|
1438 (if (nth 5 (nth i paramlist))
|
|
|
1439 (progn
|
|
|
1440 (indent-to (+ column typlen 1))
|
|
|
1441 (insert (nth 5 (nth i paramlist)))))
|
|
|
1442
|
|
|
1443 ;;
|
|
|
1444 ;; check if it was the last parameter
|
|
|
1445 ;;
|
|
|
1446 (if (not (zerop i))
|
|
|
1447 ;; no => insert ';' and newline and indent
|
|
|
1448 (progn
|
|
|
1449 (insert ";")
|
|
|
1450 (newline)
|
|
|
1451 (indent-to firstcol))
|
|
|
1452 ;; yes
|
|
|
1453 (insert ")"))
|
|
|
1454
|
|
|
1455 ) ; end of loop
|
|
|
1456
|
|
|
1457 ;;
|
|
|
1458 ;; if anything follows, except semicolon:
|
|
|
1459 ;; put it in a new line and indent it
|
|
|
1460 ;;
|
|
|
1461 (if (not (looking-at "[ \t]*[;\n]"))
|
|
|
1462 (ada-indent-newline-indent))
|
|
|
1463
|
|
|
1464 ))
|
|
|
1465
|
|
|
1466
|
|
|
1467 ;;;----------------------------;;;
|
|
|
1468 ;;; Move To Matching Start/End ;;;
|
|
|
1469 ;;;----------------------------;;;
|
|
|
1470
|
|
|
1471 (defun ada-move-to-start ()
|
|
2
|
1472 "Moves point to the matching start of the current Ada structure."
|
|
0
|
1473 (interactive)
|
|
|
1474 (let ((pos (point)))
|
|
|
1475 (unwind-protect
|
|
|
1476 (progn
|
|
|
1477 (set-syntax-table ada-mode-symbol-syntax-table)
|
|
|
1478
|
|
|
1479 (message "searching for block start ...")
|
|
|
1480 (save-excursion
|
|
|
1481 ;;
|
|
|
1482 ;; do nothing if in string or comment or not on 'end ...;'
|
|
|
1483 ;; or if an error occurs during processing
|
|
|
1484 ;;
|
|
|
1485 (or
|
|
|
1486 (ada-in-string-or-comment-p)
|
|
|
1487 (and (progn
|
|
|
1488 (or (looking-at "[ \t]*\\<end\\>")
|
|
|
1489 (backward-word 1))
|
|
|
1490 (or (looking-at "[ \t]*\\<end\\>")
|
|
|
1491 (backward-word 1))
|
|
|
1492 (or (looking-at "[ \t]*\\<end\\>")
|
|
|
1493 (error "not on end ...;")))
|
|
|
1494 (ada-goto-matching-start 1)
|
|
|
1495 (setq pos (point))
|
|
|
1496
|
|
|
1497 ;;
|
|
|
1498 ;; on 'begin' => go on, according to user option
|
|
|
1499 ;;
|
|
|
1500 ada-move-to-declaration
|
|
|
1501 (looking-at "\\<begin\\>")
|
|
|
1502 (ada-goto-matching-decl-start)
|
|
|
1503 (setq pos (point))))
|
|
|
1504
|
|
|
1505 ) ; end of save-excursion
|
|
|
1506
|
|
|
1507 ;; now really move to the found position
|
|
|
1508 (goto-char pos)
|
|
|
1509 (message "searching for block start ... done"))
|
|
|
1510
|
|
|
1511 ;;
|
|
|
1512 ;; restore syntax-table
|
|
|
1513 ;;
|
|
|
1514 (set-syntax-table ada-mode-syntax-table))))
|
|
|
1515
|
|
|
1516
|
|
|
1517 (defun ada-move-to-end ()
|
|
|
1518 "Moves point to the matching end of the current block around point.
|
|
|
1519 Moves to 'begin' if in a declarative part."
|
|
|
1520 (interactive)
|
|
|
1521 (let ((pos (point))
|
|
|
1522 (decstart nil)
|
|
|
1523 (packdecl nil))
|
|
|
1524 (unwind-protect
|
|
|
1525 (progn
|
|
|
1526 (set-syntax-table ada-mode-symbol-syntax-table)
|
|
|
1527
|
|
|
1528 (message "searching for block end ...")
|
|
|
1529 (save-excursion
|
|
|
1530
|
|
|
1531 (forward-char 1)
|
|
|
1532 (cond
|
|
|
1533 ;; directly on 'begin'
|
|
|
1534 ((save-excursion
|
|
|
1535 (ada-goto-previous-word)
|
|
|
1536 (looking-at "\\<begin\\>"))
|
|
|
1537 (ada-goto-matching-end 1))
|
|
|
1538 ;; on first line of defun declaration
|
|
|
1539 ((save-excursion
|
|
|
1540 (and (ada-goto-stmt-start)
|
|
|
1541 (looking-at "\\<function\\>\\|\\<procedure\\>" )))
|
|
|
1542 (ada-search-ignore-string-comment "\\<begin\\>"))
|
|
|
1543 ;; on first line of task declaration
|
|
|
1544 ((save-excursion
|
|
|
1545 (and (ada-goto-stmt-start)
|
|
|
1546 (looking-at "\\<task\\>" )
|
|
|
1547 (forward-word 1)
|
|
|
1548 (ada-search-ignore-string-comment "[^ \n\t]")
|
|
|
1549 (not (backward-char 1))
|
|
|
1550 (looking-at "\\<body\\>")))
|
|
|
1551 (ada-search-ignore-string-comment "\\<begin\\>"))
|
|
|
1552 ;; accept block start
|
|
|
1553 ((save-excursion
|
|
|
1554 (and (ada-goto-stmt-start)
|
|
|
1555 (looking-at "\\<accept\\>" )))
|
|
|
1556 (ada-goto-matching-end 0))
|
|
|
1557 ;; package start
|
|
|
1558 ((save-excursion
|
|
|
1559 (and (ada-goto-matching-decl-start t)
|
|
|
1560 (looking-at "\\<package\\>")))
|
|
|
1561 (ada-goto-matching-end 1))
|
|
|
1562 ;; inside a 'begin' ... 'end' block
|
|
|
1563 ((save-excursion
|
|
|
1564 (ada-goto-matching-decl-start t))
|
|
|
1565 (ada-search-ignore-string-comment "\\<begin\\>"))
|
|
|
1566 ;; (hopefully ;-) everything else
|
|
|
1567 (t
|
|
|
1568 (ada-goto-matching-end 1)))
|
|
|
1569 (setq pos (point))
|
|
|
1570
|
|
|
1571 ) ; end of save-excursion
|
|
|
1572
|
|
|
1573 ;; now really move to the found position
|
|
|
1574 (goto-char pos)
|
|
|
1575 (message "searching for block end ... done"))
|
|
|
1576
|
|
|
1577 ;;
|
|
|
1578 ;; restore syntax-table
|
|
|
1579 ;;
|
|
|
1580 (set-syntax-table ada-mode-syntax-table))))
|
|
|
1581
|
|
|
1582
|
|
|
1583 ;;;-----------------------------;;;
|
|
|
1584 ;;; Functions For Indentation ;;;
|
|
|
1585 ;;;-----------------------------;;;
|
|
|
1586
|
|
|
1587 ;; ---- main functions for indentation
|
|
|
1588
|
|
|
1589 (defun ada-indent-region (beg end)
|
|
2
|
1590 "Indents the region using `ada-indent-current' on each line."
|
|
0
|
1591 (interactive "*r")
|
|
|
1592 (goto-char beg)
|
|
|
1593 (let ((block-done 0)
|
|
|
1594 (lines-remaining (count-lines beg end))
|
|
|
1595 (msg (format "indenting %4d lines %%4d lines remaining ..."
|
|
|
1596 (count-lines beg end)))
|
|
|
1597 (endmark (copy-marker end)))
|
|
|
1598 ;; catch errors while indenting
|
|
|
1599 (condition-case err
|
|
|
1600 (while (< (point) endmark)
|
|
|
1601 (if (> block-done 9)
|
|
2
|
1602 (progn (message msg lines-remaining)
|
|
0
|
1603 (setq block-done 0)))
|
|
|
1604 (if (looking-at "^$") nil
|
|
|
1605 (ada-indent-current))
|
|
|
1606 (forward-line 1)
|
|
|
1607 (setq block-done (1+ block-done))
|
|
|
1608 (setq lines-remaining (1- lines-remaining)))
|
|
2
|
1609 ;; show line number where the error occurred
|
|
0
|
1610 (error
|
|
189
|
1611 (error "line %d: %s" (1+ (count-lines (point-min) (point))) err) nil))
|
|
0
|
1612 (message "indenting ... done")))
|
|
|
1613
|
|
|
1614
|
|
|
1615 (defun ada-indent-newline-indent ()
|
|
|
1616 "Indents the current line, inserts a newline and then indents the new line."
|
|
|
1617 (interactive "*")
|
|
189
|
1618 (ada-indent-current)
|
|
|
1619 (newline)
|
|
|
1620 (ada-indent-current))
|
|
0
|
1621
|
|
|
1622
|
|
|
1623 (defun ada-indent-current ()
|
|
|
1624 "Indents current line as Ada code.
|
|
|
1625 This works by two steps:
|
|
2
|
1626 1) It moves point to the end of the previous code line.
|
|
0
|
1627 Then it calls the function to calculate the indentation for the
|
|
|
1628 following line as if a newline would be inserted there.
|
|
|
1629 The calculated column # is saved and the old position of point
|
|
|
1630 is restored.
|
|
|
1631 2) Then another function is called to calculate the indentation for
|
|
|
1632 the current line, based on the previously calculated column #."
|
|
|
1633
|
|
|
1634 (interactive)
|
|
|
1635
|
|
|
1636 (unwind-protect
|
|
|
1637 (progn
|
|
|
1638 (set-syntax-table ada-mode-symbol-syntax-table)
|
|
|
1639
|
|
|
1640 (let ((line-end)
|
|
|
1641 (orgpoint (point-marker))
|
|
|
1642 (cur-indent)
|
|
|
1643 (prev-indent)
|
|
|
1644 (prevline t))
|
|
|
1645
|
|
|
1646 ;;
|
|
|
1647 ;; first step
|
|
|
1648 ;;
|
|
|
1649 (save-excursion
|
|
|
1650 (if (ada-goto-prev-nonblank-line t)
|
|
|
1651 ;;
|
|
|
1652 ;; we are not in the first accessible line in the buffer
|
|
|
1653 ;;
|
|
|
1654 (progn
|
|
|
1655 ;;(end-of-line)
|
|
|
1656 ;;(forward-char 1)
|
|
|
1657 ;; we are already at the BOL
|
|
|
1658 (forward-line 1)
|
|
|
1659 (setq line-end (point))
|
|
|
1660 (setq prev-indent
|
|
|
1661 (save-excursion
|
|
|
1662 (funcall (ada-indent-function) line-end))))
|
|
189
|
1663 (progn ; first line of buffer -> set indent
|
|
|
1664 (beginning-of-line) ; to 0
|
|
|
1665 (delete-horizontal-space)
|
|
|
1666 (setq prevline nil))))
|
|
0
|
1667
|
|
|
1668 (if prevline
|
|
|
1669 ;;
|
|
|
1670 ;; we are not in the first accessible line in the buffer
|
|
|
1671 ;;
|
|
|
1672 (progn
|
|
|
1673 ;;
|
|
|
1674 ;; second step
|
|
|
1675 ;;
|
|
|
1676 (back-to-indentation)
|
|
|
1677 (setq cur-indent (ada-get-current-indent prev-indent))
|
|
189
|
1678 ;; only reindent if indentation is different then the current
|
|
|
1679 (if (= (current-column) cur-indent)
|
|
|
1680 nil
|
|
2
|
1681 (delete-horizontal-space)
|
|
189
|
1682 (indent-to cur-indent))
|
|
0
|
1683 ;;
|
|
|
1684 ;; restore position of point
|
|
|
1685 ;;
|
|
|
1686 (goto-char orgpoint)
|
|
|
1687 (if (< (current-column) (current-indentation))
|
|
189
|
1688 (back-to-indentation))))))
|
|
0
|
1689
|
|
|
1690 ;;
|
|
|
1691 ;; restore syntax-table
|
|
|
1692 ;;
|
|
|
1693 (set-syntax-table ada-mode-syntax-table)))
|
|
|
1694
|
|
|
1695
|
|
|
1696 (defun ada-get-current-indent (prev-indent)
|
|
|
1697 ;; Returns the column # to indent the current line to.
|
|
|
1698 ;; PREV-INDENT is the indentation resulting from the previous lines.
|
|
|
1699 (let ((column nil)
|
|
|
1700 (pos nil)
|
|
|
1701 (match-cons nil))
|
|
|
1702
|
|
|
1703 (cond
|
|
|
1704 ;;
|
|
|
1705 ;; in open parenthesis, but not in parameter-list
|
|
|
1706 ;;
|
|
|
1707 ((and
|
|
|
1708 ada-indent-to-open-paren
|
|
|
1709 (not (ada-in-paramlist-p))
|
|
|
1710 (setq column (ada-in-open-paren-p)))
|
|
|
1711 ;; check if we have something like this (Table_Component_Type =>
|
|
|
1712 ;; Source_File_Record,)
|
|
|
1713 (save-excursion
|
|
|
1714 (if (and (ada-search-ignore-string-comment "[^ \t]" t nil)
|
|
|
1715 (looking-at "\n")
|
|
|
1716 (ada-search-ignore-string-comment "[^ \t\n]" t nil)
|
|
|
1717 (looking-at ">"))
|
|
|
1718 (setq column (+ ada-broken-indent column))))
|
|
|
1719 column)
|
|
|
1720
|
|
|
1721 ;;
|
|
|
1722 ;; end
|
|
|
1723 ;;
|
|
|
1724 ((looking-at "\\<end\\>")
|
|
189
|
1725 (let ((label 0))
|
|
|
1726 (save-excursion
|
|
|
1727 (ada-goto-matching-start 1)
|
|
|
1728
|
|
|
1729 ;;
|
|
|
1730 ;; found 'loop' => skip back to 'while' or 'for'
|
|
|
1731 ;; if 'loop' is not on a separate line
|
|
|
1732 ;;
|
|
|
1733 (if (and
|
|
|
1734 (looking-at "\\<loop\\>")
|
|
|
1735 (save-excursion
|
|
|
1736 (back-to-indentation)
|
|
|
1737 (not (looking-at "\\<loop\\>"))))
|
|
|
1738 (if (save-excursion
|
|
|
1739 (and
|
|
|
1740 (setq match-cons
|
|
|
1741 (ada-search-ignore-string-comment
|
|
|
1742 ada-loop-start-re t nil))
|
|
|
1743 (not (looking-at "\\<loop\\>"))))
|
|
|
1744 (progn
|
|
|
1745 (goto-char (car match-cons))
|
|
|
1746 (save-excursion
|
|
|
1747 (beginning-of-line)
|
|
|
1748 (if (looking-at ada-named-block-re)
|
|
|
1749 (setq label (- ada-label-indent)))))))
|
|
|
1750
|
|
|
1751 (+ (current-indentation) label))))
|
|
0
|
1752 ;;
|
|
|
1753 ;; exception
|
|
|
1754 ;;
|
|
|
1755 ((looking-at "\\<exception\\>")
|
|
|
1756 (save-excursion
|
|
|
1757 (ada-goto-matching-start 1)
|
|
|
1758 (current-indentation)))
|
|
|
1759 ;;
|
|
|
1760 ;; when
|
|
|
1761 ;;
|
|
|
1762 ((looking-at "\\<when\\>")
|
|
|
1763 (save-excursion
|
|
|
1764 (ada-goto-matching-start 1)
|
|
|
1765 (+ (current-indentation) ada-when-indent)))
|
|
|
1766 ;;
|
|
|
1767 ;; else
|
|
|
1768 ;;
|
|
|
1769 ((looking-at "\\<else\\>")
|
|
|
1770 (if (save-excursion
|
|
|
1771 (ada-goto-previous-word)
|
|
|
1772 (looking-at "\\<or\\>"))
|
|
|
1773 prev-indent
|
|
|
1774 (save-excursion
|
|
|
1775 (ada-goto-matching-start 1 nil t)
|
|
|
1776 (current-indentation))))
|
|
|
1777 ;;
|
|
|
1778 ;; elsif
|
|
|
1779 ;;
|
|
|
1780 ((looking-at "\\<elsif\\>")
|
|
|
1781 (save-excursion
|
|
|
1782 (ada-goto-matching-start 1 nil t)
|
|
|
1783 (current-indentation)))
|
|
|
1784 ;;
|
|
|
1785 ;; then
|
|
|
1786 ;;
|
|
|
1787 ((looking-at "\\<then\\>")
|
|
|
1788 (if (save-excursion
|
|
|
1789 (ada-goto-previous-word)
|
|
|
1790 (looking-at "\\<and\\>"))
|
|
|
1791 prev-indent
|
|
|
1792 (save-excursion
|
|
|
1793 (ada-search-ignore-string-comment "\\<elsif\\>\\|\\<if\\>" t nil)
|
|
|
1794 (+ (current-indentation) ada-stmt-end-indent))))
|
|
|
1795 ;;
|
|
|
1796 ;; loop
|
|
|
1797 ;;
|
|
|
1798 ((looking-at "\\<loop\\>")
|
|
|
1799 (setq pos (point))
|
|
|
1800 (save-excursion
|
|
|
1801 (goto-char (match-end 0))
|
|
|
1802 (ada-goto-stmt-start)
|
|
|
1803 (if (looking-at "\\<loop\\>\\|\\<if\\>")
|
|
|
1804 prev-indent
|
|
|
1805 (progn
|
|
|
1806 (if (not (looking-at ada-loop-start-re))
|
|
|
1807 (ada-search-ignore-string-comment ada-loop-start-re
|
|
|
1808 nil pos))
|
|
|
1809 (if (looking-at "\\<loop\\>")
|
|
|
1810 prev-indent
|
|
|
1811 (+ (current-indentation) ada-stmt-end-indent))))))
|
|
|
1812 ;;
|
|
|
1813 ;; begin
|
|
|
1814 ;;
|
|
|
1815 ((looking-at "\\<begin\\>")
|
|
|
1816 (save-excursion
|
|
|
1817 (if (ada-goto-matching-decl-start t)
|
|
|
1818 (current-indentation)
|
|
189
|
1819 prev-indent)))
|
|
0
|
1820 ;;
|
|
|
1821 ;; is
|
|
|
1822 ;;
|
|
|
1823 ((looking-at "\\<is\\>")
|
|
|
1824 (if (and
|
|
|
1825 ada-indent-is-separate
|
|
|
1826 (save-excursion
|
|
|
1827 (goto-char (match-end 0))
|
|
|
1828 (ada-goto-next-non-ws (save-excursion
|
|
|
1829 (end-of-line)
|
|
|
1830 (point)))
|
|
|
1831 (looking-at "\\<abstract\\>\\|\\<separate\\>")))
|
|
|
1832 (save-excursion
|
|
|
1833 (ada-goto-stmt-start)
|
|
|
1834 (+ (current-indentation) ada-indent))
|
|
|
1835 (save-excursion
|
|
|
1836 (ada-goto-stmt-start)
|
|
|
1837 (+ (current-indentation) ada-stmt-end-indent))))
|
|
|
1838 ;;
|
|
|
1839 ;; record
|
|
|
1840 ;;
|
|
|
1841 ((looking-at "\\<record\\>")
|
|
|
1842 (save-excursion
|
|
|
1843 (ada-search-ignore-string-comment
|
|
|
1844 "\\<\\(type\\|use\\)\\>" t nil)
|
|
|
1845 (if (looking-at "\\<use\\>")
|
|
|
1846 (ada-search-ignore-string-comment "\\<for\\>" t nil))
|
|
|
1847 (+ (current-indentation) ada-indent-record-rel-type)))
|
|
|
1848 ;;
|
|
|
1849 ;; or as statement-start
|
|
|
1850 ;;
|
|
|
1851 ((ada-looking-at-semi-or)
|
|
|
1852 (save-excursion
|
|
|
1853 (ada-goto-matching-start 1)
|
|
|
1854 (current-indentation)))
|
|
|
1855 ;;
|
|
|
1856 ;; private as statement-start
|
|
|
1857 ;;
|
|
|
1858 ((ada-looking-at-semi-private)
|
|
|
1859 (save-excursion
|
|
|
1860 (ada-goto-matching-decl-start)
|
|
|
1861 (current-indentation)))
|
|
|
1862 ;;
|
|
|
1863 ;; new/abstract/separate
|
|
|
1864 ;;
|
|
|
1865 ((looking-at "\\<\\(new\\|abstract\\|separate\\)\\>")
|
|
|
1866 (- prev-indent ada-indent (- ada-broken-indent)))
|
|
|
1867 ;;
|
|
|
1868 ;; return
|
|
|
1869 ;;
|
|
|
1870 ((looking-at "\\<return\\>")
|
|
|
1871 (save-excursion
|
|
|
1872 (forward-sexp -1)
|
|
|
1873 (if (and (looking-at "(")
|
|
|
1874 (save-excursion
|
|
|
1875 (backward-sexp 2)
|
|
|
1876 (looking-at "\\<function\\>")))
|
|
|
1877 (1+ (current-column))
|
|
|
1878 prev-indent)))
|
|
|
1879 ;;
|
|
|
1880 ;; do
|
|
|
1881 ;;
|
|
|
1882 ((looking-at "\\<do\\>")
|
|
|
1883 (save-excursion
|
|
|
1884 (ada-goto-stmt-start)
|
|
|
1885 (+ (current-indentation) ada-stmt-end-indent)))
|
|
|
1886 ;;
|
|
|
1887 ;; package/function/procedure
|
|
|
1888 ;;
|
|
|
1889 ((and (looking-at "\\<\\(package\\|function\\|procedure\\)\\>")
|
|
|
1890 (save-excursion
|
|
|
1891 (forward-char 1)
|
|
|
1892 (ada-goto-stmt-start)
|
|
|
1893 (looking-at "\\<\\(package\\|function\\|procedure\\)\\>")))
|
|
|
1894 (save-excursion
|
|
|
1895 ;; look for 'generic'
|
|
|
1896 (if (and (ada-goto-matching-decl-start t)
|
|
|
1897 (looking-at "generic"))
|
|
|
1898 (current-column)
|
|
|
1899 prev-indent)))
|
|
|
1900 ;;
|
|
|
1901 ;; label
|
|
|
1902 ;;
|
|
|
1903 ((looking-at "\\<[a-zA-Z0-9_]+[ \t\n]*:[^=]")
|
|
|
1904 (if (ada-in-decl-p)
|
|
|
1905 prev-indent
|
|
|
1906 (+ prev-indent ada-label-indent)))
|
|
|
1907 ;;
|
|
|
1908 ;; identifier and other noindent-statements
|
|
|
1909 ;;
|
|
|
1910 ((looking-at "\\<[a-zA-Z0-9_]+[ \t\n]*")
|
|
|
1911 prev-indent)
|
|
|
1912 ;;
|
|
|
1913 ;; beginning of a parameter list
|
|
|
1914 ;;
|
|
|
1915 ((looking-at "(")
|
|
|
1916 prev-indent)
|
|
|
1917 ;;
|
|
|
1918 ;; end of a parameter list
|
|
|
1919 ;;
|
|
|
1920 ((looking-at ")")
|
|
|
1921 (save-excursion
|
|
|
1922 (forward-char 1)
|
|
|
1923 (backward-sexp 1)
|
|
|
1924 (current-column)))
|
|
|
1925 ;;
|
|
|
1926 ;; comment
|
|
|
1927 ;;
|
|
|
1928 ((looking-at "--")
|
|
|
1929 (if ada-indent-comment-as-code
|
|
|
1930 prev-indent
|
|
|
1931 (current-indentation)))
|
|
|
1932 ;;
|
|
|
1933 ;; unknown syntax - maybe this should signal an error ?
|
|
|
1934 ;;
|
|
|
1935 (t
|
|
|
1936 prev-indent))))
|
|
|
1937
|
|
|
1938
|
|
|
1939 (defun ada-indent-function (&optional nomove)
|
|
|
1940 ;; Returns the function to calculate the indentation for the current
|
|
|
1941 ;; line according to the previous statement, ignoring the contents
|
|
|
1942 ;; of the current line after point. Moves point to the beginning of
|
|
|
1943 ;; the current statement, if NOMOVE is nil.
|
|
|
1944
|
|
|
1945 (let ((orgpoint (point))
|
|
189
|
1946 (func nil))
|
|
0
|
1947 ;;
|
|
|
1948 ;; inside a parameter-list
|
|
|
1949 ;;
|
|
|
1950 (if (ada-in-paramlist-p)
|
|
|
1951 (setq func 'ada-get-indent-paramlist)
|
|
|
1952 (progn
|
|
|
1953 ;;
|
|
|
1954 ;; move to beginning of current statement
|
|
|
1955 ;;
|
|
|
1956 (if (not nomove)
|
|
189
|
1957 (ada-goto-stmt-start))
|
|
0
|
1958 ;;
|
|
|
1959 ;; no beginning found => don't change indentation
|
|
|
1960 ;;
|
|
|
1961 (if (and
|
|
|
1962 (eq orgpoint (point))
|
|
|
1963 (not nomove))
|
|
189
|
1964 (setq func 'ada-get-indent-nochange)
|
|
0
|
1965
|
|
|
1966 (cond
|
|
|
1967 ;;
|
|
|
1968 ((and
|
|
|
1969 ada-indent-to-open-paren
|
|
|
1970 (ada-in-open-paren-p))
|
|
|
1971 (setq func 'ada-get-indent-open-paren))
|
|
|
1972 ;;
|
|
|
1973 ((looking-at "\\<end\\>")
|
|
|
1974 (setq func 'ada-get-indent-end))
|
|
|
1975 ;;
|
|
|
1976 ((looking-at ada-loop-start-re)
|
|
|
1977 (setq func 'ada-get-indent-loop))
|
|
|
1978 ;;
|
|
|
1979 ((looking-at ada-subprog-start-re)
|
|
|
1980 (setq func 'ada-get-indent-subprog))
|
|
|
1981 ;;
|
|
|
1982 ((looking-at ada-block-start-re)
|
|
|
1983 (setq func 'ada-get-indent-block-start))
|
|
|
1984 ;;
|
|
|
1985 ((looking-at "\\<type\\>")
|
|
|
1986 (setq func 'ada-get-indent-type))
|
|
|
1987 ;;
|
|
|
1988 ((looking-at "\\<\\(els\\)?if\\>")
|
|
|
1989 (setq func 'ada-get-indent-if))
|
|
|
1990 ;;
|
|
|
1991 ((looking-at "\\<case\\>")
|
|
|
1992 (setq func 'ada-get-indent-case))
|
|
|
1993 ;;
|
|
|
1994 ((looking-at "\\<when\\>")
|
|
|
1995 (setq func 'ada-get-indent-when))
|
|
|
1996 ;;
|
|
|
1997 ((looking-at "--")
|
|
|
1998 (setq func 'ada-get-indent-comment))
|
|
|
1999 ;;
|
|
|
2000 ((looking-at "[a-zA-Z0-9_]+[ \t\n]*:[^=]")
|
|
|
2001 (setq func 'ada-get-indent-label))
|
|
|
2002 ;;
|
|
|
2003 ((looking-at "\\<separate\\>")
|
|
|
2004 (setq func 'ada-get-indent-nochange))
|
|
|
2005 (t
|
|
|
2006 (setq func 'ada-get-indent-noindent))))))
|
|
|
2007
|
|
|
2008 func))
|
|
|
2009
|
|
|
2010
|
|
|
2011 ;; ---- functions to return indentation for special cases
|
|
|
2012
|
|
|
2013 (defun ada-get-indent-open-paren (orgpoint)
|
|
|
2014 ;; Returns the indentation (column #) for the new line after ORGPOINT.
|
|
189
|
2015 ;; Assumes point to be behind an open parenthesis not yet closed.
|
|
0
|
2016 (ada-in-open-paren-p))
|
|
|
2017
|
|
|
2018
|
|
|
2019 (defun ada-get-indent-nochange (orgpoint)
|
|
|
2020 ;; Returns the indentation (column #) of the current line.
|
|
|
2021 (save-excursion
|
|
|
2022 (forward-line -1)
|
|
|
2023 (current-indentation)))
|
|
|
2024
|
|
|
2025
|
|
|
2026 (defun ada-get-indent-paramlist (orgpoint)
|
|
|
2027 ;; Returns the indentation (column #) for the new line after ORGPOINT.
|
|
|
2028 ;; Assumes point to be inside a parameter-list.
|
|
|
2029 (save-excursion
|
|
|
2030 (ada-search-ignore-string-comment "[^ \t\n]" t nil t)
|
|
|
2031 (cond
|
|
|
2032 ;;
|
|
|
2033 ;; in front of the first parameter
|
|
|
2034 ;;
|
|
|
2035 ((looking-at "(")
|
|
|
2036 (goto-char (match-end 0))
|
|
|
2037 (current-column))
|
|
|
2038 ;;
|
|
|
2039 ;; in front of another parameter
|
|
|
2040 ;;
|
|
|
2041 ((looking-at ";")
|
|
|
2042 (goto-char (cdr (ada-search-ignore-string-comment "(\\|;" t nil t)))
|
|
|
2043 (ada-goto-next-non-ws)
|
|
|
2044 (current-column))
|
|
|
2045 ;;
|
|
|
2046 ;; inside a parameter declaration
|
|
|
2047 ;;
|
|
|
2048 (t
|
|
|
2049 (goto-char (cdr (ada-search-ignore-string-comment "(\\|;" t nil t)))
|
|
|
2050 (ada-goto-next-non-ws)
|
|
|
2051 (+ (current-column) ada-broken-indent)))))
|
|
|
2052
|
|
|
2053
|
|
|
2054 (defun ada-get-indent-end (orgpoint)
|
|
|
2055 ;; Returns the indentation (column #) for the new line after ORGPOINT.
|
|
|
2056 ;; Assumes point to be at the beginning of an end-statement.
|
|
|
2057 ;; Therefore it has to find the corresponding start. This can be a little
|
|
|
2058 ;; slow, if it has to search through big files with many nested blocks.
|
|
|
2059 ;; Signals an error if the corresponding block-start doesn't match.
|
|
|
2060 (let ((defun-name nil)
|
|
189
|
2061 (label 0)
|
|
0
|
2062 (indent nil))
|
|
|
2063 ;;
|
|
|
2064 ;; is the line already terminated by ';' ?
|
|
|
2065 ;;
|
|
|
2066 (if (save-excursion
|
|
|
2067 (ada-search-ignore-string-comment ";" nil orgpoint))
|
|
|
2068 ;;
|
|
|
2069 ;; yes, look what's following 'end'
|
|
|
2070 ;;
|
|
|
2071 (progn
|
|
|
2072 (forward-word 1)
|
|
|
2073 (ada-goto-next-non-ws)
|
|
|
2074 (cond
|
|
|
2075 ;;
|
|
|
2076 ;; loop/select/if/case/record/select
|
|
|
2077 ;;
|
|
|
2078 ((looking-at "\\<\\(loop\\|select\\|if\\|case\\|record\\)\\>")
|
|
|
2079 (save-excursion
|
|
|
2080 (ada-check-matching-start
|
|
|
2081 (buffer-substring (match-beginning 0)
|
|
|
2082 (match-end 0)))
|
|
|
2083 (if (looking-at "\\<\\(loop\\|record\\)\\>")
|
|
|
2084 (progn
|
|
|
2085 (forward-word 1)
|
|
|
2086 (ada-goto-stmt-start)))
|
|
|
2087 ;; a label ? => skip it
|
|
189
|
2088 (if (looking-at ada-named-block-re)
|
|
0
|
2089 (progn
|
|
189
|
2090 (setq label (- ada-label-indent))
|
|
0
|
2091 (goto-char (match-end 0))
|
|
|
2092 (ada-goto-next-non-ws)))
|
|
|
2093 ;; really looking-at the right thing ?
|
|
|
2094 (or (looking-at (concat "\\<\\("
|
|
|
2095 "loop\\|select\\|if\\|case\\|"
|
|
|
2096 "record\\|while\\|type\\)\\>"))
|
|
|
2097 (progn
|
|
|
2098 (ada-search-ignore-string-comment
|
|
|
2099 (concat "\\<\\("
|
|
|
2100 "loop\\|select\\|if\\|case\\|"
|
|
|
2101 "record\\|while\\|type\\)\\>")))
|
|
|
2102 (backward-word 1))
|
|
189
|
2103 (+ (current-indentation) label)))
|
|
0
|
2104 ;;
|
|
|
2105 ;; a named block end
|
|
|
2106 ;;
|
|
|
2107 ((looking-at ada-ident-re)
|
|
|
2108 (setq defun-name (buffer-substring (match-beginning 0)
|
|
|
2109 (match-end 0)))
|
|
|
2110 (save-excursion
|
|
|
2111 (ada-goto-matching-start 0)
|
|
|
2112 (ada-check-defun-name defun-name)
|
|
|
2113 (current-indentation)))
|
|
|
2114 ;;
|
|
|
2115 ;; a block-end without name
|
|
|
2116 ;;
|
|
|
2117 ((looking-at ";")
|
|
|
2118 (save-excursion
|
|
|
2119 (ada-goto-matching-start 0)
|
|
|
2120 (if (looking-at "\\<begin\\>")
|
|
|
2121 (progn
|
|
|
2122 (setq indent (current-column))
|
|
|
2123 (if (ada-goto-matching-decl-start t)
|
|
|
2124 (current-indentation)
|
|
|
2125 indent)))))
|
|
|
2126 ;;
|
|
|
2127 ;; anything else - should maybe signal an error ?
|
|
|
2128 ;;
|
|
|
2129 (t
|
|
|
2130 (+ (current-indentation) ada-broken-indent))))
|
|
|
2131
|
|
|
2132 (+ (current-indentation) ada-broken-indent))))
|
|
|
2133
|
|
|
2134
|
|
|
2135 (defun ada-get-indent-case (orgpoint)
|
|
|
2136 ;; Returns the indentation (column #) for the new line after ORGPOINT.
|
|
189
|
2137 ;; Assumes point to be at the beginning of a case-statement.
|
|
0
|
2138 (let ((cur-indent (current-indentation))
|
|
|
2139 (match-cons nil)
|
|
|
2140 (opos (point)))
|
|
|
2141 (cond
|
|
|
2142 ;;
|
|
|
2143 ;; case..is..when..=>
|
|
|
2144 ;;
|
|
|
2145 ((save-excursion
|
|
189
|
2146 (setq match-cons (and
|
|
|
2147 ;; the `=>' must be after the keyword `is'.
|
|
|
2148 (ada-search-ignore-string-comment
|
|
|
2149 "\\<is\\>" nil orgpoint)
|
|
|
2150 (ada-search-ignore-string-comment
|
|
|
2151 "[ \t\n]+=>" nil orgpoint))))
|
|
0
|
2152 (save-excursion
|
|
|
2153 (goto-char (car match-cons))
|
|
|
2154 (if (not (ada-search-ignore-string-comment "\\<when\\>" t opos))
|
|
|
2155 (error "missing 'when' between 'case' and '=>'"))
|
|
|
2156 (+ (current-indentation) ada-indent)))
|
|
|
2157 ;;
|
|
|
2158 ;; case..is..when
|
|
|
2159 ;;
|
|
|
2160 ((save-excursion
|
|
|
2161 (setq match-cons (ada-search-ignore-string-comment
|
|
|
2162 "\\<when\\>" nil orgpoint)))
|
|
|
2163 (goto-char (cdr match-cons))
|
|
|
2164 (+ (current-indentation) ada-broken-indent))
|
|
|
2165 ;;
|
|
|
2166 ;; case..is
|
|
|
2167 ;;
|
|
|
2168 ((save-excursion
|
|
|
2169 (setq match-cons (ada-search-ignore-string-comment
|
|
|
2170 "\\<is\\>" nil orgpoint)))
|
|
|
2171 (+ (current-indentation) ada-when-indent))
|
|
|
2172 ;;
|
|
|
2173 ;; incomplete case
|
|
|
2174 ;;
|
|
|
2175 (t
|
|
|
2176 (+ (current-indentation) ada-broken-indent)))))
|
|
|
2177
|
|
|
2178
|
|
|
2179 (defun ada-get-indent-when (orgpoint)
|
|
|
2180 ;; Returns the indentation (column #) for the new line after ORGPOINT.
|
|
|
2181 ;; Assumes point to be at the beginning of an when-statement.
|
|
|
2182 (let ((cur-indent (current-indentation)))
|
|
|
2183 (if (ada-search-ignore-string-comment
|
|
|
2184 "[ \t\n]+=>" nil orgpoint)
|
|
|
2185 (+ cur-indent ada-indent)
|
|
|
2186 (+ cur-indent ada-broken-indent))))
|
|
|
2187
|
|
|
2188
|
|
|
2189 (defun ada-get-indent-if (orgpoint)
|
|
|
2190 ;; Returns the indentation (column #) for the new line after ORGPOINT.
|
|
|
2191 ;; Assumes point to be at the beginning of an if-statement.
|
|
|
2192 (let ((cur-indent (current-indentation))
|
|
|
2193 (match-cons nil))
|
|
|
2194 ;;
|
|
|
2195 ;; if..then ?
|
|
|
2196 ;;
|
|
|
2197 (if (ada-search-but-not
|
|
|
2198 "\\<then\\>" "\\<and\\>[ \t\n]+\\<then\\>" nil orgpoint)
|
|
|
2199
|
|
|
2200 (progn
|
|
|
2201 ;;
|
|
|
2202 ;; 'then' first in separate line ?
|
|
|
2203 ;; => indent according to 'then'
|
|
|
2204 ;;
|
|
|
2205 (if (save-excursion
|
|
|
2206 (back-to-indentation)
|
|
|
2207 (looking-at "\\<then\\>"))
|
|
|
2208 (setq cur-indent (current-indentation)))
|
|
|
2209 (forward-word 1)
|
|
|
2210 ;;
|
|
|
2211 ;; something follows 'then' ?
|
|
|
2212 ;;
|
|
|
2213 (if (setq match-cons
|
|
|
2214 (ada-search-ignore-string-comment
|
|
|
2215 "[^ \t\n]" nil orgpoint))
|
|
|
2216 (progn
|
|
|
2217 (goto-char (car match-cons))
|
|
|
2218 (+ ada-indent
|
|
|
2219 (- cur-indent (current-indentation))
|
|
|
2220 (funcall (ada-indent-function t) orgpoint)))
|
|
|
2221
|
|
|
2222 (+ cur-indent ada-indent)))
|
|
|
2223
|
|
|
2224 (+ cur-indent ada-broken-indent))))
|
|
|
2225
|
|
|
2226
|
|
|
2227 (defun ada-get-indent-block-start (orgpoint)
|
|
|
2228 ;; Returns the indentation (column #) for the new line after
|
|
|
2229 ;; ORGPOINT. Assumes point to be at the beginning of a block start
|
|
|
2230 ;; keyword.
|
|
|
2231 (let ((cur-indent (current-indentation))
|
|
|
2232 (pos nil))
|
|
|
2233 (cond
|
|
|
2234 ((save-excursion
|
|
|
2235 (forward-word 1)
|
|
|
2236 (setq pos (car (ada-search-ignore-string-comment
|
|
|
2237 "[^ \t\n]" nil orgpoint))))
|
|
|
2238 (goto-char pos)
|
|
|
2239 (save-excursion
|
|
|
2240 (funcall (ada-indent-function t) orgpoint)))
|
|
|
2241 ;;
|
|
|
2242 ;; nothing follows the block-start
|
|
|
2243 ;;
|
|
|
2244 (t
|
|
|
2245 (+ (current-indentation) ada-indent)))))
|
|
|
2246
|
|
|
2247
|
|
|
2248 (defun ada-get-indent-subprog (orgpoint)
|
|
|
2249 ;; Returns the indentation (column #) for the new line after ORGPOINT.
|
|
|
2250 ;; Assumes point to be at the beginning of a subprog-/package-declaration.
|
|
|
2251 (let ((match-cons nil)
|
|
|
2252 (cur-indent (current-indentation))
|
|
|
2253 (foundis nil)
|
|
|
2254 (addind 0)
|
|
|
2255 (fstart (point)))
|
|
|
2256 ;;
|
|
|
2257 ;; is there an 'is' in front of point ?
|
|
|
2258 ;;
|
|
|
2259 (if (save-excursion
|
|
|
2260 (setq match-cons
|
|
|
2261 (ada-search-ignore-string-comment
|
|
189
|
2262 "\\<\\(is\\|do\\)\\>" nil orgpoint)))
|
|
0
|
2263 ;;
|
|
|
2264 ;; yes, then skip to its end
|
|
|
2265 ;;
|
|
|
2266 (progn
|
|
|
2267 (setq foundis t)
|
|
|
2268 (goto-char (cdr match-cons)))
|
|
|
2269 ;;
|
|
|
2270 ;; no, then goto next non-ws, if there is one in front of point
|
|
|
2271 ;;
|
|
|
2272 (progn
|
|
|
2273 (if (ada-search-ignore-string-comment "[^ \t\n]" nil orgpoint)
|
|
|
2274 (ada-goto-next-non-ws)
|
|
|
2275 (goto-char orgpoint))))
|
|
|
2276
|
|
|
2277 (cond
|
|
|
2278 ;;
|
|
|
2279 ;; nothing follows 'is'
|
|
|
2280 ;;
|
|
|
2281 ((and
|
|
|
2282 foundis
|
|
|
2283 (save-excursion
|
|
|
2284 (not (ada-search-ignore-string-comment
|
|
|
2285 "[^ \t\n]" nil orgpoint t))))
|
|
|
2286 (+ cur-indent ada-indent))
|
|
|
2287 ;;
|
|
|
2288 ;; is abstract/separate/new ...
|
|
|
2289 ;;
|
|
|
2290 ((and
|
|
|
2291 foundis
|
|
|
2292 (save-excursion
|
|
|
2293 (setq match-cons
|
|
|
2294 (ada-search-ignore-string-comment
|
|
|
2295 "\\<\\(separate\\|new\\|abstract\\)\\>"
|
|
|
2296 nil orgpoint))))
|
|
|
2297 (goto-char (car match-cons))
|
|
2
|
2298 (ada-search-ignore-string-comment ada-subprog-start-re t)
|
|
0
|
2299 (ada-get-indent-noindent orgpoint))
|
|
|
2300 ;;
|
|
|
2301 ;; something follows 'is'
|
|
|
2302 ;;
|
|
|
2303 ((and
|
|
|
2304 foundis
|
|
|
2305 (save-excursion
|
|
|
2306 (ada-search-ignore-string-comment "[^ \t\n]" nil orgpoint))
|
|
|
2307 (ada-goto-next-non-ws)
|
|
|
2308 (funcall (ada-indent-function t) orgpoint)))
|
|
|
2309 ;;
|
|
|
2310 ;; no 'is' but ';'
|
|
|
2311 ;;
|
|
|
2312 ((save-excursion
|
|
|
2313 (ada-search-ignore-string-comment ";" nil orgpoint))
|
|
|
2314 cur-indent)
|
|
|
2315 ;;
|
|
|
2316 ;; no 'is' or ';'
|
|
|
2317 ;;
|
|
|
2318 (t
|
|
|
2319 (+ cur-indent ada-broken-indent)))))
|
|
|
2320
|
|
|
2321
|
|
|
2322 (defun ada-get-indent-noindent (orgpoint)
|
|
|
2323 ;; Returns the indentation (column #) for the new line after ORGPOINT.
|
|
|
2324 ;; Assumes point to be at the beginning of a 'noindent statement'.
|
|
189
|
2325 (let ((label 0))
|
|
|
2326 (save-excursion
|
|
|
2327 (beginning-of-line)
|
|
|
2328 (if (looking-at ada-named-block-re)
|
|
|
2329 (setq label (- ada-label-indent))))
|
|
|
2330 (if (save-excursion
|
|
|
2331 (ada-search-ignore-string-comment ";" nil orgpoint))
|
|
|
2332 (+ (current-indentation) label)
|
|
|
2333 (+ (current-indentation) ada-broken-indent label))))
|
|
0
|
2334
|
|
|
2335
|
|
|
2336 (defun ada-get-indent-label (orgpoint)
|
|
|
2337 ;; Returns the indentation (column #) for the new line after ORGPOINT.
|
|
|
2338 ;; Assumes point to be at the beginning of a label or variable declaration.
|
|
|
2339 ;; Checks the context to decide if it's a label or a variable declaration.
|
|
|
2340 ;; This check might be a bit slow.
|
|
|
2341 (let ((match-cons nil)
|
|
|
2342 (cur-indent (current-indentation)))
|
|
|
2343 (goto-char (cdr (ada-search-ignore-string-comment ":")))
|
|
|
2344 (cond
|
|
|
2345 ;;
|
|
|
2346 ;; loop label
|
|
|
2347 ;;
|
|
|
2348 ((save-excursion
|
|
|
2349 (setq match-cons (ada-search-ignore-string-comment
|
|
|
2350 ada-loop-start-re nil orgpoint)))
|
|
|
2351 (goto-char (car match-cons))
|
|
|
2352 (ada-get-indent-loop orgpoint))
|
|
|
2353 ;;
|
|
|
2354 ;; declare label
|
|
|
2355 ;;
|
|
|
2356 ((save-excursion
|
|
|
2357 (setq match-cons (ada-search-ignore-string-comment
|
|
189
|
2358 "\\<declare\\|begin\\>" nil orgpoint)))
|
|
0
|
2359 (save-excursion
|
|
|
2360 (goto-char (car match-cons))
|
|
|
2361 (+ (current-indentation) ada-indent)))
|
|
|
2362 ;;
|
|
|
2363 ;; complete statement following colon
|
|
|
2364 ;;
|
|
|
2365 ((save-excursion
|
|
|
2366 (ada-search-ignore-string-comment ";" nil orgpoint))
|
|
|
2367 (if (ada-in-decl-p)
|
|
|
2368 cur-indent ; variable-declaration
|
|
|
2369 (- cur-indent ada-label-indent))) ; label
|
|
|
2370 ;;
|
|
|
2371 ;; broken statement
|
|
|
2372 ;;
|
|
|
2373 ((save-excursion
|
|
|
2374 (ada-search-ignore-string-comment "[^ \t\n]" nil orgpoint))
|
|
|
2375 (if (ada-in-decl-p)
|
|
|
2376 (+ cur-indent ada-broken-indent)
|
|
|
2377 (+ cur-indent ada-broken-indent (- ada-label-indent))))
|
|
|
2378 ;;
|
|
|
2379 ;; nothing follows colon
|
|
|
2380 ;;
|
|
|
2381 (t
|
|
|
2382 (if (ada-in-decl-p)
|
|
|
2383 (+ cur-indent ada-broken-indent) ; variable-declaration
|
|
|
2384 (- cur-indent ada-label-indent)))))) ; label
|
|
|
2385
|
|
|
2386
|
|
|
2387 (defun ada-get-indent-loop (orgpoint)
|
|
|
2388 ;; Returns the indentation (column #) for the new line after ORGPOINT.
|
|
|
2389 ;; Assumes point to be at the beginning of a loop statement
|
|
|
2390 ;; or (unfortunately) also a for ... use statement.
|
|
|
2391 (let ((match-cons nil)
|
|
189
|
2392 (pos (point))
|
|
|
2393 (label (save-excursion
|
|
|
2394 (beginning-of-line)
|
|
|
2395 (if (looking-at ada-named-block-re)
|
|
|
2396 (- ada-label-indent)
|
|
|
2397 0))))
|
|
|
2398
|
|
0
|
2399 (cond
|
|
|
2400
|
|
|
2401 ;;
|
|
|
2402 ;; statement complete
|
|
|
2403 ;;
|
|
|
2404 ((save-excursion
|
|
|
2405 (ada-search-ignore-string-comment ";" nil orgpoint))
|
|
189
|
2406 (+ (current-indentation) label))
|
|
0
|
2407 ;;
|
|
|
2408 ;; simple loop
|
|
|
2409 ;;
|
|
|
2410 ((looking-at "loop\\>")
|
|
189
|
2411 (+ (ada-get-indent-block-start orgpoint) label))
|
|
0
|
2412
|
|
|
2413 ;;
|
|
|
2414 ;; 'for'- loop (or also a for ... use statement)
|
|
|
2415 ;;
|
|
|
2416 ((looking-at "for\\>")
|
|
|
2417 (cond
|
|
|
2418 ;;
|
|
|
2419 ;; for ... use
|
|
|
2420 ;;
|
|
|
2421 ((save-excursion
|
|
|
2422 (and
|
|
|
2423 (goto-char (match-end 0))
|
|
|
2424 (ada-search-ignore-string-comment "[^ /n/t]" nil orgpoint)
|
|
|
2425 (not (backward-char 1))
|
|
|
2426 (not (zerop (skip-chars-forward "_a-zA-Z0-9'")))
|
|
|
2427 (ada-search-ignore-string-comment "[^ /n/t]" nil orgpoint)
|
|
|
2428 (not (backward-char 1))
|
|
|
2429 (looking-at "\\<use\\>")
|
|
|
2430 ;;
|
|
|
2431 ;; check if there is a 'record' before point
|
|
|
2432 ;;
|
|
|
2433 (progn
|
|
|
2434 (setq match-cons (ada-search-ignore-string-comment
|
|
|
2435 "\\<record\\>" nil orgpoint))
|
|
|
2436 t)))
|
|
|
2437 (if match-cons
|
|
|
2438 (goto-char (car match-cons)))
|
|
|
2439 (+ (current-indentation) ada-indent))
|
|
|
2440 ;;
|
|
|
2441 ;; for..loop
|
|
|
2442 ;;
|
|
|
2443 ((save-excursion
|
|
|
2444 (setq match-cons (ada-search-ignore-string-comment
|
|
|
2445 "\\<loop\\>" nil orgpoint)))
|
|
|
2446 (goto-char (car match-cons))
|
|
|
2447 ;;
|
|
|
2448 ;; indent according to 'loop', if it's first in the line;
|
|
|
2449 ;; otherwise to 'for'
|
|
|
2450 ;;
|
|
|
2451 (if (not (save-excursion
|
|
|
2452 (back-to-indentation)
|
|
|
2453 (looking-at "\\<loop\\>")))
|
|
|
2454 (goto-char pos))
|
|
189
|
2455 (+ (current-indentation) ada-indent label))
|
|
0
|
2456 ;;
|
|
|
2457 ;; for-statement is broken
|
|
|
2458 ;;
|
|
|
2459 (t
|
|
189
|
2460 (+ (current-indentation) ada-broken-indent label))))
|
|
0
|
2461
|
|
|
2462 ;;
|
|
|
2463 ;; 'while'-loop
|
|
|
2464 ;;
|
|
|
2465 ((looking-at "while\\>")
|
|
|
2466 ;;
|
|
|
2467 ;; while..loop ?
|
|
|
2468 ;;
|
|
|
2469 (if (save-excursion
|
|
|
2470 (setq match-cons (ada-search-ignore-string-comment
|
|
|
2471 "\\<loop\\>" nil orgpoint)))
|
|
|
2472
|
|
|
2473 (progn
|
|
|
2474 (goto-char (car match-cons))
|
|
|
2475 ;;
|
|
|
2476 ;; indent according to 'loop', if it's first in the line;
|
|
|
2477 ;; otherwise to 'while'.
|
|
|
2478 ;;
|
|
|
2479 (if (not (save-excursion
|
|
|
2480 (back-to-indentation)
|
|
|
2481 (looking-at "\\<loop\\>")))
|
|
|
2482 (goto-char pos))
|
|
189
|
2483 (+ (current-indentation) ada-indent label))
|
|
|
2484
|
|
|
2485 (+ (current-indentation) ada-broken-indent label))))))
|
|
0
|
2486
|
|
|
2487
|
|
|
2488 (defun ada-get-indent-type (orgpoint)
|
|
|
2489 ;; Returns the indentation (column #) for the new line after ORGPOINT.
|
|
|
2490 ;; Assumes point to be at the beginning of a type statement.
|
|
|
2491 (let ((match-dat nil))
|
|
|
2492 (cond
|
|
|
2493 ;;
|
|
|
2494 ;; complete record declaration
|
|
|
2495 ;;
|
|
|
2496 ((save-excursion
|
|
|
2497 (and
|
|
|
2498 (setq match-dat (ada-search-ignore-string-comment "\\<end\\>"
|
|
|
2499 nil
|
|
|
2500 orgpoint))
|
|
|
2501 (ada-goto-next-non-ws)
|
|
|
2502 (looking-at "\\<record\\>")
|
|
|
2503 (forward-word 1)
|
|
|
2504 (ada-goto-next-non-ws)
|
|
|
2505 (looking-at ";")))
|
|
|
2506 (goto-char (car match-dat))
|
|
|
2507 (current-indentation))
|
|
|
2508 ;;
|
|
|
2509 ;; record type
|
|
|
2510 ;;
|
|
|
2511 ((save-excursion
|
|
|
2512 (setq match-dat (ada-search-ignore-string-comment "\\<record\\>"
|
|
|
2513 nil
|
|
|
2514 orgpoint)))
|
|
|
2515 (goto-char (car match-dat))
|
|
|
2516 (+ (current-indentation) ada-indent))
|
|
|
2517 ;;
|
|
|
2518 ;; complete type declaration
|
|
|
2519 ;;
|
|
|
2520 ((save-excursion
|
|
|
2521 (ada-search-ignore-string-comment ";" nil orgpoint))
|
|
|
2522 (current-indentation))
|
|
|
2523 ;;
|
|
|
2524 ;; "type ... is", but not "type ... is ...", which is broken
|
|
|
2525 ;;
|
|
|
2526 ((save-excursion
|
|
|
2527 (and
|
|
|
2528 (ada-search-ignore-string-comment "\\<is\\>" nil orgpoint)
|
|
|
2529 (not (ada-search-ignore-string-comment "[^ \t\n]" nil orgpoint))))
|
|
|
2530 (+ (current-indentation) ada-indent))
|
|
|
2531 ;;
|
|
|
2532 ;; broken statement
|
|
|
2533 ;;
|
|
|
2534 (t
|
|
|
2535 (+ (current-indentation) ada-broken-indent)))))
|
|
|
2536
|
|
|
2537
|
|
|
2538 ;;; ---- support-functions for indentation
|
|
|
2539
|
|
|
2540 ;;; ---- searching and matching
|
|
|
2541
|
|
|
2542 (defun ada-goto-stmt-start (&optional limit)
|
|
|
2543 ;; Moves point to the beginning of the statement that point is in or
|
|
|
2544 ;; after. Returns the new position of point. Beginnings are found
|
|
|
2545 ;; by searching for 'ada-end-stmt-re' and then moving to the
|
|
|
2546 ;; following non-ws that is not a comment. LIMIT is actually not
|
|
|
2547 ;; used by the indentation functions.
|
|
|
2548 (let ((match-dat nil)
|
|
|
2549 (orgpoint (point)))
|
|
|
2550
|
|
|
2551 (setq match-dat (ada-search-prev-end-stmt limit))
|
|
|
2552 (if match-dat
|
|
|
2553 ;;
|
|
|
2554 ;; found a previous end-statement => check if anything follows
|
|
|
2555 ;;
|
|
|
2556 (progn
|
|
|
2557 (if (not
|
|
|
2558 (save-excursion
|
|
|
2559 (goto-char (cdr match-dat))
|
|
|
2560 (ada-search-ignore-string-comment
|
|
|
2561 "[^ \t\n]" nil orgpoint)))
|
|
|
2562 ;;
|
|
|
2563 ;; nothing follows => it's the end-statement directly in
|
|
|
2564 ;; front of point => search again
|
|
|
2565 ;;
|
|
|
2566 (setq match-dat (ada-search-prev-end-stmt limit)))
|
|
|
2567 ;;
|
|
189
|
2568 ;; if found the correct end-statement => goto next non-ws
|
|
0
|
2569 ;;
|
|
|
2570 (if match-dat
|
|
|
2571 (goto-char (cdr match-dat)))
|
|
|
2572 (ada-goto-next-non-ws))
|
|
|
2573
|
|
|
2574 ;;
|
|
|
2575 ;; no previous end-statement => we are at the beginning of the
|
|
|
2576 ;; accessible part of the buffer
|
|
|
2577 ;;
|
|
|
2578 (progn
|
|
|
2579 (goto-char (point-min))
|
|
|
2580 ;;
|
|
|
2581 ;; skip to the very first statement, if there is one
|
|
|
2582 ;;
|
|
|
2583 (if (setq match-dat
|
|
|
2584 (ada-search-ignore-string-comment
|
|
|
2585 "[^ \t\n]" nil orgpoint))
|
|
|
2586 (goto-char (car match-dat))
|
|
|
2587 (goto-char orgpoint))))
|
|
|
2588
|
|
|
2589
|
|
|
2590 (point)))
|
|
|
2591
|
|
|
2592
|
|
|
2593 (defun ada-search-prev-end-stmt (&optional limit)
|
|
|
2594 ;; Moves point to previous end-statement. Returns a cons cell whose
|
|
|
2595 ;; car is the beginning and whose cdr the end of the match.
|
|
|
2596 ;; End-statements are defined by 'ada-end-stmt-re'. Checks for
|
|
|
2597 ;; certain keywords if they follow 'end', which means they are no
|
|
|
2598 ;; end-statement there.
|
|
|
2599 (let ((match-dat nil)
|
|
|
2600 (pos nil)
|
|
|
2601 (found nil))
|
|
|
2602 ;;
|
|
|
2603 ;; search until found or beginning-of-buffer
|
|
|
2604 ;;
|
|
|
2605 (while
|
|
|
2606 (and
|
|
|
2607 (not found)
|
|
|
2608 (setq match-dat (ada-search-ignore-string-comment ada-end-stmt-re
|
|
|
2609 t
|
|
|
2610 limit)))
|
|
|
2611
|
|
|
2612 (goto-char (car match-dat))
|
|
|
2613 (if (not (ada-in-open-paren-p))
|
|
|
2614 ;;
|
|
|
2615 ;; check if there is an 'end' in front of the match
|
|
|
2616 ;;
|
|
|
2617 (if (not (and
|
|
189
|
2618 (looking-at
|
|
|
2619 "\\<\\(record\\|loop\\|select\\|else\\|then\\)\\>")
|
|
0
|
2620 (save-excursion
|
|
|
2621 (ada-goto-previous-word)
|
|
189
|
2622 (looking-at "\\<\\(end\\|or\\|and\\)\\>"))))
|
|
|
2623 (save-excursion
|
|
|
2624 (goto-char (cdr match-dat))
|
|
|
2625 (ada-goto-next-word)
|
|
|
2626 (if (not (looking-at "\\<\\(separate\\|new\\)\\>"))
|
|
|
2627 (setq found t)))
|
|
|
2628
|
|
2
|
2629 (forward-word -1)))) ; end of loop
|
|
0
|
2630
|
|
|
2631 (if found
|
|
|
2632 match-dat
|
|
|
2633 nil)))
|
|
|
2634
|
|
|
2635
|
|
|
2636 (defun ada-goto-next-non-ws (&optional limit)
|
|
|
2637 ;; Skips whitespaces, newlines and comments to next non-ws
|
|
|
2638 ;; character. Signals an error if there is no more such character
|
|
|
2639 ;; and limit is nil.
|
|
|
2640 (let ((match-cons nil))
|
|
|
2641 (setq match-cons (ada-search-ignore-string-comment
|
|
|
2642 "[^ \t\n]" nil limit t))
|
|
|
2643 (if match-cons
|
|
|
2644 (goto-char (car match-cons))
|
|
|
2645 (if (not limit)
|
|
|
2646 (error "no more non-ws")
|
|
|
2647 nil))))
|
|
|
2648
|
|
|
2649
|
|
|
2650 (defun ada-goto-stmt-end (&optional limit)
|
|
|
2651 ;; Moves point to the end of the statement that point is in or
|
|
|
2652 ;; before. Returns the new position of point or nil if not found.
|
|
|
2653 (if (ada-search-ignore-string-comment ada-end-stmt-re nil limit)
|
|
|
2654 (point)
|
|
|
2655 nil))
|
|
|
2656
|
|
|
2657
|
|
189
|
2658 (defun ada-goto-next-word (&optional backward)
|
|
|
2659 ;; Moves point to the beginning of the next word of Ada code.
|
|
|
2660 ;; If BACKWARD is non-nil, jump to the beginning of the previous word.
|
|
0
|
2661 ;; Returns the new position of point or nil if not found.
|
|
|
2662 (let ((match-cons nil)
|
|
|
2663 (orgpoint (point)))
|
|
189
|
2664 (if (not backward)
|
|
|
2665 (skip-chars-forward "_a-zA-Z0-9\\."))
|
|
0
|
2666 (if (setq match-cons
|
|
189
|
2667 (ada-search-ignore-string-comment "\\w" backward nil t))
|
|
0
|
2668 ;;
|
|
|
2669 ;; move to the beginning of the word found
|
|
|
2670 ;;
|
|
|
2671 (progn
|
|
189
|
2672 (goto-char (car match-cons))
|
|
0
|
2673 (skip-chars-backward "_a-zA-Z0-9")
|
|
|
2674 (point))
|
|
|
2675 ;;
|
|
|
2676 ;; if not found, restore old position of point
|
|
|
2677 ;;
|
|
|
2678 (progn
|
|
|
2679 (goto-char orgpoint)
|
|
|
2680 'nil))))
|
|
|
2681
|
|
|
2682
|
|
189
|
2683 (defun ada-goto-previous-word ()
|
|
|
2684 ;; Moves point to the beginning of the previous word of Ada code.
|
|
|
2685 ;; Returns the new position of point or nil if not found.
|
|
|
2686 (ada-goto-next-word t))
|
|
|
2687
|
|
|
2688
|
|
0
|
2689 (defun ada-check-matching-start (keyword)
|
|
|
2690 ;; Signals an error if matching block start is not KEYWORD.
|
|
|
2691 ;; Moves point to the matching block start.
|
|
|
2692 (ada-goto-matching-start 0)
|
|
|
2693 (if (not (looking-at (concat "\\<" keyword "\\>")))
|
|
2
|
2694 (error "matching start is not '%s'" keyword)))
|
|
0
|
2695
|
|
|
2696
|
|
|
2697 (defun ada-check-defun-name (defun-name)
|
|
|
2698 ;; Checks if the name of the matching defun really is DEFUN-NAME.
|
|
|
2699 ;; Assumes point to be already positioned by 'ada-goto-matching-start'.
|
|
|
2700 ;; Moves point to the beginning of the declaration.
|
|
|
2701
|
|
|
2702 ;;
|
|
189
|
2703 ;; named block without a `declare'
|
|
0
|
2704 ;;
|
|
189
|
2705 (if (save-excursion
|
|
|
2706 (ada-goto-previous-word)
|
|
|
2707 (looking-at (concat "\\<" defun-name "\\> *:")))
|
|
|
2708 t ; do nothing
|
|
0
|
2709 ;;
|
|
189
|
2710 ;; 'accept' or 'package' ?
|
|
0
|
2711 ;;
|
|
189
|
2712 (if (not (looking-at "\\<\\(accept\\|package\\|task\\|protected\\)\\>"))
|
|
|
2713 (ada-goto-matching-decl-start))
|
|
|
2714 ;;
|
|
|
2715 ;; 'begin' of 'procedure'/'function'/'task' or 'declare'
|
|
|
2716 ;;
|
|
|
2717 (save-excursion
|
|
0
|
2718 ;;
|
|
189
|
2719 ;; a named 'declare'-block ?
|
|
0
|
2720 ;;
|
|
189
|
2721 (if (looking-at "\\<declare\\>")
|
|
|
2722 (ada-goto-stmt-start)
|
|
0
|
2723 ;;
|
|
189
|
2724 ;; no, => 'procedure'/'function'/'task'/'protected'
|
|
0
|
2725 ;;
|
|
189
|
2726 (progn
|
|
|
2727 (forward-word 2)
|
|
|
2728 (backward-word 1)
|
|
|
2729 ;;
|
|
|
2730 ;; skip 'body' 'type'
|
|
|
2731 ;;
|
|
|
2732 (if (looking-at "\\<\\(body\\|type\\)\\>")
|
|
|
2733 (forward-word 1))
|
|
|
2734 (forward-sexp 1)
|
|
|
2735 (backward-sexp 1)))
|
|
|
2736 ;;
|
|
|
2737 ;; should be looking-at the correct name
|
|
|
2738 ;;
|
|
|
2739 (if (not (looking-at (concat "\\<" defun-name "\\>")))
|
|
|
2740 (error "matching defun has different name: %s"
|
|
|
2741 (buffer-substring (point)
|
|
|
2742 (progn (forward-sexp 1) (point))))))))
|
|
0
|
2743
|
|
|
2744
|
|
|
2745 (defun ada-goto-matching-decl-start (&optional noerror nogeneric)
|
|
|
2746 ;; Moves point to the matching declaration start of the current 'begin'.
|
|
|
2747 ;; If NOERROR is non-nil, it only returns nil if no match was found.
|
|
|
2748 (let ((nest-count 1)
|
|
|
2749 (pos nil)
|
|
|
2750 (first t)
|
|
|
2751 (flag nil))
|
|
|
2752 ;;
|
|
|
2753 ;; search backward for interesting keywords
|
|
|
2754 ;;
|
|
|
2755 (while (and
|
|
|
2756 (not (zerop nest-count))
|
|
|
2757 (ada-search-ignore-string-comment
|
|
|
2758 (concat "\\<\\("
|
|
|
2759 "is\\|separate\\|end\\|declare\\|new\\|begin\\|generic"
|
|
|
2760 "\\)\\>") t))
|
|
|
2761 ;;
|
|
|
2762 ;; calculate nest-depth
|
|
|
2763 ;;
|
|
|
2764 (cond
|
|
|
2765 ;;
|
|
|
2766 ((looking-at "end")
|
|
|
2767 (ada-goto-matching-start 1 noerror)
|
|
|
2768 (if (looking-at "begin")
|
|
|
2769 (setq nest-count (1+ nest-count))))
|
|
|
2770 ;;
|
|
|
2771 ((looking-at "declare\\|generic")
|
|
|
2772 (setq nest-count (1- nest-count))
|
|
|
2773 (setq first nil))
|
|
|
2774 ;;
|
|
|
2775 ((looking-at "is")
|
|
2
|
2776 ;; check if it is only a type definition, but not a protected
|
|
189
|
2777 ;; type definition, which should be handled like a procedure.
|
|
|
2778 (if (or (looking-at "is +<>")
|
|
|
2779 (save-excursion
|
|
|
2780 (ada-goto-previous-word)
|
|
|
2781 (skip-chars-backward "a-zA-Z0-9_.'")
|
|
|
2782 (if (save-excursion
|
|
|
2783 (backward-char 1)
|
|
|
2784 (looking-at ")"))
|
|
|
2785 (progn
|
|
|
2786 (forward-char 1)
|
|
|
2787 (backward-sexp 1)
|
|
|
2788 (skip-chars-backward "a-zA-Z0-9_.'")
|
|
|
2789 ))
|
|
|
2790 (ada-goto-previous-word)
|
|
|
2791 (and
|
|
|
2792 (looking-at "\\<type\\>")
|
|
|
2793 (save-match-data
|
|
|
2794 (ada-goto-previous-word)
|
|
|
2795 (not (looking-at "\\<protected\\>"))))
|
|
|
2796 )); end of `or'
|
|
0
|
2797 (goto-char (match-beginning 0))
|
|
|
2798 (progn
|
|
|
2799 (setq nest-count (1- nest-count))
|
|
|
2800 (setq first nil))))
|
|
|
2801
|
|
|
2802 ;;
|
|
|
2803 ((looking-at "new")
|
|
|
2804 (if (save-excursion
|
|
|
2805 (ada-goto-previous-word)
|
|
|
2806 (looking-at "is"))
|
|
|
2807 (goto-char (match-beginning 0))))
|
|
|
2808 ;;
|
|
|
2809 ((and first
|
|
|
2810 (looking-at "begin"))
|
|
|
2811 (setq nest-count 0)
|
|
|
2812 (setq flag t))
|
|
|
2813 ;;
|
|
|
2814 (t
|
|
|
2815 (setq nest-count (1+ nest-count))
|
|
|
2816 (setq first nil)))
|
|
|
2817
|
|
|
2818 ) ;; end of loop
|
|
|
2819
|
|
|
2820 ;; check if declaration-start is really found
|
|
|
2821 (if (not
|
|
|
2822 (and
|
|
|
2823 (zerop nest-count)
|
|
|
2824 (not flag)
|
|
189
|
2825 (if (looking-at "is")
|
|
|
2826 (ada-search-ignore-string-comment ada-subprog-start-re t)
|
|
|
2827 (looking-at "declare\\|generic"))))
|
|
0
|
2828 (if noerror nil
|
|
189
|
2829 (error "no matching proc/func/task/declare/package/protected"))
|
|
0
|
2830 t)))
|
|
|
2831
|
|
|
2832
|
|
|
2833 (defun ada-goto-matching-start (&optional nest-level noerror gotothen)
|
|
|
2834 ;; Moves point to the beginning of a block-start. Which block
|
|
|
2835 ;; depends on the value of NEST-LEVEL, which defaults to zero. If
|
|
|
2836 ;; NOERROR is non-nil, it only returns nil if no matching start was
|
|
|
2837 ;; found. If GOTOTHEN is non-nil, point moves to the 'then'
|
|
|
2838 ;; following 'if'.
|
|
|
2839 (let ((nest-count (if nest-level nest-level 0))
|
|
|
2840 (found nil)
|
|
|
2841 (pos nil))
|
|
|
2842
|
|
|
2843 ;;
|
|
|
2844 ;; search backward for interesting keywords
|
|
|
2845 ;;
|
|
|
2846 (while (and
|
|
|
2847 (not found)
|
|
|
2848 (ada-search-ignore-string-comment
|
|
|
2849 (concat "\\<\\("
|
|
|
2850 "end\\|loop\\|select\\|begin\\|case\\|do\\|"
|
|
|
2851 "if\\|task\\|package\\|record\\|protected\\)\\>")
|
|
|
2852 t))
|
|
|
2853
|
|
|
2854 ;;
|
|
|
2855 ;; calculate nest-depth
|
|
|
2856 ;;
|
|
|
2857 (cond
|
|
|
2858 ;; found block end => increase nest depth
|
|
|
2859 ((looking-at "end")
|
|
|
2860 (setq nest-count (1+ nest-count)))
|
|
|
2861 ;; found loop/select/record/case/if => check if it starts or
|
|
|
2862 ;; ends a block
|
|
|
2863 ((looking-at "loop\\|select\\|record\\|case\\|if")
|
|
|
2864 (setq pos (point))
|
|
|
2865 (save-excursion
|
|
|
2866 ;;
|
|
|
2867 ;; check if keyword follows 'end'
|
|
|
2868 ;;
|
|
|
2869 (ada-goto-previous-word)
|
|
189
|
2870 (if (looking-at "\\<end\\> *[^;]")
|
|
0
|
2871 ;; it ends a block => increase nest depth
|
|
|
2872 (progn
|
|
|
2873 (setq nest-count (1+ nest-count))
|
|
|
2874 (setq pos (point)))
|
|
|
2875 ;; it starts a block => decrease nest depth
|
|
|
2876 (setq nest-count (1- nest-count))))
|
|
|
2877 (goto-char pos))
|
|
|
2878 ;; found package start => check if it really is a block
|
|
|
2879 ((looking-at "package")
|
|
|
2880 (save-excursion
|
|
|
2881 (ada-search-ignore-string-comment "\\<is\\>")
|
|
|
2882 (ada-goto-next-non-ws)
|
|
|
2883 ;; ignore it if it is only a declaration with 'new'
|
|
|
2884 (if (not (looking-at "\\<new\\>"))
|
|
|
2885 (setq nest-count (1- nest-count)))))
|
|
|
2886 ;; found task start => check if it has a body
|
|
|
2887 ((looking-at "task")
|
|
|
2888 (save-excursion
|
|
|
2889 (forward-word 1)
|
|
|
2890 (ada-goto-next-non-ws)
|
|
|
2891 ;; ignore it if it has no body
|
|
|
2892 (if (not (looking-at "\\<body\\>"))
|
|
|
2893 (setq nest-count (1- nest-count)))))
|
|
|
2894 ;; all the other block starts
|
|
|
2895 (t
|
|
|
2896 (setq nest-count (1- nest-count)))) ; end of 'cond'
|
|
|
2897
|
|
|
2898 ;; match is found, if nest-depth is zero
|
|
|
2899 ;;
|
|
|
2900 (setq found (zerop nest-count))) ; end of loop
|
|
|
2901
|
|
|
2902 (if found
|
|
|
2903 ;;
|
|
|
2904 ;; match found => is there anything else to do ?
|
|
|
2905 ;;
|
|
|
2906 (progn
|
|
|
2907 (cond
|
|
|
2908 ;;
|
|
|
2909 ;; found 'if' => skip to 'then', if it's on a separate line
|
|
|
2910 ;; and GOTOTHEN is non-nil
|
|
|
2911 ;;
|
|
|
2912 ((and
|
|
|
2913 gotothen
|
|
|
2914 (looking-at "if")
|
|
|
2915 (save-excursion
|
|
|
2916 (ada-search-ignore-string-comment "\\<then\\>" nil nil)
|
|
|
2917 (back-to-indentation)
|
|
|
2918 (looking-at "\\<then\\>")))
|
|
|
2919 (goto-char (match-beginning 0)))
|
|
|
2920 ;;
|
|
|
2921 ;; found 'do' => skip back to 'accept'
|
|
|
2922 ;;
|
|
|
2923 ((looking-at "do")
|
|
|
2924 (if (not (ada-search-ignore-string-comment "\\<accept\\>" t nil))
|
|
|
2925 (error "missing 'accept' in front of 'do'"))))
|
|
|
2926 (point))
|
|
|
2927
|
|
|
2928 (if noerror
|
|
|
2929 nil
|
|
|
2930 (error "no matching start")))))
|
|
|
2931
|
|
|
2932
|
|
|
2933 (defun ada-goto-matching-end (&optional nest-level noerror)
|
|
|
2934 ;; Moves point to the end of a block. Which block depends on the
|
|
|
2935 ;; value of NEST-LEVEL, which defaults to zero. If NOERROR is
|
|
|
2936 ;; non-nil, it only returns nil if found no matching start.
|
|
|
2937 (let ((nest-count (if nest-level nest-level 0))
|
|
|
2938 (found nil))
|
|
|
2939
|
|
|
2940 ;;
|
|
|
2941 ;; search forward for interesting keywords
|
|
|
2942 ;;
|
|
|
2943 (while (and
|
|
|
2944 (not found)
|
|
|
2945 (ada-search-ignore-string-comment
|
|
|
2946 (concat "\\<\\(end\\|loop\\|select\\|begin\\|case\\|"
|
|
|
2947 "if\\|task\\|package\\|record\\|do\\)\\>")))
|
|
|
2948
|
|
|
2949 ;;
|
|
|
2950 ;; calculate nest-depth
|
|
|
2951 ;;
|
|
|
2952 (backward-word 1)
|
|
|
2953 (cond
|
|
|
2954 ;; found block end => decrease nest depth
|
|
|
2955 ((looking-at "\\<end\\>")
|
|
|
2956 (setq nest-count (1- nest-count))
|
|
|
2957 ;; skip the following keyword
|
|
|
2958 (if (progn
|
|
|
2959 (skip-chars-forward "end")
|
|
|
2960 (ada-goto-next-non-ws)
|
|
|
2961 (looking-at "\\<\\(loop\\|select\\|record\\|case\\|if\\)\\>"))
|
|
|
2962 (forward-word 1)))
|
|
|
2963 ;; found package start => check if it really starts a block
|
|
|
2964 ((looking-at "\\<package\\>")
|
|
|
2965 (ada-search-ignore-string-comment "\\<is\\>")
|
|
|
2966 (ada-goto-next-non-ws)
|
|
|
2967 ;; ignore and skip it if it is only a 'new' package
|
|
|
2968 (if (not (looking-at "\\<new\\>"))
|
|
|
2969 (setq nest-count (1+ nest-count))
|
|
|
2970 (skip-chars-forward "new")))
|
|
|
2971 ;; all the other block starts
|
|
|
2972 (t
|
|
|
2973 (setq nest-count (1+ nest-count))
|
|
|
2974 (forward-word 1))) ; end of 'cond'
|
|
|
2975
|
|
|
2976 ;; match is found, if nest-depth is zero
|
|
|
2977 ;;
|
|
|
2978 (setq found (zerop nest-count))) ; end of loop
|
|
|
2979
|
|
|
2980 (if (not found)
|
|
|
2981 (if noerror
|
|
|
2982 nil
|
|
|
2983 (error "no matching end"))
|
|
|
2984 t)))
|
|
|
2985
|
|
|
2986
|
|
|
2987 (defun ada-forward-sexp-ignore-comment ()
|
|
|
2988 ;; Skips one sexp forward, ignoring comments.
|
|
|
2989 (while (looking-at "[ \t\n]*--")
|
|
|
2990 (skip-chars-forward "[ \t\n]")
|
|
|
2991 (end-of-line))
|
|
|
2992 (forward-sexp 1))
|
|
|
2993
|
|
|
2994
|
|
|
2995 (defun ada-search-ignore-string-comment
|
|
|
2996 (search-re &optional backward limit paramlists)
|
|
|
2997 ;; Regexp-Search for SEARCH-RE, ignoring comments, strings and
|
|
|
2998 ;; parameter lists, if PARAMLISTS is nil. Returns a cons cell of
|
|
|
2999 ;; begin and end of match data or nil, if not found.
|
|
|
3000 (let ((found nil)
|
|
|
3001 (begin nil)
|
|
|
3002 (end nil)
|
|
|
3003 (pos nil)
|
|
|
3004 (search-func
|
|
|
3005 (if backward 're-search-backward
|
|
|
3006 're-search-forward)))
|
|
|
3007
|
|
|
3008 ;;
|
|
|
3009 ;; search until found or end-of-buffer
|
|
|
3010 ;;
|
|
|
3011 (while (and (not found)
|
|
|
3012 (funcall search-func search-re limit 1))
|
|
|
3013 (setq begin (match-beginning 0))
|
|
|
3014 (setq end (match-end 0))
|
|
|
3015
|
|
|
3016 (cond
|
|
|
3017 ;;
|
|
|
3018 ;; found in comment => skip it
|
|
|
3019 ;;
|
|
|
3020 ((ada-in-comment-p)
|
|
|
3021 (if backward
|
|
|
3022 (progn
|
|
|
3023 (re-search-backward "--" nil 1)
|
|
|
3024 (goto-char (match-beginning 0)))
|
|
|
3025 (progn
|
|
|
3026 (forward-line 1)
|
|
|
3027 (beginning-of-line))))
|
|
|
3028 ;;
|
|
|
3029 ;; found in string => skip it
|
|
|
3030 ;;
|
|
|
3031 ((ada-in-string-p)
|
|
|
3032 (if backward
|
|
|
3033 (progn
|
|
|
3034 (re-search-backward "\"" nil 1) ; "\"\\|#" don't treat #
|
|
|
3035 (goto-char (match-beginning 0))))
|
|
|
3036 (re-search-forward "\"" nil 1))
|
|
|
3037 ;;
|
|
|
3038 ;; found character constant => ignore it
|
|
|
3039 ;;
|
|
|
3040 ((save-excursion
|
|
|
3041 (setq pos (- (point) (if backward 1 2)))
|
|
|
3042 (and (char-after pos)
|
|
|
3043 (= (char-after pos) ?')
|
|
|
3044 (= (char-after (+ pos 2)) ?')))
|
|
|
3045 ())
|
|
|
3046 ;;
|
|
|
3047 ;; found a parameter-list but should ignore it => skip it
|
|
|
3048 ;;
|
|
|
3049 ((and (not paramlists)
|
|
|
3050 (ada-in-paramlist-p))
|
|
|
3051 (if backward
|
|
|
3052 (ada-search-ignore-string-comment "(" t nil t)))
|
|
|
3053 ;;
|
|
|
3054 ;; directly in front of a comment => skip it, if searching forward
|
|
|
3055 ;;
|
|
|
3056 ((save-excursion
|
|
|
3057 (goto-char begin)
|
|
|
3058 (looking-at "--"))
|
|
|
3059 (if (not backward)
|
|
|
3060 (progn
|
|
|
3061 (forward-line 1)
|
|
|
3062 (beginning-of-line))))
|
|
|
3063 ;;
|
|
|
3064 ;; found what we were looking for
|
|
|
3065 ;;
|
|
|
3066 (t
|
|
|
3067 (setq found t)))) ; end of loop
|
|
|
3068
|
|
|
3069 (if found
|
|
|
3070 (cons begin end)
|
|
|
3071 nil)))
|
|
|
3072
|
|
|
3073
|
|
|
3074 (defun ada-search-but-not (search-re not-search-re &optional backward limit)
|
|
|
3075 ;; Searches SEARCH-RE, ignoring parts of NOT-SEARCH-RE, strings,
|
|
|
3076 ;; comments and parameter-lists.
|
|
|
3077 (let ((begin nil)
|
|
|
3078 (end nil)
|
|
|
3079 (begin-not nil)
|
|
|
3080 (begin-end nil)
|
|
|
3081 (end-not nil)
|
|
|
3082 (ret-cons nil)
|
|
|
3083 (found nil))
|
|
|
3084
|
|
|
3085 ;;
|
|
|
3086 ;; search until found or end-of-buffer
|
|
|
3087 ;;
|
|
|
3088 (while (and
|
|
|
3089 (not found)
|
|
|
3090 (save-excursion
|
|
|
3091 (setq ret-cons
|
|
|
3092 (ada-search-ignore-string-comment search-re
|
|
|
3093 backward limit))
|
|
|
3094 (if (consp ret-cons)
|
|
|
3095 (progn
|
|
|
3096 (setq begin (car ret-cons))
|
|
|
3097 (setq end (cdr ret-cons))
|
|
|
3098 t)
|
|
|
3099 nil)))
|
|
|
3100
|
|
|
3101 (if (or
|
|
|
3102 ;;
|
|
|
3103 ;; if no NO-SEARCH-RE was found
|
|
|
3104 ;;
|
|
|
3105 (not
|
|
|
3106 (save-excursion
|
|
|
3107 (setq ret-cons
|
|
|
3108 (ada-search-ignore-string-comment not-search-re
|
|
|
3109 backward nil))
|
|
|
3110 (if (consp ret-cons)
|
|
|
3111 (progn
|
|
|
3112 (setq begin-not (car ret-cons))
|
|
|
3113 (setq end-not (cdr ret-cons))
|
|
|
3114 t)
|
|
|
3115 nil)))
|
|
|
3116 ;;
|
|
|
3117 ;; or this NO-SEARCH-RE is not a part of the SEARCH-RE
|
|
|
3118 ;; found before.
|
|
|
3119 ;;
|
|
|
3120 (or
|
|
|
3121 (<= end-not begin)
|
|
|
3122 (>= begin-not end)))
|
|
|
3123
|
|
|
3124 (setq found t)
|
|
|
3125
|
|
|
3126 ;;
|
|
|
3127 ;; not found the correct match => skip this match
|
|
|
3128 ;;
|
|
|
3129 (goto-char (if backward
|
|
|
3130 begin
|
|
|
3131 end)))) ; end of loop
|
|
|
3132
|
|
|
3133 (if found
|
|
|
3134 (progn
|
|
|
3135 (goto-char begin)
|
|
|
3136 (cons begin end))
|
|
|
3137 nil)))
|
|
|
3138
|
|
|
3139
|
|
|
3140 (defun ada-goto-prev-nonblank-line ( &optional ignore-comment)
|
|
|
3141 ;; Moves point to the beginning of previous non-blank line,
|
|
|
3142 ;; ignoring comments if IGNORE-COMMENT is non-nil.
|
|
|
3143 ;; It returns t if a matching line was found.
|
|
|
3144 (let ((notfound t)
|
|
|
3145 (newpoint nil))
|
|
|
3146
|
|
|
3147 (save-excursion
|
|
|
3148 ;;
|
|
|
3149 ;; backward one line, if there is one
|
|
|
3150 ;;
|
|
|
3151 (if (zerop (forward-line -1))
|
|
|
3152 ;;
|
|
|
3153 ;; there is some kind of previous line
|
|
|
3154 ;;
|
|
|
3155 (progn
|
|
|
3156 (beginning-of-line)
|
|
|
3157 (setq newpoint (point))
|
|
|
3158
|
|
|
3159 ;;
|
|
|
3160 ;; search until found or beginning-of-buffer
|
|
|
3161 ;;
|
|
|
3162 (while (and (setq notfound
|
|
|
3163 (or (looking-at "[ \t]*$")
|
|
|
3164 (and (looking-at "[ \t]*--")
|
|
|
3165 ignore-comment)))
|
|
|
3166 (not (ada-in-limit-line-p)))
|
|
|
3167 (forward-line -1)
|
|
|
3168 ;;(beginning-of-line)
|
|
|
3169 (setq newpoint (point))) ; end of loop
|
|
|
3170
|
|
|
3171 )) ; end of if
|
|
|
3172
|
|
|
3173 ) ; end of save-excursion
|
|
|
3174
|
|
|
3175 (if notfound nil
|
|
|
3176 (progn
|
|
|
3177 (goto-char newpoint)
|
|
|
3178 t))))
|
|
|
3179
|
|
|
3180
|
|
|
3181 (defun ada-goto-next-nonblank-line ( &optional ignore-comment)
|
|
|
3182 ;; Moves point to next non-blank line,
|
|
|
3183 ;; ignoring comments if IGNORE-COMMENT is non-nil.
|
|
|
3184 ;; It returns t if a matching line was found.
|
|
|
3185 (let ((notfound t)
|
|
|
3186 (newpoint nil))
|
|
|
3187
|
|
|
3188 (save-excursion
|
|
|
3189 ;;
|
|
|
3190 ;; forward one line
|
|
|
3191 ;;
|
|
|
3192 (if (zerop (forward-line 1))
|
|
|
3193 ;;
|
|
|
3194 ;; there is some kind of previous line
|
|
|
3195 ;;
|
|
|
3196 (progn
|
|
|
3197 (beginning-of-line)
|
|
|
3198 (setq newpoint (point))
|
|
|
3199
|
|
|
3200 ;;
|
|
|
3201 ;; search until found or end-of-buffer
|
|
|
3202 ;;
|
|
|
3203 (while (and (setq notfound
|
|
|
3204 (or (looking-at "[ \t]*$")
|
|
|
3205 (and (looking-at "[ \t]*--")
|
|
|
3206 ignore-comment)))
|
|
|
3207 (not (ada-in-limit-line-p)))
|
|
|
3208 (forward-line 1)
|
|
|
3209 (beginning-of-line)
|
|
|
3210 (setq newpoint (point))) ; end of loop
|
|
|
3211
|
|
|
3212 )) ; end of if
|
|
|
3213
|
|
|
3214 ) ; end of save-excursion
|
|
|
3215
|
|
|
3216 (if notfound nil
|
|
|
3217 (progn
|
|
|
3218 (goto-char newpoint)
|
|
|
3219 t))))
|
|
|
3220
|
|
|
3221
|
|
|
3222 ;; ---- boolean functions for indentation
|
|
|
3223
|
|
|
3224 (defun ada-in-decl-p ()
|
|
|
3225 ;; Returns t if point is inside a declarative part.
|
|
|
3226 ;; Assumes point to be at the end of a statement.
|
|
|
3227 (or
|
|
|
3228 (ada-in-paramlist-p)
|
|
|
3229 (save-excursion
|
|
|
3230 (ada-goto-matching-decl-start t))))
|
|
|
3231
|
|
|
3232
|
|
|
3233 (defun ada-looking-at-semi-or ()
|
|
|
3234 ;; Returns t if looking-at an 'or' following a semicolon.
|
|
|
3235 (save-excursion
|
|
|
3236 (and (looking-at "\\<or\\>")
|
|
|
3237 (progn
|
|
|
3238 (forward-word 1)
|
|
|
3239 (ada-goto-stmt-start)
|
|
|
3240 (looking-at "\\<or\\>")))))
|
|
|
3241
|
|
|
3242
|
|
|
3243 (defun ada-looking-at-semi-private ()
|
|
|
3244 ;; Returns t if looking-at an 'private' following a semicolon.
|
|
|
3245 (save-excursion
|
|
|
3246 (and (looking-at "\\<private\\>")
|
|
|
3247 (progn
|
|
|
3248 (forward-word 1)
|
|
|
3249 (ada-goto-stmt-start)
|
|
|
3250 (looking-at "\\<private\\>")))))
|
|
|
3251
|
|
|
3252
|
|
|
3253 ;;; make a faster??? ada-in-limit-line-p not using count-lines
|
|
|
3254 (defun ada-in-limit-line-p ()
|
|
|
3255 ;; return t if point is in first or last accessible line.
|
|
|
3256 (or (save-excursion (beginning-of-line) (= (point-min) (point)))
|
|
|
3257 (save-excursion (end-of-line) (= (point-max) (point)))))
|
|
|
3258
|
|
|
3259
|
|
|
3260 (defun ada-in-comment-p ()
|
|
|
3261 ;; Returns t if inside a comment.
|
|
2
|
3262 (nth 4 (parse-partial-sexp
|
|
|
3263 (save-excursion (beginning-of-line) (point))
|
|
|
3264 (point))))
|
|
|
3265
|
|
0
|
3266
|
|
|
3267 (defun ada-in-string-p ()
|
|
|
3268 ;; Returns t if point is inside a string
|
|
|
3269 ;; (Taken from pascal-mode.el, modified by MH).
|
|
|
3270 (save-excursion
|
|
|
3271 (and
|
|
|
3272 (nth 3 (parse-partial-sexp
|
|
|
3273 (save-excursion
|
|
|
3274 (beginning-of-line)
|
|
|
3275 (point)) (point)))
|
|
|
3276 ;; check if 'string quote' is only a character constant
|
|
|
3277 (progn
|
|
189
|
3278 (re-search-backward "\"" nil t) ; `#' is not taken as a string delimiter
|
|
0
|
3279 (not (= (char-after (1- (point))) ?'))))))
|
|
|
3280
|
|
|
3281
|
|
|
3282 (defun ada-in-string-or-comment-p ()
|
|
189
|
3283 ;; Returns t if point is inside a string, a comment, or a character constant.
|
|
|
3284 (let ((parse-result (parse-partial-sexp
|
|
|
3285 (save-excursion (beginning-of-line) (point)) (point))))
|
|
|
3286 (or ;; in-comment-p
|
|
|
3287 (nth 4 parse-result)
|
|
|
3288 ;; in-string-p
|
|
|
3289 (and
|
|
|
3290 (nth 3 parse-result)
|
|
|
3291 ;; check if 'string quote' is only a character constant
|
|
|
3292 (progn
|
|
|
3293 (re-search-backward "\"" nil t) ; `#' not regarded a string delimiter
|
|
|
3294 (not (= (char-after (1- (point))) ?'))))
|
|
|
3295 ;; in-char-const-p
|
|
|
3296 (ada-in-char-const-p))))
|
|
0
|
3297
|
|
|
3298
|
|
|
3299 (defun ada-in-paramlist-p ()
|
|
|
3300 ;; Returns t if point is inside a parameter-list
|
|
|
3301 ;; following 'function'/'procedure'/'package'.
|
|
|
3302 (save-excursion
|
|
|
3303 (and
|
|
|
3304 (re-search-backward "(\\|)" nil t)
|
|
|
3305 ;; inside parentheses ?
|
|
|
3306 (looking-at "(")
|
|
|
3307 (backward-word 2)
|
|
2
|
3308 ;; right keyword before parenthesis ?
|
|
0
|
3309 (looking-at (concat "\\<\\("
|
|
|
3310 "procedure\\|function\\|body\\|package\\|"
|
|
|
3311 "task\\|entry\\|accept\\)\\>"))
|
|
|
3312 (re-search-forward ")\\|:" nil t)
|
|
|
3313 ;; at least one ':' inside the parentheses ?
|
|
|
3314 (not (backward-char 1))
|
|
|
3315 (looking-at ":"))))
|
|
|
3316
|
|
|
3317
|
|
|
3318 ;; not really a boolean function ...
|
|
|
3319 (defun ada-in-open-paren-p ()
|
|
|
3320 ;; If point is somewhere behind an open parenthesis not yet closed,
|
|
|
3321 ;; it returns the column # of the first non-ws behind this open
|
|
|
3322 ;; parenthesis, otherwise nil."
|
|
189
|
3323 (let ((start (if (<= (point) ada-search-paren-char-count-limit)
|
|
|
3324 (point-min)
|
|
|
3325 (save-excursion
|
|
|
3326 (goto-char (- (point) ada-search-paren-char-count-limit))
|
|
|
3327 (beginning-of-line)
|
|
|
3328 (point))))
|
|
0
|
3329 parse-result
|
|
|
3330 (col nil))
|
|
|
3331 (setq parse-result (parse-partial-sexp start (point)))
|
|
|
3332 (if (nth 1 parse-result)
|
|
|
3333 (save-excursion
|
|
|
3334 (goto-char (1+ (nth 1 parse-result)))
|
|
|
3335 (if (save-excursion
|
|
|
3336 (re-search-forward "[^ \t]" nil 1)
|
|
|
3337 (backward-char 1)
|
|
|
3338 (and
|
|
|
3339 (not (looking-at "\n"))
|
|
|
3340 (setq col (current-column))))
|
|
|
3341 col
|
|
|
3342 (current-column)))
|
|
|
3343 nil)))
|
|
|
3344
|
|
|
3345
|
|
|
3346
|
|
|
3347 ;;;----------------------;;;
|
|
|
3348 ;;; Behaviour Of TAB Key ;;;
|
|
|
3349 ;;;----------------------;;;
|
|
|
3350
|
|
|
3351 (defun ada-tab ()
|
|
|
3352 "Do indenting or tabbing according to `ada-tab-policy'."
|
|
|
3353 (interactive)
|
|
|
3354 (cond ((eq ada-tab-policy 'indent-and-tab) (error "not implemented"))
|
|
|
3355 ;; ada-indent-and-tab
|
|
|
3356 ((eq ada-tab-policy 'indent-rigidly) (ada-tab-hard))
|
|
|
3357 ((eq ada-tab-policy 'indent-auto) (ada-indent-current))
|
|
|
3358 ((eq ada-tab-policy 'gei) (ada-tab-gei))
|
|
|
3359 ((eq ada-tab-policy 'indent-af) (af-indent-line)) ; GEB
|
|
|
3360 ((eq ada-tab-policy 'always-tab) (error "not implemented"))
|
|
|
3361 ))
|
|
|
3362
|
|
|
3363
|
|
|
3364 (defun ada-untab (arg)
|
|
|
3365 "Delete leading indenting according to `ada-tab-policy'."
|
|
|
3366 (interactive "P")
|
|
|
3367 (cond ((eq ada-tab-policy 'indent-rigidly) (ada-untab-hard))
|
|
|
3368 ((eq ada-tab-policy 'indent-af) (backward-delete-char-untabify ; GEB
|
|
|
3369 (prefix-numeric-value arg) ; GEB
|
|
|
3370 arg)) ; GEB
|
|
|
3371 ((eq ada-tab-policy 'indent-auto) (error "not implemented"))
|
|
|
3372 ((eq ada-tab-policy 'always-tab) (error "not implemented"))
|
|
|
3373 ))
|
|
|
3374
|
|
|
3375
|
|
|
3376 (defun ada-indent-current-function ()
|
|
189
|
3377 "Ada mode version of the indent-line-function."
|
|
0
|
3378 (interactive "*")
|
|
|
3379 (let ((starting-point (point-marker)))
|
|
|
3380 (ada-beginning-of-line)
|
|
|
3381 (ada-tab)
|
|
|
3382 (if (< (point) starting-point)
|
|
|
3383 (goto-char starting-point))
|
|
|
3384 (set-marker starting-point nil)
|
|
|
3385 ))
|
|
|
3386
|
|
|
3387
|
|
|
3388 (defun ada-tab-hard ()
|
|
|
3389 "Indent current line to next tab stop."
|
|
|
3390 (interactive)
|
|
|
3391 (save-excursion
|
|
|
3392 (beginning-of-line)
|
|
|
3393 (insert-char ? ada-indent))
|
|
|
3394 (if (save-excursion (= (point) (progn (beginning-of-line) (point))))
|
|
|
3395 (forward-char ada-indent)))
|
|
|
3396
|
|
|
3397
|
|
|
3398 (defun ada-untab-hard ()
|
|
|
3399 "indent current line to previous tab stop."
|
|
|
3400 (interactive)
|
|
|
3401 (let ((bol (save-excursion (progn (beginning-of-line) (point))))
|
|
|
3402 (eol (save-excursion (progn (end-of-line) (point)))))
|
|
|
3403 (indent-rigidly bol eol (- 0 ada-indent))))
|
|
|
3404
|
|
|
3405
|
|
|
3406
|
|
|
3407 ;;;---------------;;;
|
|
|
3408 ;;; Miscellaneous ;;;
|
|
|
3409 ;;;---------------;;;
|
|
|
3410
|
|
|
3411 (defun ada-remove-trailing-spaces ()
|
|
|
3412 "remove trailing spaces in the whole buffer."
|
|
|
3413 (interactive)
|
|
2
|
3414 (save-match-data
|
|
|
3415 (save-excursion
|
|
|
3416 (save-restriction
|
|
189
|
3417 (widen)
|
|
|
3418 (goto-char (point-min))
|
|
|
3419 (while (re-search-forward "[ \t]+$" (point-max) t)
|
|
|
3420 (replace-match "" nil nil))))))
|
|
0
|
3421
|
|
|
3422
|
|
|
3423 (defun ada-untabify-buffer ()
|
|
|
3424 ;; change all tabs to spaces
|
|
|
3425 (save-excursion
|
|
189
|
3426 (untabify (point-min) (point-max))
|
|
|
3427 nil))
|
|
0
|
3428
|
|
|
3429
|
|
|
3430 (defun ada-uncomment-region (beg end)
|
|
2
|
3431 "delete `comment-start' at the beginning of a line in the region."
|
|
0
|
3432 (interactive "r")
|
|
|
3433 (comment-region beg end -1))
|
|
|
3434
|
|
|
3435
|
|
|
3436 ;; define a function to support find-file.el if loaded
|
|
|
3437 (defun ada-ff-other-window ()
|
|
2
|
3438 "Find other file in other window using `ff-find-other-file'."
|
|
0
|
3439 (interactive)
|
|
|
3440 (and (fboundp 'ff-find-other-file)
|
|
|
3441 (ff-find-other-file t)))
|
|
|
3442
|
|
189
|
3443 ;; inspired by Laurent.GUERBY@enst-bretagne.fr
|
|
|
3444 (defun ada-gnat-style ()
|
|
|
3445 "Clean up comments, `(' and `,' for GNAT style checking switch."
|
|
|
3446 (interactive)
|
|
|
3447 (save-excursion
|
|
|
3448 (goto-char (point-min))
|
|
|
3449 (while (re-search-forward "-- ?\\([^ -]\\)" nil t)
|
|
|
3450 (replace-match "-- \\1"))
|
|
|
3451 (goto-char (point-min))
|
|
|
3452 (while (re-search-forward "\\>(" nil t)
|
|
|
3453 (replace-match " ("))
|
|
|
3454 (goto-char (point-min))
|
|
|
3455 (while (re-search-forward ",\\<" nil t)
|
|
|
3456 (replace-match ", "))
|
|
|
3457 ))
|
|
|
3458
|
|
|
3459
|
|
0
|
3460
|
|
|
3461 ;;;-------------------------------;;;
|
|
|
3462 ;;; Moving To Procedures/Packages ;;;
|
|
|
3463 ;;;-------------------------------;;;
|
|
|
3464
|
|
|
3465 (defun ada-next-procedure ()
|
|
|
3466 "Moves point to next procedure."
|
|
|
3467 (interactive)
|
|
|
3468 (end-of-line)
|
|
|
3469 (if (re-search-forward ada-procedure-start-regexp nil t)
|
|
|
3470 (goto-char (match-beginning 1))
|
|
|
3471 (error "No more functions/procedures/tasks")))
|
|
|
3472
|
|
|
3473 (defun ada-previous-procedure ()
|
|
|
3474 "Moves point to previous procedure."
|
|
|
3475 (interactive)
|
|
|
3476 (beginning-of-line)
|
|
|
3477 (if (re-search-backward ada-procedure-start-regexp nil t)
|
|
|
3478 (goto-char (match-beginning 1))
|
|
|
3479 (error "No more functions/procedures/tasks")))
|
|
|
3480
|
|
|
3481 (defun ada-next-package ()
|
|
|
3482 "Moves point to next package."
|
|
|
3483 (interactive)
|
|
|
3484 (end-of-line)
|
|
|
3485 (if (re-search-forward ada-package-start-regexp nil t)
|
|
|
3486 (goto-char (match-beginning 1))
|
|
|
3487 (error "No more packages")))
|
|
|
3488
|
|
|
3489 (defun ada-previous-package ()
|
|
|
3490 "Moves point to previous package."
|
|
|
3491 (interactive)
|
|
|
3492 (beginning-of-line)
|
|
|
3493 (if (re-search-backward ada-package-start-regexp nil t)
|
|
|
3494 (goto-char (match-beginning 1))
|
|
|
3495 (error "No more packages")))
|
|
|
3496
|
|
|
3497
|
|
|
3498 ;;;-----------------------
|
|
|
3499 ;;; define keymap for Ada
|
|
|
3500 ;;;-----------------------
|
|
|
3501
|
|
|
3502 (if (not ada-mode-map)
|
|
|
3503 (progn
|
|
|
3504 (setq ada-mode-map (make-sparse-keymap))
|
|
|
3505
|
|
|
3506 ;; Indentation and Formatting
|
|
|
3507 (define-key ada-mode-map "\C-j" 'ada-indent-newline-indent)
|
|
|
3508 (define-key ada-mode-map "\t" 'ada-tab)
|
|
|
3509 (define-key ada-mode-map "\C-c\C-l" 'ada-indent-region)
|
|
|
3510 (if (ada-xemacs)
|
|
|
3511 (define-key ada-mode-map '(shift tab) 'ada-untab)
|
|
|
3512 (define-key ada-mode-map [S-tab] 'ada-untab))
|
|
|
3513 (define-key ada-mode-map "\C-c\C-f" 'ada-format-paramlist)
|
|
|
3514 (define-key ada-mode-map "\C-c\C-p" 'ada-call-pretty-printer)
|
|
|
3515 ;;; We don't want to make meta-characters case-specific.
|
|
|
3516 ;;; (define-key ada-mode-map "\M-Q" 'ada-fill-comment-paragraph-justify)
|
|
|
3517 (define-key ada-mode-map "\M-\C-q" 'ada-fill-comment-paragraph-postfix)
|
|
|
3518
|
|
|
3519 ;; Movement
|
|
|
3520 ;;; It isn't good to redefine these. What should be done instead? -- rms.
|
|
|
3521 ;;; (define-key ada-mode-map "\M-e" 'ada-next-package)
|
|
|
3522 ;;; (define-key ada-mode-map "\M-a" 'ada-previous-package)
|
|
|
3523 (define-key ada-mode-map "\M-\C-e" 'ada-next-procedure)
|
|
|
3524 (define-key ada-mode-map "\M-\C-a" 'ada-previous-procedure)
|
|
|
3525 (define-key ada-mode-map "\C-c\C-a" 'ada-move-to-start)
|
|
|
3526 (define-key ada-mode-map "\C-c\C-e" 'ada-move-to-end)
|
|
|
3527
|
|
|
3528 ;; Compilation
|
|
|
3529 (define-key ada-mode-map "\C-c\C-c" 'compile)
|
|
189
|
3530 (define-key ada-mode-map "\C-c\C-v" 'ada-check-syntax)
|
|
|
3531 (define-key ada-mode-map "\C-c\C-m" 'ada-make-local)
|
|
0
|
3532
|
|
|
3533 ;; Casing
|
|
|
3534 (define-key ada-mode-map "\C-c\C-r" 'ada-adjust-case-region)
|
|
|
3535 (define-key ada-mode-map "\C-c\C-b" 'ada-adjust-case-buffer)
|
|
|
3536
|
|
189
|
3537 (define-key ada-mode-map "\177" 'backward-delete-char-untabify)
|
|
|
3538
|
|
0
|
3539 ;; Use predefined function of emacs19 for comments (RE)
|
|
|
3540 (define-key ada-mode-map "\C-c;" 'comment-region)
|
|
|
3541 (define-key ada-mode-map "\C-c:" 'ada-uncomment-region)
|
|
|
3542
|
|
|
3543 ;; Change basic functionality
|
|
|
3544
|
|
189
|
3545 ;; `substitute-key-definition' is not defined equally in Emacs
|
|
0
|
3546 ;; and XEmacs, you cannot put in an optional 4th parameter in
|
|
|
3547 ;; XEmacs. I don't think it's necessary, so I leave it out for
|
|
189
|
3548 ;; Emacs as well. If you encounter any problems with the
|
|
0
|
3549 ;; following three functions, please tell me. RE
|
|
|
3550 (mapcar (function (lambda (pair)
|
|
|
3551 (substitute-key-definition (car pair) (cdr pair)
|
|
|
3552 ada-mode-map)))
|
|
|
3553 '((beginning-of-line . ada-beginning-of-line)
|
|
|
3554 (end-of-line . ada-end-of-line)
|
|
|
3555 (forward-to-indentation . ada-forward-to-indentation)
|
|
|
3556 ))
|
|
189
|
3557 ;; else Emacs
|
|
0
|
3558 ;;(mapcar (lambda (pair)
|
|
|
3559 ;; (substitute-key-definition (car pair) (cdr pair)
|
|
|
3560 ;; ada-mode-map global-map))
|
|
|
3561
|
|
|
3562 ))
|
|
|
3563
|
|
|
3564
|
|
|
3565 ;;;-------------------
|
|
|
3566 ;;; define menu 'Ada'
|
|
|
3567 ;;;-------------------
|
|
|
3568
|
|
|
3569 (require 'easymenu)
|
|
|
3570
|
|
|
3571 (defun ada-add-ada-menu ()
|
|
189
|
3572 "Adds the menu 'Ada' to the menu bar in Ada mode."
|
|
0
|
3573 (easy-menu-define ada-mode-menu ada-mode-map "Menu keymap for Ada mode."
|
|
|
3574 '("Ada"
|
|
|
3575 ["Next Package" ada-next-package t]
|
|
|
3576 ["Previous Package" ada-previous-package t]
|
|
|
3577 ["Next Procedure" ada-next-procedure t]
|
|
|
3578 ["Previous Procedure" ada-previous-procedure t]
|
|
|
3579 ["Goto Start" ada-move-to-start t]
|
|
|
3580 ["Goto End" ada-move-to-end t]
|
|
|
3581 ["------------------" nil nil]
|
|
|
3582 ["Indent Current Line (TAB)"
|
|
|
3583 ada-indent-current-function t]
|
|
|
3584 ["Indent Lines in Region" ada-indent-region t]
|
|
|
3585 ["Format Parameter List" ada-format-paramlist t]
|
|
|
3586 ["Pretty Print Buffer" ada-call-pretty-printer t]
|
|
|
3587 ["------------" nil nil]
|
|
|
3588 ["Fill Comment Paragraph"
|
|
|
3589 ada-fill-comment-paragraph t]
|
|
|
3590 ["Justify Comment Paragraph"
|
|
|
3591 ada-fill-comment-paragraph-justify t]
|
|
|
3592 ["Postfix Comment Paragraph"
|
|
|
3593 ada-fill-comment-paragraph-postfix t]
|
|
|
3594 ["------------" nil nil]
|
|
|
3595 ["Adjust Case Region" ada-adjust-case-region t]
|
|
|
3596 ["Adjust Case Buffer" ada-adjust-case-buffer t]
|
|
|
3597 ["----------" nil nil]
|
|
|
3598 ["Comment Region" comment-region t]
|
|
|
3599 ["Uncomment Region" ada-uncomment-region t]
|
|
|
3600 ["----------------" nil nil]
|
|
189
|
3601 ["Global Make" compile (fboundp 'compile)]
|
|
|
3602 ["Local Make" ada-make-local t]
|
|
|
3603 ["Check Syntax" ada-check-syntax t]
|
|
0
|
3604 ["Next Error" next-error (fboundp 'next-error)]
|
|
|
3605 ["---------------" nil nil]
|
|
|
3606 ["Index" imenu (fboundp 'imenu)]
|
|
|
3607 ["--------------" nil nil]
|
|
|
3608 ["Other File Other Window" ada-ff-other-window
|
|
|
3609 (fboundp 'ff-find-other-file)]
|
|
|
3610 ["Other File" ff-find-other-file
|
|
|
3611 (fboundp 'ff-find-other-file)]))
|
|
|
3612 (if (ada-xemacs) (progn
|
|
|
3613 (easy-menu-add ada-mode-menu)
|
|
189
|
3614 (setq mode-popup-menu (cons "Ada mode" ada-mode-menu)))))
|
|
0
|
3615
|
|
|
3616
|
|
|
3617
|
|
|
3618 ;;;-------------------------------
|
|
|
3619 ;;; Define Some Support Functions
|
|
|
3620 ;;;-------------------------------
|
|
|
3621
|
|
|
3622 (defun ada-beginning-of-line (&optional arg)
|
|
|
3623 (interactive "P")
|
|
|
3624 (cond
|
|
|
3625 ((eq ada-tab-policy 'indent-af) (af-beginning-of-line arg))
|
|
|
3626 (t (beginning-of-line arg))
|
|
|
3627 ))
|
|
|
3628
|
|
|
3629 (defun ada-end-of-line (&optional arg)
|
|
|
3630 (interactive "P")
|
|
|
3631 (cond
|
|
|
3632 ((eq ada-tab-policy 'indent-af) (af-end-of-line arg))
|
|
|
3633 (t (end-of-line arg))
|
|
|
3634 ))
|
|
|
3635
|
|
|
3636 (defun ada-current-column ()
|
|
|
3637 (cond
|
|
|
3638 ((eq ada-tab-policy 'indent-af) (af-current-column))
|
|
|
3639 (t (current-column))
|
|
|
3640 ))
|
|
|
3641
|
|
|
3642 (defun ada-forward-to-indentation (&optional arg)
|
|
|
3643 (interactive "P")
|
|
|
3644 (cond
|
|
|
3645 ((eq ada-tab-policy 'indent-af) (af-forward-to-indentation arg))
|
|
|
3646 (t (forward-to-indentation arg))
|
|
|
3647 ))
|
|
|
3648
|
|
|
3649 ;;;---------------------------------------------------
|
|
189
|
3650 ;;; support for find-file.el
|
|
0
|
3651 ;;;---------------------------------------------------
|
|
|
3652
|
|
|
3653
|
|
|
3654 ;;;###autoload
|
|
|
3655 (defun ada-make-filename-from-adaname (adaname)
|
|
2
|
3656 "Determine the filename of a package/procedure from its own Ada name."
|
|
189
|
3657 ;; this is done simply by calling `gnatkr', when we work with GNAT. It
|
|
0
|
3658 ;; must be a more complex function in other compiler environments.
|
|
|
3659 (interactive "s")
|
|
|
3660 (let (krunch-buf)
|
|
|
3661 (setq krunch-buf (generate-new-buffer "*gkrunch*"))
|
|
|
3662 (save-excursion
|
|
|
3663 (set-buffer krunch-buf)
|
|
189
|
3664 ;; send adaname to external process `gnatkr'.
|
|
|
3665 (call-process "gnatkr" nil krunch-buf nil
|
|
0
|
3666 adaname ada-krunch-args)
|
|
|
3667 ;; fetch output of that process
|
|
|
3668 (setq adaname (buffer-substring
|
|
|
3669 (point-min)
|
|
|
3670 (progn
|
|
|
3671 (goto-char (point-min))
|
|
|
3672 (end-of-line)
|
|
|
3673 (point))))
|
|
|
3674 (kill-buffer krunch-buf)))
|
|
|
3675 (setq adaname adaname) ;; can I avoid this statement?
|
|
|
3676 )
|
|
|
3677
|
|
|
3678
|
|
|
3679 ;;; functions for placing the cursor on the corresponding subprogram
|
|
|
3680 (defun ada-which-function-are-we-in ()
|
|
2
|
3681 "Determine whether we are on a function definition/declaration.
|
|
|
3682 If that is the case remember the name of that function."
|
|
0
|
3683
|
|
|
3684 (setq ff-function-name nil)
|
|
|
3685
|
|
|
3686 (save-excursion
|
|
|
3687 (if (re-search-backward ada-procedure-start-regexp nil t)
|
|
|
3688 (setq ff-function-name (buffer-substring (match-beginning 0)
|
|
|
3689 (match-end 0)))
|
|
|
3690 ; we didn't find a procedure start, perhaps there is a package
|
|
|
3691 (if (re-search-backward ada-package-start-regexp nil t)
|
|
|
3692 (setq ff-function-name (buffer-substring (match-beginning 0)
|
|
|
3693 (match-end 0)))
|
|
|
3694 ))))
|
|
|
3695
|
|
|
3696
|
|
|
3697 ;;;---------------------------------------------------
|
|
|
3698 ;;; support for font-lock
|
|
|
3699 ;;;---------------------------------------------------
|
|
|
3700
|
|
189
|
3701 ;; Strings are a real pain in Ada because a single quote character is
|
|
|
3702 ;; overloaded as a string quote and type/instance delimiter. By default, a
|
|
|
3703 ;; single quote is given punctuation syntax in `ada-mode-syntax-table'.
|
|
|
3704 ;; So, for Font Lock mode purposes, we mark single quotes as having string
|
|
|
3705 ;; syntax when the gods that created Ada determine them to be. sm.
|
|
|
3706
|
|
|
3707 (defconst ada-font-lock-syntactic-keywords
|
|
|
3708 ;; Mark single quotes as having string quote syntax in 'c' instances.
|
|
|
3709 '(("\\(\'\\).\\(\'\\)" (1 (7 . ?\')) (2 (7 . ?\')))))
|
|
0
|
3710
|
|
|
3711 (defconst ada-font-lock-keywords-1
|
|
|
3712 (list
|
|
|
3713 ;;
|
|
189
|
3714 ;; handle "type T is access function return S;"
|
|
|
3715 ;;
|
|
|
3716 (list "\\<\\(function[ \t]+return\\)\\>" '(1 font-lock-keyword-face) )
|
|
|
3717 ;;
|
|
0
|
3718 ;; accept, entry, function, package (body), protected (body|type),
|
|
|
3719 ;; pragma, procedure, task (body) plus name.
|
|
|
3720 (list (concat
|
|
|
3721 "\\<\\("
|
|
|
3722 "accept\\|"
|
|
|
3723 "entry\\|"
|
|
189
|
3724 "function\\|"
|
|
|
3725 "package[ \t]+body\\|"
|
|
|
3726 "package\\|"
|
|
|
3727 "pragma\\|"
|
|
|
3728 "procedure\\|"
|
|
|
3729 "protected[ \t]+body\\|"
|
|
|
3730 "protected[ \t]+type\\|"
|
|
|
3731 "protected\\|"
|
|
0
|
3732 ;; "p\\(\\(ackage\\|rotected\\)\\(\\|[ \t]+\\(body\\|type\\)\\)\
|
|
|
3733 ;;\\|r\\(agma\\|ocedure\\)\\)\\|"
|
|
|
3734 "task[ \t]+body\\|"
|
|
189
|
3735 "task[ \t]+type\\|"
|
|
|
3736 "task"
|
|
0
|
3737 ;; "task\\(\\|[ \t]+body\\)"
|
|
|
3738 "\\)\\>[ \t]*"
|
|
|
3739 "\\(\\sw+\\(\\.\\sw*\\)*\\)?")
|
|
|
3740 '(1 font-lock-keyword-face) '(2 font-lock-function-name-face nil t)))
|
|
2
|
3741 "Subdued level highlighting for Ada mode.")
|
|
0
|
3742
|
|
|
3743 (defconst ada-font-lock-keywords-2
|
|
|
3744 (append ada-font-lock-keywords-1
|
|
|
3745 (list
|
|
|
3746 ;;
|
|
|
3747 ;; Main keywords, except those treated specially below.
|
|
|
3748 (concat "\\<\\("
|
|
|
3749 ; ("abort" "abs" "abstract" "accept" "access" "aliased" "all"
|
|
|
3750 ; "and" "array" "at" "begin" "case" "declare" "delay" "delta"
|
|
|
3751 ; "digits" "do" "else" "elsif" "entry" "exception" "exit" "for"
|
|
|
3752 ; "generic" "if" "in" "is" "limited" "loop" "mod" "not"
|
|
|
3753 ; "null" "or" "others" "private" "protected"
|
|
|
3754 ; "range" "record" "rem" "renames" "requeue" "return" "reverse"
|
|
|
3755 ; "select" "separate" "tagged" "task" "terminate" "then" "until"
|
|
|
3756 ; "while" "xor")
|
|
|
3757 "a\\(b\\(ort\\|s\\(\\|tract\\)\\)\\|cce\\(pt\\|ss\\)\\|"
|
|
|
3758 "l\\(iased\\|l\\)\\|nd\\|rray\\|t\\)\\|begin\\|case\\|"
|
|
|
3759 "d\\(e\\(clare\\|l\\(ay\\|ta\\)\\)\\|igits\\|o\\)\\|"
|
|
|
3760 "e\\(ls\\(e\\|if\\)\\|ntry\\|x\\(ception\\|it\\)\\)\\|for\\|"
|
|
|
3761 "generic\\|i[fns]\\|l\\(imited\\|oop\\)\\|mod\\|n\\(ot\\|ull\\)\\|"
|
|
|
3762 "o\\(r\\|thers\\|ut\\)\\|pr\\(ivate\\|otected\\)\\|"
|
|
189
|
3763 "r\\(a\\(ise\\|nge\\)\\|e\\(cord\\|m\\|names\\|queue\\|turn\\|verse\\)\\)\\|"
|
|
0
|
3764 "se\\(lect\\|parate\\)\\|"
|
|
|
3765 "t\\(agged\\|erminate\\|hen\\)\\|until\\|" ; task removed
|
|
|
3766 "wh\\(ile\\|en\\)\\|xor" ; "when" added
|
|
|
3767 "\\)\\>")
|
|
|
3768 ;;
|
|
|
3769 ;; Anything following end and not already fontified is a body name.
|
|
189
|
3770 '("\\<\\(end\\)\\>\\([ \t]+\\)?\\([a-zA-Z0-9_\\.]+\\)?"
|
|
|
3771 (1 font-lock-keyword-face) (3 font-lock-function-name-face nil t))
|
|
0
|
3772 ;;
|
|
|
3773 ;; Variable name plus optional keywords followed by a type name. Slow.
|
|
|
3774 ; (list (concat "\\<\\(\\sw+\\)\\>[ \t]*:?[ \t]*"
|
|
|
3775 ; "\\(access\\|constant\\|in\\|in[ \t]+out\\|out\\)?[ \t]*"
|
|
|
3776 ; "\\(\\sw+\\)?")
|
|
|
3777 ; '(1 font-lock-variable-name-face)
|
|
|
3778 ; '(2 font-lock-keyword-face nil t) '(3 font-lock-type-face nil t))
|
|
|
3779 ;;
|
|
|
3780 ;; Optional keywords followed by a type name.
|
|
|
3781 (list (concat ; ":[ \t]*"
|
|
189
|
3782 "\\<\\(access\\|constant\\|in[ \t]+out\\|in\\|out\\)\\>"
|
|
0
|
3783 "[ \t]*"
|
|
|
3784 "\\(\\sw+\\)?")
|
|
|
3785 '(1 font-lock-keyword-face nil t) '(2 font-lock-type-face nil t))
|
|
|
3786 ;;
|
|
|
3787 ;; Keywords followed by a type or function name.
|
|
|
3788 (list (concat "\\<\\("
|
|
|
3789 "new\\|of\\|subtype\\|type"
|
|
|
3790 "\\)\\>[ \t]*\\(\\sw+\\)?[ \t]*\\((\\)?")
|
|
|
3791 '(1 font-lock-keyword-face)
|
|
|
3792 '(2 (if (match-beginning 4)
|
|
2
|
3793 font-lock-function-name-face
|
|
|
3794 font-lock-type-face) nil t))
|
|
0
|
3795 ;;
|
|
|
3796 ;; Keywords followed by a (comma separated list of) reference.
|
|
|
3797 (list (concat "\\<\\(goto\\|raise\\|use\\|with\\)\\>" ; "when" removed
|
|
|
3798 ; "[ \t]*\\(\\sw+\\(\\.\\sw*\\)*\\)?") ; RE
|
|
|
3799 "[ \t]*\\([a-zA-Z0-9_\\.\\|, ]+\\)\\W")
|
|
|
3800 '(1 font-lock-keyword-face) '(2 font-lock-reference-face nil t))
|
|
|
3801 ;;
|
|
|
3802 ;; Goto tags.
|
|
|
3803 '("<<\\(\\sw+\\)>>" 1 font-lock-reference-face)
|
|
|
3804 ))
|
|
2
|
3805 "Gaudy level highlighting for Ada mode.")
|
|
|
3806
|
|
189
|
3807 (defvar ada-font-lock-keywords ada-font-lock-keywords-1
|
|
|
3808 "Default expressions to highlight in Ada mode.")
|
|
|
3809
|
|
|
3810
|
|
|
3811 ;; set font-lock properties for XEmacs
|
|
|
3812 (if (ada-xemacs)
|
|
|
3813 (put 'ada-mode 'font-lock-defaults
|
|
|
3814 '(ada-font-lock-keywords
|
|
|
3815 nil t ((?\_ . "w")(?\. . "w")) beginning-of-line)))
|
|
0
|
3816
|
|
|
3817 ;;;
|
|
189
|
3818 ;;; support for outline
|
|
|
3819 ;;;
|
|
|
3820
|
|
|
3821 ;; used by outline-minor-mode
|
|
|
3822 (defun ada-outline-level ()
|
|
|
3823 (save-excursion
|
|
|
3824 (skip-chars-forward "\t ")
|
|
|
3825 (current-column)))
|
|
|
3826
|
|
|
3827 ;;;
|
|
|
3828 ;;; generate body
|
|
0
|
3829 ;;;
|
|
|
3830 (defun ada-gen-comment-until-proc ()
|
|
|
3831 ;; comment until spec of a procedure or a function.
|
|
|
3832 (forward-line 1)
|
|
|
3833 (set-mark-command (point))
|
|
|
3834 (if (re-search-forward ada-procedure-start-regexp nil t)
|
|
|
3835 (progn (goto-char (match-beginning 1))
|
|
|
3836 (comment-region (mark) (point)))
|
|
|
3837 (error "No more functions/procedures")))
|
|
|
3838
|
|
|
3839
|
|
|
3840 (defun ada-gen-treat-proc (match)
|
|
|
3841 ;; make dummy body of a procedure/function specification.
|
|
|
3842 ;; MATCH is a cons cell containing the start and end location of the
|
|
|
3843 ;; last search for ada-procedure-start-regexp.
|
|
|
3844 (goto-char (car match))
|
|
2
|
3845 (let (proc-found func-found procname functype)
|
|
0
|
3846 (cond
|
|
|
3847 ((or (setq proc-found (looking-at "^[ \t]*procedure"))
|
|
|
3848 (setq func-found (looking-at "^[ \t]*function")))
|
|
|
3849 ;; treat it as a proc/func
|
|
|
3850 (forward-word 2)
|
|
|
3851 (forward-word -1)
|
|
|
3852 (setq procname (buffer-substring (point) (cdr match))) ; store proc name
|
|
|
3853
|
|
|
3854 ;; goto end of procname
|
|
|
3855 (goto-char (cdr match))
|
|
|
3856
|
|
|
3857 ;; skip over parameterlist
|
|
|
3858 (forward-sexp)
|
|
|
3859 ;; if function, skip over 'return' and result type.
|
|
|
3860 (if func-found
|
|
|
3861 (progn
|
|
|
3862 (forward-word 1)
|
|
|
3863 (skip-chars-forward " \t\n")
|
|
|
3864 (setq functype (buffer-substring (point)
|
|
|
3865 (progn
|
|
|
3866 (skip-chars-forward
|
|
|
3867 "a-zA-Z0-9_\.")
|
|
|
3868 (point))))))
|
|
|
3869 ;; look for next non WS
|
|
|
3870 (cond
|
|
|
3871 ((looking-at "[ \t]*;")
|
|
|
3872 (delete-region (match-beginning 0) (match-end 0)) ;; delete the ';'
|
|
|
3873 (ada-indent-newline-indent)
|
|
|
3874 (insert " is")
|
|
|
3875 (ada-indent-newline-indent)
|
|
|
3876 (if func-found
|
|
|
3877 (progn
|
|
|
3878 (insert "Result : ")
|
|
|
3879 (insert functype)
|
|
|
3880 (insert ";")
|
|
|
3881 (ada-indent-newline-indent)))
|
|
|
3882 (insert "begin -- ")
|
|
|
3883 (insert procname)
|
|
|
3884 (ada-indent-newline-indent)
|
|
|
3885 (insert "null;")
|
|
|
3886 (ada-indent-newline-indent)
|
|
|
3887 (if func-found
|
|
|
3888 (progn
|
|
|
3889 (insert "return Result;")
|
|
|
3890 (ada-indent-newline-indent)))
|
|
|
3891 (insert "end ")
|
|
|
3892 (insert procname)
|
|
|
3893 (insert ";")
|
|
|
3894 (ada-indent-newline-indent)
|
|
|
3895 )
|
|
|
3896 ;; else
|
|
|
3897 ((looking-at "[ \t\n]*is")
|
|
|
3898 ;; do nothing
|
|
|
3899 )
|
|
|
3900 ((looking-at "[ \t\n]*rename")
|
|
|
3901 ;; do nothing
|
|
|
3902 )
|
|
|
3903 (t
|
|
|
3904 (message "unknown syntax")))
|
|
|
3905 ))))
|
|
|
3906
|
|
|
3907
|
|
|
3908 (defun ada-make-body ()
|
|
|
3909 "Create an Ada package body in the current buffer.
|
|
|
3910 The potential old buffer contents is deleted first, then we copy the
|
|
|
3911 spec buffer in here and modify it to make it a body.
|
|
|
3912
|
|
|
3913 This function typically is to be hooked into `ff-file-created-hooks'."
|
|
|
3914 (interactive)
|
|
|
3915 (delete-region (point-min) (point-max))
|
|
|
3916 (insert-buffer (car (cdr (buffer-list))))
|
|
|
3917 (ada-mode)
|
|
|
3918
|
|
|
3919 (let (found)
|
|
|
3920 (if (setq found
|
|
|
3921 (ada-search-ignore-string-comment ada-package-start-regexp))
|
|
|
3922 (progn (goto-char (cdr found))
|
|
|
3923 (insert " body")
|
|
|
3924 ;; (forward-line -1)
|
|
|
3925 ;;(comment-region (point-min) (point))
|
|
|
3926 )
|
|
|
3927 (error "No package"))
|
|
|
3928
|
|
|
3929 ;; (comment-until-proc)
|
|
|
3930 ;; does not work correctly
|
|
|
3931 ;; must be done by hand
|
|
|
3932
|
|
|
3933 (while (setq found
|
|
|
3934 (ada-search-ignore-string-comment ada-procedure-start-regexp))
|
|
|
3935 (ada-gen-treat-proc found))))
|
|
|
3936
|
|
|
3937
|
|
|
3938 ;;; provide ourself
|
|
|
3939
|
|
|
3940 (provide 'ada-mode)
|
|
|
3941
|
|
|
3942 ;;; ada-mode.el ends here
|
