Current File : //usr/local/share/emacs/27.2/lisp/dabbrev.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(byte-code "\300\301\302\303\304\305\306\307\306\310& \210\311\312\313\314\315DD\316\317\320\306\301&\210\311\321\313\314\322DD\323\317\324\306\301&\210\311\325\313\314\326DD\327\317\330\306\301&\210\311\331\313\314\332DD\333\317\320\306\301&\210\311\334\313\314\335DD\336\317\337\306\301&\210\311\340\313\314\341DD\342\317\320\306\301&\210\311\343\313\314\344DD\345\317\346\306\301\347\350& \210\311\351\313\314\352DD\353\317\354\306\301&\210\311\355\313\314\356DD\357\317\360\306\301&\210\311\361\313\314\362DD\363\317\320\306\301&\210\311\364\313\314\365DD\366\317\367\306\301\347\370& \210\311\371\313\314\372DD\373\317\374\306\301\347\375& \210\311\376\313\314\377DD\201@ \317\201A \306\301&\207" [custom-declare-group dabbrev nil "Dynamic Abbreviations." :tag "Dynamic Abbreviations" :group abbrev convenience custom-declare-variable dabbrev-backward-only funcall function #[0 "\300\207" [nil] 1] "If non-nil, `dabbrev-expand' only looks backwards." :type boolean dabbrev-limit #[0 "\300\207" [nil] 1] "Limits region searched by `dabbrev-expand' to this many chars away." (choice (const :tag "off" nil) integer) dabbrev-abbrev-skip-leading-regexp #[0 "\300\207" [nil] 1] "Regexp for skipping leading characters of an abbreviation.\n\nExample: Set this to \"\\\\$\" for programming languages\nin which variable names may appear with or without a leading `$'.\n(For example, in Makefiles.)\n\nSet this to nil if no characters should be skipped." (choice regexp (const :tag "off" nil)) dabbrev-eliminate-newlines #[0 "\300\207" [t] 1] "Non-nil means dabbrev should not insert newlines.\nInstead it converts them to spaces." dabbrev-case-fold-search #[0 "\300\207" [case-fold-search] 1] "Control whether dabbrev searches should ignore case.\nA value of nil means case is significant.\nA value of `case-fold-search' means case is significant\n if `case-fold-search' is nil.\nAny other non-nil version means case is not significant." (choice (const :tag "off" nil) (const :tag "like search" case-fold-search) (other :tag "on" t)) dabbrev-upcase-means-case-search #[0 "\300\207" [nil] 1] "The significance of an uppercase character in an abbreviation.\nA nil value means case fold search when searching for possible expansions;\nnon-nil means case sensitive search.\n\nThis variable has an effect only when the value of\n`dabbrev-case-fold-search' says to ignore case." dabbrev-case-distinction #[0 "\300\207" [case-replace] 1] "Whether dabbrev treats expansions as the same if they differ in case.\n\nA value of nil means treat them as different.\nA value of `case-replace' means distinguish them if `case-replace' is nil.\nAny other non-nil value means to treat them as the same.\n\nThis variable has an effect only when the value of\n`dabbrev-case-fold-search' specifies to ignore case." (choice (const :tag "off" nil) (const :tag "based on `case-replace'" case-replace) (other :tag "on" t)) :version "22.1" dabbrev-case-replace #[0 "\300\207" [case-replace] 1] "Whether dabbrev applies the abbreviations's case pattern to the expansion.\n\nA value of nil means preserve the expansion's case pattern.\nA value of `case-replace' means preserve it if `case-replace' is nil.\nAny other non-nil value means modify the expansion\nby applying the abbreviation's case pattern to it.\n\nThis variable has an effect only when the value of\n`dabbrev-case-fold-search' specifies to ignore case." (choice (const :tag "off" nil) (const :tag "based on `case-replace'" case-replace) (other :tag "on" t)) dabbrev-abbrev-char-regexp #[0 "\300\207" [nil] 1] "Regexp to recognize a character in an abbreviation or expansion.\nThis regexp will be surrounded with \\\\( ... \\\\) when actually used.\n\nSet this variable to \"\\\\sw\" if you want ordinary words or\n\"\\\\sw\\\\|\\\\s_\" if you want symbols (including characters\nwhose syntax is \"symbol\" as well as those whose syntax is\n\"word\"). The abbreviation is from point to the start of the\nprevious sequence of characters matching this variable.\n\nThe default value of nil is equivalent to \"\\\\sw\\\\|\\\\s_\".\n\nFor instance, suppose the current buffer is in `c-mode'. If this\nvariable is nil or \"\\\\sw\\\\|\\\\s_\", then expanding\n`debug_print_in_' looks for a symbol starting with\n`debug_print_in_'. If you set this variable to \"\\\\sw\", that\nexpansion looks for a word prefixed with `in_' (e.g., it would\nmatch `in_range', but not `in_close_range'). If expanding\n`debug_print_in' it would look for a word starting with\n`in' (e.g. `integer')." (choice (const nil) regexp) dabbrev-check-all-buffers #[0 "\300\207" [t] 1] "Non-nil means dabbrev package should search *all* buffers.\n\nDabbrev always searches the current buffer first. Then, if\n`dabbrev-check-other-buffers' says so, it searches the buffers\ndesignated by `dabbrev-select-buffers-function'.\n\nThen, if `dabbrev-check-all-buffers' is non-nil, dabbrev searches\nall the other buffers, except those named in `dabbrev-ignored-buffer-names',\nor matched by `dabbrev-ignored-buffer-regexps'." dabbrev-ignored-buffer-names #[0 "\300\207" [("*Messages*" "*Buffer List*")] 1] "List of buffer names that dabbrev should not check.\nSee also `dabbrev-ignored-buffer-regexps'." (repeat (string :tag "Buffer name")) "20.3" dabbrev-ignored-buffer-regexps #[0 "\300\207" [nil] 1] "List of regexps matching names of buffers that dabbrev should not check.\nSee also `dabbrev-ignored-buffer-names'." (repeat regexp) "21.1" dabbrev-check-other-buffers #[0 "\300\207" [t] 1] "Should \\[dabbrev-expand] look in other buffers?\nnil: Don't look in other buffers.\nt: Also look for expansions in the buffers pointed out by\n `dabbrev-select-buffers-function'.\nAnything else: When we can't find any more expansions in\nthe current buffer, then ask the user whether to look in other\nbuffers too.\n\nThe default value is t." (choice (const :tag "off" nil) (const :tag "on" t) (other :tag "ask" other))] 10)
#@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 (#$ . 6337))
(byte-code "\300\301\302\303\304DD\305\306\303\307\310&\210\300\311\302\303\312DD\313\306\314\307\310&\207" [custom-declare-variable dabbrev-friend-buffer-function funcall function #[0 "\300\207" [dabbrev--same-major-mode-p] 1] "A function to decide whether dabbrev should search OTHER-BUFFER.\nThe function should take one argument, OTHER-BUFFER, and return\nnon-nil if that buffer should be searched. Have a look at\n`dabbrev--same-major-mode-p' for an example.\n\nThe value of `dabbrev-friend-buffer-function' has an effect only if\nthe value of `dabbrev-select-buffers-function' uses it. The function\n`dabbrev--select-buffers' is one function you can use here.\n\nA mode setting this variable should make it buffer local." :type :group dabbrev dabbrev-search-these-buffers-only #[0 "\300\207" [nil] 1] "If non-nil, a list of buffers which dabbrev should search.\nIf this variable is non-nil, dabbrev will only look in these buffers.\nIt will not even look in the current buffer if it is not a member of\nthis list." (choice (const nil) (repeat :tag "List of buffers" string))] 8)
(defvar dabbrev--last-table nil)
(defvar dabbrev--last-abbreviation nil)
(defvar dabbrev--last-abbrev-location nil)
(defvar dabbrev--last-direction 0)
(defvar dabbrev--last-expansion nil)
(defvar dabbrev--last-expansion-location nil)
(defvar dabbrev--friend-buffer-list nil)
(defvar dabbrev--last-buffer nil)
(defvar dabbrev--last-buffer-found nil)
(defvar dabbrev--last-case-pattern nil)
(defvar dabbrev--check-other-buffers dabbrev-check-other-buffers)
(defvar dabbrev--check-all-buffers dabbrev-check-all-buffers)
(defvar dabbrev--abbrev-char-regexp nil)
(defvar dabbrev--progress-reporter nil)
#@40 Get the buffer from which mini-buffer.
(defalias 'dabbrev--minibuffer-origin #[0 "\300\301 !\207" [window-buffer minibuffer-selected-window] 2 (#$ . 8389)])
(put 'dabbrev--minibuffer-origin 'byte-optimizer 'byte-compile-inline-expand)
#@31
(fn ELEMENT LIST CONDITION)
(defalias 'dabbrev-filter-elements '(macro . #[771 "\300\301\302E\303\302E\304\302\303\305BB\306\303\301\307
\310BBEE\311BBBB\312BBBB\207" [let dabbrev-result dabbrev-tail setq while ((car dabbrev-tail)) if cons (dabbrev-result) ((setq dabbrev-tail (cdr dabbrev-tail))) ((nreverse dabbrev-result))] 16 (#$ . 8630)]))
#@15
(fn ABBREV)
(defalias 'dabbrev--ignore-case-p #[257 "\301=\203\n \202 \205 \n?\206 \211\227\230\207" [dabbrev-case-fold-search case-fold-search dabbrev-upcase-means-case-search] 3 (#$ . 8990)])
#@437 Completion on current word.
Like \[dabbrev-expand] but finds all expansions in the current buffer
and presents suggestions for completion.
With a prefix argument ARG, 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 \[universal-argument] \[universal-argument]),
then it searches *all* buffers.
(fn &optional ARG)
(defalias 'dabbrev-completion #[256 "\302 \210\303 \304!\210`\305!\210`\306!\307C\310\311\312\313\314 #\315\"\316\317%\205+ \320\2057 \321!\322U\323#\207" [dabbrev--check-other-buffers dabbrev--check-all-buffers dabbrev--reset-global-variables dabbrev--abbrev-at-point search-backward search-forward dabbrev--ignore-case-p uninitialized make-byte-code 771 "\211\306=\203 \306\307\310B\311BB\207\302\242\312=\203l \212\300\313\300\301\"\301 \211:\2041 \314\315\300
\203. \316\202/ \317#\210\302\301\203; \204? \202g \300\211\226\230\203M \320\321\"\202g \322\300\323\324#\322\300\323\324#\226\230\203c \320\325\"\202g \320\326\"\240\210)\210)\327\302\242$\207" vconcat vector [dabbrev--last-abbreviation completion-ignore-case dabbrev--check-other-buffers metadata cycle-sort-function identity ((category . dabbrev)) uninitialized dabbrev--find-all-expansions user-error "No dynamic expansion for \"%s\" found%s" "" " in this-buffer" mapcar upcase substring 0 1 capitalize downcase complete-with-action dabbrev-case-replace] 10 "\n\n(fn S P A)" t prefix-numeric-value 16 completion-in-region] 14 (#$ . 9200) "*P"])
#@1055 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', if `dabbrev-check-other-buffers'
says so. Then, if `dabbrev-check-all-buffers' is non-nil, look in
all the other buffers, subject to constraints specified
by `dabbrev-ignored-buffer-names' and `dabbrev-ignored-buffer-regexps'.
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].
(fn ARG)
(defalias 'dabbrev-expand #[257 "\306\211\211\211\211`\212\2045 \307!\2035 \310!\2035 \n=\204) \311 \2035 `U\2035 \262\f\262
\262\202\271 h\312=\203\224 \307!\203\224 \310!\203\224 `TU\203\224 \313\262\212\214~\210&\203^ &q\210
\314=\204q
\315=\203x '`W\203x '\fG\\''b\210\316\317(\320Q!\210\321'`\"\262`'*\322\202\271 \323 \210\204\251 )\203\245 \314\202\255 \315\202\255 \324!\262\325 \262\326\262\306\262\204\310 \327\330 !#\262)\204\373 \323 \210\203\352 \212\211*B*\331!\210c\210``G\\|\210)\332\333\203\364 \334\202\365 \335#\202U&+=\204\336\337 !\204\340\341\342&!\"\210&+\202 \340\306!\210p&=\204)&\204<'\247\203<'`V\203<\343'!'\211*B*\344$\262\345 \211\207" [dabbrev--last-abbrev-location last-command this-command dabbrev--last-abbreviation dabbrev--last-expansion dabbrev--last-direction nil markerp marker-position window-minibuffer-p 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 dabbrev--ignore-case-p search-backward user-error "No%s dynamic expansion for `%s' found" " further" "" minibuffer-window-active-p selected-window message "Expansion found in `%s'" buffer-name copy-marker dabbrev--substitute-expansion point-marker dabbrev--last-buffer dabbrev--last-expansion-location dabbrev--abbrev-char-regexp dabbrev-backward-only buffer-undo-list dabbrev--last-buffer-found] 12 (#$ . 10788) "*P"])
#@85 Check if OTHER-BUFFER has the same major mode as current buffer.
(fn OTHER-BUFFER)
(defalias 'dabbrev--same-major-mode-p #[257 "rq\210)=\207" [major-mode] 3 (#$ . 13383)])
#@87 Back over all abbrev type characters and then moves forward over
all skip characters.
(defalias 'dabbrev--goto-start-of-abbrev #[0 "\302 \303\304\305\306\307!\310\"\311$\216`\312 V\203? \313u\210\314!\2036 `\312 V\2036 `\315`\316`S#U\2046 \313u\210\202 \314!\204? \317u\210 \205O \314 !\205O \317u\210\202C )\207" [dabbrev--abbrev-char-regexp dabbrev-abbrev-skip-leading-regexp match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 minibuffer-prompt-end -1 looking-at field-beginning nil 1] 7 (#$ . 13565)])
#@55 Extract the symbol at point to serve as abbreviation.
(defalias 'dabbrev--abbrev-at-point #[0 "o\203 \302\303!\210\212`\304 \305\306\307\310\311!\312\"\313$\216\212\314u\210\315 \206# \316!)\204> \317 \206. \316\320\321#\203: \322u\210\202> \302\303!\210)\210\323 \210\324`\")\207" [dabbrev--last-abbrev-location dabbrev-abbrev-char-regexp user-error "No possible abbreviation preceding point" match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 -1 looking-at "\\sw\\|\\s_" re-search-backward nil t 1 dabbrev--goto-start-of-abbrev buffer-substring-no-properties] 7 (#$ . 14122)])
#@34 Initialize all global variables.
(defalias 'dabbrev--reset-global-variables #[0 "\306\211\306\211\306\211\306\211 \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 dabbrev-check-all-buffers dabbrev--check-all-buffers] 3 (#$ . 14753)])
#@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 #[0 "\301\211\211\302 \262\2033 @\262p=\204, \303!\204, \304\300!\203, !\203, \211B\262A\262\202 \237\207" [dabbrev-friend-buffer-function nil buffer-list dabbrev--ignore-buffer-p boundp] 5 (#$ . 15359)])
#@261 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'.
(fn ABBREV REVERSE N IGNORE-CASE)
(defalias 'dabbrev--try-find #[1028 "\212\214~\210\304\203\f b\210\211\305V\2039 \306\205+ \n\303=\203* \202+ \n#\211\262\2039 \211S\262\202 )\266\211\203B `\211\262*\207" [dabbrev--last-expansion-location case-fold-search dabbrev-case-distinction case-replace nil 0 dabbrev--search] 12 (#$ . 16112)])
#@142 Return a list of all possible expansions of ABBREV.
If IGNORE-CASE is non-nil, accept matches which differ in case.
(fn ABBREV IGNORE-CASE)
(defalias 'dabbrev--find-all-expansions #[514 "\300\211\212eb\210\301\302#\211\262\203 \211B\262\202 )\207" [nil dabbrev--find-expansion -1] 8 (#$ . 16700)])
#@69 Return non-nil if BUFFER should be ignored by dabbrev.
(fn BUFFER)
(defalias 'dabbrev--ignore-buffer-p #[257 "\302!\211\235\206# \303\203! \211\204! \304@\"\262A\262\202 \262\207" [dabbrev-ignored-buffer-names dabbrev-ignored-buffer-regexps buffer-name nil string-match] 7 (#$ . 17013)])
#@509 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.
(fn ABBREV DIRECTION IGNORE-CASE)
(defalias 'dabbrev--find-expansion #[771 "\212\203 q\210 \204% \306Y\203% \307^\211\203% \310\311\307]$\206\234 \203- \203E \306X\203E \312\211\203E \310\313\307[]$\206\234 \312\204^ \204^ \314 \315\316 G[\306\211\307\317&\313\211\204\225 \203\225 \211A\242\211q\210\f G[\313\247\203\201 @Y\205\206 \320#\266e\310\313\307$\262\202_ \321\f!\210\211\262)\207" [dabbrev--last-buffer dabbrev-search-these-buffers-only dabbrev--last-direction dabbrev--friend-buffer-list dabbrev--progress-reporter dabbrev--last-expansion-location 0 1 dabbrev--try-find t -1 nil dabbrev--make-friend-buffer-list make-progress-reporter "Scanning for dabbrevs..." 1.5 progress-reporter-do-update progress-reporter-done] 12 (#$ . 17320)])
(defalias 'dabbrev--make-friend-buffer-list #[0 "\304\305\"C\204` \203` \306=\204 \307\310!\211\203` \211\n \240\210 \203X \211\311\242\312\211\211\313 \262\203Q @\262\211\242>\204J \314!\204J \211B\262A\262\202/ \237\266\203\"\240\210\211\315p\242\"\240\210\211\242\203u \316\317\320\321\322\323!\324\"\325\326%!\210\327 \203\216 \204\216 \211\330\331 !\315\330\331 !\242\"B\240\210\211\242\207" [dabbrev-search-these-buffers-only dabbrev--check-other-buffers dabbrev-select-buffers-function dabbrev--check-all-buffers mapcar get-buffer t y-or-n-p "Scan other buffers also? " append nil buffer-list dabbrev--ignore-buffer-p delq walk-windows make-byte-code 257 "\211\301 =?\205 \302!\300\242>\205 \300\302!\303\302!\300\242\"B\240\207" vconcat vector [selected-window window-buffer delq] 6 "\n\n(fn W)" window-minibuffer-p window-buffer minibuffer-selected-window] 9])
#@43
(fn STRING &optional FIXEDCASE LITERAL)
(defalias 'dabbrev--safe-replace-match #[769 "\301=\203\f \302#\207\303#\207" [major-mode picture-mode picture-replace-match replace-match] 7 (#$ . 19485)])
#@504 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.
(fn OLD ABBREV EXPANSION RECORD-CASE-PATTERN)
(defalias 'dabbrev--substitute-expansion #[1028 "\304!\205 \301=\203 \202 \305\232\203# \n\203 \n!\262\306\262\307\310\"\311\312\"\211\203b \211\227\230\204> \211\226\230\203U \211\227\230\204e \211\226\230\203U GZ\310V\204e \307\313 G#\230\203e \306\262\266\211\227\230\203x \211\227\230\203x \306\262\211\203\200 \227\262\203\234 \211\205\233 \211\226\232\203\223 \314\202\233 \211\227\232\205\233 \315 \203\306 \305\232\203\252 \313\202\254 G\311\316#\203\305 \313\224T\262\317\305\306\211$\262\202\254 \210\203\323 \212\320!\210)\202\333 \320!\210\321!\210\322?\323#\266\207" [dabbrev-case-replace case-replace dabbrev--last-case-pattern dabbrev-eliminate-newlines dabbrev--ignore-case-p " " nil substring 1 string-match "[[:alpha:]]" 0 upcase downcase "[\n ]+" replace-match search-backward search-forward dabbrev--safe-replace-match t] 12 (#$ . 19698)])
#@793 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.
(fn ABBREV REVERSE IGNORE-CASE)
(defalias 'dabbrev--search #[771 "\305 \306\307\310\311\312!\313\"\314$\216\315!\316\317R\315!\320\321R\322\323\211\214\n\2036 ` \2032 \n[\2023 \n\\}\210\204\254 \203G \324\323\322#\202L \325\323\322#\203\254 \307\224b\210\326 \210\327!\203\233 \325!\210\330\307!\262\262\203q \227\262\323\211\211\f\262\203\221 @\262\230\203\212 \211B\262A\262\202w \237\266\203\203\233 \323\262\203\245 \307\224\202\247 \307\225b\210\2026 \205\265 \fB\211*\266\205)\207" [dabbrev--abbrev-char-regexp inhibit-point-motion-hooks dabbrev-limit dabbrev--last-expansion-location dabbrev--last-table match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 regexp-quote "\\(" "\\)" "\\(\\(" "\\)+\\)" t nil re-search-backward re-search-forward dabbrev--goto-start-of-abbrev looking-at match-string-no-properties] 14 (#$ . 21121)])
(provide 'dabbrev)
Mini Shell