HOME

Mini Shell 1.0
DIR:/usr/share/emacs/26.1/lisp/progmodes/
Current File : //usr/share/emacs/26.1/lisp/progmodes/ada-stmt.elc
;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301\302\303#\210\300\304!\210\300\305!\207" [require skeleton nil t easymenu ada-mode] 4)
#@55 Return the name of the current function or procedure.
(defalias 'ada-func-or-proc-name #[nil "\212\302\303	\304\302#\203\305\306!\202\307*\207" [case-fold-search ada-procedure-start-regexp t re-search-backward nil match-string 5 "NAME?"] 4 (#$ . 515)])
(put 'ada-array 'no-self-insert t)
#@580 Insert array type definition.
Prompt for component type and index subtypes.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-array #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil "array (" ("index definition: " str ", ") -2 ") of " _ 59)] 4 (#$ . 815) "*P\nP"])
(put 'ada-case 'no-self-insert t)
#@607 Build skeleton case statement.
Prompt for the selector expression.  Also builds the first when clause.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-case #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[selector expression]: " "case " str " is" n > "when " ("discrete choice: " str " | ") -3 " =>" n > _ n < < "end case;")] 4 (#$ . 1612) "*P\nP"])
(put 'ada-when 'no-self-insert t)
#@559 Start a case statement alternative with a when clause.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-when #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil < "when " ("discrete choice: " str " | ") -3 " =>" n >)] 4 (#$ . 2495) "*P\nP"])
(put 'ada-declare-block 'no-self-insert t)
#@574 Insert a block with a declare part.
Indent for the first declaration.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-declare-block #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[block name]: " < str & 58 & n > "declare" n > _ n < "begin" n > n < "end " str | -1 59)] 4 (#$ . 3277) "*P\nP"])
(put 'ada-exception-block 'no-self-insert t)
#@578 Insert a block with an exception part.
Indent for the first line of code.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-exception-block #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[block name]: " < str & 58 & n > "begin" n > _ n < "exception" n > n < "end " str | -1 59)] 4 (#$ . 4115) "*P\nP"])
(put 'ada-exception 'no-self-insert t)
#@552 Insert an indented exception part into a block.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-exception #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil < "exception" n >)] 4 (#$ . 4955) "*P\nP"])
(put 'ada-exit-1 'no-self-insert t)
#@579 Insert then exit condition of the exit statement, prompting for condition.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-exit-1 #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[exit condition]: " "when " str | -5)] 4 (#$ . 5691) "*P\nP"])
(put 'ada-exit 'no-self-insert t)
#@569 Insert an exit statement, prompting for loop name and condition.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-exit #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[name of loop to exit]: " "exit " str & 32 (ada-exit-1) | -1 59)] 4 (#$ . 6465) "*P\nP"])
#@53 Insert a descriptive header at the top of the file.
(defalias 'ada-header #[nil "\212eb\210\300\301!\203\301K \202\302 )\207" [fboundp make-header ada-header-tmpl] 2 (#$ . 7219) "*"])
(put 'ada-header-tmpl 'no-self-insert t)
#@569 Insert a comment block containing the module title, author, etc.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-header-tmpl #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[Description]: " "--                              -*- Mode: Ada -*-" "\n" ada-fill-comment-prefix "Filename        : " (buffer-name) "\n" ada-fill-comment-prefix "Description     : " str "\n" ada-fill-comment-prefix "Author          : " (user-full-name) "\n" ada-fill-comment-prefix "Created On      : " (current-time-string) "\n" ada-fill-comment-prefix "Last Modified By: ." "\n" ada-fill-comment-prefix "Last Modified On: ." "\n" ada-fill-comment-prefix "Update Count    : 0" "\n" ada-fill-comment-prefix "Status          : Unknown, Use with caution!" "\n")] 4 (#$ . 7455) "*P\nP"])
(put 'ada-display-comment 'no-self-insert t)
#@559 Inserts three comment lines, making a display comment.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-display-comment #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil "--\n" ada-fill-comment-prefix _ "\n--")] 4 (#$ . 8758) "*P\nP"])
(put 'ada-if 'no-self-insert t)
#@570 Insert skeleton if statement, prompting for a boolean-expression.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-if #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[condition]: " "if " str " then" n > _ n < "end if;")] 4 (#$ . 9525) "*P\nP"])
(put 'ada-elsif 'no-self-insert t)
#@582 Add an elsif clause to an if statement,
prompting for the boolean-expression.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-elsif #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[condition]: " < "elsif " str " then" n >)] 4 (#$ . 10303) "*P\nP"])
(put 'ada-else 'no-self-insert t)
#@556 Add an else clause inside an if-then-end-if clause.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-else #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil < "else" n >)] 4 (#$ . 11085) "*P\nP"])
(put 'ada-loop 'no-self-insert t)
#@576 Insert a skeleton loop statement.  The exit statement is added by hand.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-loop #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[loop name]: " < str & 58 & n > "loop" n > _ n < "end loop " str | -1 59)] 4 (#$ . 11814) "*P\nP"])
(put 'ada-for-loop-prompt-variable 'no-self-insert t)
#@534 Prompt for the loop variable.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-for-loop-prompt-variable #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[loop variable]: " str)] 4 (#$ . 12640) "*P\nP"])
(put 'ada-for-loop-prompt-range 'no-self-insert t)
#@531 Prompt for the loop range.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-for-loop-prompt-range #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[loop range]: " str)] 4 (#$ . 13391) "*P\nP"])
(put 'ada-for-loop 'no-self-insert t)
#@576 Build a skeleton for-loop statement, prompting for the loop parameters.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-for-loop #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[loop name]: " < str & 58 & n > "for " (ada-for-loop-prompt-variable) " in " (ada-for-loop-prompt-range) " loop" n > _ n < "end loop " str | -1 59)] 4 (#$ . 14120) "*P\nP"])
(put 'ada-while-loop-prompt-entry-condition 'no-self-insert t)
#@541 Prompt for the loop entry condition.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-while-loop-prompt-entry-condition #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[entry condition]: " str)] 4 (#$ . 15033) "*P\nP"])
(put 'ada-while-loop 'no-self-insert t)
#@544 Insert a skeleton while loop statement.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-while-loop #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[loop name]: " < str & 58 & n > "while " (ada-while-loop-prompt-entry-condition) " loop" n > _ n < "end loop " str | -1 59)] 4 (#$ . 15791) "*P\nP"])
(put 'ada-package-spec 'no-self-insert t)
#@545 Insert a skeleton package specification.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-package-spec #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[package name]: " "package " str " is" n > _ n < "end " str 59)] 4 (#$ . 16629) "*P\nP"])
(put 'ada-package-body 'no-self-insert t)
#@566 Insert a skeleton package body -- includes a begin statement.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-package-body #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[package name]: " "package body " str " is" n > _ n < "end " str 59)] 4 (#$ . 17410) "*P\nP"])
(put 'ada-private 'no-self-insert t)
#@569 Undent and start a private section of a package spec.  Reindent.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-private #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil < "private" n >)] 4 (#$ . 18212) "*P\nP"])
(put 'ada-function-spec-prompt-return 'no-self-insert t)
#@538 Prompts for function result type.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-function-spec-prompt-return #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[result type]: " str)] 4 (#$ . 18983) "*P\nP"])
(put 'ada-function-spec 'no-self-insert t)
#@570 Insert a function specification.  Prompts for name and arguments.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-function-spec #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[function name]: " "function " str " (" ("[parameter_specification]: " str "; ") -2 ")" " return " (ada-function-spec-prompt-return) ";" n)] 4 (#$ . 19731) "*P\nP"])
(put 'ada-procedure-spec 'no-self-insert t)
#@576 Insert a procedure specification, prompting for its name and arguments.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-procedure-spec #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[procedure name]: " "procedure " str " (" ("[parameter_specification]: " str "; ") -2 ")" ";" n)] 4 (#$ . 20616) "*P\nP"])
(put 'ada-subprogram-body 'no-self-insert t)
#@602 Insert frame for subprogram body.
Invoke right after `ada-function-spec' or `ada-procedure-spec'.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-subprogram-body #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil (save-excursion (let ((pos (1+ (point)))) (ada-search-ignore-string-comment ada-subprog-start-re t nil) (when (ada-search-ignore-string-comment "(" nil pos t 'search-forward) (backward-char 1) (forward-sexp 1))) (if (looking-at ";") (delete-char 1))) " is" n _ n < "begin" n n < "exception" n "when others => null;" n < < "end " (ada-func-or-proc-name) ";" n)] 4 (#$ . 21466) "*P\nP"])
(put 'ada-separate 'no-self-insert t)
#@540 Finish a body stub with `separate'.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-separate #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil > "separate;" n <)] 4 (#$ . 22602) "*P\nP"])
(put 'ada-record 'no-self-insert t)
#@547 Insert a skeleton record type declaration.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-record #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil "record" n > _ n < "end record;")] 4 (#$ . 23326) "*P\nP"])
(put 'ada-subtype 'no-self-insert t)
#@578 Start insertion of a subtype declaration, prompting for the subtype name.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-subtype #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[subtype name]: " "subtype " str " is " _ 59 (not (message "insert subtype indication.")))] 4 (#$ . 24071) "*P\nP"])
(put 'ada-type 'no-self-insert t)
#@572 Start insertion of a type declaration, prompting for the type name.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-type #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[type name]: " "type " str 40 ("[discriminant specs]: " str " ") | (backward-delete-char 1) | 41 " is " (not (message "insert type definition.")))] 4 (#$ . 24899) "*P\nP"])
(put 'ada-task-body 'no-self-insert t)
#@553 Insert a task body, prompting for the task name.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-task-body #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[task name]: " "task body " str " is\n" "begin\n" > _ n < "end " str ";")] 4 (#$ . 25779) "*P\nP"])
(put 'ada-task-spec 'no-self-insert t)
#@562 Insert a task specification, prompting for the task name.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-task-spec #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[task name]: " "task " str " (" ("[discriminant]: " str "; ") ") is\n" > "entry " _ n < "end " str ";")] 4 (#$ . 26572) "*P\nP"])
(put 'ada-get-param1 'no-self-insert t)
#@562 Prompt for arguments and if any enclose them in brackets.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-get-param1 #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil ("[parameter_specification]: " str "; ") & -2 & ")")] 4 (#$ . 27405) "*P\nP"])
(put 'ada-get-param 'no-self-insert t)
#@562 Prompt for arguments and if any enclose them in brackets.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-get-param #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil " (" (ada-get-param1) | -2)] 4 (#$ . 28190) "*P\nP"])
(put 'ada-entry 'no-self-insert t)
#@555 Insert a task entry, prompting for the entry name.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-entry #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[entry name]: " "entry " str (ada-get-param) ";" n)] 4 (#$ . 28945) "*P\nP"])
(put 'ada-entry-family-prompt-discriminant 'no-self-insert t)
#@565 Insert an entry specification, prompting for the entry name.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-entry-family-prompt-discriminant #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[discriminant name]: " str)] 4 (#$ . 29737) "*P\nP"])
(put 'ada-entry-family 'no-self-insert t)
#@565 Insert an entry specification, prompting for the entry name.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-entry-family #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[entry name]: " "entry " str " (" (ada-entry-family-prompt-discriminant) ")" (ada-get-param) ";" n)] 4 (#$ . 30522) "*P\nP"])
(put 'ada-select 'no-self-insert t)
#@527 Insert a select block.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-select #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil "select\n" > _ n < "end select;")] 4 (#$ . 31353) "*P\nP"])
(put 'ada-accept-1 'no-self-insert t)
#@568 Insert a condition statement, prompting for the condition name.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-accept-1 #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[condition]: " "when " str | -5)] 4 (#$ . 32079) "*P\nP"])
(put 'ada-accept-2 'no-self-insert t)
#@570 Insert an accept statement, prompting for the name and arguments.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-accept-2 #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[accept name]: " > "accept " str (ada-get-param) " do" n > _ n < "end " str ";")] 4 (#$ . 32844) "*P\nP"])
(put 'ada-accept 'no-self-insert t)
#@575 Insert an accept statement (prompt for condition, name and arguments).

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-accept #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil > (ada-accept-1) & " =>\n" (ada-accept-2))] 4 (#$ . 33657) "*P\nP"])
(put 'ada-or-accept 'no-self-insert t)
#@568 Insert an accept alternative, prompting for the condition name.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-or-accept #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil < "or\n" (ada-accept))] 4 (#$ . 34441) "*P\nP"])
(put 'ada-or-delay 'no-self-insert t)
#@563 Insert a delay alternative, prompting for the delay value.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-or-delay #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("[delay value]: " < "or\n" > "delay " str ";")] 4 (#$ . 35200) "*P\nP"])
(put 'ada-or-terminate 'no-self-insert t)
#@536 Insert a terminate alternative.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'ada-or-terminate #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil < "or\n" > "terminate;")] 4 (#$ . 35977) "*P\nP"])
(provide 'ada-stmt)