;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:15 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/progmodes/ada-mode.el
;;; in Emacs version 24.3.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\302\303#\210\300\305\302\303#\210\300\306\302\303#\207" [require find-file nil t align which-func compile] 4)
#@26 Return Ada mode version.
(defalias 'ada-mode-version #[nil "\301\302\303!\203\304!\202)\207" [version-string "4.00" called-interactively-p interactive message] 2 (#$ . 713) nil])
#@190 List of functions to call when Ada mode is invoked.
This hook is automatically executed after the `ada-mode' is
fully loaded.
This is a good place to add Ada environment specific bindings.
(defvar ada-mode-hook nil (#$ . 906))
(byte-code "\300\301\302\303\304\305\306\307&\210\310\311\312\313\314\315\306\301&\210\310\316\317\320\314\321\306\301&\210\310\322\323\324\314\321\306\301&\210\310\325\322\326\314\321\306\301&\210\310\327\330\331\314\332\306\301&\210\310\333\334\335\314\336\306\301&\210\310\337\340\341\314\342\306\301&\210\310\343\344\345\314\346\306\301&\210\310\347\312\350\314\315\306\301&\210\351\347\352\353#\210\310\354\355\356\314\321\306\301&\210\310\357\312\360\314\315\306\301&\210\310\361\312\362\314\315\306\301&\210\310\363\312\364\314\315\306\301&\210\310\365\302\366\314\315\306\301&\210\310\367\312\370\314\315\306\301&\210\310\371\355\372\314\321\306\301&\210\310\373\322\374\314\321\306\301&\210\310\375\317\376\314\321\306\301&\210\310\377\312\201@\314\315\306\301&\210\310\201A\201B\201C\314\201D\306\301&\210\310\201E\201F\201G\314\201D\306\301&\210\310\201H\201I\201J\314\321\306\301&\210\310\201K\201L\201M\314\201N\306\301&\210\310\201O\302\201P\314\315\306\301&\210\310\201Q\201R\201S\314\201T\306\301&\210\310\201U\201V\201W\314\201X\306\301&\207" [custom-declare-group ada nil "Major mode for editing and compiling Ada source in Emacs." :link (custom-group-link :tag "Font Lock Faces group" font-lock-faces) :group languages custom-declare-variable ada-auto-case t "Non-nil means automatically change case of preceding word while typing.\nCasing is done according to `ada-case-keyword', `ada-case-identifier'\nand `ada-case-attribute'." :type boolean ada-broken-decl-indent 0 "Number of columns to indent a broken declaration.\n\nAn example is :\n  declare\n     A,\n     >>>>>B : Integer;" integer ada-broken-indent 2 "Number of columns to indent the continuation of a broken line.\n\nAn example is :\n   My_Var : My_Type := (Field1 =>\n			>>>>>>>>>Value);" ada-continuation-indent "Number of columns to indent the continuation of broken lines in parenthesis.\n\nAn example is :\n   Func (Param1,\n	 >>>>>Param2);" ada-case-attribute 'ada-capitalize-word "Function to call to adjust the case of Ada attributes.\nIt may be `downcase-word', `upcase-word', `ada-loose-case-word',\n`ada-capitalize-word' or `ada-no-auto-case'." (choice (const downcase-word) (const upcase-word) (const ada-capitalize-word) (const ada-loose-case-word) (const ada-no-auto-case)) ada-case-exception-file (list (convert-standard-filename '"~/.emacs_case_exceptions")) "List of special casing exceptions dictionaries for identifiers.\nThe first file is the one where new exceptions will be saved by Emacs\nwhen you call `ada-create-case-exception'.\n\nThese files should contain one word per line, that gives the casing\nto be used for that word in Ada files.  If the line starts with the\ncharacter *, then the exception will be used for substrings that either\nstart at the beginning of a word or after a _ character, and end either\nat the end of the word or at a _ character.  Each line can be terminated\nby a comment." (repeat (file)) ada-case-keyword 'downcase-word "Function to call to adjust the case of an Ada keywords.\nIt may be `downcase-word', `upcase-word', `ada-loose-case-word' or\n`ada-capitalize-word'." (choice (const downcase-word) (const upcase-word) (const ada-capitalize-word) (const ada-loose-case-word) (const ada-no-auto-case)) ada-case-identifier 'ada-loose-case-word "Function to call to adjust the case of an Ada identifier.\nIt may be `downcase-word', `upcase-word', `ada-loose-case-word' or\n`ada-capitalize-word'." (choice (const downcase-word) (const upcase-word) (const ada-capitalize-word) (const ada-loose-case-word) (const ada-no-auto-case)) ada-clean-buffer-before-saving "Non-nil means remove trailing spaces and untabify the buffer before saving." make-obsolete-variable "use the `write-file-functions' hook." "23.2" ada-indent 3 "Size of Ada indentation.\n\nAn example is :\nprocedure Foo is\nbegin\n>>>>>>>>>>null;" ada-indent-after-return "Non-nil means automatically indent after RET or LFD." ada-indent-align-comments "Non-nil means align comments on previous line comments, if any.\nIf nil, indentation is calculated as usual.\nNote that indentation is calculated only if `ada-indent-comment-as-code' is t.\n\nFor instance:\n    A := 1;   --  A multi-line comment\n	      --  aligned if `ada-indent-align-comments' is t" ada-indent-comment-as-code "Non-nil means indent comment lines as code.\nA nil value means do not auto-indent comments." ada-indent-handle-comment-special "Non-nil if comment lines should be handled specially inside parenthesis.\nBy default, if the line that contains the open parenthesis has some\ntext following it, then the following lines will be indented in the\nsame column as this text.  This will not be true if the first line is\na comment and `ada-indent-handle-comment-special' is t.\n\ntype A is\n  (   Value_1,    --  common behavior, when not a comment\n      Value_2);\n\ntype A is\n  (   --  `ada-indent-handle-comment-special' is nil\n      Value_1,\n      Value_2);\n\ntype A is\n  (   --  `ada-indent-handle-comment-special' is non-nil\n   Value_1,\n   Value_2);" ada-indent-is-separate "Non-nil means indent 'is separate' or 'is abstract' if on a single line." ada-indent-record-rel-type "Indentation for 'record' relative to 'type' or 'use'.\n\nAn example is:\n   type A is\n   >>>>>>>>>>>record" ada-indent-renames "Indentation for renames relative to the matching function statement.\nIf `ada-indent-return' is null or negative, the indentation is done relative to\nthe open parenthesis (if there is no parenthesis, `ada-broken-indent' is used).\n\nAn example is:\n   function A (B : Integer)\n       return C;\n   >>>renames Foo;" ada-indent-return "Indentation for 'return' relative to the matching 'function' statement.\nIf `ada-indent-return' is null or negative, the indentation is done relative to\nthe open parenthesis (if there is no parenthesis, `ada-broken-indent' is used).\n\nAn example is:\n   function A (B : Integer)\n   >>>>>return C;" ada-indent-to-open-paren "Non-nil means indent according to the innermost open parenthesis." ada-fill-comment-prefix "--  " "Text inserted in the first columns when filling a comment paragraph.\nNote: if you modify this variable, you will have to invoke `ada-mode'\nagain to take account of the new value." string ada-fill-comment-postfix " --" "Text inserted at the end of each line when filling a comment paragraph.\nUsed by `ada-fill-comment-paragraph-postfix'." ada-label-indent -4 "Number of columns to indent a label.\n\nAn example is:\nprocedure Foo is\nbegin\n>>>>Label:\n\nThis is also used for <<..>> labels" ada-language-version 'ada95 "Ada language version; one of `ada83', `ada95', `ada2005'." (choice (const ada83) (const ada95) (const ada2005)) ada-move-to-declaration "Non-nil means `ada-move-to-start' moves to the subprogram declaration, not to 'begin'." ada-popup-key '[down-mouse-3] "Key used for binding the contextual menu.\nIf nil, no contextual menu is available." (restricted-sexp :match-alternatives (stringp vectorp)) ada-search-directories (append '(".") (split-string (or (getenv "ADA_INCLUDE_PATH") "") ":") '("/usr/adainclude" "/usr/local/adainclude" "/opt/gnu/adainclude")) "Default list of directories to search for Ada files.\nSee the description for the `ff-search-directories' variable.  This variable\nis the initial value of `ada-search-directories-internal'." (repeat (choice :tag "Directory" (const :tag "default" nil) (directory :format "%v")))] 8)
#@220 Internal version of `ada-search-directories'.
Its value is the concatenation of the search path as read in the project file
and the standard runtime location, and the value of the user-defined
`ada-search-directories'.
(defvar ada-search-directories-internal ada-search-directories (#$ . 8614))
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\313\306\307&\210\300\314\315\316\304\305\306\307&\210\300\317\320\321\304\305\306\307&\210\300\322\315\323\304\305\306\307&\210\300\324\325\326\304\327\306\307&\207" [custom-declare-variable ada-stmt-end-indent 0 "Number of columns to indent the end of a statement on a separate line.\n\nAn example is:\n   if A = B\n   >>>>then" :type integer :group ada ada-tab-policy 'indent-auto "Control the behavior of the TAB key.\nMust be one of :\n`indent-rigidly' : always adds `ada-indent' blanks at the beginning of the line.\n`indent-auto'    : use indentation functions in this file.\n`always-tab'     : do `indent-relative'." (choice (const indent-auto) (const indent-rigidly) (const always-tab)) ada-use-indent ada-broken-indent "Indentation for the lines in a 'use' statement.\n\nAn example is:\n   use Ada.Text_IO,\n   >>>>Ada.Numerics;" ada-when-indent 3 "Indentation for 'when' relative to 'exception' or 'case'.\n\nAn example is:\n   case A is\n   >>>>when B =>" ada-with-indent "Indentation for the lines in a 'with' statement.\n\nAn example is:\n   with Ada.Text_IO,\n   >>>>Ada.Numerics;" ada-which-compiler 'gnat "Name of the compiler to use.\nThis will determine what features are made available through the Ada mode.\nThe possible choices are:\n`gnat': Use Ada Core Technologies' GNAT compiler.  Add some cross-referencing\n    features.\n`generic': Use a generic compiler." (choice (const gnat) (const generic))] 8)
#@94 List of possible suffixes for Ada body files.
The extensions should include a `.' if needed.
(defvar ada-body-suffixes '(".adb") (#$ . 10418))
#@94 List of possible suffixes for Ada spec files.
The extensions should include a `.' if needed.
(defvar ada-spec-suffixes '(".ads") (#$ . 10567))
#@20 Menu for Ada mode.
(defvar ada-mode-menu (make-sparse-keymap "Ada") (#$ . 10716))
#@33 Local keymap used for Ada mode.
(defvar ada-mode-map (make-sparse-keymap) (#$ . 10804))
#@43 Keymap used for non-standard keybindings.
(defvar ada-mode-extra-map (make-sparse-keymap) (#$ . 10898))
#@54 Prefix key to access `ada-mode-extra-map' functions.
(defvar ada-mode-extra-prefix "" (#$ . 11008))
#@34 Local abbrev table for Ada mode.
(defvar ada-mode-abbrev-table nil (#$ . 11116))
(define-abbrev-table 'ada-mode-abbrev-table nil)
#@54 Syntax table to be used for editing Ada source code.
(defvar ada-mode-syntax-table nil (#$ . 11252))
#@56 Syntax table for Ada, where `_' is a word constituent.
(defvar ada-mode-symbol-syntax-table nil (#$ . 11359))
#@63 Variable to save key binding of RET when casing is activated.
(defvar ada-ret-binding nil (#$ . 11475))
#@53 Alist of words (entities) that have special casing.
(defvar ada-case-exception nil (#$ . 11585))
#@257 Alist of substrings (entities) that have special casing.
The substrings are detected for word constituent when the word
is not itself in `ada-case-exception', and only for substrings that
either are at the beginning or end of the word, or start after '_'.
(defvar ada-case-exception-substring nil (#$ . 11689))
#@63 Variable to save key binding of LFD when casing is activated.
(defvar ada-lfd-binding nil (#$ . 12006))
#@96 Variable used by `find-file' to find the name of the other package.
See `ff-other-file-alist'.
(defvar ada-other-file-alist nil (#$ . 12116))
#@157 Ada support for align.el <= 2.2.
This variable provides regular expressions on which to align different lines.
See `align-mode-alist' for more information.
(defvar ada-align-list '(("[^:]\\(\\s-*\\):[^:]" 1 t) ("[^=]\\(\\s-+\\)=[^=]" 1 t) ("\\(\\s-*\\)use\\s-" 1) ("\\(\\s-*\\)--" 1)) (#$ . 12265))
#@103 Ada support for align.el >= 2.8.
This variable defines several rules to use to align different lines.
(defvar ada-align-modes '((ada-declaration (regexp . "[^:]\\(\\s-*\\):[^:]") (valid lambda nil (not (ada-in-comment-p))) (modes quote (ada-mode))) (ada-assignment (regexp . "[^=]\\(\\s-+\\)=[^=]") (valid lambda nil (not (ada-in-comment-p))) (modes quote (ada-mode))) (ada-comment (regexp . "\\(\\s-*\\)--") (modes quote (ada-mode))) (ada-use (regexp . "\\(\\s-*\\)use\\s-") (valid lambda nil (not (ada-in-comment-p))) (modes quote (ada-mode)))) (#$ . 12571))
#@64 See the variable `align-region-separate' for more information.
(defconst ada-align-region-separate "^\\s-*\\($\\|\\(begin\\|declare\\|else\\|end\\|exception\\|for\\|function\\|generic\\|if\\|is\\|procedure\\|record\\|return\\|type\\|when\\)\\>\\)" (#$ . 13138))
#@45 Regular expression matching Ada83 keywords.
(defconst ada-83-keywords "\\<\\(a\\(?:b\\(?:ort\\|s\\)\\|cce\\(?:pt\\|ss\\)\\|ll\\|nd\\|rray\\|t\\)\\|b\\(?:egin\\|ody\\)\\|c\\(?:ase\\|onstant\\)\\|d\\(?:e\\(?:clare\\|l\\(?:ay\\|ta\\)\\)\\|igits\\|o\\)\\|e\\(?:ls\\(?:e\\|if\\)\\|n\\(?:d\\|try\\)\\|x\\(?:ception\\|it\\)\\)\\|f\\(?:or\\|unction\\)\\|g\\(?:eneric\\|oto\\)\\|i[fns]\\|l\\(?:imited\\|oop\\)\\|mod\\|n\\(?:ew\\|ot\\|ull\\)\\|o\\(?:thers\\|ut\\|[fr]\\)\\|p\\(?:ackage\\|r\\(?:agma\\|\\(?:ivat\\|ocedur\\)e\\)\\)\\|r\\(?:a\\(?:\\(?:is\\|ng\\)e\\)\\|e\\(?:cord\\|m\\|names\\|turn\\|verse\\)\\)\\|s\\(?:e\\(?:lect\\|parate\\)\\|ubtype\\)\\|t\\(?:ask\\|erminate\\|hen\\|ype\\)\\|use\\|w\\(?:h\\(?:en\\|ile\\)\\|ith\\)\\|xor\\)\\>" (#$ . 13406))
#@45 Regular expression matching Ada95 keywords.
(defconst ada-95-keywords "\\<\\(a\\(?:b\\(?:ort\\|s\\(?:tract\\)?\\)\\|cce\\(?:pt\\|ss\\)\\|l\\(?:iased\\|l\\)\\|nd\\|rray\\|t\\)\\|b\\(?:egin\\|ody\\)\\|c\\(?:ase\\|onstant\\)\\|d\\(?:e\\(?:clare\\|l\\(?:ay\\|ta\\)\\)\\|igits\\|o\\)\\|e\\(?:ls\\(?:e\\|if\\)\\|n\\(?:d\\|try\\)\\|x\\(?:ception\\|it\\)\\)\\|f\\(?:or\\|unction\\)\\|g\\(?:eneric\\|oto\\)\\|i[fns]\\|l\\(?:imited\\|oop\\)\\|mod\\|n\\(?:ew\\|ot\\|ull\\)\\|o\\(?:thers\\|ut\\|[fr]\\)\\|p\\(?:ackage\\|r\\(?:agma\\|ivate\\|o\\(?:cedure\\|tected\\)\\)\\)\\|r\\(?:a\\(?:\\(?:is\\|ng\\)e\\)\\|e\\(?:cord\\|m\\|names\\|queue\\|turn\\|verse\\)\\)\\|s\\(?:e\\(?:lect\\|parate\\)\\|ubtype\\)\\|t\\(?:a\\(?:gged\\|sk\\)\\|erminate\\|hen\\|ype\\)\\|u\\(?:ntil\\|se\\)\\|w\\(?:h\\(?:en\\|ile\\)\\|ith\\)\\|xor\\)\\>" (#$ . 14161))
#@47 Regular expression matching Ada2005 keywords.
(defconst ada-2005-keywords "\\<\\(a\\(?:b\\(?:ort\\|s\\(?:tract\\)?\\)\\|cce\\(?:pt\\|ss\\)\\|l\\(?:iased\\|l\\)\\|nd\\|rray\\|t\\)\\|b\\(?:egin\\|ody\\)\\|c\\(?:ase\\|onstant\\)\\|d\\(?:e\\(?:clare\\|l\\(?:ay\\|ta\\)\\)\\|igits\\|o\\)\\|e\\(?:ls\\(?:e\\|if\\)\\|n\\(?:d\\|try\\)\\|x\\(?:ception\\|it\\)\\)\\|f\\(?:or\\|unction\\)\\|g\\(?:eneric\\|oto\\)\\|i\\(?:nterface\\|[fns]\\)\\|l\\(?:imited\\|oop\\)\\|mod\\|n\\(?:ew\\|ot\\|ull\\)\\|o\\(?:thers\\|ut\\|verriding\\|[fr]\\)\\|p\\(?:ackage\\|r\\(?:agma\\|ivate\\|o\\(?:cedure\\|tected\\)\\)\\)\\|r\\(?:a\\(?:\\(?:is\\|ng\\)e\\)\\|e\\(?:cord\\|m\\|names\\|queue\\|turn\\|verse\\)\\)\\|s\\(?:e\\(?:lect\\|parate\\)\\|ubtype\\|ynchronized\\)\\|t\\(?:a\\(?:gged\\|sk\\)\\|erminate\\|hen\\|ype\\)\\|u\\(?:ntil\\|se\\)\\|w\\(?:h\\(?:en\\|ile\\)\\|ith\\)\\|xor\\)\\>" (#$ . 14994))
#@43 Regular expression matching Ada keywords.
(defvar ada-keywords ada-2005-keywords (#$ . 15876))
#@36 Regexp matching an Ada identifier.
(defconst ada-ident-re "[[:alpha:]]\\(?:[_[:alnum:]]\\)*" (#$ . 15977))
#@31 Regexp matching a goto label.
(defconst ada-goto-label-re (concat "<<" ada-ident-re ">>") (#$ . 16090))
#@84 Regexp matching a block label.
Note that this also matches a variable declaration.
(defconst ada-block-label-re (concat ada-ident-re "[ 	\n]*:[^=]") (#$ . 16200))
#@40 Regexp matching a goto or block label.
(defconst ada-label-re (concat "\\(?:" ada-block-label-re "\\)\\|\\(?:" ada-goto-label-re "\\)") (#$ . 16369))
#@117 Regexp matching Ada subprogram start.
The actual start is at (match-beginning 4).  The name is in (match-string 5).
(defvar ada-procedure-start-regexp "^[ 	]*\\(with[ 	]+\\)?\\(\\(not[ 	]+\\)?overriding[ 	]+\\)?\\(procedure\\|function\\|task\\)[ 	\n]+\\(\\(\"[^\"]+\"\\)\\|\\(\\(\\sw\\|[_.]\\)+\\)\\)" (#$ . 16526))
#@63 Regexp matching a fully qualified name (including attribute).
(defconst ada-name-regexp "\\([a-zA-Z][a-zA-Z0-9_.']*[a-zA-Z0-9]\\)" (#$ . 16848))
#@76 Regexp matching start of package.
The package name is in (match-string 4).
(defconst ada-package-start-regexp (concat "^[ 	]*\\(private[ 	]+\\)?\\(package\\)[ 	\n]+\\(body[ 	]*\\)?" ada-name-regexp) (#$ . 16999))
#@43 Regexp matching filename:linenr[:column].
(defconst ada-compile-goto-error-file-linenr-re "\\([-_.a-zA-Z0-9]+\\):\\([0-9]+\\)\\(:\\([0-9]+\\)\\)?" (#$ . 17218))
#@42 Regexp for keywords starting Ada blocks.
(defvar ada-block-start-re "\\<\\(\\(?:begin\\|declare\\|e\\(?:lse\\|xception\\)\\|generic\\|loop\\|or\\|private\\|select\\)\\|\\(\\(limited\\|abstract\\|tagged\\)[ 	\n]+\\)*record\\)\\>" (#$ . 17385))
#@89 Regexp of possible ends for a non-broken statement.
A new statement starts after these.
(defvar ada-end-stmt-re "\\(;\\|=>[ 	]*$\\|=>[ 	]*--.*$\\|^[ 	]*separate[ 	]*(\\(\\sw\\|[_.]\\)+)\\|\\<\\(begin\\|d\\(?:eclare\\|o\\)\\|else\\|generic\\|is\\|loop\\|private\\|record\\|select\\|then\\(?: abort\\)?\\)\\>\\|^[ 	]*\\(function\\|p\\(?:\\(?:ackag\\|rocedur\\)e\\)\\)\\>\\(\\sw\\|[ 	_.]\\)+\\<is\\>\\|^[ 	]*exception\\>\\)" (#$ . 17634))
#@43 Regexp used in `ada-goto-matching-start'.
(defvar ada-matching-start-re "\\<\\(begin\\|case\\|d\\(?:eclare\\|o\\)\\|end\\|function\\|if\\|loop\\|p\\(?:ackage\\|ro\\(?:cedure\\|tected\\)\\)\\|record\\|select\\|task\\)\\>" (#$ . 18076))
#@33 Regexp for the start of a loop.
(defvar ada-loop-start-re "\\<\\(for\\|while\\|loop\\)\\>" (#$ . 18317))
#@39 Regexp for the start of a subprogram.
(defvar ada-subprog-start-re "\\<\\(accept\\|entry\\|function\\|overriding\\|p\\(?:ackage\\|ro\\(?:cedure\\|tected\\)\\)\\|task\\)\\>" (#$ . 18428))
#@71 Set to true when the right mouse button was clicked on an identifier.
(defvar ada-contextual-menu-on-identifier nil (#$ . 18621))
#@464 Position of point just before displaying the menu.
This is a list (point buffer).
Since `ada-popup-menu' moves the point where the user clicked, the region
is modified.  Therefore no command from the menu knows what the user selected
before displaying the contextual menu.
To get the original region, restore the point to this position before
calling `region-end' and `region-beginning'.
Modify this variable if you want to restore the point to another position.
(defvar ada-contextual-menu-last-point nil (#$ . 18758))
#@183 Menu to use when the user presses the right mouse button.
The variable `ada-contextual-menu-on-identifier' will be set to t before
displaying the menu if point was on an identifier.
(defvar ada-contextual-menu nil (#$ . 19285))
(easy-menu-do-define 'ada-contextual-menu nil "Menu to use when the user presses the right mouse button.\nThe variable `ada-contextual-menu-on-identifier' will be set to t before\ndisplaying the menu if point was on an identifier." '("Ada" ["Goto Declaration/Body" ada-point-and-xref :included ada-contextual-menu-on-identifier] ["Goto Body" ada-point-and-xref-body :included ada-contextual-menu-on-identifier] ["Goto Previous Reference" ada-xref-goto-previous-reference] ["List References" ada-find-references :included ada-contextual-menu-on-identifier] ["List Local References" ada-find-local-references :included ada-contextual-menu-on-identifier] ["-" nil nil] ["Other File" ff-find-other-file] ["Goto Parent Unit" ada-goto-parent]))
(defconst ada-imenu-comment-re "\\([ 	]*--.*\\)?")
(defconst ada-imenu-subprogram-menu-re (concat "^[ 	]*\\(overriding[ 	]*\\)?\\(procedure\\|function\\)[ 	\n]+" "\\(\\(\\sw\\|_\\)+\\)[ 	\n]*\\([ 	\n]\\|([^)]+)" ada-imenu-comment-re "\\)[ 	\n]*" "\\(return[ 	\n]+\\(\\sw\\|[_.]\\)+[ 	\n]*\\)?is[ 	\n]"))
#@174 Imenu generic expression for Ada mode.
See `imenu-generic-expression'.  This variable will create several submenus for
each type of entity that can be found in an Ada file.
(defvar ada-imenu-generic-expression (byte-code "\302\303E\304\305\306\211	\307	\310\311\312\260	\313E\314\315\316\317\257\207" [ada-imenu-subprogram-menu-re ada-imenu-comment-re nil 3 "*Specs*" "^[ 	]*\\(procedure\\|function\\)[ 	\n]+\\(\\(\\sw\\|_\\)+\\)" "\\(" "[ 	\n]+\\|[ 	\n]*([^)]+)" "\\)" "\\([ 	\n]*return[ 	\n]+\\(\\sw\\|[_.]\\)+[ 	\n]*\\)?" "\\)?;" 2 ("*Tasks*" "^[ 	]*task[ 	]+\\(type[ 	]+\\)?\\(\\(body[ 	]+\\)?\\(\\sw\\|_\\)+\\)" 2) ("*Type Defs*" "^[ 	]*\\(sub\\)?type[ 	]+\\(\\(\\sw\\|_\\)+\\)" 2) ("*Protected*" "^[ 	]*protected[ 	]+\\(type[ 	]+\\)?\\(\\(body[ 	]+\\)?\\(\\sw\\|_\\)+\\)" 2) ("*Packages*" "^[ 	]*package[ 	]+\\(\\(body[ 	]+\\)?\\(\\sw\\|[_.]\\)+\\)" 1)] 11) (#$ . 20563))
#@47 Mouse interface for `ada-compile-goto-error'.
(defalias 'ada-compile-mouse-goto-error #[nil "\301!\210\302`!\207" [last-input-event mouse-set-point ada-compile-goto-error] 2 (#$ . 21449) nil])
#@393 Replace `compile-goto-error' from compile.el.
If POS is on a file and line location, go to this position.  It adds
to compile.el the capacity to go to a reference in an error message.
For instance, on these lines:
  foo.adb:61:11:  [...] in call to size declared at foo.ads:11
  foo.adb:61:11:  [...] in call to local declared at line 20
the 4 file locations can be clicked on and jumped to.
(defalias 'ada-compile-goto-error #[(pos) "b\210\306\307x\210n\204\202\310	!\204-\212\311 \210\310	!)\203\202\212\310\312!\203&\313v\210\310\314!)\203\202\315\224\2038\316\315!\202;\316\317!\315\224\203F\316\317!\202R\212\311 \210\310	!\210\316\317!)\320 \307\212\321\320 \316\317!\322#\210\fq\210
;\203teb\210\323
!Sy\210\320 )\324\n\307#\210,\202\205\325 \210\326 \207" [pos ada-compile-goto-error-file-linenr-re source error-pos file line "-a-zA-Z0-9_:./\\" nil looking-at beginning-of-line "\\([0-9]+\\)" -1 "line \\([0-9]+\\)" 2 match-string 1 point-marker compilation-find-file "./" string-to-number compilation-goto-locus compile-goto-error recenter] 4 (#$ . 21650) "d"])
#@158 Create the two syntax tables use in the Ada mode.
The standard table declares `_' as a symbol constituent, the second one
declares it as a word constituent.
(defalias 'ada-create-syntax-table #[nil "\302 \303\304\305#\210\303\306\307#\210\303\310\311#\210\303\312\311#\210\303\313\311#\210\303\314\311#\210\303\315\311#\210\303\316\311#\210\303\317\311#\210\303\320\311#\210\303\321\311#\210\303\322\311#\210\303\323\311#\210\303\324\311#\210\303\325\311#\210\303\326\311#\210\303\327\311#\210\303\330\311#\210\303\331\311#\210\303\332\311#\210\303\333\334#\210\303\335\305#\210\303\336\337#\210\303\340\337#\210\303\341\342#\210\303\343\344#\210\303\345\346#\210\347!\303\341\350	#\207" [ada-mode-syntax-table ada-mode-symbol-syntax-table make-syntax-table modify-syntax-entry 37 "$" 34 "\"" 58 "." 59 38 124 43 42 47 61 60 62 36 91 93 123 125 46 92 39 45 ". 12" 35 12 ">   " 10 95 "_" 40 "()" 41 ")(" copy-syntax-table "w"] 4 (#$ . 22746) nil])
#@107 Return t if inside a comment.
If PARSE-RESULT is non-nil, use it instead of calling `parse-partial-sexp'.
(defalias 'ada-in-comment-p #[(&optional parse-result) "\301\206\n\302\303 `\"8\207" [parse-result 4 parse-partial-sexp line-beginning-position] 4 (#$ . 23730)])
(put 'ada-in-comment-p 'byte-optimizer 'byte-compile-inline-expand)
#@115 Return t if point is inside a string.
If PARSE-RESULT is non-nil, use it instead of calling `parse-partial-sexp'.
(defalias 'ada-in-string-p #[(&optional parse-result) "\301\206\n\302\303 `\"8\207" [parse-result 3 parse-partial-sexp line-beginning-position] 4 (#$ . 24075)])
(put 'ada-in-string-p 'byte-optimizer 'byte-compile-inline-expand)
#@117 Return t if inside a comment or string.
If PARSE-RESULT is non-nil, use it instead of calling `parse-partial-sexp'.
(defalias 'ada-in-string-or-comment-p #[(&optional parse-result) "\206	\301\302 `\"\211\303\206\301\302 `\"8)\206)\304\206'\301\302 `\"8)\207" [parse-result parse-partial-sexp line-beginning-position 3 4] 5 (#$ . 24426)])
(put 'ada-in-string-or-comment-p 'byte-optimizer 'byte-compile-inline-expand)
#@59 Return t if point is after a prefix of a numeric literal.
(defalias 'ada-in-numeric-literal-p #[nil "\300\301!\207" [looking-back "\\([0-9]+#[0-9a-fA-F_]+\\)"] 2 (#$ . 24860)])
(put 'ada-in-numeric-literal-p 'byte-optimizer 'byte-compile-inline-expand)
#@103 Execute FUNCTION when called from the contextual menu.
It forces Emacs to change the cursor position.
(defalias 'ada-call-from-contextual-menu #[(function) " \210`pD\211\207" [function ada-contextual-menu-last-point] 2 (#$ . 25120) nil])
#@297 Pops up a contextual menu, depending on where the user clicked.
POSITION is the location the mouse was clicked on.
Sets `ada-contextual-menu-last-point' to the current position before
displaying the menu.  When a function from the menu is called, the
point is where the mouse button was clicked.
(defalias 'ada-popup-menu #[(position) "\306`pD\307\n!\210\306f\205S\306fz\310U\204\306f\311U\205S\306\312\313 `\"\211\314\2062\312\313 `\"8)\206E\315\206C\312\313 `\"8))?\205S\212\316\317!\210\320 )?\321\322!\203b\322K
!\210\202{\306\323
\"\211\203z\324
\325@!\" \210)	\211A@)q\210	@b)\207" [deactivate-mark ada-contextual-menu-last-point last-input-event parse-result ada-contextual-menu-on-identifier ada-contextual-menu nil mouse-set-point 119 95 parse-partial-sexp line-beginning-position 3 4 skip-syntax-forward "w" ada-after-keyword-p fboundp popup-menu x-popup-menu lookup-key vector choice position x] 5 (#$ . 25367) "e"])
#@217 Define SPEC and BODY as being valid extensions for Ada files.
Going from body to spec with `ff-find-other-file' used these
extensions.
SPEC and BODY are two regular expressions that must match against
the file name.
(defalias 'ada-add-extensions #[(spec body) "\306!\307P\310	\n\"\211\203\f\211A@)BC\241\210\202&\311\302	\fCD\"\210*\306\f!\307P\310	\n\"\211\203E\211A@)BC\241\210\202M\311\302	CD\"\210*\311\312\306\f!\313P\314B\"\210\311\312\306!\313P\314B\"\210\311\315\f\"\210\311\316\"\210\317\320!\205}\320K\f!\210\320K!\207" [body reg ada-other-file-alist tmp spec x regexp-quote "$" assoc add-to-list auto-mode-alist "\\'" ada-mode ada-spec-suffixes ada-body-suffixes fboundp speedbar-add-supported-extension] 5 (#$ . 26333)])
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [ada-mode-hook variable-documentation put purecopy "Hook run when entering Ada mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp ada-mode-map definition-name ada-mode] 5)
(defvar ada-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [ada-mode-map variable-documentation put purecopy "Keymap for `ada-mode'." boundp ada-mode-syntax-table definition-name ada-mode] 5)
(defvar ada-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [ada-mode-syntax-table variable-documentation put purecopy "Syntax table for `ada-mode'." ada-mode-abbrev-table definition-name ada-mode] 5)
(defvar ada-mode-abbrev-table (progn (define-abbrev-table 'ada-mode-abbrev-table nil) ada-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [ada-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `ada-mode'." ada-mode derived-mode-parent prog-mode] 5)
#@219 Ada mode is the major mode for editing Ada code.

In addition to any hooks its parent mode `prog-mode' might have run,
this mode runs the hook `ada-mode-hook', as the final step
during initialization.

\{ada-mode-map}
(defalias 'ada-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324@\325\"\204V@A=\204V\326@\325AC#\210\327!\210\330\f!\210@A\306\331!\210\332\306\333!\210\332\306\334!\210\335\306\336!\210\337\306\340!\210\341 \306\342!\210\343\"\306\344!\210\345$\306\346!\210\307&\306\347!\210\350'\306\351!\210\307\211)B\352\353!\203\264\307+\306\354!\210\355,\356\357\360\"\210\306\361!\210\3621\306\363!\210\364C!3\306\365!\210\3665\306\367!\210\3707\371D\372E\356\373\374\"\210\306\375!\210\376\377\201V\201WB\201X\201YB\201Z\201[BE\"\210\306\201F!\210\201\\F\306\201G!\210\201]GHI\201^J\306\201K!\210\201_K\201`\201a\311\"\210\201`\201b\311\"\210\306\201M!\210LM\201`\201c\201d\"\210\201`\201c\201e\"\210\201fN\201`\201N\201g\"\210\201`\201N\201h\"\210\201`\201N\201i\"\210\201`\201N\201j\"\210\201`\201N\201k\"\210NOP\203\264
\201lP\201m#\210@A\306\201Q!\210\201nQ\306\201R!\210\201fR\306\201S!\210\201oS\201pT\"\210\306\201U!\210\201qU\356\201r\201s\201f\307$\210\356\201t\201u\201f\201v$\210)\201w\201x!\207" [delay-mode-hooks major-mode mode-name ada-mode-map ada-mode-syntax-table parent make-local-variable t prog-mode ada-mode "Ada" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table paragraph-start "[ 	\n\f]*$" paragraph-separate comment-end "" comment-start-skip "---*[ 	]*" comment-line-break-function #[(&optional soft) "\302\303	!)\207" [fill-prefix soft nil indent-new-comment-line] 2] indent-line-function ada-indent-current-function comment-column 40 parse-sexp-ignore-comments comment-padding 0 parse-sexp-lookup-properties boundp imenu-case-fold-search fill-paragraph-function ada-fill-comment-paragraph add-hook compilation-mode-hook #[nil "\301\302\303#\210\301\304\305#\210\301\306\305#\207" [compilation-minor-mode-map define-key [mouse-2] ada-compile-mouse-goto-error "" ada-compile-goto-error "
"] 4] font-lock-defaults (ada-font-lock-keywords nil t ((95 . "w") (35 . ".")) beginning-of-line) syntax-propertize-function syntax-propertize-via-font-lock ff-other-file-alist ada-other-file-alist ff-search-directories ada-search-directories-internal ada-set-point-accordingly ada-make-body ff-pre-load-hook ada-which-function-are-we-in ff-special-constructs mapc #[(pair) "\301\302\"\207" [pair add-to-list ff-special-constructs] 3] ada-mode-abbrev-table local-abbrev-table case-fold-search ada-font-lock-syntactic-keywords ff-post-load-hook ff-file-created-hook outline-regexp outline-level ada-imenu-generic-expression imenu-generic-expression imenu-sort-function ispell-check-comments ada-align-region-separate align-region-separate ada-align-modes align-mode-rules-list ada-popup-key which-func-functions comment-multi-line add-log-current-defun-function ada-mode-menu skeleton-further-elements "^\\(private[ 	]\\)?[ 	]*package[ 	]+\\(body[ 	]+\\)?\\(\\(\\sw\\|[_.]\\)+\\)\\.\\(\\sw\\|_\\)+[ 	\n]+is" #[nil "\302\303\304\305!!	#\207" [ada-search-directories-internal ada-spec-suffixes ff-get-file ada-make-filename-from-adaname match-string 3] 5] "^separate[ 	\n]*(\\(\\(\\sw\\|[_.]\\)+\\))" #[nil "\302\303\304\305!!	#\207" [ada-search-directories-internal ada-spec-suffixes ff-get-file ada-make-filename-from-adaname match-string 1] 5] "^with[ 	]+\\([a-zA-Z0-9_\\.]+\\)" #[nil "\302\303\304\305!!	#\207" [ada-search-directories-internal ada-spec-suffixes ff-get-file ada-make-filename-from-adaname match-string 1] 5] "\\([ 	]*\\(procedure\\|function\\|package\\|if\\|while\\|for\\|declare\\|case\\|end\\|begin\\|loop\\)\\|--\\)" ada-outline-level imenu--sort-by-name exclusive add-to-list align-dq-string-modes align-open-comment-modes align-exclude-rules-list (ada-solo-comment (regexp . "^\\(\\s-*\\)--") (modes quote (ada-mode))) (ada-solo-use (regexp . "^\\(\\s-*\\)\\<use\\>") (modes quote (ada-mode))) nil (ada-declaration-assign (regexp . "[^:]\\(\\s-*\\):[^:]") (valid lambda nil (not (ada-in-comment-p))) (repeat . t) (modes quote (ada-mode))) (ada-associate (regexp . "[^=]\\(\\s-*\\)=>") (valid lambda nil (not (ada-in-comment-p))) (modes quote (ada-mode))) (ada-comment (regexp . "\\(\\s-*\\)--") (modes quote (ada-mode))) (ada-use (regexp . "\\(\\s-*\\)\\<use\\s-") (valid lambda nil (not (ada-in-comment-p))) (modes quote (ada-mode))) (ada-at (regexp . "\\(\\s-+\\)at\\>") (modes quote (ada-mode))) define-key ada-popup-menu (ada-which-function) ada-which-function easy-menu-add ((< '(backward-delete-char-untabify (min ada-indent (current-column))))) skeleton-end-hook ada-adjust-case-skeleton hack-local-variables-hook #[nil "\306\301!\210\206	\307\n\310=\203\202)\n\311=\203 
\202)\n\312=\203)\f
\2050\313 \207" [ada-fill-comment-prefix comment-start ada-language-version ada-83-keywords ada-keywords ada-95-keywords make-local-variable "-- " ada83 ada95 ada2005 ada-activate-keys-for-case ada-2005-keywords ada-auto-case] 2] local run-mode-hooks ada-mode-hook] 7 (#$ . 28318) nil])
#@53 Adjust the case of the text inserted by a skeleton.
(defalias 'ada-adjust-case-skeleton #[nil "\212`\301\302Jb\210\303v\210`b\"*\207" [aa-end ada-adjust-case-region beg -1] 3 (#$ . 33785)])
#@40 Should we operate on an active region?
(defalias 'ada-region-selected #[nil "\300\301!\203	\301 \207\302 \207" [fboundp use-region-p region-active-p] 2 (#$ . 33983)])
#@140 Save the casing exception lists to the file FILE-NAME.
Casing exception lists are `ada-case-exception' and `ada-case-exception-substring'.
(defalias 'ada-save-exceptions-to-file #[(file-name) "\303\304!!\210\305 \210\306\307\310\311	!\312\"\"\210\306\313\310\311\n!\314\"\"\210\315 \210\316\317!\207" [file-name ada-case-exception ada-case-exception-substring find-file expand-file-name erase-buffer mapc #[(x) "@\301\261\207" [x "\n"] 2] sort copy-sequence #[(a b) "@	@\231\207" [a b] 2] #[(x) "\301@\302\261\207" [x "*" "\n"] 3] #[(a b) "@	@\231\207" [a b] 2] save-buffer kill-buffer nil] 5 (#$ . 34158)])
#@258 Define WORD as an exception for the casing system.
If WORD is not given, then the current word in the buffer is used instead.
The new word is added to the first file in `ada-case-exception-file'.
The standard casing rules will no longer apply to this word.
(defalias 'ada-create-case-exception #[(&optional word) ";\203	\202<\203@\202\306\307!\n\2046\310 p\311\216\312
!\210\212\313\314!\210\315`\212\316v\210`)\",\317	!\210\320\232\204V\321\n\322#\203V\321\n\322#\n\240\210\202]\323\324\n\322B\"\210\325	!)\207" [ada-case-exception-file file-name word #1=#:buffer #2=#:table ada-mode-symbol-syntax-table error "No exception file specified.  See variable ada-case-exception-file" syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-syntax-table skip-syntax-backward "w" buffer-substring-no-properties 1 ada-case-read-exceptions-from-file nil assoc-string t add-to-list ada-case-exception ada-save-exceptions-to-file] 4 (#$ . 34780) nil])
#@360 Define the substring WORD as an exception for the casing system.
If WORD is not given, then the current word in the buffer is used instead,
or the selected region if any is active.
The new word is added to the first file in `ada-case-exception-file'.
When auto-casing a word, this substring will be special-cased, unless the
word itself has a special casing.
(defalias 'ada-create-case-exception-substring #[(&optional word) ";\203	\202<\203@\202\305\306!\n\204F\307 \203*\310\311 \312 \"\202F\313z\314\216\315\313\316\317 #\210\212\320\321!\210\310`\212\322v\210`)\"+\323	!\210\f\324\232\204c\325\n\f\326#\203c\325\n\f\326#\n\240\210\202j\327\304\n\326B\"\210\330	!\210\331\332\333\n\334Q\")\207" [ada-case-exception-file file-name word underscore-syntax ada-case-exception-substring error "No exception file specified.  See variable ada-case-exception-file" ada-region-selected buffer-substring-no-properties region-beginning region-end 95 ((byte-code "\301\302\303\304\"\305 #\207" [underscore-syntax modify-syntax-entry 95 make-string 1 syntax-table] 5)) modify-syntax-entry "." syntax-table skip-syntax-backward "w" 1 ada-case-read-exceptions-from-file nil assoc-string t add-to-list ada-save-exceptions-to-file message "%s" "Defining " " as a casing exception"] 5 (#$ . 35787) nil])
#@58 Read the content of the casing exception file FILE-NAME.
(defalias 'ada-case-read-exceptions-from-file #[(file-name) "\306\307!!\205dp\310\307!!\210\311\n!\210~\210eb\210m\204]\312`\212\313v\210`)\"\314\315!\316\"\203G\313\317O\320\f\321#\204V\322\304\321B\"\210\202V\320
\321#\204V\322\305\321B\"\210)\313y\210\202\323\317!\210	q)\207" [file-name buffer ada-mode-symbol-syntax-table word ada-case-exception-substring ada-case-exception file-readable-p expand-file-name find-file set-syntax-table buffer-substring-no-properties 1 char-equal string-to-char 42 nil assoc-string t add-to-list kill-buffer] 4 (#$ . 37104)])
#@69 Read all the casing exception files from `ada-case-exception-file'.
(defalias 'ada-case-read-exceptions #[nil "\303\211\n;\203
\304\n!\207\n<\205\305\304\n\"\207" [ada-case-exception ada-case-exception-substring ada-case-exception-file nil ada-case-read-exceptions-from-file mapcar] 4 (#$ . 37749) nil])
#@49 Adjust case of substrings in the previous word.
(defalias 'ada-adjust-case-substring #[nil "`\306\307z\310\212\311v\210\312\216\313\307\314\315 #\210
\205I\316\317
\211@@)!\316Q\212\320	\f\306#\203@\321
\211@@)\306\"\210\202*)
A\211\204\310.\207" [ada-case-exception-substring re underscore-syntax case-fold-search max substrings t 95 nil -1 ((byte-code "\301\302\303\304\"\305 #\207" [underscore-syntax modify-syntax-entry 95 make-string 1 syntax-table] 5)) modify-syntax-entry "." syntax-table "\\b" regexp-quote re-search-forward replace-match x] 6 (#$ . 38064) nil])
#@170 Adjust case of the previous identifier.
The auto-casing is done according to the value of `ada-case-identifier'
and the exceptions defined in `ada-case-exception-file'.
(defalias 'ada-adjust-case-identifier #[nil "\305\232\204
\305f\306\232\203	\307!\210\310 \207`\212\311\312!\210`)\305\313\f{\314#\211\2036\f|\210\n@c\202<	\307!\210\310 +\207" [ada-case-exception ada-case-identifier match start end nil 95 -1 ada-adjust-case-substring skip-syntax-backward "w" assoc-string t] 4 (#$ . 38661) nil])
#@65 Return t if cursor is after a keyword that is not an attribute.
(defalias 'ada-after-keyword-p #[nil "\212\301v\210`Sf\205`Sf\302U\206`Sf\303U?\205 \304\305P!)\207" [ada-keywords -1 95 39 looking-at "[^_]"] 3 (#$ . 39180)])
#@133 Adjust the case of the word before the character just typed.
If FORCE-IDENTIFIER is non-nil then also adjust keyword as identifier.
(defalias 'ada-adjust-case #[(&optional force-identifier) "o?\205\205\304u\210o\204\203g\305=\203`SSf\305=\204\203`Sfz\306=\203\203\307\310\311 `\"\211\312\2068\310\311 `\"8)\206K\313\206I\310\311 `\"8))\204\203\314\315!\204\203\212\304v\210`eU\204b\304u\210g\305U)\203p	\304!\210\202\203\n\204\200\316 \203\200\304!\210\202\203\317 \210\320u\207" [parse-result ada-case-attribute force-identifier ada-case-keyword -1 39 119 nil parse-partial-sexp line-beginning-position 3 4 looking-back "\\([0-9]+#[0-9a-fA-F_]+\\)" ada-after-keyword-p ada-adjust-case-identifier 1] 4 (#$ . 39417)])
#@140 Adjust the case of the previous word, and process the character just typed.
ARG is the prefix the user entered with \[universal-argument].
(defalias 'ada-adjust-case-interactive #[(arg) "\203d	\306 p\307\216\310
!\210\n\311=\204\n\312=\203A\313c\210\314 \210\315\316!\210\n\311=\2034 \210\202T\n\312=\203T \210\202T\n\317=\203M\320 \210\202T\321\322!!\210\n\323=\203`\314\324!\202b\314 ,\207	\311=\203n \207	\312=\203x \207\321\322!!\207" [ada-auto-case last-command-event lastk #1=#:buffer #2=#:table ada-mode-symbol-syntax-table syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-syntax-table 10 13 " " ada-adjust-case delete-char -1 9 ada-tab self-insert-command prefix-numeric-value 95 t ada-lfd-binding ada-ret-binding arg] 3 (#$ . 40166) "P"])
#@75 Modify the key bindings for all the keys that should readjust the casing.
(defalias 'ada-activate-keys-for-case #[nil "\204\302\303!	\204\302\304!\305\306\307\"\207" [ada-ret-binding ada-lfd-binding key-binding "
" "\n" mapcar #[(key) "\302\303	!\304#\207" [ada-mode-map key define-key char-to-string ada-adjust-case-interactive] 4] (96 95 35 37 38 42 40 41 45 61 43 124 59 58 39 34 60 44 46 62 47 10 32 13)] 3 (#$ . 40990) nil])
#@175 Upcase first letter and letters following `_' in the following word.
No other letter is modified.
ARG is ignored, and is there for compatibility with `capitalize-word' only.
(defalias 'ada-loose-case-word #[(&optional _arg) "\212\212\302\303!\210`)\304\305\303!\210\204\306\307	\304#\2054`	W\2054\203'\310\311g\226\312\"\210\313\312!\210\202+\207" [first end skip-syntax-forward "w" t skip-syntax-backward search-forward "_" nil insert-char 1 delete-char] 4 (#$ . 41435) nil])
#@378 Do nothing.  ARG is ignored.
This function can be used for the auto-casing variables in Ada mode, to
adapt to unusual auto-casing schemes.  Since it does nothing, you can for
instance use it for `ada-case-identifier' if you don't want any special
auto-casing for identifiers, whereas keywords have to be lower-cased.
See also `ada-auto-case' to disable auto casing altogether.
(defalias 'ada-no-auto-case #[(&optional _arg) "\300\207" [nil] 1 (#$ . 41931)])
#@150 Upcase first letter and letters following '_', lower case other letters.
ARG is ignored, and is there for compatibility with `capitalize-word' only.
(defalias 'ada-capitalize-word #[(&optional _arg) "\212\302\303!\210`)\212\304\303!\210`)\305\306\307\"\210\310	\"\210\305\306\303\"*\207" [begin end skip-syntax-forward "w" skip-syntax-backward modify-syntax-entry 95 "_" capitalize-region] 3 (#$ . 42396) nil])
#@128 Adjust the case of all words in the region between FROM and TO.
Attention: This function might take very long for big regions!
(defalias 'ada-adjust-case-region #[(from to) "\306\211\211\211\307\310!\210\311 p\312\216\313!\210\212b\210\314\315\316#\203\230\317\225`V\205:\212\320u\210\321\322!\211)\306\323\324 `\"\211\325\206S\323\324 `\"8)\206i\326\206g\323\324 `\"8))\204`\321!\nb\210\203\203\320!\210\202\222	\203\217\320!\210\202\222\327 \210b\210\202\307\330!.\207" [attribp keywordp end begin #1=#:buffer #2=#:table nil message "Adjusting case ..." syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-syntax-table re-search-backward "\\<\\(\\sw+\\)\\>" t 1 -1 looking-at "'.[^']" parse-partial-sexp line-beginning-position 3 4 ada-adjust-case-identifier "Adjusting case ... Done" ada-mode-symbol-syntax-table to from parse-result ada-keywords ada-case-attribute ada-case-keyword] 4 (#$ . 42817) "*r"])
#@114 Adjust the case of all words in the whole buffer.
ATTENTION: This function might take very long for big buffers!
(defalias 'ada-adjust-case-buffer #[nil "\300ed\"\207" [ada-adjust-case-region] 3 (#$ . 43825) "*"])
#@42 Reformat the parameter list point is in.
(defalias 'ada-format-paramlist #[nil "\306\211\211\211\307 p\310\216\311!\210\312 \204\313\314!\210\315\316P\317\306#\210\320\321!\210\322u\210`\323\321!\210`\324\322!\210\325c\210\326\327!\210`\330T\n\"	|\210b\210\331!.\207" [paramlist delend end begin #1=#:buffer #2=#:table nil syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-syntax-table ada-in-paramlist-p error "Not in parameter list" ada-search-ignore-string-comment "\\|\\<body\\>" t down-list 1 -1 forward-sexp delete-char "\n" forward-comment -1000 ada-scan-paramlist ada-insert-paramlist ada-mode-symbol-syntax-table ada-subprog-start-re] 4 (#$ . 44045) nil])
#@104 Scan the parameter list found in between BEGIN and END.
Return the equivalent internal parameter list.
(defalias 'ada-scan-paramlist #[(begin end) "\306\211\307\306\211\211\211b\210\f\203\316\310 \210`\311\312\306\307$\211\2031@A\2024b\210\313\314!\210\315\316!C\311\317\306\n\307\320%\210`\321
\311\322\306\n\307\323%:C\"b\210\321
\311\324\306\n\307\323%:C\"b\210\321
\311\325\306\n\307\323%:C\"b\210\310 \210\313\326!\203\214\316v\210\310 \210\202}\313\327!\210\321
\315\330!C\"\330\225\211b\210\321
\311\331\306\n\307\320%\211\205\260@\n{C\"\321
C\"\n=\203\310\306\211\202	b\210\202\332!.\207" [match-cons semipos epos apos notend param nil t ada-goto-next-non-ws ada-search-ignore-string-comment "[ 	\n]*;" looking-at "\\(\\(\\sw\\|[_, 	\n]\\)*\\(\\sw\\|_\\)\\)[ 	\n]*:[^=]" match-string 1 ":" search-forward append "in" word-search-forward "out" "access" "\\<\\(in\\|out\\|access\\)\\>" "\\<\\(\\sw\\|[_.' 	]\\)+\\>" 0 ":=" reverse paramlist begin end] 9 (#$ . 44777)])
#@45 Insert a formatted PARAMLIST in the buffer.
(defalias 'ada-insert-paramlist #[(paramlist) "G\306\211\307\211\211\211\211)*+\310+!\204[+S+*+8@G]*)\311+88G])
\206A+8A@\f\206L\312+88\206W\313+88\202\212\314\315\307\316#\210\317\320!)\203{\321 \210\212\317\322!\203w\323\324!\210)\202\232\325 \210\212\317\326!\203\214\323\327!\210\202\226\317\330!\203\226\323\324!\210)\331c\210\332c\210\321 \210iG+\310+!\204V
+S+	+8@c\210\333\n*\334#j\210\335c\210i+8A@\203\327\336c\210\202\353
\204\337\203\353\313+88\204\353\337c\210\312+88\203\372\340c\210\202
\f\204
\203
\313+88\204
\341c\210\313+88\203
\342c\210i\311+88c\210\343+88\203=
\333\n)\334#j\210\343+88c\210\310+!\203J
\344c\210\202\246\345c\210\346 \210	j\210\202\246\317\347!?\205_
\350 .\207" [paramlist firstcol column accessp outp inp 0 nil zerop 4 2 3 re-search-backward "^.\\|[^ 	]" t looking-at "^." ada-indent-current "\\(is\\|return\\)" replace-match " \\1" fixup-whitespace "[ 	]*\\(\n\\|;\\)" "\\1" "[ 	]*\\(is\\|return\\)" " " "(" + 1 ": " "in " "   " "out " "    " "access " 5 ")" ";" newline "[ 	]*\\(;\\|\n\\|is\\|return\\)" ada-indent-newline-indent typlen parlen i] 8 (#$ . 45814)])
#@40 Indent the region between BEG end END.
(defalias 'ada-indent-region #[(beg end) "b\210\306\307	\"\310\311\307	\"\"\312	!`\nW\203@
\313V\203-\f
Z\306\314\f\"\210\315f\316U\2047\317 \210\320y\210
T\202\314\321!,\207" [beg end endmark msg lines-remaining block-done 0 count-lines format "%%4d out of %4d lines remaining ..." copy-marker 39 message nil 10 ada-indent-current 1 "Indenting ... done"] 7 (#$ . 47057) "*r"])
#@73 Indent the current line, insert a newline and then indent the new line.
(defalias 'ada-indent-newline-indent #[nil "\300 \210\301 \210\300 \207" [ada-indent-current newline] 1 (#$ . 47496) "*"])
#@107 Insert a newline and indent it.
The original line is re-indented if `ada-indent-after-return' is non-nil.
(defalias 'ada-indent-newline-indent-conditional #[nil "\301 \210\203\302u\210\303 \210\304u\210\303 \207" [ada-indent-after-return newline -1 ada-indent-current 1] 1 (#$ . 47698) "*"])
#@67 Indent the current line and explain how the calculation was done.
(defalias 'ada-justified-indent-current #[nil "\302 \212@b\210\303\304`\")A\305\232\203 \306\307\310	!P!\210\202*\306\311\312\313A\314#\"\210)\212@b\210\315\304!*\207" [cur-indent line ada-indent-current count-lines 1 (0) message "same indentation as line " number-to-string "%s" mapconcat #[(x) "9\203	\301!\207\247\203\302!\207<\205!\303\301\211A@)!P\207" [x symbol-name number-to-string "- "] 4] " + " sit-for] 6 (#$ . 47999) nil])
#@202 Re-indent and re-case all the files found on the command line.
This function should be used from the command line, with a
command like:
  emacs -batch -l ada-mode -f ada-batch-reformat file1 file2 ...
(defalias 'ada-batch-reformat #[nil "\203$@\302\303	\"\210\304	!\210\305ed\"\210\306 \210\307	!\210)A\211\204\302\310!\210\311\312!\207" [command-line-args-left source message "Formatting %s" find-file ada-indent-region ada-adjust-case-buffer write-file "Done" kill-emacs 0] 4 (#$ . 48526)])
#@117 Move point to the beginning of the previous word of Ada code.
Return the new position of point or nil if not found.
(defalias 'ada-goto-previous-word #[nil "\300\301!\207" [ada-goto-next-word t] 2 (#$ . 49034)])
(put 'ada-goto-previous-word 'byte-optimizer 'byte-compile-inline-expand)
#@118 Indent current line as Ada code.
Return the calculation that was done, including the reference point
and the offset.
(defalias 'ada-indent-current #[nil "\306 \307\211\211\307\216\310 p\311\216\312!\210\212\212\313\314y!)\203)\315 \210\316 \202,e\317D)\n\203@\212\n@b\210i)\nA\202D\317\307	\203d	@\247\203V	@\\\202]\320	@!\\	A\211\204H\212\315 \210i)U\204x\321 \210\322 \210j\210b\210i\323 W\203\205\315 \210,\n,\207" [prev-indent tmp-indent cur-indent orgpoint #1=#:buffer #2=#:table point-marker nil syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-syntax-table zerop -1 back-to-indentation ada-get-current-indent 0 eval beginning-of-line delete-horizontal-space current-indentation ada-mode-symbol-syntax-table] 5 (#$ . 49327) nil])
#@53 Return the indentation to use for the current line.
(defalias 'ada-get-current-indent #[nil "\306\211\211\211\212\307 \210\310\311!\210\312y\210`)
\203\313 \204\314 \211\203\212g\315U\203=\212\fb\210\316\306x\210`S)\317D\202{\316\306x\203_`Sf\320U\203_\310\311!\204_`Sf\321U\203_\f\322D\202{`Sf\315U\203j\323 \210`Sf\324>\203x\f\317D\202{\f\325D)\2029\306f\204\214\326\306\211#\2029\306f\227\327U\203r
\330\331!\203
\317\306@A\212\332\312!\210\212\307 \210\330\333!)\203\343\212\334\335\336\"@@)\212\334B\336@#\211\205\312\330\337!?)\203\343\n@b\210\212\340 \210\330C!\203\342D[A)\330\341!\203
\212\307 \210\330\342!)\203\377\212\340 \210`)\317D\202
\212\334\343\336\"@)\317D\202
\212\340 \210`)A\\\317D+\2029\330\344!\2030
\212\332\312!\210\212\340 \210`*\317D\2029\330\345!\203[
\212\346\336!\210\330\347!)\203J
\326\306\211#\2029\212\332\312\306\336#\210\340 \210`)\317D\2029\330\350!\2059\212\332\312\306\336#\210\340 \210`)\317D\2029\306f\227\351U\203\220
\330\352!\203\220
\212\332\312!\210\212\340 \210`*\353D\2029\306f\227\354U\203\303
\330\355!\203\303
\212\346\336!\210\330\356!)\203\262
\326\306\211#\2029\212\334\357\336\306#\210\340 \210`)\360D\2029\306f\227\361U\203\330\362!\203`\212\317\225b\210\363 \210\330\364!\203\351
\326\306\211#\202\330B!\204\367
\334B\306#\210\330\337!\203\326\306\211#\202\340 \210`\360D)\2029\306f\227\361U\203\330\365!\204+\306f\227\366U\203J\330\367!\203J\212\334\370\336\306#\210\330\371!\203@\334\372\336\306\211\373%\210\340 \210`)\374D\2029\306f\227\375U\203q\330\376!\203q\212\377\336!\203h\340 \210`\317D\202m\326\306\211#)\2029\306f\227\201NU\203\320\330\201O!\203\320E\203\257\212\317\225b\210\201P\201Q !\210\330\201R!)\203\257\212\363 \210\340 \210`)\201SD\2029\212\363 \210\330\201T!\203\304\340 \210`\317D\202\314\340 \210`\201SD)\2029\306f\227\366U\203\253\330\201U!\203\253\212\201VF\330\201W!\203\306\212\334\201X\336\")\203\n@f\227\366U\203\n@b\210\201YF)\310\201Z!\210`Sf\315U\203)\201[\201\\!\210\202.\201\\v\210\312Gg\201]U\203|\212\201\\v\210\330\201^!\206V\201\\v\210\201_G\330\201^!)\203|\201`F!\317X\203p`\201aFDD\202\247G[v\210`FD\202\247\201`F!\317V\203\242\212\201\\v\210\330\201b!)\203\242\201\\v\210`FD\202\247\326\306\211#+\2029\306f\227\201cU\204\277\306f\227\201dU\203\334\201e \204\315\201f \203\334\212\332\312!\210\340 \210`)\317D\2029\306f\227\201gU\203\374\330\201h!\203\374\212\363 \210\340 \210`)\360D\2029\306f\201iU\203oH\203d\306I\203[\212\201\\y\210\307 \210\204L\201j\201k\201Q \336#\203L\306J\201lJ\206A\201m\201n `\"8)\204`\211\203)\203[\201_Z\317D\202`\326\306\211#)\2029\212\340 \210`)\317D\2029\306f\201oU\203\222K\201p\232\203\222\330\201q!\203\222\201r \317D\2029m\204\254\306f\315U\203\254\212\312u\210\323\312!\210`)\317D\2029\330\201s!\203\274\326\306\211#\2029\306f\227\201dU\204\320\306f\227\201tU\203\330\201u!\203\212\306LL\204\374\334\201v\336\"\203\374\212\201\\v\210\330\201w!?L)\202\334)\330\201x!\203\340 \210`\317D\202\326\306\211#)\2029\330M!\2059\201y \203-\326\306\211#\2029\201z\326\306\211#\201{\"\211\206C\326\306\211#-\207" [orgpoint result match-cons pos column ada-indent-to-open-paren nil beginning-of-line forward-comment -10000 1 ada-in-paramlist-p ada-in-open-paren-p 41 " 	" 0 10 62 ada-broken-indent backward-sexp (44 59 40 41) ada-continuation-indent ada-indent-on-previous-lines 101 looking-at "end\\>" ada-goto-matching-start ".+\\<loop\\>" ada-search-ignore-string-comment ";" t "\\<loop\\>" back-to-indentation "record" "^[ 	]*\\(record\\|limited record\\)" "\\<type\\>" "exception\\>" "else\\>" ada-goto-next-word "\\<or\\>" "elsif\\>" 119 "when\\>" ada-when-indent 116 "then\\>" "and\\>" "\\<\\(elsif\\|if\\|select\\)\\>" ada-stmt-end-indent 108 "loop\\>" ada-goto-stmt-start "\\<\\(loop\\|if\\)\\>" "limited\\>" 114 "record\\>" "\\<\\(type\\|use\\)\\>" "\\<use\\>" "for" word-search-backward ada-indent-record-rel-type 98 "begin\\>" ada-goto-decl-start limit label ada-loop-start-re ada-block-label-re ada-label-indent ada-indent-is-separate var num-back ada-indent-comment-as-code ada-indent-align-comments parse-result ada-which-compiler found ada-label-re 105 "is\\>" ada-goto-next-non-ws point-at-eol "\\<abstract\\>\\|\\<separate\\>" ada-indent "\\<overriding\\|package\\|procedure\\|function\\>" "re\\(turn\\|names\\)\\>" ada-indent-return "renames" ";\\|return\\>" ada-indent-renames -1000 forward-sexp -1 40 "\\(function\\|procedure\\)\\>" 2 eval - "function\\>" 111 112 ada-looking-at-semi-or ada-looking-at-semi-private 100 "do\\>" 45 search-forward "--" 3 parse-partial-sexp line-beginning-position 35 gnat "#[ 	]*\\(if\\|els\\(e\\|if\\)\\|end[ 	]*if\\)" point-at-bol "\\(new\\|abstract\\|separate\\)\\>" 102 "\\<\\(package\\|function\\|procedure\\)\\>" "\\<\\(generic\\|end\\|begin\\|overriding\\|package\\|procedure\\|function\\)\\>" "with" "\\<generic\\|overriding\\>" ada-in-decl-p append (ada-label-indent)] 7 (#$ . 50140)])
#@269 Calculate the indentation for the new line after ORGPOINT.
The result list is based on the previous lines in the buffer.
If NOMOVE is nil, moves point to the beginning of the current statement.
if INITIAL-POS is non-nil, moves point to INITIAL-POS before calculation.
(defalias 'ada-indent-on-previous-lines #[(&optional nomove orgpoint initial-pos) "\203b\210`\306 \203\307 \202\353\n\204\310\311!\210	`=\203*\n\204*\312 \202\353\2038\313 \2038\314 \202\353\315\316!\203D\317\f!\202\353\315
!\203P\320\f!\202\353\315'!\203]\321\f!\202\353\315(!\203j\322\f!\202\353\315)!\203w\323\f!\202\353\315*!\203\204\324\f!\202\353\315\325!\203\220\326\f!\202\353\315\327!\203\234\330\f!\202\353\315\331!\203\250\332\f!\202\353\315\333!\203\264\334\f!\202\353\315\335!\203\277\312 \202\353\315\336!\203\350\212\337\340	\311#)\203\330\341 \210`\342D\202\353`\315\343!\203\343\344\202\344\345D\202\353\346\f!)\207" [initial-pos oldpoint nomove ada-indent-to-open-paren orgpoint ada-loop-start-re ada-in-paramlist-p ada-get-indent-paramlist ada-goto-stmt-start t ada-get-indent-nochange ada-in-open-paren-p ada-get-indent-open-paren looking-at "end\\>" ada-get-indent-end ada-get-indent-loop ada-get-indent-subprog ada-get-indent-block-start ada-get-indent-block-label ada-get-indent-goto-label "\\(sub\\)?type\\>" ada-get-indent-type "\\(\\(els\\)?if\\>\\)\\|then abort\\>" ada-get-indent-if "case\\>" ada-get-indent-case "when\\>" ada-get-indent-when "separate\\>" "with\\>\\|use\\>" search-forward ";" back-to-indentation 0 "with" ada-with-indent ada-use-indent ada-get-indent-noindent ada-subprog-start-re ada-block-start-re ada-block-label-re ada-goto-label-re] 4 (#$ . 55276)])
#@73 Calculate the indentation when point is behind an unclosed parenthesis.
(defalias 'ada-get-indent-open-paren #[nil "\300 \301D\207" [ada-in-open-paren-p 0] 2 (#$ . 57001)])
#@54 Return the current indentation of the previous line.
(defalias 'ada-get-indent-nochange #[nil "\212\300y\210\301 \210`)\302D\207" [-1 back-to-indentation 0] 2 (#$ . 57180)])
#@66 Calculate the indentation when point is inside a parameter list.
(defalias 'ada-get-indent-paramlist #[nil "\212\300\301\302\303\302$\210\303f\304U\203\305\225b\210`\305D\202V\303f\306U\2032\300\307\302\303\302$Ab\210\310 \210`\305D\202Vg\311U\203Gh\312U\203G\313 \210`\314D\202V\300\307\302\303\302$Ab\210\310 \210`\314D)\207" [ada-search-ignore-string-comment "[^ 	\n]" t nil 40 0 59 "(\\|;" ada-goto-next-non-ws 61 58 back-to-indentation ada-broken-indent] 5 (#$ . 57360)])
#@127 Calculate the indentation when point is just before an end statement.
ORGPOINT is the limit position used in the calculation.
(defalias 'ada-get-indent-end #[(orgpoint) "\304\211\212\305\306\304\n\304\307%)\203\262\310v\210\311 \210\312\313!\203/\212\314\315\316!!\210)\212\317 \210`)\316D\202\272\312\320!\203W\212\314\315\316!!\210\310v\210\321 \210\312\322!\204M\305\323\324\"\210\317 \210`)\316D\202\272\312!\203t\315\316!\212\325\316!\210\326	!\210)\317 \210`\316D\202\272\304f\327U\203\247\212\325\316!\210\312\330!\203\235`\316D\331\324!\203\231\317 \210`\316D\202\243\202\243\317 \210`\316D)\202\272\212\317 \210`)\332D\202\272\212\317 \210`)\332D*\207" [indent defun-name orgpoint ada-ident-re nil ada-search-ignore-string-comment ";" search-forward 1 ada-goto-next-non-ws looking-at "\\<\\(loop\\|select\\|if\\|case\\|return\\)\\>" ada-check-matching-start match-string 0 back-to-indentation "\\<record\\>" ada-goto-stmt-start "\\(for\\|type\\)\\>" "\\<type\\>" t ada-goto-matching-start ada-check-defun-name 59 "\\<begin\\>" ada-goto-decl-start ada-broken-indent] 6 (#$ . 57852)])
#@127 Calculate the indentation when point is just before a case statement.
ORGPOINT is the limit position used in the calculation.
(defalias 'ada-get-indent-case #[(orgpoint) "\303`\212\304\305\303\n\303\306%\205\304\307\303\n#\211)\2036\212	@b\210\304\310\311#\204+\312\313!\210\212\314 \210`*\315D\202t\212\304\310\303\n\303\306%\211)\203S	Ab\210\212\314 \210`)\316D\202t\212\304\305\303\n\303\306%\211)\203l\212\314 \210`)\317D\202t\212\314 \210`)\316D*\207" [opos match-cons orgpoint nil ada-search-ignore-string-comment "is" word-search-forward "[ 	\n]+=>" "when" t error "Missing 'when' between 'case' and '=>'" back-to-indentation ada-indent ada-broken-indent ada-when-indent] 6 (#$ . 58972)])
#@127 Calculate the indentation when point is just before a when statement.
ORGPOINT is the limit position used in the calculation.
(defalias 'ada-get-indent-when #[(orgpoint) "\212\302 \210`)\303\304\305	#\203\306D\202\307D)\207" [cur-indent orgpoint back-to-indentation ada-search-ignore-string-comment "[ 	\n]*=>" nil ada-indent ada-broken-indent] 4 (#$ . 59690)])
#@126 Calculate the indentation when point is just before an if statement.
ORGPOINT is the limit position used in the calculation.
(defalias 'ada-get-indent-if #[(orgpoint) "\212\303 \210`)\304\305\306\304\n#\211\203@f\227\307U\204	\203;\212\303 \210\310\311!)\2032\212\303 \210`)\312v\210	\313D\202>	\314D*\207" [match-cons cur-indent orgpoint back-to-indentation nil ada-search-ignore-string-comment "\\<\\(then\\|and[ 	]*then\\)\\>" 97 looking-at "\\<then\\>" 1 ada-indent ada-broken-indent] 4 (#$ . 60066)])
#@122 Calculate the indentation when point is at the start of a block.
ORGPOINT is the limit position used in the calculation.
(defalias 'ada-get-indent-block-start #[(orgpoint) "\304\212\305v\210\306	!\211)\203b\210\212\307\310	\")\202^\311\312!\203C\212\313 \210\311\314!)\2037\212\315 \210`)\316D\202^\212\317\320\310\"@)\316D\202^\311\n!\203V\212\315 \210`)Z\316D\202^\212\315 \210`)\316D)\207" [pos orgpoint ada-block-label-re ada-label-indent nil 1 ada-goto-next-non-ws ada-indent-on-previous-lines t looking-at "record" beginning-of-line "^[ 	]*\\(record\\|limited record\\)" back-to-indentation ada-indent ada-search-ignore-string-comment "\\<type\\>"] 3 (#$ . 60591)])
#@123 Calculate the indentation when point is just before a subprogram.
ORGPOINT is the limit position used in the calculation.
(defalias 'ada-get-indent-subprog #[(orgpoint) "\305\212\306 \210`)\305\212\307\310\305#\211)\203 \311\nAb\210\202)\312!\204)b\210\203>\212\307\313\305\311$)\204>	\314D\202\214\203]\212\307\315\305#\211)\203]\n@b\210\307\f\311\"\210\316!\202\214\203w\212\312!\211)\203w\nb\203w\317\311\"\206\214\212\307\320\305\305\321%)\203\211	\322D\202\214	\323D+\207" [foundis cur-indent match-cons orgpoint ada-subprog-start-re nil back-to-indentation ada-search-ignore-string-comment "\\<\\(is\\|do\\)\\>" t ada-goto-next-non-ws "[^ 	\n]" ada-indent "\\<\\(separate\\|new\\|abstract\\)\\>" ada-get-indent-noindent ada-indent-on-previous-lines ";" search-forward 0 ada-broken-indent] 6 (#$ . 61283)])
#@128 Calculate the indentation when point is just before a 'noindent stmt'.
ORGPOINT is the limit position used in the calculation.
(defalias 'ada-get-indent-noindent #[(orgpoint) "\305\212\306 \210\307 \203\310 \210\212\311 \210`)\305D\202\252\312\313!\203*\212\311 \210`)\314D\202\252\312\315	P!\2038\n[\202\207\316\212\317\320\316\f#\205U`\211\205U\212\321u\210\322\323!\210\312\324!))\204x\212\317\325\316\f#\205t`\211\205t\212\326u\210\322\323!\210\312\327!))\203\206b\210\330\331\316\323#\210\212\311 \210))\212\317\332\316\f\316\333%)\203\240\212\311 \210`)\\\305D\202\252\212\311 \210`)\\\334D*\207" [label ada-block-label-re ada-label-indent p orgpoint 0 beginning-of-line ada-in-paramlist-p ada-previous-procedure back-to-indentation looking-at "[ 	]*\\(\\sw\\|_\\)*[ 	]*,[ 	]*$" ada-broken-decl-indent "[ 	]*" nil ada-search-ignore-string-comment "\\<private\\>" -7 ada-goto-next-word t "with" "\\<record\\>" -6 "null" re-search-backward "\\<\\(type\\|subtype\\)\\>" ";" search-forward ada-broken-indent] 6 (#$ . 62136)])
#@128 Calculate the indentation when before a label or variable declaration.
ORGPOINT is the limit position used in the calculation.
(defalias 'ada-get-indent-block-label #[(orgpoint) "\304\212\305 \210`)\306\307\304\"\210\212\306\n\304#\211)\203$	@b\210\310!\202]\212\306\311\304#\211)\203?	@b\210\212\305 \210`)\312D\202]\313 \203Z\212\306\314\304#)\203T\315D\202]\316D\202]\317D*\207" [cur-indent match-cons ada-loop-start-re orgpoint nil back-to-indentation ada-search-ignore-string-comment ":" ada-get-indent-loop "\\<declare\\|begin\\>" ada-indent ada-in-decl-p ";" 0 ada-broken-indent (- ada-label-indent)] 4 (#$ . 63194)])
#@49 Calculate the indentation when at a goto label.
(defalias 'ada-get-indent-goto-label #[(orgpoint) "\302\303!\210\304 \210`Y\203`	ZC\207\305\306\"\207" [orgpoint ada-label-indent search-forward ">>" ada-goto-next-non-ws ada-indent-on-previous-lines t] 3 (#$ . 63844)])
#@125 Calculate the indentation when just before a loop or a for ... use.
ORGPOINT is the limit position used in the calculation.
(defalias 'ada-get-indent-loop #[(orgpoint) "\306`\212\307 \210\310!\203	[\202\311)\212\312\313\306
\306\314%)\203/\212\307 \210`)\n\\\311D\202(
\310\315!\203R\316
!\n\311\232\203C\202(
@\n\\\211A@)D\202(
\310\317!\203\353\212\311\225b\205\217\320
!\205\217\321v\205\217\306f\322U\203v\321v\202w\323\205\217\320
!\205\217\310\324!\205\217\312\325\306
\306\326%\323)\203\261\f\203\246\f@b\210\212\307 \210`)\327D\202(
\212\307 \210`)\330D\202(
\212\312\331\306
\306\326%\211)\203\336\f@b\210\212\307 \210\310\332!)\204\321b\210\212\307 \210`)\n\\\327D\202(
\212\307 \210`)\n\\\330D\202(
\310\333!\205(
\212\312\331\306
\306\326%\211)\203
\f@b\210\212\307 \210\310\332!)\204
b\210\212\307 \210`)\n\\\327D\202(
\212\307 \210`)\n\\\330D+\207" [ada-block-label-re ada-label-indent label pos match-cons orgpoint nil back-to-indentation looking-at 0 ada-search-ignore-string-comment ";" search-forward "loop\\>" ada-get-indent-block-start "for\\>" ada-goto-next-non-ws 1 39 t "\\<use\\>" "record" word-search-forward ada-indent ada-broken-indent "loop" "\\<loop\\>" "while\\>" x] 7 (#$ . 64123)])
#@113 Calculate the indentation when before a type statement.
ORGPOINT is the limit position used in the calculation.
(defalias 'ada-get-indent-type #[(orgpoint) "\302\212\303\304\302	\302\305%\211\205(\306 \205(\307\310!\205(\311v\205(\306 \205(\302f\312U)\203;@b\210\212\313 \210`)\314D\202\225\212\303\315\302	\302\305%\211)\203X@b\210\212\313 \210`)\316D\202\225\212\303\317\302	\302\320%)\203o\212\313 \210`)\314D\202\225\212\303\321\302	\302\305%\205~\306	!?)\203\215\212\313 \210`)\322D\202\225\212\313 \210`)\322D)\207" [match-dat orgpoint nil ada-search-ignore-string-comment "end" word-search-forward ada-goto-next-non-ws looking-at "\\<record\\>" 1 59 back-to-indentation 0 "record" ada-indent ";" search-forward "is" ada-broken-indent] 6 (#$ . 65381)])
#@200 Move point to the beginning of the statement that point is in or after.
Return the new position of point.
As a special case, if we are looking at a closing parenthesis, skip to the
open parenthesis.
(defalias 'ada-goto-stmt-start #[(&optional ignore-goto-label) "\303`\304 \211\203/\305\306!\204;\212	Ab\210\307\n\")\204!\304 	\203)	Ab\210\307 \210\202;eb\210\307!\204;b\210`*\207" [orgpoint match-dat ignore-goto-label nil ada-search-prev-end-stmt looking-at "declare" ada-goto-next-non-ws] 4 (#$ . 66166)])
#@124 Move point to previous end statement.
Return a cons cell whose car is the beginning and whose cdr
is the end of the match.
(defalias 'ada-search-prev-end-stmt #[nil "\303\211\204t\304\n\305\"\211\203t	@b\210\306 \204\307\310!\2032\212\311\305!\210\307\312!)\2032\313v\210\202\307\314!\203[\212\311\305!\210\311\305!\210\307\315!)?\205V\212	Ab\210\316 \210\307\317!)?\211\202\307\320!\203n\212\313v\210\307\314!?)\202\305\211\203\205y	*\207" [found match-dat ada-end-stmt-re nil ada-search-ignore-string-comment t ada-in-open-paren-p looking-at "\\<\\(record\\|loop\\|select\\|else\\|then\\)\\>" ada-goto-next-word "\\<\\(end\\|or\\|and\\)\\>[ 	]*[^;]" -1 "is" "subtype" ada-goto-next-non-ws "\\<\\(a\\(?:bstract\\|ccess\\|rray\\)\\|new\\|\\(?:priv\\|separ\\)ate\\)\\>\\|(" "private"] 4 (#$ . 66695)])
#@214 Skip to next non-whitespace character.
Skips spaces, newlines and comments, and possibly goto labels.
Return `point' if moved, nil if not.
Stop the search at LIMIT.
Do not call this function from within a string.
(defalias 'ada-goto-next-non-ws #[(&optional limit skip-goto-label) "\204d`X\203A\304\305!\210m\2040\212\306u\210\307\310	\206$\311\312 `\"8*\2030\313\306!\210\202\n\203A\314!\203A\315\225b\210\202`W\205H`\207" [limit parse-result skip-goto-label ada-goto-label-re forward-comment 10000 1 nil 3 parse-partial-sexp line-beginning-position forward-sexp looking-at 0] 4 (#$ . 67529)])
#@148 Move point to the end of the statement that point is in or before.
Return the new position of point or nil if not found.
Stop the search at LIMIT.
(defalias 'ada-goto-stmt-end #[(&optional limit) "\302\303	#\205	`\207" [ada-end-stmt-re limit ada-search-ignore-string-comment nil] 4 (#$ . 68150)])
#@181 Move point to the beginning of the next word of Ada code.
If BACKWARD is non-nil, jump to the beginning of the previous word.
Return the new position of point or nil if not found.
(defalias 'ada-goto-next-word #[(&optional backward) "\304`\305\306z!\307\306\310\"\210\204\311\310!\210\312\313\304\314$\211\203,\n@b\210\315\310!\210\202/	b\210\307\306\"+\207" [old-syntax orgpoint match-cons backward nil char-to-string 95 modify-syntax-entry "w" skip-syntax-forward ada-search-ignore-string-comment "\\w" t skip-syntax-backward] 5 (#$ . 68456)])
#@98 Signal an error if matching block start is not KEYWORD.
Moves point to the matching block start.
(defalias 'ada-check-matching-start #[(keyword) "\301\302!\210\303\304\305Q!?\205\306\307\"\207" [keyword ada-goto-matching-start 0 looking-at "\\<" "\\>" error "Matching start is not '%s'"] 4 (#$ . 69019)])
#@181 Check if the name of the matching defun really is DEFUN-NAME.
Assumes point to be already positioned by `ada-goto-matching-start'.
Moves point to the beginning of the declaration.
(defalias 'ada-check-defun-name #[(defun-name) "\212\302\303!\210\304\305\306Q!)\203\303\207\304	!\204\307 \210\212\304\310!\203+\311\312!\210\312v\210\202B\313v\210\312v\210\304\314!\203:\315v\210\316\315!\210\317\315!\210\304\305\320Q!?\205V\321\322`\316\315!\210`{\")\207" [defun-name ada-subprog-start-re ada-goto-next-word t looking-at "\\<" "\\> *:" ada-goto-decl-start "\\<declare\\>" forward-comment -1 2 "\\<\\(body\\|type\\)\\>" 1 forward-sexp backward-sexp "\\>" error "Matching defun has different name: %s"] 5 (#$ . 69335)])
#@143 Move point to the declaration start of the current construct.
If NOERROR is non-nil, return nil if no match was found;
otherwise throw error.
(defalias 'ada-goto-decl-start #[(&optional noerror) "\306\307\310\311\211\312\313!\203\310\312\314!\204%\212\315\316\310\"\210\312\317!)\203'\310\320\f!\204^
\315\310\"\203^
\312\321!\203u\322\306
\"\210\312\313!\203'\310+\212+\203q\315\323\310\"\210\312\321!\203b\322\306
\310#\210\202I\311+\312\313!\204I\fT\202I*\202'\312\317!\203\207	\203'\311\fS\202'\312\324!\203\240\212\325v\210\312\326!\204\234\fS\311)\202'\312\327!\203\256\fS\310\202'\312\330!\203
\312\331!\204'\212\332\333!\210\325u\210\311f\334U\203\324\306u\210\335\306!\210\332\333!\210\336\311x\210\337\310!\210\312\340!\205\361\341 ,\342\216\337\310!\210\312\343!*?)\204'\212\337 \210\312\344!)\204'\fS\311\202'\312\345!\203!
\212\337\310!\210\312\330!)\203'\346\224b\210\202'\n\2030
\312\313!\2030
\346\202'\312\347!\203K
\212\325v\210\312\350!\204G
\203G
\fS)\202'\312\313!\203V
\311\202'\fT\311\202'\320\f!\203|
\312\330!\203r
\315-\310\"\202u
\312\327!\203|
\310\202\204

?\205\204
\351\352!-\207" [stop-at-when count-generic first regexp nest-count noerror 1 "\\<\\(begin\\|declare\\|end\\|generic\\|i[fs]\\|new\\|separate\\|when\\)\\>" t nil looking-at "begin" "\\<\\(package\\|procedure\\|function\\)\\>" ada-search-ignore-string-comment "\\<\\(package\\|procedure\\|function\\|generic\\)\\>" "generic" zerop "end" ada-goto-matching-start "\\<\\(declare\\|begin\\|end\\|procedure\\|function\\|task\\|package\\)\\>" "if" -1 "\\<end[ 	\n]*if\\>" "declare\\|generic" "is" "is[ t]+<>" forward-comment -10000 41 backward-sexp "a-zA-Z0-9_.'" ada-goto-next-word "\\<\\(sub\\)?type\\|case\\>" match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "\\<protected\\>" "\\<null\\>" "new" 0 "when" "\\<exit[ 	\n]*when\\>" error "No matching proc/func/task/declare/package/protected" loop-again save-match-data-internal ada-subprog-start-re] 5 (#$ . 70070)])
#@260 Move point to the beginning of a block-start.
Which block depends on the value of NEST-LEVEL, which defaults to zero.
If NOERROR is non-nil, it only returns nil if no matching start was found.
If GOTOTHEN is non-nil, point moves to the 'then' following 'if'.
(defalias 'ada-goto-matching-start #[(&optional nest-level noerror gotothen) "\203\202	\306\307\211\211\204\254
\310
\311\"\203\254
\312\313!\203,\212\314v\210\312\315!)\204\312\316!\203<\307\nB\fT\202\244
\312\317!\203u`\212\320\311!\210\312\321!\203[\fT`\307\nB\202n\fS\n@\203k\nAA\211\202_\nA)	b\210\202\244
\312\322!\203\277\212`\310\323\307\"8	\203\217	@b\210\202\235\324\325\326\327\330\3318T\"!Q!\210*\312\332!\204\270\331v\210\333 \210\312\334!\204\270\n@\204\270\fS)\nA\202\244
\312\335!\203
\212\331v\210\333 \210\312\336!\204
\312\337!\203
\340v\210\333 \210\312\341!\204
\312\342!\203\357\310\343\307\"\210\310\344\307\"\2119\203
9@b\210\312\345!\203
\fS)\202
\331v\210\312\346!\204
\fS)\nA\202\244
\312\347!\203O
\nA\331::\306V\203K
\n@\311\232\203@
:T:\202E
:S:\nA\202*
)\202\244
\312\350!\203s
\212\310\351\307\"\211\203c
	@b\210\312\345!\203l
\nA*\fS\202\244
\312\352!\204
\312\353!\203\233
\212\310\354\307\"\211\203\215
	@b\210\312\345!\203\227
\nAA*\202\244
\312\355!\nB\fS\356\f!\211\203o\203\264
`\202\373
\203\362
;\203\335
\312\357!\203\335
\212\310\360\307\211\211\361%\210\362 \210\312\363!)\203\335
\306\224b\210\202\356
\312\364!\203\356
\310\365\311\"\204\356
\324\366!\210`\202\373
<?\205\373
\324\367!,\207" [nest-level pos last-was-begin found nest-count ada-matching-start-re 0 nil ada-search-ignore-string-comment t looking-at "\\<record\\>" -1 "\\<null\\>" "end" "loop\\|select\\|record\\|case\\|if" ada-goto-next-word "\\<end\\>[ 	]*[^;]" "package" "\\<\\(is\\|renames\\|;\\)\\>" error "No matching 'is' or 'renames' for 'package' at" " line " number-to-string count-lines 1 "renames" ada-goto-next-non-ws "\\<\\(new\\|separate\\|begin\\)\\>" "task" "\\<body\\>" "\\<type\\>" 2 ";" "(" ")" "\\<\\(is\\|;\\)\\>" "is" "[ 	]*;" "declare" "protected" "\\(\\<is\\>\\|\\<renames\\>\\|;\\)" "procedure" "function" "\\(\\<is\\>\\|\\<renames\\>\\|)[ 	]*;\\)" "begin" zerop "if" "then" word-search-forward back-to-indentation "\\<then\\>" "do" "\\<accept\\|return\\>" "Missing 'accept' or 'return' in front of 'do'" "No matching start" current tmp count gotothen noerror] 8 (#$ . 72143)])
#@178 Move point to the end of a block.
Which block depends on the value of NEST-LEVEL, which defaults to zero.
If NOERROR is non-nil, it only returns nil if no matching start found.
(defalias 'ada-goto-matching-end #[(&optional nest-level noerror) "\206\306\307\310\211\311\312!?\311\313!\203\314u\210\204\265\315\f\310\"\203\265\316v\210\311\317!\203Z	\2038\314v\210\202\260`\315\320!\210`Sf\321U\203\260\322 \210\311\323!\204\260\nb\210\324\306\325\"\210\202\260\311\326!\203z
S\211\306X\327\310w\210\322 \210\311\330!\203\260\314v\210\202\260\311\331!\203\242\315\332\310\211\211\333%\210\322 \210\311\323!\203\230\306\225b\210\202\260
T\211\306X\202\260	\204\251
T
\306X\314v\210\310\202\203\275\325\202\306?\205\306\334\335!-\207" [nest-level first pos found regex nest-count 0 "\\<\\(begin\\|case\\|do\\|end\\|function\\|if\\|loop\\|p\\(?:\\(?:ackag\\|rocedur\\)e\\)\\|record\\|select\\|task\\)\\>" nil looking-at "declare" "\\<if\\|loop\\|case\\|begin\\>" 1 ada-search-ignore-string-comment -1 "\\<procedure\\|function\\>" "is\\|;" 115 ada-goto-next-non-ws "\\<new\\>" ada-goto-matching-end t "\\<end\\>" "end" "\\<\\(loop\\|select\\|record\\|case\\|if\\)\\>" "\\<package\\>" "is" word-search-forward error "No matching end" noerror] 7 (#$ . 74598)])
#@441 Regexp-search for SEARCH-RE, ignoring comments, strings.
Returns a cons cell of begin and end of match data or nil, if not found.
If BACKWARD is non-nil, search backward; search forward otherwise.
The search stops at pos LIMIT.
If PARAMLISTS is nil, ignore parameter lists.
The search is done using SEARCH-FUNC.  SEARCH-FUNC can be optimized
in case we are searching for a constant string.
Point is moved at the beginning of the SEARCH-RE.
(defalias 'ada-search-ignore-string-comment #[(search-re &optional backward limit paramlists search-func) "\306\211\211\211\f\204
\203\307\202\310\311 p !\312\216\313\"!\210\204\351#\203?
\2038#`X\204?#`Y\203\351\f$#\314#\203\351\315\224\315\225\316\317 `\"\211\320\206a\316\321 `\"8)\203v\3228b\210
\204$\323\314!\210\202$\324\206\202\316\321 `\"8)\203\246\3228b\210
\204$\325\314!\203\240\325\326!\210\327 \210\202$\306\210\202$\nf\330U\203\303\nTf\330U\203\303
\204$\331u\210\325\326!\210\202$%\204\343\332 \203\343
\203\332\333\334\306\335#\210\202$\336\337\306\335#\210\202$\335\211\203(+\205\361\n	B,\207" [parse-result end begin found search-func backward nil re-search-backward re-search-forward syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1=#:buffer #2=#:table set-syntax-table] 2)) set-syntax-table 1 0 parse-partial-sexp point-at-bol 3 line-beginning-position 8 forward-sexp 4 forward-comment 1000 beginning-of-line 45 -1 ada-in-paramlist-p search-backward "(" t search-forward ")" #1# #2# ada-mode-symbol-syntax-table limit search-re paramlists] 5 (#$ . 75901)])
#@96 Return t if point is inside a declarative part.
Assumes point to be at the end of a statement.
(defalias 'ada-in-decl-p #[nil "\300 \206\n\212\301\302!)\207" [ada-in-paramlist-p ada-goto-decl-start t] 2 (#$ . 77495)])
#@55 Return t if looking at an 'or' following a semicolon.
(defalias 'ada-looking-at-semi-or #[nil "\212\300\301!\205\302v\210\303 \210\300\301!)\207" [looking-at "\\<or\\>" 1 ada-goto-stmt-start] 2 (#$ . 77720)])
#@193 Return t if looking at the start of a private section in a package.
Return nil if the private is part of the package name, as in
'private package A is...' (this can only happen at top level).
(defalias 'ada-looking-at-semi-private #[nil "\212\300\301!\205'\300\302!?\205'\303\304!\210o?\205'`Sf\305U\206'\306v\205'\300\307!)\207" [looking-at "\\<private\\>" "\\<private[ 	]*\\(package\\|generic\\)" forward-comment -1000 59 -3 "\\<package\\>"] 2 (#$ . 77938)])
#@106 Return t if point is inside the parameter-list of a declaration, but not a subprogram call or aggregate.
(defalias 'ada-in-paramlist-p #[nil "\212\301\302\303\304\303$\205Z\304f\305U\205Z\306\304x\210`Sf\307U\203#\310u\210\202&\311v\210\311v\205Z\304\312\313 `\"\211\314\206?\312\313 `\"8)\206R\315\206P\312\313 `\"8))?\205Z\316\317!)\207" [parse-result ada-search-ignore-string-comment "(\\|)" t nil 40 " 	\n" 34 -3 -1 parse-partial-sexp line-beginning-position 3 4 looking-at "\\<\\(procedure\\|function\\|body\\|task\\|entry\\|accept\\|access[ 	]+procedure\\|access[ 	]+function\\|type\\)\\>"] 5 (#$ . 78411)])
#@139 Search for REGEXP, ignoring comments, strings, 'and then', 'or else'.
If BACKWARDP is non-nil, search backward; search forward otherwise.
(defalias 'ada-search-ignore-complex-boolean #[(regexp backwardp) "\303\304	\n\"\211\203\212\305v\210\306\307!)\204)\207" [result regexp backwardp nil ada-search-ignore-string-comment -1 looking-at "and then\\|or else"] 3 (#$ . 79048)])
#@131 Non-nil if in an open parenthesis.
Return value is the position of the first non-ws behind the last unclosed
parenthesis, or nil.
(defalias 'ada-in-open-paren-p #[nil "\212\302`\303\304\305\"@\206\fe\"\211A@\205)A@Tb\210	\203$\306\307!\204(\310\311w\210`*\207" [parse ada-indent-handle-comment-special parse-partial-sexp ada-search-ignore-complex-boolean "\\<\\(;\\|is\\|then\\|loop\\|begin\\|else\\)\\>" t looking-at "[ 	]+--" " 	" nil] 6 (#$ . 79437)])
#@188 Do indenting or tabbing according to `ada-tab-policy'.
In Transient Mark mode, if the mark is active, operate on the contents
of the region.  Otherwise, operate only on the current line.
(defalias 'ada-tab #[nil "\301=\203	\302 \207\303=\203\304 \203\305\306 \307 \"\207\310 \207\311=\205'\312\313!\207" [ada-tab-policy indent-rigidly ada-tab-hard indent-auto ada-region-selected ada-indent-region region-beginning region-end ada-indent-current always-tab error "Not implemented"] 3 (#$ . 79905) nil])
#@57 Delete leading indenting according to `ada-tab-policy'.
(defalias 'ada-untab #[(_arg) "\301=\203	\302 \207\303=\203\304\305!\207\306=\205\304\305!\207" [ada-tab-policy indent-rigidly ada-untab-hard indent-auto error "Not implemented" always-tab] 2 (#$ . 80422) "P"])
#@49 Ada mode version of the `indent-line-function'.
(defalias 'ada-indent-current-function #[nil "\301 \302 \210\303 \210`W\203b\210\304\211\223)\207" [starting-point point-marker beginning-of-line ada-tab nil] 3 (#$ . 80703) "*"])
#@39 Indent current line to next tab stop.
(defalias 'ada-tab-hard #[nil "\212\301 \210\302\303\"\210)n\205u\207" [ada-indent beginning-of-line insert-char 32] 3 (#$ . 80943) nil])
#@43 Indent current line to previous tab stop.
(defalias 'ada-untab-hard #[nil "\301\302 \303 [#\207" [ada-indent indent-rigidly point-at-bol point-at-eol] 4 (#$ . 81129) nil])
#@45 Remove trailing spaces in the whole buffer.
(defalias 'ada-remove-trailing-spaces #[nil "\301 \302\216\212\214~\210eb\210\303\304d\305#\205\306\307\310\211#\210\202\f,\207" [save-match-data-internal match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) re-search-forward "[ 	]+$" t replace-match "" nil] 4 (#$ . 81308) nil])
#@64 Clean up comments, `(' and `,' for GNAT style checking switch.
(defalias 'ada-gnat-style #[nil "\212eb\210\301\302\303\304#\203\305\306!\210\307y\210\310 \210\202eb\210\301\311\303\304#\203V\303\312\313 `\"\211\314\2068\312\313 `\"8)\206K\315\206I\312\313 `\"8))\204\305\316!\210\202eb\210\301\317\303\304#\203\226\320u\210\303\312\313 `\"\211\314\206x\312\313 `\"8)\206\213\315\206\211\312\313 `\"8))\204Y\305\321!\210\202Yeb\210\301\322\303\304#\203\323\303\312\313 `\"\211\314\206\265\312\313 `\"8)\206\310\315\206\306\312\313 `\"8))\204\231\305\323!\210\202\231eb\210\301\324\303\304#\203
\303\312\313 `\"\211\314\206\362\312\313 `\"8)\206
\315\206
\312\313 `\"8))\204\326\305\325!\210\202\326eb\210\301\326\303\304#\203M
\303\312\313 `\"\211\314\206/
\312\313 `\"8)\206B
\315\206@
\312\313 `\"8))\204
\305\327!\210\202
eb\210\301\330\303\304#\203\217
\212\331\224b\210\303\312\313 `\"\211\314\206q
\312\313 `\"8)\206\204
\315\206\202
\312\313 `\"8)*\204P
\305\332!\210\202P
eb\210\301\333\303\304#\205\307\224b\210\334\335!\204\317
\303\312\313 `\"\211\314\206\270
\312\313 `\"8)\206\313
\315\206\311
\312\313 `\"8))\203\330
\307y\210\310 \210\202\222
\336\307!\337\230\203\347
\305\340!\210\202\336\307!\341\230\203\366
\305\342!\210\202\336\307!\343\230\203\305\344!\210\202\336\307!\345\230\203\305\346!\210\202\305\347!\210\307u\210\202\222
)\207" [parse-result re-search-forward "--[ 	]*\\([^-\n]\\)" nil t replace-match "--  \\1" 1 beginning-of-line "\\>(" parse-partial-sexp line-beginning-position 3 4 " (" ";--" -1 "; --" "([ 	]+" "(" ")[ 	]+)" "))" "\\>:" " :" ",[ 	]*\\(.\\)" 0 ", \\1" "[ 	]*\\(/=\\|\\*\\*\\|:=\\|\\.\\.\\|[-:+*/]\\)[ 	]*" looking-at "--" match-string "/=" " /= " ".." " .. " "**" " ** " ":=" " := " " \\1 "] 4 (#$ . 81686) nil])
#@64 Move point to the matching start of the current Ada structure.
(defalias 'ada-move-to-start #[nil "`\306 p\307\216\310!\210\212\311\312\313 `\"\211\314\f\206\"\312\313 `\"8)\2065\f\315\f\2063\312\313 `\"8))\204t\316\317!\204B\320v\210\316\317!\204K\320v\210\316\317!\204W\321\322!\203t\323\324!\203t`\211\203t
\203t\316\325!\203t\326 \203t`)b,\207" [pos #1=#:buffer #2=#:table ada-mode-symbol-syntax-table parse-result ada-move-to-declaration syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-syntax-table nil parse-partial-sexp line-beginning-position 3 4 looking-at "[ 	]*\\<end\\>" -1 error "Not on end ...;" ada-goto-matching-start 1 "\\<begin\\>" ada-goto-decl-start] 4 (#$ . 83550) nil])
#@93 Move point to the end of the block around point.
Moves to 'begin' if in a declarative part.
(defalias 'ada-move-to-end #[nil "`\305\306 p\307\216\310\f!\210\212\212\311\312!\210\313\314!)\203#\315\316!\210\202\312\212\311\312!\205<\313\317!\205<\320\321!\205<`Sf\322U?)\203L\311\312!\210\315\323\324\"\210\202\312\212\325 \205e\313\326!\205e\316v\205e\327 \205e\313\330!)\203t\320\331\305\211\211\332%\210\202\312\212\325 \205}\313\333!)\203\210\315\323!\210\202\312\212\334\324!\205\220`\211\205\230\313\335!)\203\243\315\316!\210\202\312\212\311\312!\210\313\336!)\203\267\315\323\324\"\210\202\312\203\306b\210\315\323\324\"\210\202\312\315\316!\210`)	b-\207" [decl-start pos #1=#:buffer #2=#:table ada-mode-symbol-syntax-table nil syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-syntax-table skip-syntax-backward "w" looking-at "\\<begin\\>" ada-goto-matching-end 1 "\\<function\\>\\|\\<procedure\\>" ada-search-ignore-string-comment "is\\|;" 59 0 t ada-goto-stmt-start "\\<task\\>" ada-goto-next-non-ws "\\<body\\>" "begin" word-search-forward "\\<accept\\>" ada-goto-decl-start "\\<package\\>" "\\<declare\\>"] 7 (#$ . 84313) nil])
#@31 Move point to next procedure.
(defalias 'ada-next-procedure #[nil "\301\210\302\301\303#\203\304\224b\207\305\306!\207" [ada-procedure-start-regexp nil re-search-forward t 4 error "No more functions/procedures/tasks"] 4 (#$ . 85530) nil])
#@35 Move point to previous procedure.
(defalias 'ada-previous-procedure #[nil "\301 \210\302\303\304#\203\305\224b\207\306\307!\207" [ada-procedure-start-regexp beginning-of-line re-search-backward nil t 4 error "No more functions/procedures/tasks"] 4 (#$ . 85779) nil])
#@29 Move point to next package.
(defalias 'ada-next-package #[nil "\301\210\302\301\303#\203\304\224b\207\305\306!\207" [ada-package-start-regexp nil re-search-forward t 1 error "No more packages"] 4 (#$ . 86055) nil])
#@33 Move point to previous package.
(defalias 'ada-previous-package #[nil "\301 \210\302\303\304#\203\305\224b\207\306\307!\207" [ada-package-start-regexp beginning-of-line re-search-backward nil t 1 error "No more packages"] 4 (#$ . 86280) nil])
#@49 Create the keymap associated with the Ada mode.
(defalias 'ada-create-keymap #[nil "\304	\n#\210\304\305\306#\210\304\307\306#\210\304\310\311#\210\304\312\313#\210\304\314\315#\210\304\316\317#\210\304\320\321#\210\304\322\323#\210\304\324\325#\210\304\326\327#\210\304\330\331#\210\332\333\"\204U\304\333\334#\210\304\335\336#\210\304\337\340#\210\304\341\342#\210\304\343\344#\210\304\345\346!\203y\347\202z\350\351#\210\304\352\353#\210\304\354\355#\210\304\356\357#\210\304\360\361#\210\304\362\363#\210\304\n\364\365#\210\304\366\367#\210\304\370\371#\210\304\372\373#\210\304\333\374#\210\304\n\375\376#\210\304\n\377\201@#\210\304\n\201A\201B#\210\304\201C\201D#\210\304\n\201E\201F#\210\304\201G\201H#\210\304\201I\201J#\210\304\n\201K\201L#\210\304\201M\201N#\210\304\n\201O\201P#\210\304\n\201Q\201R#\210\304\201S\201T#\210\201U \304\201V\201W#\210\304\201X\201Y#\210\304\201Z\201[#\210\304\377\201\\#\210\304\375\201]#\210\304\201^\201_#\210\304\201`\201a#\210\304\201b\201c#\210\304\201d\201e#\210\304\201f\201g#\210\304\201h\201i#\210\304\201j\201k#\210\304\201O\201l#\210\304\201m\201n#\210\304\201K\201o#\210\304\201p\201q#\210\304\201r\201s#\210\304\201t\201u#\210\304\201v\201w#\210\304\201x\201y#\210\304\201z\201{#\210\304\201|\201}#\210\304\201Q\201~#\210\304\201\201\200#\210\304\201\201\201\202#\210\304\201\203\201\204#\210\304\201\205\201\206#\210\304\201\207\201\210#\210\304\n\201x#)\207" [ada-mode-map ada-mode-extra-prefix ada-mode-extra-map map define-key "\n" ada-indent-newline-indent-conditional "
" "	" ada-tab "	" ada-justified-indent-current "\f" ada-indent-region [(shift tab)] ada-untab "" ada-format-paramlist "\205" ada-next-procedure "\201" ada-previous-procedure "
" ada-move-to-start "" ada-move-to-end lookup-key "" compile "" ada-adjust-case-buffer "" ada-case-read-exceptions "" ada-create-case-exception "\231" ada-create-case-exception-substring boundp delete-key-deletes-forward [backspace] "" backward-delete-char-untabify "" ada-make-subprogram-body ";" comment-region ":" ada-uncomment-region [S-mouse-3] ada-point-and-xref [(control tab)] ada-complete-identifier "o" ff-find-other-file "5" ada-goto-declaration-other-frame "" ada-goto-declaration "" ada-xref-goto-previous-reference ada-compile-application "c" ada-change-prj "d" ada-set-default-project-file "g" ada-gdb-application "
" ada-set-main-compile-application "r" ada-run-application "" ada-goto-parent "" ada-find-references "l" ada-find-local-references "" ada-check-current "f" ada-find-file "u" ada-prj-edit "nd" ada-narrow-to-defun make-sparse-keymap "h" ada-header "
" ada-array "b" ada-exception-block ada-declare-block ada-case "" ada-elsif "e" ada-else "" ada-package-spec "k" ada-package-body "" ada-procedure-spec "p" ada-subprogram-body "" ada-function-spec ada-for-loop "i" ada-if ada-loop "" ada-record "" ada-subtype "S" ada-tabsize "" ada-task-spec "t" ada-task-body "" ada-type "" ada-private ada-use "" ada-with "" ada-when "w" ada-while-loop "" ada-exception "x" ada-exit] 4 (#$ . 86532)])
#@47 Create the Ada menu as shown in the menu bar.
(defalias 'ada-create-menu #[nil "\302\303\304!\210\305\306	\307$\210)\304\207" [m ada-mode-map ("Ada" ("Help" ["Ada Mode" (info "ada-mode") t] ["GNAT User's Guide" (info "gnat_ugn") (eq ada-which-compiler 'gnat)] ["GNAT Reference Manual" (info "gnat_rm") (eq ada-which-compiler 'gnat)] ["Gcc Documentation" (info "gcc") (eq ada-which-compiler 'gnat)] ["Gdb Documentation" (info "gdb") (eq ada-which-compiler 'gnat)] ["Ada95 Reference Manual" (info "arm95") t]) ("Options" :included (derived-mode-p 'ada-mode) ["Auto Casing" (setq ada-auto-case (not ada-auto-case)) :style toggle :selected ada-auto-case] ["Auto Indent After Return" (setq ada-indent-after-return (not ada-indent-after-return)) :style toggle :selected ada-indent-after-return] ["Automatically Recompile For Cross-references" (setq ada-xref-create-ali (not ada-xref-create-ali)) :style toggle :selected ada-xref-create-ali :included (eq ada-which-compiler 'gnat)] ["Confirm Commands" (setq ada-xref-confirm-compile (not ada-xref-confirm-compile)) :style toggle :selected ada-xref-confirm-compile :included (eq ada-which-compiler 'gnat)] ["Show Cross-references In Other Buffer" (setq ada-xref-other-buffer (not ada-xref-other-buffer)) :style toggle :selected ada-xref-other-buffer :included (eq ada-which-compiler 'gnat)] ["Tight Integration With GNU Visual Debugger" (setq ada-tight-gvd-integration (not ada-tight-gvd-integration)) :style toggle :selected ada-tight-gvd-integration :included (string-match "gvd" ada-prj-default-debugger)]) ["Customize" (customize-group 'ada) :included (fboundp 'customize-group)] ["Check file" ada-check-current t] ["Compile file" ada-compile-current t] ["Set main and Build" ada-set-main-compile-application t] ["Show main" ada-show-current-main t] ["Build" ada-compile-application t] ["Run" ada-run-application t] ["Debug" ada-gdb-application (eq ada-which-compiler 'gnat)] ["------" nil nil] ("Project" ["Show project" ada-show-current-project t] ["Load..." ada-set-default-project-file t] ["New..." ada-prj-new t] ["Edit..." ada-prj-edit t]) ("Goto" :included (derived-mode-p 'ada-mode) ["Goto Declaration/Body" ada-goto-declaration (eq ada-which-compiler 'gnat)] ["Goto Body" ada-goto-body (eq ada-which-compiler 'gnat)] ["Goto Declaration Other Frame" ada-goto-declaration-other-frame (eq ada-which-compiler 'gnat)] ["Goto Previous Reference" ada-xref-goto-previous-reference (eq ada-which-compiler 'gnat)] ["List Local References" ada-find-local-references (eq ada-which-compiler 'gnat)] ["List References" ada-find-references (eq ada-which-compiler 'gnat)] ["Goto Reference To Any Entity" ada-find-any-references (eq ada-which-compiler 'gnat)] ["Goto Parent Unit" ada-goto-parent (eq ada-which-compiler 'gnat)] ["--" nil nil] ["Next compilation error" next-error t] ["Previous Package" ada-previous-package t] ["Next Package" ada-next-package t] ["Previous Procedure" ada-previous-procedure t] ["Next Procedure" ada-next-procedure t] ["Goto Start Of Statement" ada-move-to-start t] ["Goto End Of Statement" ada-move-to-end t] ["-" nil nil] ["Other File" ff-find-other-file t] ["Other File Other Window" ada-ff-other-window t]) ("Edit" :included (derived-mode-p 'ada-mode) ["Search File On Source Path" ada-find-file t] ["------" nil nil] ["Complete Identifier" ada-complete-identifier t] ["-----" nil nil] ["Indent Line" ada-indent-current-function t] ["Justify Current Indentation" ada-justified-indent-current t] ["Indent Lines in Selection" ada-indent-region t] ["Indent Lines in File" (ada-indent-region (point-min) (point-max)) t] ["Format Parameter List" ada-format-paramlist t] ["-" nil nil] ["Comment Selection" comment-region t] ["Uncomment Selection" ada-uncomment-region t] ["--" nil nil] ["Fill Comment Paragraph" fill-paragraph t] ["Fill Comment Paragraph Justify" ada-fill-comment-paragraph-justify t] ["Fill Comment Paragraph Postfix" ada-fill-comment-paragraph-postfix t] ["---" nil nil] ["Adjust Case Selection" ada-adjust-case-region t] ["Adjust Case in File" ada-adjust-case-buffer t] ["Create Case Exception" ada-create-case-exception t] ["Create Case Exception Substring" ada-create-case-exception-substring t] ["Reload Case Exceptions" ada-case-read-exceptions t] ["----" nil nil] ["Make body for subprogram" ada-make-subprogram-body t] ["-----" nil nil] ["Narrow to subprogram" ada-narrow-to-defun t]) ("Templates" :included (derived-mode-p 'ada-mode) ["Header" ada-header t] ["-" nil nil] ["Package Body" ada-package-body t] ["Package Spec" ada-package-spec t] ["Function Spec" ada-function-spec t] ["Procedure Spec" ada-procedure-spec t] ["Proc/func Body" ada-subprogram-body t] ["Task Body" ada-task-body t] ["Task Spec" ada-task-spec t] ["Declare Block" ada-declare-block t] ["Exception Block" ada-exception-block t] ["--" nil nil] ["Entry" ada-entry t] ["Entry family" ada-entry-family t] ["Select" ada-select t] ["Accept" ada-accept t] ["Or accept" ada-or-accept t] ["Or delay" ada-or-delay t] ["Or terminate" ada-or-terminate t] ["---" nil nil] ["Type" ada-type t] ["Private" ada-private t] ["Subtype" ada-subtype t] ["Record" ada-record t] ["Array" ada-array t] ["----" nil nil] ["If" ada-if t] ["Else" ada-else t] ["Elsif" ada-elsif t] ["Case" ada-case t] ["-----" nil nil] ["While Loop" ada-while-loop t] ["For Loop" ada-for-loop t] ["Loop" ada-loop t] ["------" nil nil] ["Exception" ada-exception t] ["Exit" ada-exit t] ["When" ada-when t])) (lambda (#1=#:def-tmp-var) (defvar ada-mode-menu #1# #2="Menu keymap for Ada mode")) nil easy-menu-do-define ada-mode-menu #2#] 5 (#$ . 89751)])
(ad-add-advice 'comment-region '(ada-uncomment-anywhere nil nil (advice lambda nil (if (and (consp arg) (derived-mode-p 'ada-mode)) (save-excursion (let ((cs (concat "^[ 	]*" (regexp-quote comment-start)))) (goto-char beg) (while (re-search-forward cs end t) (replace-match comment-start))))))) 'before nil)
#@70 Uncomment region BEG .. END.
ARG gives number of comment characters.
(defalias 'ada-uncomment-region #[(beg end &optional arg) "\304X\203\305\306!\210\306	\n\206\307[#\210\310\306!\207\306	\n\206!\307[C#\210\311	\n\"\207" [emacs-major-version beg end arg 20 ad-activate comment-region 2 ad-deactivate ada-indent-region] 4 (#$ . 95643) "r\nP"])
#@63 Fill current comment paragraph and justify each line as well.
(defalias 'ada-fill-comment-paragraph-justify #[nil "\300\301!\207" [ada-fill-comment-paragraph full] 2 (#$ . 96001) nil])
#@120 Fill current comment paragraph and justify each line as well.
Adds `ada-fill-comment-postfix' at the end of each line.
(defalias 'ada-fill-comment-paragraph-postfix #[nil "\300\301\302\"\207" [ada-fill-comment-paragraph full t] 3 (#$ . 96193) nil])
#@247 Fill the current comment paragraph.
If JUSTIFY is non-nil, each line is justified as well.
If POSTFIX and JUSTIFY are non-nil, `ada-fill-comment-postfix' is appended
to each line filled and justified.
The paragraph is indented on the first line.
(defalias 'ada-fill-comment-paragraph #[(&optional justify postfix) "\306\307\206\f\310\311 `\"8)\204\312\313!\204\314\315!\210\306\211\306\316 \306\211\"\317 #\320 \210m\204M\312\321!\203M\322y\210m\203G\323c\210\2020\320 \210\2020\324 \210\316 \fb\210\320 \210o\204l\312\321!\203l\325y\210\320 \210\202Yo\204s\322y\210\324 \210\316 \320 \210i\n`|\210\nb\210\326\327\330#\203\224\331\323!\210\202\205Sb\210\316 $\"\332\n	#\210%\203\262#&GZ#\333\n'#\210%\203\340\214\nb\210\n}\210m\204\337\306\210\334\335#iZ\"\210&c\210\306y\210\202\306)(\336X\204\365(\337U\203\377)\340X\203\377b\210\306\210\341\322!\210\fb.\207" [parse-result indent from to opos parse-sexp-lookup-properties nil 4 parse-partial-sexp line-beginning-position looking-at "[ 	]*--" error "Not inside comment" point-marker current-fill-column back-to-indentation ".*--[ 	]*[^ 	\n]" 1 "\n" beginning-of-line -1 re-search-forward "--\n" t replace-match set-left-margin fill-region-as-paragraph insert-char 32 19 20 2 delete-char fill-prefix fill-column ada-fill-comment-prefix postfix ada-fill-comment-postfix justify emacs-major-version emacs-minor-version] 5 (#$ . 96449) "P"])
#@130 Determine the filename in which ADANAME is found.
This matches the GNAT default naming convention, except for
pre-defined units.
(defalias 'ada-make-filename-from-adaname #[(adaname) "\301\302\"\203\303\304\305\211$\202\227\207" [adaname string-match "\\." replace-match "-" t] 5 (#$ . 97904)])
#@122 Return the name of the other file.
The name returned is the body if `current-buffer' is the spec,
or the spec otherwise.
(defalias 'ada-other-file-name #[nil "\306\211\307 \f\204)\n\203)\310\311\n@\312Q	\"\203#\313\314\315	\"\nA\202	\f\204O
\204O\n\203O\310\311\n@\312Q	\"\203I\313\314\315	\"\nA\202/\f\204[\204[	\202\235\f\203d
\202f	\n\203\234\316\317!\203\207\317\320	\n@P!!\211\203\203)\202\225\321	\n@P!\203\225	\n@P\nA\211\204l\f,\207" [ada-spec-suffixes name suffixes is-body is-spec ada-body-suffixes nil buffer-file-name string-match "\\(.*\\)" "$" t match-string 1 fboundp ada-find-src-file-in-dir file-name-nondirectory file-exists-p other] 5 (#$ . 98214)])
#@103 Return the name of the function whose definition/declaration point is in.
Used in `ff-pre-load-hook'.
(defalias 'ada-which-function-are-we-in #[nil "\303\212\303\210\304	\303\305#\203\306\307!\211\206#\304\n\303\305#\205#\306\310!\211)\207" [ff-function-name ada-procedure-start-regexp ada-package-start-regexp nil re-search-backward t match-string 5 4] 4 (#$ . 98935)])
#@53 Last line on which `ada-which-function' was called.
(defvar ada-last-which-function-line -1 (#$ . 99320))
#@56 Last subprogram name returned by `ada-which-function'.
(defvar ada-last-which-function-subprog 0 (#$ . 99432))
(byte-code "\300\301!\210\300\302!\207" [make-variable-buffer-local ada-last-which-function-subprog ada-last-which-function-line] 2)
#@238 Return the name of the function whose body the point is in.
This function works even in the case of nested subprograms, whereas the
standard Emacs function `which-function' does not.
Since the search can be long, the results are cached.
(defalias 'ada-which-function #[nil "\306\307`\"`\310\211\211\211\211!U\203\"\202\241\212\310\210\311\310w\210\310\312\313\217\210\314\310w\210\315\316!\203=\307v\210\314\310w\210\317\310w\210\320\310w\210\204\231\321#\310\322#\203\231\323\324!\310$\325$\206`\326\327 `\"8)\204A\212\330\225b\210\315\331!)\204A\212\332 \210i\333\334\n\335\336	\337\"\340\260!\203\213`\202\215d\fY\203\225\n)\202A
!\").\207" [found indent func-name end-pos pos line count-lines 1 nil " 	\n(" (up-list 1) ((error)) " 	\n" looking-at "return" "a-zA-Z0-9_'" "is 	\n" re-search-backward t match-string-no-properties 3 4 parse-partial-sexp line-beginning-position 0 "[ 	\n]*new" back-to-indentation ada-search-ignore-string-comment "end[ 	]+" "[ 	]*;\\|^" make-string 32 "end;" ada-last-which-function-line ada-last-which-function-subprog ada-imenu-subprogram-menu-re parse-result] 8 (#$ . 99683)])
#@61 Find other file in other window using `ff-find-other-file'.
(defalias 'ada-ff-other-window #[nil "\300\301!\205	\301\302!\207" [fboundp ff-find-other-file t] 2 (#$ . 100840) nil])
#@81 Move to the function declaration that was set by `ff-which-function-are-we-in'.
(defalias 'ada-set-point-accordingly #[nil "\205eb\210\301\302P\303\"?\205eb\207" [ff-function-name ada-search-ignore-string-comment "\\b" nil] 3 (#$ . 101027)])
#@144 Return the file name for the body of SPEC-NAME.
If SPEC-NAME is nil, return the body for the current package.
Return nil if no body was found.
(defalias 'ada-get-body-name #[(&optional spec-name) "\204\306 	\307\211\203,G@GZ@\n\307O\230\203%\310\nOA\211\204*\311\312!\203?\312\f\313\314\315!!!
#\207\313\314\315!!!\316P\207" [spec-name ada-spec-suffixes end suffixes ada-search-directories-internal ada-body-suffixes buffer-file-name nil 0 fboundp ff-get-file-name ada-make-filename-from-adaname file-name-nondirectory file-name-sans-extension ".adb"] 7 (#$ . 101282) nil])
(defconst ada-font-lock-syntactic-keywords '(("[^a-zA-Z0-9)]\\('\\)[^\n]\\('\\)" (1 (7 . 39)) (2 (7 . 39))) ("^[ 	]*\\(#\\(if\\|else\\|elsif\\|end\\)\\)" (1 (11 . 10)))))
#@47 Default expressions to highlight in Ada mode.
(defvar ada-font-lock-keywords '(("\\<\\(function[ 	]+return\\)\\>" (1 font-lock-keyword-face)) ("^[ 	]*\\(#.*\n\\)" (1 font-lock-type-face t)) ("\\<\\(accept\\|entry\\|function\\|package[ 	]+body\\|package\\|pragma\\|procedure\\|protected[ 	]+body\\|protected[ 	]+type\\|protected\\|task[ 	]+body\\|task[ 	]+type\\|task\\)\\>[ 	]*\\(\\sw+\\(\\.\\sw*\\)*\\)?" (1 font-lock-keyword-face) (2 font-lock-function-name-face nil t)) ("\\<\\(access[ 	]+all\\|access[ 	]+constant\\|access\\|constant\\|in[ 	]+reverse\\|\\|in[ 	]+out\\|in\\|out\\)\\>[ 	]*\\(\\sw+\\(\\.\\sw*\\)*\\)?" (1 font-lock-keyword-face nil t) (2 font-lock-type-face nil t)) "\\<\\(a\\(?:b\\(?:ort\\|s\\(?:tract\\)?\\)\\|cce\\(?:pt\\|ss\\)\\|l\\(?:iased\\|l\\)\\|nd\\|rray\\|t\\)\\|begin\\|case\\|d\\(?:e\\(?:clare\\|l\\(?:ay\\|ta\\)\\)\\|igits\\|o\\)\\|e\\(?:ls\\(?:e\\|if\\)\\|ntry\\|x\\(?:ception\\|it\\)\\)\\|for\\|generic\\|i\\(?:nterface\\|[fns]\\)\\|l\\(?:imited\\|oop\\)\\|mod\\|n\\(?:ot\\|ull\\)\\|o\\(?:r\\|thers\\|verriding\\)\\|pr\\(?:ivate\\|otected\\)\\|r\\(?:a\\(?:\\(?:is\\|ng\\)e\\)\\|e\\(?:cord\\|m\\|names\\|queue\\|turn\\|verse\\)\\)\\|s\\(?:e\\(?:lect\\|parate\\)\\|ynchronized\\)\\|t\\(?:a\\(?:gged\\|sk\\)\\|erminate\\|hen\\)\\|until\\|w\\(?:h\\(?:en\\|ile\\)\\|ith\\)\\|xor\\)\\>" ("\\<\\(end\\)\\>\\([ 	]+\\)?\\(\\(\\sw\\|[_.]\\)+\\)?" (1 font-lock-keyword-face) (3 font-lock-function-name-face nil t)) ("\\<\\(new\\|of\\|subtype\\|type\\)\\>[ 	]*\\(\\sw+\\(\\.\\sw*\\)*\\)?[ 	]*\\((\\)?" (1 font-lock-keyword-face) (2 (if (match-beginning 4) font-lock-function-name-face font-lock-type-face) nil t)) ("\\<\\(goto\\|raise\\|use\\|with\\)[ 	]+\\([a-zA-Z0-9_., 	]+\\)\\W" (1 font-lock-keyword-face) (2 font-lock-constant-face nil t)) ("<<\\(\\sw+\\)>>" 1 font-lock-constant-face) ("\\([0-9]+#[0-9a-fA-F_]+#\\)" (1 font-lock-constant-face t)) ("\\W\\([-+]?[0-9._]+\\)\\>" (1 font-lock-constant-face))) (#$ . 102055))
#@65 This is so that `current-column' DTRT in otherwise-hidden text.
(defalias 'ada-outline-level #[nil "\301\212\302 \210i*\207" [buffer-invisibility-spec nil back-to-indentation] 1 (#$ . 104010)])
#@202 Make text outside current subprogram invisible.
The subprogram visible is the one that contains or follow point.
Optional ARG is ignored.
Use \[widen] to go back to the full visibility for the buffer.
(defalias 'ada-narrow-to-defun #[(&optional _arg) "\212\301~\210\302y\210\303 \210\304 \305 \210\301\210`}\210\306\307!*\207" [end nil 1 ada-previous-procedure point-at-bol ada-move-to-end message "Use M-x widen to get back to full visibility in the buffer"] 2 (#$ . 104212) nil])
#@169 Make dummy body of a procedure/function specification.
MATCH is a cons cell containing the start and end locations of the last search
for `ada-procedure-start-regexp'.
(defalias 'ada-gen-treat-proc #[(match) "@b\210\304\211\211\305\306!\204\305\307!\211\203\230\310v\210\311v\210`A{Ab\210\305\312!\2040\313 \210\203C\314v\210\315\304w\210`\316\304w\210`{\305\317!\203\206\320\224\320\225|\210\321 \210\322c\210\321 \210\203e\323	\324\261\210\321 \210\325c\210\321 \210\203u\326c\210\202x\327c\210\321 \210\330\n\324\261\210\321 \202\262\305\331!\206\262\305\332!\206\262\333\334!\202\262\305\335!\205\262\333\336!\210\310v\210\305\317!\203\260\304y\202\262\337 +\207" [match functype procname func-found nil looking-at "^[ 	]*procedure" "^[ 	]*function" 2 -1 "[ 	\n]*\\(;\\|return\\)" forward-sexp 1 " 	\n" "a-zA-Z0-9_." "[ 	]*;" 0 ada-indent-newline-indent "is" "Result : " ";" "begin" "return Result;" "null;" "end " "[ 	\n]*is" "[ 	\n]*rename" message "unknown syntax" "^[ 	]*task" "Task conversion is not yet implemented" ada-move-to-end] 3 (#$ . 104705)])
#@168 Create an Ada package body in the current buffer.
The spec must be the previously visited buffer.
This function typically is to be hooked into `ff-file-created-hook'.
(defalias 'ada-make-body #[nil "ed|\210\304\305 A@!\210eb\210\306 \210\307\211\310\n\307\"\211\203(	Ab\210\311c\210\202,\312\313!\210\314\nQ\310\307\"\211\205U	@b\210\315\n!\203N	Ab\210\311c\210\2021\316	!\210\2021*\207" [ada-procedure-or-package-start-regexp found ada-package-start-regexp ada-procedure-start-regexp insert-buffer-substring buffer-list ada-mode nil ada-search-ignore-string-comment " body" error "No package" "\\|" looking-at ada-gen-treat-proc] 3 (#$ . 105803)])
#@82 Create a dummy subprogram body in package body file from spec surrounding point.
(defalias 'ada-make-subprogram-body #[nil "\304\305\306#\307\224\305	\203r\nb\210\310\311\305\306#\203,`Sf\312U\203,\313\314\305\"\210\313\315\305\"\210\n`{\316 \211\203>\317!\210\202B\320\321!\210\214~\210db\210\322\323!\210\304\324\305\306#\210\304\325\305\306#\210\326 \210\327u\210\nc\210\304\305\306#\210\330\307\224\307\225B!)\202u\320\331!+\207" [ada-procedure-start-regexp found spec body-file re-search-backward nil t 0 re-search-forward "(\\|;" 40 ada-search-ignore-string-comment ")" ";" ada-get-body-name find-file error "No body found for the package.  Create it first" forward-comment -10000 "\\<end\\>" "^begin" newline -1 ada-gen-treat-proc "Not in subprogram spec"] 5 (#$ . 106471) nil])
(byte-code "\301 \210\302 \210\303 \210\304\305\306\"\210\307\232\203\304\310\311\"\210\312 \210\313\314\315\316\317$\210\313\320\315\316\317$\210\313\321\315\316\317$\210\313\322\315\316\317$\210\313\323\315\316\317$\210\313\324\315\316\317$\210\313\325\315\316\317$\210\313\326\315\316\317$\210\313\327\315\316\317$\210\313\330\315\316\317$\210\313\331\315\316\317$\210\313\332\315\316\317$\210\313\333\315\316\317$\210\313\334\315\316\317$\210\313\335\315\316\317$\210\313\336\315\316\317$\210\313\337\315\316\317$\210\313\340\315\316\317$\210\313\341\315\316\317$\210\313\342\315\316\317$\210\313\343\315\316\317$\210\313\344\315\316\317$\210\313\345\346\316\317$\210\313\347\346\316\317$\210\313\350\346\316\317$\210\313\351\346\316\317$\210\313\352\353\316\317$\210\313\354\353\316\317$\210\313\355\353\316\317$\210\313\356\353\316\317$\210\313\357\353\316\317$\210\313\360\353\316\317$\210\313\361\353\316\317$\210\313\362\353\316\317$\210\313\363\353\316\317$\210\313\364\353\316\317$\210\313\365\353\316\317$\210\313\366\353\316\317$\210\313\367\353\316\317$\210\313\370\353\316\317$\210\313\371\353\316\317$\210\313\372\353\316\317$\210\313\373\353\316\317$\210\313\374\353\316\317$\210\313\375\353\316\317$\210\313\376\353\316\317$\210\313\377\353\316\317$\210\313\201@\353\316\317$\210\313\201A\353\316\317$\210\313\201B\353\316\317$\210\313\201C\353\316\317$\210\313\201D\353\316\317$\210\313\201E\353\316\317$\210\313\201F\353\316\317$\210\201G\201H!\207" [ada-which-compiler ada-create-keymap ada-create-menu ada-create-syntax-table ada-add-extensions ".ads" ".adb" gnat ".ads.dg" ".adb.dg" ada-case-read-exceptions autoload ada-change-prj "ada-xref" nil t ada-check-current ada-compile-application ada-compile-current ada-complete-identifier ada-find-file ada-find-any-references ada-find-src-file-in-dir ada-find-local-references ada-find-references ada-gdb-application ada-goto-declaration ada-goto-declaration-other-frame ada-goto-parent ada-make-body-gnatstub ada-point-and-xref ada-reread-prj-file ada-run-application ada-set-default-project-file ada-xref-goto-previous-reference ada-set-main-compile-application ada-show-current-main ada-customize "ada-prj" ada-prj-edit ada-prj-new ada-prj-save ada-array "ada-stmt" ada-case ada-declare-block ada-else ada-elsif ada-exception ada-exception-block ada-exit ada-for-loop ada-function-spec ada-header ada-if ada-loop ada-package-body ada-package-spec ada-private ada-procedure-spec ada-record ada-subprogram-body ada-subtype ada-tabsize ada-task-body ada-task-spec ada-type ada-use ada-when ada-while-loop ada-with provide ada-mode] 5)