;ELC ;;; Compiled by rms@psilocin.ai.mit.edu on Thu Jun 25 00:29:20 1998 ;;; from file /gd/gnu/emacs/lisp/dabbrev.el ;;; in Emacs version 20.2.96.2 ;;; with bytecomp version 2.47 ;;; 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 "`dabbrev.el' was compiled for Emacs 19.29 or later")) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (custom-declare-group 'dabbrev nil "Dynamic Abbreviations" :tag "Dynamic Abbreviations" :group 'abbrev :group 'convenience) #@53 *If non-nil, `dabbrev-expand' only looks backwards. (custom-declare-variable 'dabbrev-backward-only 'nil '(#$ . -726) :type 'boolean :group 'dabbrev) #@70 *Limits region searched by `dabbrev-expand' to this many chars away. (custom-declare-variable 'dabbrev-limit 'nil '(#$ . -882) :type '(choice (const :tag "off" nil) integer) :group 'dabbrev) #@263 *Regexp for skipping leading characters of an abbreviation. Example: Set this to "\\$" for programming languages in which variable names may appear with or without a leading `$'. (For example, in Makefiles.) Set this to nil if no characters should be skipped. (custom-declare-variable 'dabbrev-abbrev-skip-leading-regexp 'nil '(#$ . -1080) :type '(choice regexp (const :tag "off" nil)) :group 'dabbrev) #@241 *Control whether dabbrev searches should ignore case. A value of nil means case is significant. A value of `case-fold-search' means case is significant if `case-fold-search' is nil. Any other non-nil version means case is not significant. (custom-declare-variable 'dabbrev-case-fold-search ''case-fold-search '(#$ . -1492) :type '(choice (const :tag "off" nil) (const :tag "like search" case-fold-search) (other :tag "on" t)) :group 'dabbrev) #@230 *The significance of an uppercase character in an abbreviation. nil means case fold search, non-nil means case sensitive search. This variable has an effect only when the value of `dabbrev-case-fold-search' says to ignore case. (custom-declare-variable 'dabbrev-upcase-means-case-search 'nil '(#$ . -1943) :type 'boolean :group 'dabbrev) #@342 *Controls whether dabbrev preserves case when expanding the abbreviation. A value of nil means preserve case. A value of `case-replace' means preserve case if `case-replace' is nil. Any other non-nil version means do not preserve case. This variable has an effect only when the value of `dabbrev-case-fold-search' specifies to ignore case. (custom-declare-variable 'dabbrev-case-replace ''case-replace '(#$ . -2289) :type '(choice (const :tag "off" nil) (const :tag "like M-x query-replace" case-replace) (other :tag "on" t)) :group 'dabbrev) #@1012 *Regexp to recognize a character in an abbreviation or expansion. This regexp will be surrounded with \\( ... \\) when actually used. Set this variable to "\\sw" if you want ordinary words or "\\sw\\|\\s_" if you want symbols (including characters whose syntax is "symbol" as well as those whose syntax is "word". The value nil has a special meaning: the abbreviation is from point to previous word-start, but the search is for symbols. For instance, if you are programming in Lisp, `yes-or-no-p' is a symbol, while `yes', `or', `no' and `p' are considered words. If this variable is nil, then expanding `yes-or-no-' looks for a symbol starting with or containing `no-'. If you set this variable to "\\sw\\|\\s_", that expansion looks for a symbol starting with `yes-or-no-'. Finally, if you set this variable to "\\sw", then expanding `yes-or-no-' signals an error because `-' is not part of a word; but expanding `yes-or-no' looks for a word starting with `no'. The recommended value is "\\sw\\|\\s_". (custom-declare-variable 'dabbrev-abbrev-char-regexp 'nil '(#$ . -2841) :type '(choice (const nil) regexp) :group 'dabbrev) #@378 *Non-nil means dabbrev package should search *all* buffers. Dabbrev always searches the current buffer first. Then, if `dabbrev-check-other-buffers' says so, it searches the buffers designated by `dabbrev-select-buffers-function'. Then, if `dabbrev-check-all-buffers' is non-nil, dabbrev searches all the other buffers, except those named in `dabbrev-ignored-buffer-names'. (custom-declare-variable 'dabbrev-check-all-buffers 't '(#$ . -3983) :type 'boolean :group 'dabbrev) #@54 *List of buffer names that dabbrev should not check. (custom-declare-variable 'dabbrev-ignored-buffer-names ''("*Messages*" "*Buffer List*") '(#$ . -4467) :type '(repeat (string :tag "Buffer name")) :group 'dabbrev :version "20.3") #@338 *Should \[dabbrev-expand] look in other buffers? nil: Don't look in other buffers. t: Also look for expansions in the buffers pointed out by `dabbrev-select-buffers-function'. Anything else: When we can't find any more expansions in the current buffer, then ask the user whether to look in other buffers too. The default value is t. (custom-declare-variable 'dabbrev-check-other-buffers 't '(#$ . -4706) :type '(choice (const :tag "off" nil) (const :tag "on" t) (other :tag "ask" other)) :group 'dabbrev) #@279 A function that selects buffers that should be searched by dabbrev. The function should take no arguments and return a list of buffers to search for expansions. Have a look at `dabbrev--select-buffers' for an example. A mode setting this variable should make it buffer local. (defvar dabbrev-select-buffers-function 'dabbrev--select-buffers (#$ . 5222)) #@493 *A function to decide whether dabbrev should search OTHER-BUFFER. The function should take one argument, OTHER-BUFFER, and return non-nil if that buffer should be searched. Have a look at `dabbrev--same-major-mode-p' for an example. The value of `dabbrev-friend-buffer-function' has an effect only if the value of `dabbrev-select-buffers-function' uses it. The function `dabbrev--select-buffers' is one function you can use here. A mode setting this variable should make it buffer local. (custom-declare-variable 'dabbrev-friend-buffer-function ''dabbrev--same-major-mode-p '(#$ . -5585) :type 'function :group 'dabbrev) #@210 If non-nil, a list of buffers which dabbrev should search. If this variable is non-nil, dabbrev will only look in these buffers. It will not even look in the current buffer if it is not a member of this list. (custom-declare-variable 'dabbrev-search-these-buffers-only 'nil '(#$ . 6217)) (byte-code "\306\300!\204\307\300 B\306\302!\204\307\302 B\306\303!\204 \307\303 B\306\304!\204,\307\304 B\306\305!\2048\310\305 B\306\311!\204E\307 \311 B\306\312!\204R\307\n\312 B\306\313!\204_\307 \313 B\306\314!\204l\307\f\314 B\306\315!\204y\307 \315 B\306\316!\204\206\307\316 B\306\317!\204\223\307\317 B\306\320!\204\241\320 B\306\321!\204\256\307\321 B\307\207" [dabbrev--last-obarray current-load-list dabbrev--last-table dabbrev--last-abbreviation dabbrev--last-abbrev-location dabbrev--last-direction boundp nil 0 dabbrev--last-expansion dabbrev--last-expansion-location dabbrev--friend-buffer-list dabbrev--last-buffer dabbrev--last-buffer-found dabbrev--last-completion-buffer dabbrev--last-case-pattern dabbrev--check-other-buffers dabbrev--abbrev-char-regexp dabbrev-check-other-buffers] 2) (defalias 'dabbrev--minibuffer-origin #[nil "\300 A@\207" [buffer-list] 1]) (put 'dabbrev--minibuffer-origin 'byte-optimizer 'byte-compile-inline-expand) (defalias 'dabbrev-filter-elements '(macro . #[(element list condition) "\303\304\305E\306\305 E\307\305\306\310BB\311\n\306\304\312\313BBEE\314BBBB\315BBBB\207" [element list condition let dabbrev-result dabbrev-tail setq while ((car dabbrev-tail)) if cons (dabbrev-result) ((setq dabbrev-tail (cdr dabbrev-tail))) ((nreverse dabbrev-result))] 13])) (byte-code "\301\302\303#\210\301\304\305#\207" [esc-map define-key "/" dabbrev-expand [67108911] dabbrev-completion] 4) #@472 Completion on current word. Like \[dabbrev-expand] but finds all expansions in the current buffer and presents suggestions for completion. With a prefix argument, it searches all buffers accepted by the function pointed out by `dabbrev-friend-buffer-function' to find the completions. If the prefix argument is 16 (which comes from C-u C-u), then it searches *all* buffers. With no prefix argument, it reuses an old completion list if there is a suitable one already. (defalias 'dabbrev-completion #[(&optional arg) "\306 \210\205\307\205\310!\311U\312 \f\305=\203 \202!\f\205.(?\206. \211\227\230)*+\313,\212\204~+\203~-p=\204Y\314\315 !\203~-\316 A@=\203~.\203~ G.GY\203~. \317.GO\230\203~\320 +\"\211,\204\370 .\321 )\")/0\3220G\317\"\211+G\317V\204\252\323\324 1\203\247\325\202\250\326#\210)\203\2642\204\275\327\3300\"\210\202\351 \211\226\230\203\315\327\3310\"\210\202\351 \317\332O \317\332O\226\230\203\343\327\3330\"\210\202\351\327\3340\"\210+*p-\320 +\",*),;\204 ,,\325\230\2047,\227 \227\230\2047\335,+\"G\332V\203)\336\337\340\341 !\"\210\202-\336\342!\210\343\313 ,#\210\202K\336\344!\210\345\220\346\335,+\"!\221\210\336\347!\210\314\315 !\205U\336\313!.\207" [arg dabbrev-check-other-buffers dabbrev-check-all-buffers abbrev dabbrev-case-fold-search case-fold-search dabbrev--reset-global-variables t prefix-numeric-value 16 dabbrev--abbrev-at-point nil window-minibuffer-p selected-window buffer-list 0 try-completion dabbrev--find-all-expansions make-vector error "No dynamic expansion for \"%s\" found%s" "" " in this-buffer" mapcar #[(string) "\302 \"\207" [string my-obarray intern] 3] #[(string) "\302\226 \"\207" [string my-obarray intern] 3] 1 #[(string) "\302\303! \"\207" [string my-obarray intern capitalize] 3] #[(string) "\302\227 \"\207" [string my-obarray intern] 3] all-completions message "Repeat `%s' to see all completions" key-description this-command-keys "The only possible completion" dabbrev--substitute-expansion "Making completion list..." " *Completions*" display-completion-list "Making completion list...done" dabbrev-upcase-means-case-search ignore-case-p dabbrev--last-obarray my-obarray init dabbrev--last-completion-buffer dabbrev--last-abbreviation completion-ignore-case completion-list dabbrev--check-other-buffers dabbrev-case-replace] 6 (#$ . 8000) "*P"]) #@817 Expand previous word "dynamically". Expands to the most recent, preceding word for which this is a prefix. If no suitable preceding word is found, words following point are considered. If still no suitable word is found, then look in the buffers accepted by the function pointed out by variable `dabbrev-friend-buffer-function'. A positive prefix argument, N, says to take the Nth backward *distinct* possibility. A negative argument says search forward. If the cursor has not moved from the end of the previous expansion and no argument is given, replace the previously-made expansion with the next possible expansion not yet tried. The variable `dabbrev-backward-only' may be used to limit the direction of search to backward if set non-nil. See also `dabbrev-abbrev-char-regexp' and \[dabbrev-completion]. (defalias 'dabbrev-expand #[(arg) "\306\211\211\211\211`\212%\204B\307&!\203B\310&!\203B'(=\2046\311\312 !\203B&`U\203B)*+\202\314h\313=\203\253\307&!\203\253\310&!\203\253`&TU\203\253\314\212,\203j,q\210+\315=\204+\316=\203\207-`W\203\207-*G\\--b\210\317\320.\321Q!\210\322-`\"/\203\241 \226`-)\323+\202\314\324 \210%\204\3000\203\274\315\202\304\316\202\304\325%!\326 \327\306 \204\360\330 1\331=\203\337\202\3411\205\3562?\206\356 \211\227\230#) \204\"\324 \210\n\203\2123B3\332\n!\210 c\210``\nG\\|\210)\333\334\n\203\335\202\336 #\202\224,4=\2049\337\340\341,!\"\210,4\202=\337\306!\210p,=\204I,\204\\-\247\203\\-`V\203\\\342-!-3B3\343\n #\210\f\203\2111\331=\203x\202z1\205\2072?\205\207 \211\226\232/ * )\344 \211&.\207" [orig-point direction old expansion record-case-pattern abbrev nil markerp marker-position window-minibuffer-p selected-window 32 " " 1 0 re-search-forward "\\(\\(" "\\)+\\)" buffer-substring-no-properties -1 dabbrev--reset-global-variables prefix-numeric-value dabbrev--abbrev-at-point t dabbrev--find-expansion case-fold-search search-backward error "No%s dynamic expansion for `%s' found" " further" "" message "Expansion found in '%s'" buffer-name copy-marker dabbrev--substitute-expansion point-marker arg dabbrev--last-abbrev-location last-command this-command dabbrev--last-abbreviation dabbrev--last-expansion dabbrev--last-direction dabbrev--last-buffer dabbrev--last-expansion-location dabbrev--abbrev-char-regexp dabbrev--last-case-pattern dabbrev-backward-only dabbrev-case-fold-search dabbrev-upcase-means-case-search buffer-undo-list dabbrev--last-buffer-found] 6 (#$ . 10412) "*P"]) (defalias 'dabbrev--same-major-mode-p #[(other-buffer) "\212 q\210)=\207" [major-mode other-buffer] 2]) (defalias 'dabbrev--goto-start-of-abbrev #[nil "\303 \304\216o\204%\305u\210\306 !\203o\204\305u\210\202\f\306 !\204%\307u\210\n\2055\306\n!\2055\307u\210\202)*\207" [save-match-data-internal dabbrev--abbrev-char-regexp dabbrev-abbrev-skip-leading-regexp match-data ((set-match-data save-match-data-internal)) -1 looking-at 1] 2]) (defalias 'dabbrev--abbrev-at-point #[nil "o\203\303\304!\210\212`\305 \306\216\212\307u\210\310\311\n\206\312\313Q!)\2048\314\n\206(\312\315\316#\2034\317u\210\2028\303\304!\210*\320 \210\321`\")\207" [dabbrev--last-abbrev-location save-match-data-internal dabbrev-abbrev-char-regexp error "No possible abbreviation preceding point" match-data ((set-match-data save-match-data-internal)) -1 looking-at "\\(" "\\sw\\|\\s_" "\\)+" re-search-backward nil t 1 dabbrev--goto-start-of-abbrev buffer-substring-no-properties] 4]) (defalias 'dabbrev--reset-global-variables #[nil "\306\306\306\306\306\306\306\306 \306\n \206\307\f \211\207" [dabbrev--last-table dabbrev--last-abbreviation dabbrev--last-abbrev-location dabbrev--last-direction dabbrev--last-expansion dabbrev--last-expansion-location nil "\\sw\\|\\s_" dabbrev--friend-buffer-list dabbrev--last-buffer dabbrev--last-buffer-found dabbrev-abbrev-char-regexp dabbrev--abbrev-char-regexp dabbrev-check-other-buffers dabbrev--check-other-buffers] 2]) (defalias 'dabbrev--select-buffers #[nil "\212\305\306 !\203\307 A@q\210p\310\211\211\307 \211\203=\n@ =\2046\311\304!\2036\f !\2036 B\nA\211\204 \237-\207" [orig-buffer buffer dabbrev-tail dabbrev-result dabbrev-friend-buffer-function window-minibuffer-p selected-window buffer-list nil boundp] 4]) (defalias 'dabbrev--try-find #[(abbrev reverse n ignore-case) "\212\214~\210\306 \203 b\210\n \f\307V\203*\310 \n\n#\211\203*\fS\211\202*\2031`+\207" [expansion dabbrev--last-expansion-location ignore-case n count case-fold-search nil 0 dabbrev--search abbrev reverse] 5]) (defalias 'dabbrev--find-all-expansions #[(abbrev ignore-case) "\304\211\212eb\210\305\n\306 #\211\203 B\202) *\207" [expansion all-expansions abbrev ignore-case nil dabbrev--find-expansion -1] 4]) (defalias 'dabbrev--scanning-message #[nil "\300\301\302p!\"\207" [message "Scanning `%s'" buffer-name] 4]) (defalias 'dabbrev--find-expansion #[(abbrev direction ignore-case) "\306\212 \203 q\210\307 \210\202)\n\204)\310\311 !\203)\312 A@q\210eb\210\313\307 \210\n\204M \314Y\203M\315 ^\211\203M\316 \317\315 ]$\211\203M\202J\n\203U \203t \314X\203t\313\211\203t\316 \306\315 []$\211\203t\202J\313\204\366 \204\366\320\321\n\"\211\204\366\203\366\317=\204\236\322\323!\211\203\366\306\306 \203\365\306\211\211 !\"\312 \211!\203\346!@ \324 !#\235\204\335 >\204\335 \"B\"!A\211!\204\277\"\237+\237\325\"*\203\"\326\311 !\211$\311 =\204!\327$!\330\327$!\"B\326$!\211$\202)\204I\203I@A q\210\307 \210e%\316 \306\315$\211\203&*\207" [expansion dabbrev--last-buffer dabbrev-search-these-buffers-only direction dabbrev--last-direction abbrev nil dabbrev--scanning-message window-minibuffer-p selected-window buffer-list -1 0 1 dabbrev--try-find t mapcar get-buffer y-or-n-p "Scan other buffers also? " buffer-name append next-window window-buffer delq ignore-case dabbrev--friend-buffer-list dabbrev--check-other-buffers friend-buffer-list non-friend-buffer-list dabbrev-select-buffers-function dabbrev-check-all-buffers buffer dabbrev-tail dabbrev-result dabbrev-ignored-buffer-names w dabbrev--last-expansion-location] 6]) (defalias 'dabbrev--safe-replace-match #[(string &optional fixedcase literal) "\304=\203\f\305 \n #\207\306 \n #\207" [major-mode string fixedcase literal picture-mode picture-replace-match replace-match] 4]) (defalias 'dabbrev--substitute-expansion #[(old abbrev expansion) "\301=\203\n \202 \205$\n\203 \211\227\230\205$\f\305=\203# \202$\f \306\307O\211\211\227\230\204<\211\226\230\203J \211\227\230\204X \211\226\230\204X \310 GO\230\203X\307 ) \311\232\203b\307  \203l\227\203{\212\312!\210)\202\312 !\210\313 ?\314#)\207" [dabbrev-case-fold-search case-fold-search dabbrev-upcase-means-case-search abbrev dabbrev-case-replace case-replace 1 nil 0 " " search-backward dabbrev--safe-replace-match t use-case-replace expansion expansion-rest old] 5]) (defalias 'dabbrev--search #[(abbrev reverse ignore-case) "\306 \307\216\310 !\311\n\312R\310 !\313\n\314R\315\214\2030`\203+[\202-\\}\210 \204\262\203A\316 \315\317#\202F\320 \315\317#\203\262\321\224b\210\322 \210\323 !\203\237\320\f!\210\324\325\224\325\225\"\203i \227\315\211\211\211\203\226@ \230\203\215BA\211\204z\237+\203\237\315\203\253\321\224b\210\2020\321\225b\210\2020 \205\330\324\321\224\321\225\" B\203\325\326 !\203\325\202\327).\207" [save-match-data-internal abbrev dabbrev--abbrev-char-regexp found-string pattern2 pattern1 match-data ((set-match-data save-match-data-internal)) regexp-quote "\\(" "\\)" "\\(\\(" "\\)+\\)" nil re-search-backward t re-search-forward 0 dabbrev--goto-start-of-abbrev looking-at buffer-substring-no-properties 1 eval dabbrev-limit dabbrev--last-expansion-location reverse ignore-case table-string dabbrev-tail dabbrev-result dabbrev--last-table result dabbrev-case-replace] 6]) (provide 'dabbrev)