;ELC ;;; Compiled by pot@pot.cnuce.cnr.it on Tue Mar 18 15:37:43 2003 ;;; from file /home/pot/gnu/emacs-pretest.new/lisp/dabbrev.el ;;; in Emacs version 21.3 ;;; with bytecomp version 2.85.4.1 ;;; 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 '(#$ . -740) :type 'boolean :group 'dabbrev) #@70 *Limits region searched by `dabbrev-expand' to this many chars away. (custom-declare-variable 'dabbrev-limit 'nil '(#$ . -896) :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 '(#$ . -1094) :type '(choice regexp (const :tag "off" nil)) :group 'dabbrev) #@88 *Non-nil means dabbrev should not insert newlines. Instead it converts them to spaces. (custom-declare-variable 'dabbrev--eliminate-newlines 't '(#$ . -1505) :type 'boolean :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 '(#$ . -1702) :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 '(#$ . -2153) :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 '(#$ . -2499) :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 '(#$ . -3051) :type '(choice (const nil) regexp) :group 'dabbrev) #@419 *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', or matched by `dabbrev-ignored-regexps'. (custom-declare-variable 'dabbrev-check-all-buffers 't '(#$ . -4193) :type 'boolean :group 'dabbrev) #@97 *List of buffer names that dabbrev should not check. See also `dabbrev-ignored-buffer-regexps'. (custom-declare-variable 'dabbrev-ignored-buffer-names ''("*Messages*" "*Buffer List*") '(#$ . -4718) :type '(repeat (string :tag "Buffer name")) :group 'dabbrev :version "20.3") #@116 *List of regexps matching names of buffers that dabbrev should not check. See also `dabbrev-ignored-buffer-names'. (custom-declare-variable 'dabbrev-ignored-buffer-regexps 'nil '(#$ . -5000) :type '(repeat regexp) :group 'dabbrev :version "21.1") #@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 '(#$ . -5254) :type '(choice (const :tag "off" nil) (const :tag "on" t) (other :tag "ask" other)) :group 'dabbrev) #@282 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. See the source of `dabbrev--select-buffers' for an example. A mode setting this variable should make it buffer local. (defvar dabbrev-select-buffers-function 'dabbrev--select-buffers (#$ . 5770)) #@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 '(#$ . -6136) :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 '(#$ . 6768)) (byte-code "\301B\306\301!\204\f\307\302B\306\302!\204\307\303B\306\303!\204$\307\304B\306\304!\2040\307\305B\306\305!\204<\310\311B\306\311!\204I\307 \312B\306\312!\204V\307\n\313B\306\313!\204c\307 \314B\306\314!\204p\307\f\315B\306\315!\204}\307 \316B\306\316!\204\212\307\317B\306\317!\204\227\307\320B\306\320!\204\245\321B\306\321!\204\262\307\307\207" [current-load-list dabbrev--last-obarray 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\2048,\227 \227\230\2048\335,+\"G\332V\203)\336\337\340\341 !\"\210\202-\336\342!\210\343\313 ,\313$\210\202L\336\344!\210\345\220\346\335,+\"!\221\210\336\347!\210\314\315 !\205V\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" mapc #[(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 (#$ . 8552) "*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\304h\313=\203\243\307'!\203\243\310'!\203\243`'TU\203\243\314\212-\203j-q\210,\315=\204,\316=\203\207.`W\203\207.+G\\..b\210\317\320/\321Q!\210\322.`\"`.)\323,\202\304\324 \210&\204\2700\203\264\315\202\274\316\202\274\325&!\326 \327\306 \204\350\330 1\331=\203\327\202\3311\205\3462?\206\346 \211\227\230#) \204\324 \210\n\203\n\2123B3\332\n!\210 c\210``\nG\\|\210)\333\334\n\203\335\202\336 #\202s-4=\2048\337\312 !\2048\340\341\342-!\"\210-4\202<\340\306!\210p-=\204H-\204[.\247\203[.`V\203[\343.!.3B3\344\n \f$\210 + *\345 \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" "" minibuffer-window-active-p 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-backward-only dabbrev-case-fold-search dabbrev-upcase-means-case-search buffer-undo-list dabbrev--last-buffer-found] 6 (#$ . 10966) "*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]) #@493 Return a list of other buffers to search for a possible abbrev. The current buffer is not included in the list. This function makes a list of all the buffers returned by `buffer-list', then discards buffers whose names match `dabbrev-ignored-buffer-names' or `dabbrev-ignored-buffer-regexps'. It also discards buffers for which `dabbrev-friend-buffer-function', if it is bound, returns nil when called with the buffer as argument. It returns the list of the buffers that are not discarded. (defalias 'dabbrev--select-buffers #[nil "\304\211\211\305 \211\2033 @p=\204,\306!\204,\307\303!\203, !\203,\nB A\211\204 \n\237+\207" [buffer dabbrev-tail dabbrev-result dabbrev-friend-buffer-function nil buffer-list dabbrev--ignore-buffer-p boundp] 4 (#$ . 14946)]) #@226 Search for ABBREV, backwards if REVERSE, N times. If IGNORE-CASE is non-nil, ignore case while searching. Return the expansion found, and save the location of the start of the expansion in `dabbrev--last-expansion-location'. (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 (#$ . 15730)]) #@117 Return a list of all possible expansions of ABBREV. If IGNORE-CASE is non-nil, accept matches which differ in case. (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 (#$ . 16265)]) (defalias 'dabbrev--scanning-message #[nil "\300\301 !?\205\302\303\304p!\"\207" [window-minibuffer-p selected-window message "Scanning `%s'" buffer-name] 4]) #@56 Return non-nil if BUFFER should be ignored by dabbrev. (defalias 'dabbrev--ignore-buffer-p #[(buffer) "\306!\211\n\235\206% \307\211\203#\f\204#\310 @ \" A\211\204\f*)\207" [buffer bn dabbrev-ignored-buffer-names dabbrev-ignored-buffer-regexps match tail buffer-name nil string-match] 4 (#$ . 16768)]) #@475 Find one occurrence of ABBREV, and return the expansion. DIRECTION > 0 means look that many times backwards. DIRECTION < 0 means look that many times forward. DIRECTION = 0 means try both backward and forward. IGNORE-CASE non-nil means ignore case when searching. This sets `dabbrev--last-direction' to 1 or -1 according to the direction in which the occurrence was actually found. It sets `dabbrev--last-expansion-location' to the location of the start of the occurrence. (defalias 'dabbrev--find-expansion #[(abbrev direction ignore-case) "\212\203 q\210\306 \210 \204(\n\307Y\203(\310\n^\211\203(\311\f\312\310\n] $\206\200 \2030\203H\n\307X\203H\313\211\203H\311\f\314\310\n[] $\206\200\313\204W\204W\315 \314\203}@Aq\210\306 \210e\311\f\314\310 $\211\203Z))\207" [dabbrev--last-buffer dabbrev-search-these-buffers-only direction dabbrev--last-direction abbrev ignore-case dabbrev--scanning-message 0 1 dabbrev--try-find t -1 nil dabbrev--make-friend-buffer-list dabbrev--friend-buffer-list expansion dabbrev--last-expansion-location] 6 (#$ . 17088)]) (defalias 'dabbrev--make-friend-buffer-list #[nil "\306\307\"\204^\n\203^\n\310=\204\311\312!\211\203^ \f\203Y\313 \314\211\211\315 \211\203S@\211 >\204J\316 !\204J BA\211\2044\237+\"\317p \" \203f\320\321!\210\322\323 !\203~\204~\315 A@\317\315 A@ \"B )\207" [dabbrev-search-these-buffers-only list dabbrev--check-other-buffers dabbrev-select-buffers-function dabbrev-check-all-buffers buffer mapcar get-buffer t y-or-n-p "Scan other buffers also? " append nil buffer-list dabbrev--ignore-buffer-p delq walk-windows #[(w) "\302 =?\205\303! >\205\303!\304\303! \"B\211\207" [w list selected-window window-buffer delq] 4] window-minibuffer-p selected-window dabbrev-tail dabbrev-result] 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]) #@457 Replace OLD with EXPANSION in the buffer. OLD is text currently in the buffer, perhaps the abbreviation or perhaps another expansion that was tried previously. ABBREV is the abbreviation we are expanding. It is " " if we are copying subsequent words. EXPANSION is the expansion substring to be used this time. RECORD-CASE-PATTERN, if non-nil, means set `dabbrev--last-case-pattern' to record whether we upcased the expansion, downcased it, or did neither. (defalias 'dabbrev--substitute-expansion #[(old abbrev expansion record-case-pattern) "\301=\203\n \202 \205$\n\203 \211\227\230\205$\f\305=\203# \202$\f \306\232\203;\2038!\307\310\307O\211\211\227\230\204Q\211\226\230\203f \211\227\230\204t \211\226\230\203f G\310V\204t \311 GO\230\203t\307)\211\227\230\203\207 \211\227\230\203\207\307\203\221\227\203\260\205\256 \211\226\232\203\246\312\202\256 \211\227\232\205\256\313\203\311\314\315\"\203\311\316\306\307\211$\202\265\203\330\212\317!\210)\202\340\317 !\210\320 !\210\321?\322#)\207" [dabbrev-case-fold-search case-fold-search dabbrev-upcase-means-case-search abbrev dabbrev-case-replace case-replace " " nil 1 0 upcase downcase string-match "\n" replace-match search-backward search-forward dabbrev--safe-replace-match t use-case-replace dabbrev--last-case-pattern expansion expansion-rest record-case-pattern dabbrev--eliminate-newlines old] 6 (#$ . 19148)]) #@760 Search for something that could be used to expand ABBREV. Second arg, REVERSE, is t for reverse search, nil for forward. The variable `dabbrev-limit' controls the maximum search region size. Third argument IGNORE-CASE non-nil means treat case as insignificant while looking for a match and when comparing with previous matches. Also if that's non-nil and the match is found at the beginning of a sentence and is in lower case except for the initial then it is converted to all lower case for return. Table of expansions already seen is examined in buffer `dabbrev--last-table' so that only distinct possibilities are found by dabbrev-re-expand. Returns the expansion found, or nil if not found. Leaves point at the location of the start of the expansion. (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 (#$ . 20616)]) (byte-code "\302\303\211\203 @\304\305\"\210 A\211\204*\306\307!\207" [mess #:--dolist-temp--97269 ("^No dynamic expansion for .* found$" "^No further dynamic expansion for .* found$" "^No possible abbreviation preceding point$") nil add-to-list debug-ignored-errors provide dabbrev] 4)