;ELC ;;; Compiled by cyd@localhost on Mon Apr 23 22:24:45 2007 ;;; from file /home/cyd/emacs/lisp/progmodes/ada-mode.el ;;; in Emacs version 22.0.99 ;;; with all optimizations. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. (if (and (boundp 'emacs-version) (< (aref emacs-version (1- (length emacs-version))) ?A) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19.29"))) (error "`ada-mode.el' was compiled for Emacs 19.29 or later")) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (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) #@125 Return t if Emacs's version is greater or equal to MAJOR.MINOR. If IS-XEMACS is non-nil, check for XEmacs instead of Emacs. (defalias 'ada-check-emacs-version #[(major minor &optional is-xemacs) "\306\307\"\206 \306\310\"\n\203 \204\n\206 ?\205- \fV\206- \fU\205-  Y)\207" [emacs-version xemacs-running is-xemacs emacs-major-version major emacs-minor-version string-match "Lucid" "XEmacs" minor] 3 (#$ . 726)]) #@26 Return Ada mode version. (defalias 'ada-mode-version #[nil "\301t\203\f\302!\202 )\207" [version-string "3.7" message] 2 (#$ . 1157) nil]) #@191 *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 (#$ . -1308)) (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) #@170 *Non-nil means automatically change case of preceding word while typing. Casing is done according to `ada-case-keyword', `ada-case-identifier' and `ada-case-attribute'. (custom-declare-variable 'ada-auto-case 't '(#$ . -1727) :type 'boolean :group 'ada) #@110 *Number of columns to indent a broken declaration. An example is : declare A, >>>>>B : Integer; (custom-declare-variable 'ada-broken-decl-indent '0 '(#$ . -1988) :type 'integer :group 'ada) #@136 *Number of columns to indent the continuation of a broken line. An example is : My_Var : My_Type := (Field1 => >>>>>>>>>Value); (custom-declare-variable 'ada-broken-indent '2 '(#$ . -2198) :type 'integer :group 'ada) #@129 *Number of columns to indent the continuation of broken lines in parenthesis. An example is : Func (Param1, >>>>>Param2); (custom-declare-variable 'ada-continuation-indent 'ada-broken-indent '(#$ . -2429) :type 'integer :group 'ada) #@167 *Function to call to adjust the case of Ada attributes. It may be `downcase-word', `upcase-word', `ada-loose-case-word', `ada-capitalize-word' or `ada-no-auto-case'. (custom-declare-variable 'ada-case-attribute ''ada-capitalize-word '(#$ . -2675) :type '(choice (const downcase-word) (const upcase-word) (const ada-capitalize-word) (const ada-loose-case-word) (const ada-no-auto-case)) :group 'ada) #@547 *List of special casing exceptions dictionaries for identifiers. The first file is the one where new exceptions will be saved by Emacs when you call `ada-create-case-exception'. These files should contain one word per line, that gives the casing to be used for that word in Ada files. If the line starts with the character *, then the exception will be used for substrings that either start at the beginning of a word or after a _ character, and end either at the end of the word or at a _ character. Each line can be terminated by a comment. (custom-declare-variable 'ada-case-exception-file '(list (convert-standard-filename '"~/.emacs_case_exceptions")) '(#$ . -3081) :type '(repeat (file)) :group 'ada) #@148 *Function to call to adjust the case of an Ada keywords. It may be `downcase-word', `upcase-word', `ada-loose-case-word' or `ada-capitalize-word'. (custom-declare-variable 'ada-case-keyword ''downcase-word '(#$ . -3798) :type '(choice (const downcase-word) (const upcase-word) (const ada-capitalize-word) (const ada-loose-case-word) (const ada-no-auto-case)) :group 'ada) #@150 *Function to call to adjust the case of an Ada identifier. It may be `downcase-word', `upcase-word', `ada-loose-case-word' or `ada-capitalize-word'. (custom-declare-variable 'ada-case-identifier ''ada-loose-case-word '(#$ . -4177) :type '(choice (const downcase-word) (const upcase-word) (const ada-capitalize-word) (const ada-loose-case-word) (const ada-no-auto-case)) :group 'ada) #@78 *Non-nil means remove trailing spaces and untabify the buffer before saving. (custom-declare-variable 'ada-clean-buffer-before-saving 't '(#$ . -4566) :type 'boolean :group 'ada) #@83 *Size of Ada indentation. An example is : procedure Foo is begin >>>>>>>>>>null; (custom-declare-variable 'ada-indent '3 '(#$ . -4751) :type 'integer :group 'ada) #@55 *Non-nil means automatically indent after RET or LFD. (custom-declare-variable 'ada-indent-after-return 't '(#$ . -4921) :type 'boolean :group 'ada) #@296 *Non-nil means align comments on previous line comments, if any. If nil, indentation is calculated as usual. Note that indentation is calculated only if `ada-indent-comment-as-code' is t. For instance: A := 1; -- A multi-line comment -- aligned if ada-indent-align-comments is t (custom-declare-variable 'ada-indent-align-comments 't '(#$ . -5077) :type 'boolean :group 'ada) #@93 *Non-nil means indent comment lines as code. A nil value means do not auto-indent comments. (custom-declare-variable 'ada-indent-comment-as-code 't '(#$ . -5475) :type 'boolean :group 'ada) #@610 *Non-nil if comment lines should be handled specially inside parenthesis. By default, if the line that contains the open parenthesis has some text following it, then the following lines will be indented in the same column as this text. This will not be true if the first line is a comment and `ada-indent-handle-comment-special' is t. type A is ( Value_1, -- common behavior, when not a comment Value_2); type A is ( -- `ada-indent-handle-comment-special' is nil Value_1, Value_2); type A is ( -- `ada-indent-handle-comment-special' is non-nil Value_1, Value_2); (custom-declare-variable 'ada-indent-handle-comment-special 'nil '(#$ . -5672) :type 'boolean :group 'ada) #@75 *Non-nil means indent 'is separate' or 'is abstract' if on a single line. (custom-declare-variable 'ada-indent-is-separate 't '(#$ . -6394) :type 'boolean :group 'ada) #@106 *Indentation for 'record' relative to 'type' or 'use'. An example is: type A is >>>>>>>>>>>record (custom-declare-variable 'ada-indent-record-rel-type '3 '(#$ . -6569) :type 'integer :group 'ada) #@311 *Indentation for renames relative to the matching function statement. If `ada-indent-return' is null or negative, the indentation is done relative to the open parenthesis (if there is no parenthesis, `ada-broken-indent' is used). An example is: function A (B : Integer) return C; >>>renames Foo; (custom-declare-variable 'ada-indent-renames 'ada-broken-indent '(#$ . -6779) :type 'integer :group 'ada) #@296 *Indentation for 'return' relative to the matching 'function' statement. If `ada-indent-return' is null or negative, the indentation is done relative to the open parenthesis (if there is no parenthesis, `ada-broken-indent' is used). An example is: function A (B : Integer) >>>>>return C; (custom-declare-variable 'ada-indent-return '0 '(#$ . -7202) :type 'integer :group 'ada) #@68 *Non-nil means indent according to the innermost open parenthesis. (custom-declare-variable 'ada-indent-to-open-paren 't '(#$ . -7592) :type 'boolean :group 'ada) #@181 *Text inserted in the first columns when filling a comment paragraph. Note: if you modify this variable, you will have to invoke `ada-mode' again to take account of the new value. (custom-declare-variable 'ada-fill-comment-prefix '"-- " '(#$ . -7762) :type 'string :group 'ada) #@120 *Text inserted at the end of each line when filling a comment paragraph. Used by `ada-fill-comment-paragraph-postfix'. (custom-declare-variable 'ada-fill-comment-postfix '" --" '(#$ . -8048) :type 'string :group 'ada) #@126 *Number of columns to indent a label. An example is: procedure Foo is begin >>>>Label: This is also used for <<..>> labels (custom-declare-variable 'ada-label-indent '-4 '(#$ . -8273) :type 'integer :group 'ada) #@60 *Ada language version; one of `ada83', `ada95', `ada2005'. (custom-declare-variable 'ada-language-version ''ada95 '(#$ . -8493) :type '(choice (const ada83) (const ada95) (const ada2005)) :group 'ada) #@89 *Non-nil means `ada-move-to-start' moves to the subprogram declaration, not to 'begin'. (custom-declare-variable 'ada-move-to-declaration 'nil '(#$ . -8700) :type 'boolean :group 'ada) #@85 *Key used for binding the contextual menu. If nil, no contextual menu is available. (custom-declare-variable 'ada-popup-key ''[down-mouse-3] '(#$ . -8891) :type '(restricted-sexp :match-alternatives (stringp vectorp)) :group 'ada) #@191 *Default list of directories to search for Ada files. See the description for the `ff-search-directories' variable. This variable is the initial value of `ada-search-directories-internal'. (custom-declare-variable 'ada-search-directories '(append '(".") (split-string (or (getenv "ADA_INCLUDE_PATH") "") ":") '("/usr/adainclude" "/usr/local/adainclude" "/opt/gnu/adainclude")) '(#$ . -9129) :type '(repeat (choice :tag "Directory" (const :tag "default" nil) (directory :format "%v"))) :group 'ada) #@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 (#$ . 9635)) #@113 *Number of columns to indent the end of a statement on a separate line. An example is: if A = B >>>>then (custom-declare-variable 'ada-stmt-end-indent '0 '(#$ . -9937) :type 'integer :group 'ada) #@237 *Control the behavior of the TAB key. Must be one of : `indent-rigidly' : always adds `ada-indent' blanks at the beginning of the line. `indent-auto' : use indentation functions in this file. `always-tab' : do `indent-relative'. (custom-declare-variable 'ada-tab-policy ''indent-auto '(#$ . -10147) :type '(choice (const indent-auto) (const indent-rigidly) (const always-tab)) :group 'ada) #@107 *Indentation for the lines in a 'use' statement. An example is: use Ada.Text_IO, >>>>Ada.Numerics; (custom-declare-variable 'ada-use-indent 'ada-broken-indent '(#$ . -10551) :type 'integer :group 'ada) #@106 *Indentation for 'when' relative to 'exception' or 'case'. An example is: case A is >>>>when B => (custom-declare-variable 'ada-when-indent '3 '(#$ . -10767) :type 'integer :group 'ada) #@109 *Indentation for the lines in a 'with' statement. An example is: with Ada.Text_IO, >>>>Ada.Numerics; (custom-declare-variable 'ada-with-indent 'ada-broken-indent '(#$ . -10967) :type 'integer :group 'ada) #@259 *Name of the compiler to use. This will determine what features are made available through the Ada mode. The possible choices are: `gnat': Use Ada Core Technologies' GNAT compiler. Add some cross-referencing features. `generic': Use a generic compiler. (custom-declare-variable 'ada-which-compiler ''gnat '(#$ . -11186) :type '(choice (const gnat) (const generic)) :group 'ada) #@94 List of possible suffixes for Ada body files. The extensions should include a `.' if needed. (defvar ada-body-suffixes '(".adb") (#$ . 11575)) #@94 List of possible suffixes for Ada spec files. The extensions should include a `.' if needed. (defvar ada-spec-suffixes '(".ads") (#$ . 11724)) #@20 Menu for Ada mode. (defvar ada-mode-menu (make-sparse-keymap "Ada") (#$ . 11873)) #@33 Local keymap used for Ada mode. (defvar ada-mode-map (make-sparse-keymap) (#$ . 11961)) #@34 Local abbrev table for Ada mode. (defvar ada-mode-abbrev-table nil (#$ . 12055)) #@54 Syntax table to be used for editing Ada source code. (defvar ada-mode-syntax-table nil (#$ . 12142)) #@56 Syntax table for Ada, where `_' is a word constituent. (defvar ada-mode-symbol-syntax-table nil (#$ . 12249)) #@63 Variable to save key binding of RET when casing is activated. (defvar ada-ret-binding nil (#$ . 12365)) #@53 Alist of words (entities) that have special casing. (defvar ada-case-exception nil (#$ . 12475)) #@257 Alist of substrings (entities) that have special casing. The substrings are detected for word constituant 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 (#$ . 12579)) #@63 Variable to save key binding of LFD when casing is activated. (defvar ada-lfd-binding nil (#$ . 12896)) #@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 (#$ . 13006)) #@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)) (#$ . 13155)) #@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)))) (#$ . 13461)) #@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\\)\\>\\)" (#$ . 14028)) #@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\\)\\>" (#$ . 14296)) #@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\\)\\>" (#$ . 15051)) #@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\\)\\>" (#$ . 15884)) #@43 Regular expression matching Ada keywords. (defvar ada-keywords ada-2005-keywords (#$ . 16766)) #@46 Regexp matching Ada (qualified) identifiers. (defconst ada-ident-re "\\(\\sw\\|[_.]\\)+" (#$ . 16867)) #@116 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\\|[_.]\\)+\\)\\)" (#$ . 16977)) #@63 Regexp matching a fully qualified name (including attribute). (defconst ada-name-regexp "\\([a-zA-Z][a-zA-Z0-9_.']*[a-zA-Z0-9]\\)" (#$ . 17298)) #@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) (#$ . 17449)) #@43 Regexp matching filename:linenr[:column]. (defconst ada-compile-goto-error-file-linenr-re "\\([-_.a-zA-Z0-9]+\\):\\([0-9]+\\)\\(:\\([0-9]+\\)\\)?" (#$ . 17668)) #@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\\)\\>" (#$ . 17835)) #@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\\|[ _.]\\)+\\\\|^[ ]*exception\\>\\)" (#$ . 18076)) #@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\\)\\>" (#$ . 18503)) #@48 Regexp used in `ada-goto-matching-decl-start'. (defvar ada-matching-decl-start-re "\\<\\(begin\\|declare\\|end\\|generic\\|i[fs]\\|new\\|separate\\|when\\)\\>" (#$ . 18744)) #@33 Regexp for the start of a loop. (defvar ada-loop-start-re "\\<\\(for\\|while\\|loop\\)\\>" (#$ . 18924)) #@39 Regexp for the start of a subprogram. (defvar ada-subprog-start-re "\\<\\(accept\\|entry\\|function\\|p\\(?:ackage\\|ro\\(?:cedure\\|tected\\)\\)\\|task\\)\\>" (#$ . 19035)) #@40 Regexp of the name of a block or loop. (defvar ada-named-block-re "[ ]*\\(\\sw\\|_\\)+[ ]*:[^=]" (#$ . 19215)) #@71 Set to true when the right mouse button was clicked on an identifier. (defvar ada-contextual-menu-on-identifier nil (#$ . 19334)) #@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 (#$ . 19471)) #@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 (#$ . 19998)) (byte-code "\302\303\304\305\306$\210\301B\307\310!\210\311B\312\313\314 \315\316\260!\207" [current-load-list ada-imenu-comment-re 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]) (lambda (#1=#:defconst-tmp-var) (defconst ada-imenu-comment-re #1#)) "\\([ ]*--.*\\)?" ada-imenu-subprogram-menu-re (lambda (#2=#:defconst-tmp-var) (defconst ada-imenu-subprogram-menu-re #2#)) "^[ ]*\\(procedure\\|function\\)[ \n]+" "\\(\\(\\sw\\|_\\)+\\)[ \n]*\\([ \n]\\|([^)]+)" "\\)[ \n]*" "\\(return[ \n]+\\(\\sw\\|[_.]\\)+[ \n]*\\)?is[ \n]"] 6) #@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 \303E\313\314\315\316\257\207" [ada-imenu-subprogram-menu-re ada-imenu-comment-re nil 2 "*Specs*" "^[ ]*\\(procedure\\|function\\)[ \n]+\\(\\(\\sw\\|_\\)+\\)" "\\(" "[ \n]+\\|[ \n]*([^)]+)" "\\)" "\\([ \n]*return[ \n]+\\(\\sw\\|[_.]\\)+[ \n]*\\)?" "\\)?;" ("*Tasks*" "^[ ]*task[ ]+\\(type[ ]+\\)?\\(\\(body[ ]+\\)?\\(\\sw\\|_\\)+\\)" 2) ("*Type Defs*" "^[ ]*\\(sub\\)?type[ ]+\\(\\(\\sw\\|_\\)+\\)" 2) ("*Protected*" "^[ ]*protected[ ]+\\(type[ ]+\\)?\\(\\(body[ ]+\\)?\\(\\sw\\|_\\)+\\)" 2) ("*Packages*" "^[ ]*package[ ]+\\(\\(body[ ]+\\)?\\(\\sw\\|[_.]\\)+\\)" 1)] 11) (#$ . 21464)) #@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 (#$ . 22348) 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\310 !\204-\212\311 \210\310 !)\203\212\310\312!\203&\313v\210\310\314!)\203\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 ;\203q\323\324 !!\210\320 )\325 \n\307#\210,\202\202\326 \210\327 \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 "./" goto-line string-to-number compilation-goto-locus compile-goto-error recenter] 4 (#$ . 22549) "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!\210\304\305\306#\210\304\307\310#\210\304\311\312#\210\304\313\312#\210\304\314\312#\210\304\315\312#\210\304\316\312#\210\304\317\312#\210\304\320\312#\210\304\321\312#\210\304\322\312#\210\304\323\312#\210\304\324\312#\210\304\325\312#\210\304\326\312#\210\304\327\312#\210\304\330\312#\210\304\331\312#\210\304\332\312#\210\304\333\312#\210\304\334\335#\210\304\336\306#\210\304\337\340#\210\304\341\340#\210\304\342\343#\210\304\344\345#\210\304\346\347#\210\350!\304\342\351 #\207" [ada-mode-syntax-table ada-mode-symbol-syntax-table make-syntax-table set-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 (#$ . 23643) nil]) #@118 Deactivate Ada mode's properties handling. This would be a duplicate of font-lock if both are used at the same time. (defalias 'ada-deactivate-properties #[nil "\300\301\302\303#\207" [remove-hook after-change-functions ada-after-change-function t] 4 (#$ . 24654)]) #@180 Initialize some special text properties in the whole buffer. In particular, character constants are said to be strings, #...# are treated as numbers instead of gnatprep comments. (defalias 'ada-initialize-properties #[nil "\212\214~\210eb\210\300\301\302\303#\203\304\305\224\305\225\306#\210\202eb\210\300\307\302\303#\2030\304\305\224\305\225\310#\210\202\311\302!\210\312\313\314\302\303$*\207" [re-search-forward "'.'" nil t add-text-properties 0 (syntax-table ("'" . 34)) "^[ ]*#" (syntax-table (11 . 10)) set-buffer-modified-p add-hook after-change-functions ada-after-change-function] 5 (#$ . 24927)]) #@131 Called when the region between BEG and END was changed in the buffer. OLD-LEN indicates what the length of the replaced text was. (defalias 'ada-after-change-function #[(beg end old-len) "\303`\212\304 \305\216\306 \210\307`\310#\210\311\312\303#\203&\313\314\224\314\225\315#\210\202\306 \210\316\317!\2056\313\314\224\314\225\320#-\207" [eol inhibit-point-motion-hooks save-match-data-internal t match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) beginning-of-line remove-text-properties (syntax-table nil) re-search-forward "'.'" add-text-properties 0 (syntax-table ("'" . 34)) looking-at "^[ ]*#" (syntax-table (11 . 10))] 4 (#$ . 25551)]) #@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 (#$ . 26258)]) (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 (#$ . 26603)]) (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 (#$ . 26954)]) (put 'ada-in-string-or-comment-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 (#$ . 27389) 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] 6 (#$ . 27636) "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 (#$ . 28602)]) #@2071 Ada mode is the major mode for editing Ada code. Bindings are as follows: (Note: 'LFD' is control-j.) \{ada-mode-map} Indent line '\[ada-tab]' Indent line, insert newline and indent the new line. '\[newline-and-indent]' Re-format the parameter-list point is in '\[ada-format-paramlist]' Indent all lines in region '\[ada-indent-region]' Adjust case of identifiers and keywords in region '\[ada-adjust-case-region]' Adjust case of identifiers and keywords in buffer '\[ada-adjust-case-buffer]' Fill comment paragraph, justify and append postfix '\[fill-paragraph]' Next func/proc/task '\[ada-next-procedure]' Previous func/proc/task '\[ada-previous-procedure]' Next package '\[ada-next-package]' Previous package '\[ada-previous-package]' Goto matching start of current 'end ...;' '\[ada-move-to-start]' Goto end of current block '\[ada-move-to-end]' Comments are handled using standard GNU Emacs conventions, including: Start a comment '\[indent-for-comment]' Comment region '\[comment-region]' Uncomment region '\[ada-uncomment-region]' Continue comment on next line '\[indent-new-comment-line]' If you use imenu.el: Display index-menu of functions and procedures '\[imenu]' If you use find-file.el: Switch to other file (Body <-> Spec) '\[ff-find-other-file]' or '\[ff-mouse-find-other-file] Switch to other file in other window '\[ada-ff-other-window]' or '\[ff-mouse-find-other-file-other-window] If you use this function in a spec and no body is available, it gets created with body stubs. If you use ada-xref.el: Goto declaration: '\[ada-point-and-xref]' on the identifier or '\[ada-goto-declaration]' with point on the identifier Complete identifier: '\[ada-complete-identifier]'. (defalias 'ada-mode #[nil "\306 \210\307\301!\210\307\302!\210\310\307\303!\210\310\307\304!\210\311\307\305!\210\312\307\313!\210\314 \307\315!\210\316 \307\317!\210\320\321\322\323\"\203K\307\324!\210\325\307\326!\210\327\307\330!\210\325\211@\331\332!\203^\325\307\333!\210\334\307\335!\210A\336\337\340\"\210\307\341!\210\342!\307\343!\210\344#\307\345!\210\346%\347B\350C\336\351\352\"\210\307\353!\210\354\355\356\357B\360\361B\362\363BE\"\210\307\364!\210\3654\307\366!\210\3676\370D\307\371!\210\3729\373\374\375\"\210\373\376\375\"\210\307\377!\210E?\373\201\\\201]\"\210\373\201\\\201^\"\210\201_F\373\201F\201`\"\210\373\201F\201a\"\210\373\201F\201b\"\210\373\201F\201c\"\210\373\201F\201d\"\210FGH\203'\201eIH\201f#\210\201g\201J\201_\"\210JK\307\201L!\210\201hL\201_M\375N\201iO\201jI!\210\201kPI\"\210\201lQ!\210R\203|\336\201m\201n\"\210\336\201m\201o\"\210\307\201S!\210\201pS\336\201q\201r\201_\325$\210\201s\201t!\210\307\201U!\210T\203\256TU\202\263\201uU\201v \210\336\201w\201x\201_\325$\210V\201y=\203\325WX\202\362V\201z=\203\345YX\202\362V\201{=\203\362ZX[\205\373\201| \207" [mode-require-final-newline require-final-newline paragraph-start paragraph-separate comment-end comment-start-skip kill-all-local-variables make-local-variable "[ \n\f]*$" "" "---*[ ]*" 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 ada-check-emacs-version 20 3 parse-sexp-ignore-comments t comment-padding 0 parse-sexp-lookup-properties boundp imenu-case-fold-search fill-paragraph-function ada-fill-comment-paragraph imenu-generic-expression add-hook compilation-mode-hook #[nil "\302\300!\210\303\304 \305\306#\210\304 \307\310#\210\304 \311\310#\207" [compile-auto-highlight compilation-minor-mode-map make-local-variable 40 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 (font-lock-syntactic-keywords . ada-font-lock-syntactic-keywords)) 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] "^\\(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] outline-regexp "\\([ ]*\\(procedure\\|function\\|package\\|if\\|while\\|for\\|declare\\|case\\|end\\|begin\\|loop\\)\\|--\\)" outline-level ada-outline-level imenu--sort-by-name ispell-check-comments exclusive add-to-list align-dq-string-modes ada-mode align-open-comment-modes align-region-separate case-fold-search ada-imenu-generic-expression ff-post-load-hook ff-file-created-hook imenu-sort-function ada-align-region-separate ada-align-modes align-mode-rules-list ada-popup-key ada-mode-map ada-mode-abbrev-table local-abbrev-table which-func-functions comment-multi-line major-mode mode-name ada-mode-menu ada-mode-syntax-table ada-clean-buffer-before-saving skeleton-further-elements ada-fill-comment-prefix comment-start ada-language-version ada-83-keywords ada-keywords ada-95-keywords ada-2005-keywords ada-auto-case align-exclude-rules-list (ada-solo-comment (regexp . "^\\(\\s-*\\)--") (modes quote (ada-mode))) (ada-solo-use (regexp . "^\\(\\s-*\\)\\") (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-*\\)\\") (modes quote (ada-mode))) define-key ada-popup-menu define-abbrev-table (ada-which-function) "Ada" use-local-map easy-menu-add set-syntax-table local-write-file-hooks delete-trailing-whitespace #[nil "\300ed\"\207" [untabify] 3] ((< '(backward-delete-char-untabify (min ada-indent (current-column))))) skeleton-end-hook ada-adjust-case-skeleton run-mode-hooks ada-mode-hook "-- " ada-initialize-properties font-lock-mode-hook ada-deactivate-properties ada83 ada95 ada2005 ada-activate-keys-for-case] 7 (#$ . 29365) 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 (#$ . 36588)]) #@73 Return t if a region has been selected by the user and is still active. (defalias 'ada-region-selected #[nil "\300J\205\301J\207" [transient-mark-mode mark-active] 1 (#$ . 36786)]) #@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 mapcar #[(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 (#$ . 36976)]) #@259 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 words 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) "\306 \307\n;\203\n\202\n<\203\n@\202\310\311!\210\312 !\210\f\2046\212\313\314!\210\315`\212\316v\210`)\")\312 !\210\317!\210 \307\232\204W\320\f \321#\203W\320\f \321#\f\240\210\202^\322\305\f\321B\"\210\323!*\207" [file-name previous-syntax-table ada-case-exception-file ada-mode-symbol-syntax-table word ada-case-exception syntax-table nil error "No exception file specified. See variable ada-case-exception-file" set-syntax-table skip-syntax-backward "w" buffer-substring-no-properties 1 ada-case-read-exceptions-from-file assoc-string t add-to-list ada-save-exceptions-to-file] 4 (#$ . 37600) 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 (#$ . 38546) 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 (#$ . 39863)]) #@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 (#$ . 40508) 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 (#$ . 40823) 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 (#$ . 41420) 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 (#$ . 41939)]) #@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\304u\210o\204}g\305=\203`SSf\305=\204}`Sfz\306=\203}\307\310\311 `\"\211\312\2068\310\311 `\"8)\206K\313\206I\310\311 `\"8))\204}\212\304v\210`eU\204\\\304u\210g\305U)\203j \304!\210\202}\n\204z\314 \203z \304!\210\202}\315 \210\316u\207" [parse-result ada-case-attribute force-identifier ada-case-keyword -1 39 119 nil parse-partial-sexp line-beginning-position 3 4 ada-after-keyword-p ada-adjust-case-identifier 1] 5 (#$ . 42176)]) #@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) "\203a \306 \307\216\310\f!\210 \311=\204 \312=\203>\313c\210\314 \210\315\316!\210 \311=\2031 \210\202Q \312=\203Q \210\202Q \317=\203J\320 \210\202Q\321\322!!\210 \323=\203]\314\324!\202_\314 +\207 \311=\203j \207 \312=\203t \207\321\322!!\207" [ada-auto-case last-command-char previous-syntax-table lastk ada-mode-symbol-syntax-table ada-lfd-binding syntax-table ((set-syntax-table previous-syntax-table)) set-syntax-table 10 13 " " ada-adjust-case delete-backward-char 1 9 ada-tab self-insert-command prefix-numeric-value 95 t ada-ret-binding arg] 3 (#$ . 42839) "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 (#$ . 43631) 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 (#$ . 44076) nil]) #@377 Do nothing. ARG is ignored. This function can be used for the auto-casing variables in Ada mode, to adapt to unusal 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" ["Do nothing. ARG is ignored.\nThis function can be used for the auto-casing variables in Ada mode, to\nadapt to unusal auto-casing schemes. Since it does nothing, you can for\ninstance use it for `ada-case-identifier' if you don't want any special\nauto-casing for identifiers, whereas keywords have to be lower-cased.\nSee also `ada-auto-case' to disable auto casing altogether."] 1 (#$ . 44571)]) #@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 (#$ . 45413) 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\311!\210\312\216\212\313 !\210b\210\314\315\316#\203\225\317\225`V\2057\212\320u\210\321\322!\211)\306\323\324 `\"\211\325\206P\323\324 `\"8)\206f\326\206d\323\324 `\"8))\204`\321! b\210 \203\200\320!\210\202\217\n\203\214\320!\210\202\217\327 \210\fb\210\202\310\330!.\207" [previous-syntax-table attribp keywordp end begin ada-mode-symbol-syntax-table nil syntax-table message "Adjusting case ..." ((set-syntax-table previous-syntax-table)) 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" to from parse-result ada-keywords ada-case-attribute ada-case-keyword] 5 (#$ . 45833) "*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 (#$ . 46809) "*"]) #@42 Reformat the parameter list point is in. (defalias 'ada-format-paramlist #[nil "\306\211\211\211\307 \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`\330\fT \"\f\n|\210\fb\210\331 !.\207" [previous-syntax-table paramlist delend end begin ada-mode-symbol-syntax-table nil syntax-table ((set-syntax-table previous-syntax-table)) set-syntax-table ada-in-paramlist-p error "Not in parameter list" ada-search-ignore-string-comment "\\|\\" t down-list 1 -1 forward-sexp delete-char "\n" forward-comment -1000 ada-scan-paramlist ada-insert-paramlist ada-subprog-start-re] 5 (#$ . 47029) 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\2024 b\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 (#$ . 47731)]) #@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\n)\\\333\\j\210\334c\210i*8A@\203\327\335c\210\202\353 \204\337 \203\353\313*88\204\353\336c\210\312*88\203\372\337c\210\202\f\204 \203\313*88\204\340c\210\313*88\203\341c\210i\311*88c\210\342*88\203=\n(\\\333\\j\210\342*88c\210\310*!\203J\343c\210\202\246\344c\210\345 \210 j\210\202\246\317\346!?\205_\347 .\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 (#$ . 48768)]) #@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 (#$ . 50007) "*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 (#$ . 50446) "*"]) #@110 Insert a newline and indent it. The original line is indented first if `ada-indent-after-return' is non-nil. (defalias 'ada-indent-newline-indent-conditional #[nil "\203\301 \210\302 \210\301 \207" [ada-indent-after-return ada-indent-current newline] 1 (#$ . 50648) "*"]) #@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 (#$ . 50929) nil]) #@215 Re-indent and re-case all the files found on the command line. This function should be used from the Unix/Windows 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 "Formating %s" find-file ada-indent-region ada-adjust-case-buffer write-file "Done" kill-emacs 0] 4 (#$ . 51456)]) #@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 (#$ . 51976)]) (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 \310\211\211\311\216\312 !\210\212\212\313\314y!)\203$\315 \210\316 \202'e\317D)\n\203;\212\n@b\210i)\nA\202?\317\310 \203_ @\247\203Q @\\\202X\320 @!\\ A\211\204C\212\315 \210i)U\204s\321 \210\322 \210j\210 b\210i\323 W\203\200\315 \210)\n-\207" [prev-indent tmp-indent cur-indent orgpoint previous-syntax-table ada-mode-symbol-syntax-table syntax-table point-marker nil ((set-syntax-table previous-syntax-table)) set-syntax-table zerop -1 back-to-indentation ada-get-current-indent 0 eval beginning-of-line delete-horizontal-space current-indentation] 6 (#$ . 52269) 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)\202@\306f\204\214\326\306\211#\202@\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\307 \210\330C!\203\342D[A)\330\340!\203 \212\307 \210\330\341!)\203\377\212\342 \210`)\317D\202\212\334\343\336\"@)\317D\202\212\342 \210`)A\\\317D+\202@\330\344!\2030\212\332\312!\210\212\342 \210`*\317D\202@\330\345!\203[\212\346\336!\210\330\347!)\203J\326\306\211#\202@\212\332\312\306\336#\210\342 \210`)\317D\202@\330\350!\205@\212\332\312\306\336#\210\342 \210`)\317D\202@\306f\227\351U\203\220\330\352!\203\220\212\332\312!\210\212\342 \210`*\353D\202@\306f\227\354U\203\303\330\355!\203\303\212\346\336!\210\330\356!)\203\262\326\306\211#\202@\212\334\357\336\306#\210\342 \210`)\360D\202@\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 \342 \210`\360D)\202@\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\342 \210`)\374D\202@\306f\227\375U\203q\330\376!\203q\212\377\336!\203h\342 \210`\317D\202m\326\306\211#)\202@\306f\227\201MU\203\322\330\201N!\203\322E\203\261\212\317\225b\210\201O\212\306\210`)!\210\330\201P!)\203\261\212\363 \210\342 \210`)\201QD\202@\212\363 \210\330\201R!\203\306\342 \210`\317D\202\316\342 \210`\201QD)\202@\306f\227\366U\203\255\330\201S!\203\255\212\201TF\330\201U!\203\306\212\334\201V\336\") \203\f @f\227\366U\203\f @b\210\201WF)\310\201X!\210`Sf\315U\203+\201Y\201Z!\210\2020\201Zv\210\312Gg\201[U\203~\212\201Zv\210\330\201\\!\206X\201Zv\210\201]G\330\201\\!)\203~\201^F!\317X\203r`\201_FDD\202\251G[v\210`FD\202\251\201^F!\317V\203\244\212\201Zv\210\330\201`!)\203\244\201Zv\210`FD\202\251\326\306\211#+\202@\306f\227\201aU\204\301\306f\227\201bU\203\336\201c \204\317\201d \203\336\212\332\312!\210\342 \210`)\317D\202@\306f\227\201eU\203\376\330\201f!\203\376\212\363 \210\342 \210`)\360D\202@\306f\201gU\203sH\203h\306I\203_\212\201Zy\210\307 \210 \204P\201h\201i\212\306\210`)\336#\203P\306J\201jJ\206E\201k\201l `\"8)\204`\211\203  )\203_ \201]Z\317D\202d\326\306\211#)\202@\212\342 \210`)\317D\202@\306f\201mU\203\230K\201n\232\203\230\330\201o!\203\230\212\307 \210`)\317D\202@m\204\262\306f\315U\203\262\212\312u\210\323\312!\210`)\317D\202@\330\201p!\203\302\326\306\211#\202@\306f\227\201bU\204\326\306f\227\201qU\203\330\201r!\203\212\306LL\204\334\201s\336\"\203\212\201Zv\210\330\201t!?L)\202\342)\330\201u!\203\342 \210`\317D\202\326\306\211#)\202@\330\201v!\205@\201w \2034\326\306\211#\202@\201x\326\306\211#\201y\"\211\206J\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 ".+\\" ada-search-ignore-string-comment ";" t "\\" "record" "^[ ]*\\(record\\|limited record\\)" back-to-indentation "\\" "exception\\>" "else\\>" ada-goto-next-word "\\" "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\\)\\>" "\\" "for" word-search-backward ada-indent-record-rel-type 98 "begin\\>" ada-goto-matching-decl-start limit label ada-loop-start-re ada-named-block-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 105 "is\\>" ada-goto-next-non-ws "\\\\|\\" ada-indent "\\" "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\\)" "\\(new\\|abstract\\|separate\\)\\>" 102 "\\<\\(package\\|function\\|procedure\\)\\>" "\\<\\(generic\\|end\\|begin\\|package\\|procedure\\|function\\)\\>" "with" "generic" "\\(\\sw\\|_\\)+[ \n]*:[^=]" ada-in-decl-p append (ada-label-indent)] 7 (#$ . 53041)]) #@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\360\n\204\310 \210 `=\203)\n\204)\311 \202\360 \2037\312 \2037\313 \202\360\314\315!\203C\316\f!\202\360\314 !\203O\317\f!\202\360\314(!\203\\\320\f!\202\360\314)!\203i\321\f!\202\360\314\322!\203u\323\f!\202\360\314\324!\203\201\325\f!\202\360\314\326!\203\215\327\f!\202\360\314\330!\203\231\331\f!\202\360\314\332!\203\245\333\f!\202\360\314\334!\203\260\311 \202\360\314\335!\203\304\212\336 \210`)*[\\C\202\360\314\337!\203\355\212\340\341 \342#)\203\335\336 \210`\343D\202\360`\314\344!\203\350\345\202\351\346D\202\360\347\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 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 "\\(sub\\)?type\\>" ada-get-indent-type "\\(\\(els\\)?if\\>\\)\\|then abort\\>" ada-get-indent-if "case\\>" ada-get-indent-case "when\\>" ada-get-indent-when "\\(\\sw\\|_\\)+[ \n]*:[^=]" ada-get-indent-label "separate\\>" "<<" back-to-indentation "with\\>\\|use\\>" search-forward ";" t 0 "with" ada-with-indent ada-use-indent ada-get-indent-noindent ada-subprog-start-re ada-block-start-re ada-label-indent] 4 (#$ . 58148)]) #@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 (#$ . 59871)]) #@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 (#$ . 60050)]) #@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`\305D)\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 (#$ . 60230)]) #@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\\)\\>" ada-check-matching-start match-string 0 back-to-indentation "\\" ada-goto-stmt-start "\\(for\\|type\\)\\>" "\\" t ada-goto-matching-start ada-check-defun-name 59 "\\" ada-goto-matching-decl-start ada-broken-indent] 6 (#$ . 60722)]) #@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 (#$ . 61842)]) #@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 (#$ . 62560)]) #@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 "\\" 1 ada-indent ada-broken-indent] 4 (#$ . 62936)]) #@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) "\302\212\303v\210\304 !\211)\203b\210\212\305\306 \")\202K\307\310!\203C\212\311 \210\307\312!)\2037\212\313 \210`)\314D\202K\212\315\316\306\"@)\314D\202K\212\313 \210`)\314D)\207" [pos orgpoint 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 "\\"] 3 (#$ . 63461)]) #@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 (#$ . 64076)]) #@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\250\312\313!\203*\212\311 \210`)\314D\202\250\312 !\2036\n[\202\205\315\212\316\317\315\f#\205S`\211\205S\212\320u\210\321\322!\210\312\323!))\204v\212\316\324\315\f#\205r`\211\205r\212\325u\210\321\322!\210\312\326!))\203\204 b\210\327\330\315\322#\210\212\311 \210))\212\316\331\315\f\315\332%)\203\236\212\311 \210`)\\\305D\202\250\212\311 \210`)\\\333D*\207" [label ada-named-block-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 "\\" -7 ada-goto-next-word t "with" "\\" -6 "null" re-search-backward "\\<\\(type\\|subtype\\)\\>" ";" search-forward ada-broken-indent] 6 (#$ . 64929)]) #@128 Calculate the indentation when before a label or variable declaration. ORGPOINT is the limit position used in the calculation. (defalias 'ada-get-indent-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 "\\" ada-indent ada-in-decl-p ";" 0 ada-broken-indent (- ada-label-indent)] 4 (#$ . 65974)]) #@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\315 \210`)\n\\\311D\202#\310\316!\203M\317 !\n\311\232\203C \202# @\n\\ AD\202#\310\320!\203\346\212\311\225b\205\212\321 !\205\212\322v\205\212\306f\323U\203q\322v\202r\324\205\212\321 !\205\212\310\325!\205\212\312\326\306 \306\327%\324)\203\254\f\203\241\f@b\210\212\315 \210`)\330D\202#\212\315 \210`)\331D\202#\212\312\332\306 \306\327%\211)\203\331\f@b\210\212\315 \210\310\333!)\204\314 b\210\212\315 \210`)\n\\\330D\202#\212\315 \210`)\n\\\331D\202#\310\334!\205#\212\312\332\306 \306\327%\211)\203\f@b\210\212\315 \210\310\333!)\204\f b\210\212\315 \210`)\n\\\330D\202#\212\315 \210`)\n\\\331D+\207" [ada-named-block-re ada-label-indent label pos match-cons orgpoint nil beginning-of-line looking-at 0 ada-search-ignore-string-comment ";" search-forward back-to-indentation "loop\\>" ada-get-indent-block-start "for\\>" ada-goto-next-non-ws 1 39 t "\\" "record" word-search-forward ada-indent ada-broken-indent "loop" "\\" "while\\>"] 6 (#$ . 66619)]) #@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 "\\" 1 59 back-to-indentation 0 "record" ada-indent ";" search-forward "is" ada-broken-indent] 6 (#$ . 67886)]) #@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 #[nil "\302`\303 \211\203.\304\305!\204:\212 Ab\210\306!)\204 \303  \203( Ab\210\306 \210\202:eb\210\306!\204:b\210`*\207" [orgpoint match-dat nil ada-search-prev-end-stmt looking-at "declare" ada-goto-next-non-ws] 3 (#$ . 68671)]) #@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 (#$ . 69153)]) #@142 Skip white spaces, newlines and comments to next non-ws character. Stop the search at LIMIT. Do not call this function from within a string. (defalias 'ada-goto-next-non-ws #[(&optional limit) "\204d`X\2030\302\303!\210m\2040\212\304u\210\305\306 \206$\307\310 `\"8*\2030\311\304!\210\202`W\2057`\207" [limit parse-result forward-comment 10000 1 nil 3 parse-partial-sexp line-beginning-position forward-sexp] 4 (#$ . 69987)]) #@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 (#$ . 70434)]) #@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 \203#\312\313\314\304\314$\202)\312\313\304\211\314$\211\2039\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 (#$ . 70740)]) #@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 (#$ . 71340)]) #@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'\311v\210\202>\312v\210\311v\210\304\313!\2036\314v\210\315\314!\210\316\314!\210\304\305\317Q!?\205R\320\321`\315\314!\210`{\")\207" [defun-name ada-subprog-start-re ada-goto-next-word t looking-at "\\<" "\\> *:" ada-goto-matching-decl-start "\\" -1 2 "\\<\\(body\\|type\\)\\>" 1 forward-sexp backward-sexp "\\>" error "Matching defun has different name: %s"] 5 (#$ . 71656)]) #@136 Move point to the matching declaration start of the current 'begin'. If NOERROR is non-nil, it only returns nil if no match was found. (defalias 'ada-goto-matching-decl-start #[(&optional noerror recursive) "\306?\307\211\310\311!\203\312\310\313!\204$\212\314\315\312\"\210\310\316!)\203&\312\317\f!\204[\314 \312\"\203[\310\320!\203v\321\306)\"\210\310\311!\203&\312*\212*\203r\314\322\312\"\210\310\320!\203c\321\306)\312#\210\202I\307*\310\311!\204I\fT\202I*\202&\310\316!\203\210\n\203&\307\fS\202&\310\323!\203\241\212\324v\210\310\325!\204\235\fS\307)\202&\310\326!\203\257\fS\312\202&\310\327!\203\310\330!\204\366\212\331\332!\210\324u\210\307f\333U\203\325\306u\210\334\306!\210\331\332!\210\335\307x\210\336\312!\210\310\337!\205\362\340 +\341\216\336\312!\210\310\342!*?)\203\375\343\224b\210\202&\fS\307\202&\310\344!\203\212\336\312!\210\310\327!)\203&\343\224b\210\202& \203-\310\311!\203-\343\202&\310\345!\203H\212\324v\210\310\346!\204D \203D\fS)\202&\310\311!\203S\307\202&\fT\307\202&\317\f!\203y\310\327!\203o\314,\312\"\202r\310\326!\203y\312\202\202)?\205\202\347\350!,\207" [recursive stop-at-when count-generic first nest-count ada-matching-decl-start-re 1 nil looking-at "begin" t "\\<\\(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 "\\" "declare\\|generic" "is" "is[ ]+<>" 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)) "\\" 0 "new" "when" "\\" error "No matching proc/func/task/declare/package/protected" noerror loop-again save-match-data-internal ada-subprog-start-re] 4 (#$ . 72371)]) #@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\"9 \203\217 @b\210\202\235\324\325\326\327\330\3319T\"!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\"\211:\203:@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\376 \203\365<\203\335\312\357!\203\335\212\310\360\307\211\211\361%\210\362 \210\312\363!)\203\335\306\224b\210\202\361\312\364!\203\361\310\365\311\307\211\366%\204\361\324\367!\210`\202\376=?\205\376\324\370!,\207" [nest-level pos last-was-begin found nest-count ada-matching-start-re 0 nil ada-search-ignore-string-comment t looking-at "\\" -1 "\\" "end" "loop\\|select\\|record\\|case\\|if" ada-goto-next-word "\\[ ]*[^;]" "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" "\\" "\\" 2 ";" "(" ")" "\\<\\(is\\|;\\)\\>" "is" "[ ]*;" "declare" "protected" "\\(\\\\|\\\\|;\\)" "procedure" "function" "\\(\\\\|\\\\|)[ ]*;\\)" "begin" zerop "if" "then" word-search-forward back-to-indentation "\\" "do" "accept" word-search-backward "Missing 'accept' in front of 'do'" "No matching start" current tmp count gotothen noerror] 8 (#$ . 74387)]) #@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" "\\" 1 ada-search-ignore-string-comment -1 "\\" "is\\|;" 115 ada-goto-next-non-ws "\\" ada-goto-matching-end t "\\" "end" "\\<\\(loop\\|select\\|record\\|case\\|if\\)\\>" "\\" "is" word-search-forward error "No matching end" noerror] 7 (#$ . 76847)]) #@440 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\307  \204\203\310\202\311\312!\210\f\204\355 \203;\2034 `X\204; `Y\203\355 ! \313#\203\355\314\224\314\225\315\212\316 \210`)`\"\211\317 \206a\315\320 `\"8)\203w\321 8b\210\204\322\313!\210\202 \323 \206\203\315\320 `\"8)\203\250\321 8b\210\204\324\313!\203\242\324\325!\210\316 \210\202\306\210\202 f\326U\203\306 Tf\326U\203\306\204\327u\210\324\325!\210\202\"\204\347\330 \203\347\203\336\331\332\306\333#\210\202\334\335\306\333#\210\202\333\211\203#\312!\210\f\205\370 \nB-\207" [previous-syntax-table parse-result end begin found search-func nil syntax-table re-search-backward re-search-forward set-syntax-table 1 0 parse-partial-sexp beginning-of-line 3 line-beginning-position 8 forward-sexp 4 forward-comment 1000 45 -1 ada-in-paramlist-p search-backward "(" t search-forward ")" backward ada-mode-symbol-syntax-table limit search-re paramlists] 6 (#$ . 78150)]) #@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-matching-decl-start t] 2 (#$ . 79668)]) #@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 "\\" 1 ada-goto-stmt-start] 2 (#$ . 79902)]) #@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 "\\" "\\"] 2 (#$ . 80120)]) #@47 Return t if point is inside a parameter-list. (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\\|pragma\\|type\\)\\>"] 5 (#$ . 80592)]) #@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 (#$ . 81179)]) #@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 (#$ . 81568)]) #@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 (#$ . 82036) 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 (#$ . 82553) "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 (#$ . 82833) "*"]) #@39 Indent current line to next tab stop. (defalias 'ada-tab-hard #[nil "\212\301 \210\302\303\"\210)\212`\301 \210`U)\205u\207" [ada-indent beginning-of-line insert-char 32] 3 (#$ . 83073) nil]) #@43 Indent current line to previous tab stop. (defalias 'ada-untab-hard #[nil "\212\303 \210`)\212\304\210`)\305 \n[#*\207" [eol bol ada-indent beginning-of-line nil indent-rigidly] 4 (#$ . 83275) 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 (#$ . 83484) 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\202eb\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\202Peb\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 "] 5 (#$ . 83862) nil]) #@64 Move point to the matching start of the current Ada structure. (defalias 'ada-move-to-start #[nil "`\305 \306\216\307\n!\210\212\310\311\312 `\"\211\313 \206 \311\312 `\"8)\2063 \314 \2061\311\312 `\"8))\204r\315\316!\204@\317v\210\315\316!\204I\317v\210\315\316!\204U\320\321!\203r\322\323!\203r`\211\203r\f\203r\315\324!\203r\325 \203r`) b+\207" [previous-syntax-table pos ada-mode-symbol-syntax-table parse-result ada-move-to-declaration syntax-table ((set-syntax-table previous-syntax-table)) set-syntax-table nil parse-partial-sexp line-beginning-position 3 4 looking-at "[ ]*\\" -1 error "Not on end ...;" ada-goto-matching-start 1 "\\" ada-goto-matching-decl-start] 5 (#$ . 85726) nil]) #@102 Move point to the matching end of the block around point. Moves to 'begin' if in a declarative part. (defalias 'ada-move-to-end #[nil "`\304\305 \306\216\307 !\210\212\212\310\311!\210\312\313!)\203!\314\315!\210\202\310\212\310\311!\205:\312\316!\205:\317\320!\205:`Sf\321U?)\203J\310\311!\210\314\322\323\"\210\202\310\212\324 \205c\312\325!\205c\315v\205c\326 \205c\312\327!)\203r\317\330\304\211\211\331%\210\202\310\212\324 \205{\312\332!)\203\206\314\322!\210\202\310\212\333\323!\205\216`\211\205\226\312\334!)\203\241\314\315!\210\202\310\212\310\311!\210\312\335!)\203\265\314\322\323\"\210\202\310 \203\304 b\210\314\322\323\"\210\202\310\314\315!\210`)\nb,\207" [previous-syntax-table decl-start pos ada-mode-symbol-syntax-table nil syntax-table ((set-syntax-table previous-syntax-table)) set-syntax-table skip-syntax-backward "w" looking-at "\\" ada-goto-matching-end 1 "\\\\|\\" ada-search-ignore-string-comment "is\\|;" 59 0 t ada-goto-stmt-start "\\" ada-goto-next-non-ws "\\" "begin" word-search-forward "\\" ada-goto-matching-decl-start "\\" "\\"] 7 (#$ . 86465) 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 (#$ . 87668) 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 (#$ . 87917) 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 (#$ . 88193) 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 (#$ . 88418) nil]) #@49 Create the keymap associated with the Ada mode. (defalias 'ada-create-keymap #[nil "\302\303\304#\210\302\305\304#\210\302\306\307#\210\302\310\311#\210\302\312\313#\210\302\314\315#\210\302\316\317#\210\302\320\321#\210\302\322\323#\210\302\324\325#\210\302\326\327#\210\330\331\"\204O\302\331\332#\210\302\333\334#\210\302\335\336#\210\302\337\340#\210\302\341\342#\210\343\344!\203v\302\345\346#\210\202|\302\347\346#\210\302\350\351#\210\302\352\353#\210\302\354\355#\210\302\356\357#\210\302\360\361#\210\302\362\363#\210\302\364\365#\210\302\366\367#\210\302\370\371#\210\302\331\372#\210\302\373\374#\210\302\375\376#\210\302\377\201@#\210\302\201A\201B#\210\302\201C\201D#\210\302\201E\201F#\210\302\201G\201H#\210\302\201I\201J#\210\302\201K\201L#\210\302\201M\201N#\210\302\201O\201P#\210\201Q \302 \201R\201S#\210\302 \201T\201U#\210\302 \201V\201W#\210\302 \201X\201Y#\210\302 \201Z\201[#\210\302 \201\\\201]#\210\302 \201^\201_#\210\302 \201`\201a#\210\302 \201b\201c#\210\302 \201d\201e#\210\302 \201f\201g#\210\302 \201h\201i#\210\302 \201j\201k#\210\302 \201l\201m#\210\302 \201n\201o#\210\302 \201p\201q#\210\302 \201r\201s#\210\302 \201t\201u#\210\302 \201v\201w#\210\302 \201x\201y#\210\302 \201z\201{#\210\302 \201|\201}#\210\302 \201~\201#\210\302 \201\200\201\201#\210\302 \201\202\201\203#\210\302 \201\204\201\205#\210\302 \201\206\201\207#\210\302 \201\210\201\211#\210\302\201\212 #)\207" [ada-mode-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 [C-tab] ada-complete-identifier [S-mouse-3] ada-point-and-xref "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 make-sparse-keymap "h" ada-header "" ada-array "b" ada-exception-block "d" ada-declare-block "c" ada-case "" ada-elsif "e" ada-else " " ada-package-spec "k" ada-package-body "" ada-procedure-spec "p" ada-subprogram-body "" ada-function-spec "f" ada-for-loop "i" ada-if "l" ada-loop "" ada-record "" ada-subtype "S" ada-tabsize "" ada-task-spec "t" ada-task-body "" ada-type "" ada-private "u" ada-use "" ada-with "" ada-when "w" ada-while-loop "" ada-exception "x" ada-exit "t"] 4 (#$ . 88670)]) #@47 Create the Ada menu as shown in the menu bar. (defalias 'ada-create-menu #[nil "\302\303\304\305\306#\210\307\304!\204\310\304\311\"\210\312\304 \306$\210)\311\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 (eq major-mode '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 (eq major-mode '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 (eq major-mode '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 (eq major-mode '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-accep 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])) put ada-mode-menu variable-documentation "Menu keymap for Ada mode" default-boundp set-default nil easy-menu-do-define] 5 (#$ . 91823)]) (ad-add-advice 'comment-region '(ada-uncomment-anywhere nil nil (advice lambda nil (if (and arg (listp arg) (string= mode-name "Ada")) (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 (#$ . 97746) "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 (#$ . 98104) 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 (#$ . 98296) 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\205 Sb\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\377 b\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 (#$ . 98552) "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 (#$ . 100007)]) #@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 (#$ . 100318)]) #@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 (#$ . 101040)]) #@53 Last line on which `ada-which-function' was called. (defvar ada-last-which-function-line -1 (#$ . 101426)) #@56 Last subprogram name returned by `ada-which-function'. (defvar ada-last-which-function-subprog 0 (#$ . 101539)) (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 2 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 (#$ . 101791)]) #@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 (#$ . 102949) 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 (#$ . 103136)]) #@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\nO A\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 (#$ . 103391) nil]) (byte-code "\301B\302\303!\207" [current-load-list ada-font-lock-syntactic-keywords (lambda (#1=#:defconst-tmp-var) (defconst ada-font-lock-syntactic-keywords #1#)) (("[^a-zA-Z0-9)]\\('\\)[^'\n]\\('\\)" (1 (7 . 39)) (2 (7 . 39))) ("^[ ]*\\(#\\(if\\|else\\|elsif\\|end\\)\\)" (1 (11 . 10))))] 2) #@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-reference-face nil t)) ("<<\\(\\sw+\\)>>" 1 font-lock-reference-face) ("\\([0-9]+#[0-9a-fA-F_]+#\\)" (1 font-lock-constant-face t)) ("\\W\\([-+]?[0-9._]+\\)\\>" (1 font-lock-constant-face))) (#$ . 104291)) #@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 (#$ . 106248)]) #@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\212\304 \210`)\305 \210\301\210`}\210\306\307!*\207" [end nil 1 ada-previous-procedure beginning-of-line ada-move-to-end message "Use M-x widen to get back to full visibility in the buffer"] 2 (#$ . 106450) 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 (#$ . 106957)]) #@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 (#$ . 108055)]) #@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 "\\" "^begin" newline -1 ada-gen-treat-proc "Not in subprogram spec"] 5 (#$ . 108723) 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\211$\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)