| Current Path : /usr/share/emacs/24.3/lisp/ |
Linux gator3171.hostgator.com 4.19.286-203.ELK.el7.x86_64 #1 SMP Wed Jun 14 04:33:55 CDT 2023 x86_64 |
| Current File : //usr/share/emacs/24.3/lisp/subr.elc |
;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:12:49 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/subr.el
;;; in Emacs version 24.3
;;; 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.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
#@150 Record `defcustom' calls made before `custom.el' is loaded to handle them.
Each element of this list holds the arguments to one call to `defcustom'.
(defvar custom-declare-variable-list nil (#$ . 546))
(defalias 'custom-declare-variable-early #[(&rest arguments) " B\211\207" [arguments custom-declare-variable-list] 2])
#@1373 Tell the byte-compiler that function FN is defined, in FILE.
Optional ARGLIST is the argument list used by the function. The
FILE argument is not used by the byte-compiler, but by the
`check-declare' package, which checks that FILE contains a
definition for FN. ARGLIST is used by both the byte-compiler and
`check-declare' to check for consistency.
FILE can be either a Lisp file (in which case the ".el"
extension is optional), or a C file. C files are expanded
relative to the Emacs "src/" directory. Lisp files are
searched for using `locate-library', and if that fails they are
expanded relative to the location of the file containing the
declaration. A FILE with an "ext:" prefix is an external file.
`check-declare' will check such files if they are found, and skip
them without error if they are not.
FILEONLY non-nil means that `check-declare' will only check that
FILE exists, not that it defines FN. This is intended for
function-definitions that `check-declare' does not recognize, e.g.
`defstruct'.
To specify a value for FILEONLY without passing an argument list,
set ARGLIST to t. This is necessary because nil means an
empty argument list, rather than an unspecified one.
Note that for the purposes of `check-declare', this statement
must be the first non-whitespace on a line.
For more information, see Info node `(elisp)Declaring Functions'.
(defalias 'declare-function '(macro . #[(fn file &optional arglist fileonly) "\300\207" [nil] 1 (#$ . 877)]))
(defalias 'not 'null)
#@82 Evaluate FORM, expecting it not to return.
If FORM does return, signal an error.
(defalias 'noreturn '(macro . #[(form) "\301\302BB\207" [form prog1 ((error "Form marked with `noreturn' did return"))] 3 (#$ . 2387)]))
(put 'noreturn 'edebug-form-spec t)
#@182 Evaluate FORM, expecting a constant return value.
This is the global do-nothing version. There is also `testcover-1value'
that complains if FORM ever does return differing values.
(defalias '1value '(macro . #[(form) "\207" [form] 1 (#$ . 2649)]))
(put '1value 'edebug-form-spec t)
#@360 Set the `edebug-form-spec' property of SYMBOL according to SPEC.
Both SYMBOL and SPEC are unevaluated. The SPEC can be:
0 (instrument no arguments); t (instrument all arguments);
a symbol (naming a function with an Edebug specification); or a list.
The elements of the list describe the argument types; see
Info node `(elisp)Specification List' for details.
(defalias 'def-edebug-spec '(macro . #[(symbol spec) "\302\303D\304\303 DF\207" [symbol spec put quote 'edebug-form-spec] 5 (#$ . 2940)]))
#@748 Return a lambda expression.
A call of the form (lambda ARGS DOCSTRING INTERACTIVE BODY) is
self-quoting; the result of evaluating the lambda expression is the
expression itself. The lambda expression may then be treated as a
function, i.e., stored as the function value of a symbol, passed to
`funcall' or `mapcar', etc.
ARGS should take the same form as an argument list for a `defun'.
DOCSTRING is an optional documentation string.
If present, it should describe how to call the function.
But documentation strings are usually not useful in nameless functions.
INTERACTIVE should be a call to the function `interactive', which see.
It may also be omitted.
BODY should be a list of Lisp expressions.
(fn ARGS [DOCSTRING] [INTERACTIVE] BODY)
(defalias 'lambda '(macro . #[(&rest cdr) "\301\302BD\207" [cdr function lambda] 3 (#$ . 3446)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\300\301\306\307#\207" [put lambda doc-string-elt 2 lisp-indent-function defun edebug-form-spec (&define lambda-list [&optional stringp] [&optional ("interactive" interactive)] def-body)] 4)
#@50 Set variable VAR to value VAL in current buffer.
(defalias 'setq-local '(macro . #[(var val) "\302\303\304DD E\207" [var val set make-local-variable quote] 4 (#$ . 4543)]))
#@169 Define VAR as a buffer-local variable with default value VAL.
Like `defvar' but additionally marks the variable as being automatically
buffer-local wherever it is set.
(defalias 'defvar-local '(macro . #[(var val &optional docstring) "\303\304 \nF\305\306DDE\207" [var val docstring progn defvar make-variable-buffer-local quote] 5 (#$ . 4724)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put defvar-local edebug-form-spec defvar doc-string-elt 3] 4)
#@273 Return a function that is a partial application of FUN to ARGS.
ARGS is a list of the first N arguments to pass to FUN.
The result is a new function which does the same as FUN, except that
the first N arguments are fixed at the values with which this function
was called.
(defalias 'apply-partially #[(fun &rest args) "\302\303\304\305\306D\307\310\311 \"\312\"BBF\207" [fun args closure (t) (&rest args) apply quote append mapcar #[(arg) "\301D\207" [arg quote] 2] (args)] 9 (#$ . 5199)])
#@187 Add NEWELT to the list stored in the generalized variable PLACE.
This is morally equivalent to (setf PLACE (cons NEWELT PLACE)),
except that PLACE is only evaluated once (after NEWELT).
(defalias 'push '(macro . #[(newelt place) "9\203
\305\306 EE\207\307\310!\210 \311\n!\203 \n\202 \312\313!\314\315\" \n=\2030 \f\2027 \316 \nDC\f\"+\207" [place newelt #1=#:exp v #2=#:body setq cons require macroexp macroexp-copyable-p make-symbol "v" gv-get #[(getter setter) "\303 \nE!\207" [setter v getter cons] 4] macroexp-let*] 5 (#$ . 5698)]))
(put 'push 'edebug-form-spec '(form gv-place))
#@211 Return the first element of PLACE's value, and remove it from the list.
PLACE must be a generalized variable whose value is a list.
If the value is nil, `pop' returns nil but does not actually
change the list.
(defalias 'pop '(macro . #[(place) "\3019\203 \302\303\304DEE\202 \305\306\"D\207" [place car prog1 setq cdr gv-get #[(getter setter) "\302 \303D!E\207" [getter setter prog1 cdr] 5]] 7 (#$ . 6301)]))
(put 'pop 'edebug-form-spec '(gv-place))
#@181 If COND yields non-nil, do BODY, else return nil.
When COND yields non-nil, eval BODY forms sequentially and return
value of last one, or nil if there are none.
(fn COND BODY...)
(defalias 'when '(macro . #[(cond &rest body) "\302\303 BE\207" [cond body if progn] 4 (#$ . 6768)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put when lisp-indent-function 1 edebug-form-spec t] 4)
#@173 If COND yields nil, do BODY, else return nil.
When COND yields nil, eval BODY forms sequentially and return
value of last one, or nil if there are none.
(fn COND BODY...)
(defalias 'unless '(macro . #[(cond &rest body) "\302\303 BBB\207" [cond body if nil] 4 (#$ . 7170)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\306\307!\204? \310\311\312\313B\"\210\300\311\302\303#\210\300\311\304\314#\210\310\315\312\316B\"\210\300\315\302\303#\210\300\315\304\311#\210\310\317\312\320B\"\210\300\207" [put unless lisp-indent-function 1 edebug-form-spec t featurep cl defalias dolist macro #[(spec &rest body) "\304 \203< \305\nA@DC\306\305\n@\307DDC\310 \311\312DEC\"BBE\nAA\2056 \305\n@\313BC\nAABBCBBB\202n \305\nA@D\n@D\306\311\n@\307DE\310 \311\312DEC\"BBB\nAA\205k \311\n@\314BB\nAABBBB)\207" [temp lexical-binding spec body --dolist-tail-- let while car append setq cdr (nil) (nil)] 12 "Loop over a list.\nEvaluate BODY with VAR bound to each car from LIST, in turn.\nThen evaluate RESULT to get return value, default nil.\n\n(fn (VAR LIST [RESULT]) BODY...)"] ((symbolp form &optional form) body) dotimes #[(spec &rest body) "\306\307A@\f\203M \310 \311 D
\nDD\312\313
E\311@
DCBB\314
\315
DEF\211 AA)\205F \311@
DC\211 AA)BBC)BBB\202q \311 D@\nDD\312\313@ E\316\314@\315@DEC\"BBAABBB+\207" [spec end start temp lexical-binding counter --dotimes-limit-- 0 --dotimes-counter-- let while < setq 1+ append body x] 11 "Loop a certain number of times.\nEvaluate BODY with VAR bound to successive integers running from 0,\ninclusive, to COUNT, exclusive. Then evaluate RESULT to get\nthe return value (nil if RESULT is omitted).\n\n(fn (VAR COUNT [RESULT]) BODY...)"] declare #[(&rest _specs) "\300\207" [nil] 1 "Do not evaluate any arguments, and return nil.\nIf a `declare' form appears as the first form in the body of a\n`defun' or `defmacro' form, SPECS specifies various additional\ninformation about the function or macro; these go into effect\nduring the evaluation of the `defun' or `defmacro' form.\n\nThe possible values of SPECS are specified by\n`defun-declarations-alist' and `macro-declarations-alist'."]] 4)
#@183 Execute BODY; if an error occurs, return nil.
Otherwise, return result of last form in BODY.
See also `with-demoted-errors' that does something similar
without silencing all errors.
(defalias 'ignore-errors '(macro . #[(&rest body) "\301\302\303B\304BBB\207" [body condition-case nil progn ((error nil))] 4 (#$ . 9343)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put ignore-errors edebug-form-spec t lisp-indent-function 0] 4)
#@93 Do nothing and return nil.
This function accepts any number of arguments, but ignores them.
(defalias 'ignore #[(&rest _ignore) "\300\207" [nil] 1 (#$ . 9793) nil])
#@240 Signal an error, making error message by passing all args to `format'.
In Emacs, the convention is that error messages start with a capital
letter but *do not* end with a period. Please follow this convention
for the sake of consistency.
(defalias 'error #[(&rest args) "\301\302\303\304\"C\"\210\202 " [args signal error apply format] 5 (#$ . 9965)])
(set-advertised-calling-convention 'error '(string &rest args) "23.1")
#@426 Signal a pilot error, making error message by passing all args to `format'.
In Emacs, the convention is that error messages start with a capital
letter but *do not* end with a period. Please follow this convention
for the sake of consistency.
This is just like `error' except that `user-error's are expected to be the
result of an incorrect manipulation on the part of the user, rather than the
result of an actual problem.
(defalias 'user-error #[(format &rest args) "\302\303\304\300 #C\"\210\202 " [format args signal user-error apply] 6 (#$ . 10398)])
#@145 Return non-nil if OBJECT seems to be a frame configuration.
Any list whose car is `frame-configuration' is assumed to be a frame
configuration.
(defalias 'frame-configuration-p #[(object) ":\205 @\301=\207" [object frame-configuration] 2 (#$ . 10964)])
#@33 Return the car of the car of X.
(defalias 'caar #[(x) "@@\207" [x] 1 (#$ . 11226)])
(put 'caar 'byte-optimizer 'byte-compile-inline-expand)
#@33 Return the car of the cdr of X.
(defalias 'cadr #[(x) "A@\207" [x] 1 (#$ . 11373)])
(put 'cadr 'byte-optimizer 'byte-compile-inline-expand)
#@33 Return the cdr of the car of X.
(defalias 'cdar #[(x) "@A\207" [x] 1 (#$ . 11520)])
(put 'cdar 'byte-optimizer 'byte-compile-inline-expand)
#@33 Return the cdr of the cdr of X.
(defalias 'cddr #[(x) "AA\207" [x] 1 (#$ . 11667)])
(put 'cddr 'byte-optimizer 'byte-compile-inline-expand)
#@196 Return the last link of LIST. Its car is the last element.
If LIST is nil, return nil.
If N is non-nil, return the Nth-to-last link of LIST.
If N is bigger than the length of LIST, return LIST.
(defalias 'last #[(list &optional n) "\203 \303Y\205) \304 !\nW\203 \nZ \233\202 )\207 \205) \304 !S \233\207" [n list m 0 safe-length] 2 (#$ . 11815)])
#@57 Return a copy of LIST with the last N elements removed.
(defalias 'butlast #[(list &optional n) "\203\f \302X\203\f \207\303\304 !\"\207" [n list 0 nbutlast copy-sequence] 3 (#$ . 12178)])
#@46 Modifies LIST to remove the last N elements.
(defalias 'nbutlast #[(list &optional n) "G\n\204 \303\n W\205 \n\304V\203 S\nZ\233\305\241\210)\207" [list m n 1 0 nil] 2 (#$ . 12377)])
#@198 Destructively remove `equal' duplicates from LIST.
Store the result in LIST and return it. LIST must be a proper list.
Of several `equal' occurrences of an element in LIST, the first
one is kept.
(defalias 'delete-dups #[(list) "\211\203 \302 @ A\"\241\210 A\211\204 )\207" [list tail delete] 5 (#$ . 12576)])
#@1279 Return a sequence of numbers from FROM to TO (both inclusive) as a list.
INC is the increment used between numbers in the sequence and defaults to 1.
So, the Nth element of the list is (+ FROM (* N INC)) where N counts from
zero. TO is only included if there is an N for which TO = FROM + N * INC.
If TO is nil or numerically equal to FROM, return (FROM).
If INC is positive and TO is less than FROM, or INC is negative
and TO is larger than FROM, return nil.
If INC is zero and TO is neither nil nor numerically equal to
FROM, signal an error.
This function is primarily designed for integer arguments.
Nevertheless, FROM, TO and INC can be integer or float. However,
floating point arithmetic is inexact. For instance, depending on
the machine, it may quite well happen that
(number-sequence 0.4 0.6 0.2) returns the one element list (0.4),
whereas (number-sequence 0.4 0.8 0.2) returns a list with three
elements. Thus, if some of the arguments are floats and one wants
to make sure that TO is included, one may have to explicitly write
TO as (+ FROM (* N INC)) or use a variable whose value was
computed with this exact expression. Alternatively, you can,
of course, also replace TO with a slightly larger value
(or a slightly more negative value if INC is negative).
(defalias 'number-sequence #[(from &optional to inc) "\203\n U\203
C\207\n\204 \306\307\n!\203 \310\311!\210\312\313 \n\313V\203@ X\203W
B\fT \f\n_\\\211\202* Y\203W
B\fT \f\n_\\\211\202A
\237+\207" [to from inc next n seq 1 zerop error "The increment can not be zero" nil 0] 4 (#$ . 12902)])
#@226 Make a copy of TREE.
If TREE is a cons cell, this recursively copies both its car and its cdr.
Contrast to `copy-sequence', which copies only along the cdrs. With second
argument VECP, this copies vectors as well as conses.
(defalias 'copy-tree #[(tree &optional vecp) ":\2038 \305:\2032 @@:\204 \203& \306@!\203& \307@ \"\n B)A\211\202 \237\244)\207 \203b \306!\203b \310!\211G \fS\211\311Y\203_ \f\307\fH \"I\210\202I )\207\207" [tree result newcar vecp i nil vectorp copy-tree copy-sequence 0] 6 (#$ . 14506)])
#@472 Find object KEY in a pseudo-alist ALIST.
ALIST is a list of conses or objects. Each element
(or the element's car, if it is a cons) is compared with KEY by
calling TEST, with two arguments: (i) the element or its car,
and (ii) KEY.
If that is non-nil, the element matches; then `assoc-default'
returns the element's cdr, if it is a cons, or DEFAULT if the
element is not a cons.
If no element matches, the value is nil.
If TEST is omitted or nil, `equal' is used.
(defalias 'assoc-default #[(key alist &optional test default) "\306\306\n\203> \204> \n@
\206 \307\f:\203 \f@\202! \f \"\2036 \310\f:\2033 \fA\2025 \n)\nA\211\204\n +\207" [alist value tail found elt test nil equal t key default] 4 (#$ . 15053)])
#@210 Like `assoc', but ignores differences in case and text representation.
KEY must be a string. Upper-case and lower-case letters are treated as equal.
Unibyte strings are converted to multibyte for comparison.
(defalias 'assoc-ignore-case #[(key alist) "\302 \303#\207" [key alist assoc-string t] 4 (#$ . 15792)])
(make-obsolete 'assoc-ignore-case 'assoc-string "22.1")
#@144 Like `assoc', but ignores differences in text representation.
KEY must be a string.
Unibyte strings are converted to multibyte for comparison.
(defalias 'assoc-ignore-representation #[(key alist) "\302 \303#\207" [key alist assoc-string nil] 4 (#$ . 16169)])
(make-obsolete 'assoc-ignore-representation 'assoc-string "22.1")
#@243 Like `member', but ignore differences in case and text representation.
ELT must be a string. Upper-case and lower-case letters are treated as equal.
Unibyte strings are converted to multibyte for comparison.
Non-strings in LIST are ignored.
(defalias 'member-ignore-case #[(elt list) "\203! @;\203 \302 \303\304@\303\304\305&\305=\204! A\211\204 \207" [list elt compare-strings 0 nil t] 9 (#$ . 16502)])
#@136 Delete from ALIST all elements whose car is `eq' to KEY.
Return the modified alist.
Elements of ALIST that are not conses are ignored.
(defalias 'assq-delete-all #[(key alist) "@:\203 @@ =\203 A\211\202 \304 A\211\203< \n@:\2036 \n@@ =\2036 \nA\241\210\202 \n\211\202 *\207" [alist key tail-cdr tail nil] 3 (#$ . 16923)])
#@138 Delete from ALIST all elements whose cdr is `eq' to VALUE.
Return the modified alist.
Elements of ALIST that are not conses are ignored.
(defalias 'rassq-delete-all #[(value alist) "@:\203 @A =\203 A\211\202 \304 A\211\203< \n@:\2036 \n@A =\2036 \nA\241\210\202 \n\211\202 *\207" [alist value tail-cdr tail nil] 3 (#$ . 17268)])
#@136 Return a copy of SEQ with all occurrences of ELT removed.
SEQ must be a list, vector, or string. The comparison is done with `equal'.
(defalias 'remove #[(elt seq) "<\204\n \302 \"\207\302 \303!\"\207" [seq elt delete copy-sequence] 4 (#$ . 17620)])
#@176 Return LIST with all occurrences of ELT removed.
The comparison is done with `eq'. Contrary to `delq', this does not use
side-effects, and the argument LIST is not modified.
(defalias 'remq #[(elt list) " @=\203 A\211\204 >\203 \302\303 !\"\207 \207" [elt list delq copy-sequence] 4 (#$ . 17881)])
#@157 Convert KEYS to the internal Emacs key representation.
KEYS should be a string constant in the format used for
saving keyboard macros (see `edmacro-mode').
(defalias 'kbd #[(keys) "\301!\207" [keys read-kbd-macro] 2 (#$ . 18196)])
(put 'kbd 'pure t)
#@50 Beep to tell the user this binding is undefined.
(defalias 'undefined #[nil "\300 \207" [ding] 1 (#$ . 18453) nil])
(put 'undefined 'suppress-keymap t)
#@218 Make MAP override all normally self-inserting keys to be undefined.
Normally, as an exception, digits and minus-sign are set to make prefix args,
but optional second arg NODIGITS non-nil treats them like other chars.
(defalias 'suppress-keymap #[(map &optional nodigits) "\303\304\305#\210 \206* \306\303\307\310#\210\311\211\312X\205) \303\313\n!\314#\210\nT\211\202 )\207" [map nodigits loop define-key [remap self-insert-command] undefined nil "-" negative-argument 48 57 char-to-string digit-argument] 5 (#$ . 18612)])
#@529 Construct a new keymap composed of MAPS and inheriting from PARENT.
When looking up a key in the returned map, the key is looked in each
keymap of MAPS in turn until a binding is found.
If no binding is found in MAPS, the lookup continues in PARENT, if non-nil.
As always with keymap inheritance, a nil binding in MAPS overrides
any corresponding binding in PARENT, but it does not override corresponding
bindings in other keymaps of MAPS.
MAPS can be a list of keymaps or a single keymap.
PARENT if non-nil should be a keymap.
(defalias 'make-composed-keymap #[(maps &optional parent) "\302\303\304!\203
C\202 \"B\207" [maps parent keymap append keymapp] 4 (#$ . 19149)])
#@644 Add binding in KEYMAP for KEY => DEFINITION, right after AFTER's binding.
This is like `define-key' except that the binding for KEY is placed
just after the binding for the event AFTER, instead of at the beginning
of the map. Note that AFTER must be an event type (like KEY), NOT a command
(like DEFINITION).
If AFTER is t or omitted, the new binding goes at the end of the keymap.
AFTER should be a single event type--a symbol or a character, not a sequence.
Bindings are always added before any inherited map.
The order of bindings in a keymap only matters when it is used as
a menu, so this function is not useful for non-menu keymaps.
(defalias 'define-key-after #[(keymap key definition &optional after) "\204 \306\307 !\204 \310\311\307 D\"\210\nG\312X\203 \n\313H\2022 \314 \315\316\317\320\321\n\"!\"\"\n\211GSH \322\211 \f?\205\226
\205\226
A@\242\n=\203Q
\211AA\241\210\307
@!\203[
@
@\242=\203i \306=\203v
A@\301=\204v
A\204\220
A@\301=\203\200 \306 \204\216
\nB
AB\241\210\306
A\2029 +\207" [after keymap key inserted done tail t keymapp signal wrong-type-argument 1 0 lookup-key apply vector butlast mapcar identity nil definition] 8 (#$ . 19835)])
#@93 Implement `map-keymap' with sorting.
Don't call this function; it is for internal use only.
(defalias 'map-keymap-sorted #[#'keymap "\305\306\307 \"\210\310\311\"\211\305\211\205& @\f\n@\nA\"\210 A\211\204 \305+\207" [list keymap p --dolist-tail-- function nil map-keymap #[(a b) " B\nB\211\207" [a b list] 2] sort #[(a b) "@ @\250\203 \250\203 W\207\302\207 \250\203 \302\207 \231\207" [a b t] 2]] 4 (#$ . 21032)])
#@41 Return the binding part of a menu-item.
(defalias 'keymap--menu-item-binding #[(val) ":\204 \207@\305=\203( \3068\307\233\310\n\311\"\211\203% !\202& +\207A:\203? \211 A@);\203? \211 AA)\207@;\203H A\207\207" [val binding plist filter x menu-item 2 3 plist-get :filter] 4 (#$ . 21476)])
#@70 Build a menu-item like ITEM but with its binding changed to BINDING.
(defalias 'keymap--menu-item-with-binding #[(item binding) ":\204 \207@\304=\203. \305!\211AA\211 \240\210\306\nA\307\"\203+ \n\310\nA\307\311#\241\210)\207A:\203J \211A@);\203J @\211A@) BB\207@ B\207" [item binding tail x menu-item copy-sequence plist-get :filter plist-put nil] 6 (#$ . 21787)])
#@31 Merge bindings VAL1 and VAL2.
(defalias 'keymap--merge-bindings #[(val1 val2) "\306!\306 !\307 !\203 \307\n!\204 \2025 \310 \nE\307!\203- \307 !?\205. \202. \311\f
\"**\207" [val1 val2 map2 map1 item map keymap--menu-item-binding keymapp keymap keymap--menu-item-with-binding] 3 (#$ . 22174)])
#@259 Return a simpler equivalent keymap.
This resolves inheritance and redefinitions. The returned keymap
should behave identically to a copy of KEYMAP w.r.t `lookup-key'
and use in active keymaps and menus.
Subkeymaps may be modified but are not canonicalized.
(defalias 'keymap-canonicalize #[(map) "\306\211\307!\310!\203 \311\312\"\202 \n\203 \313\202 \314 !\n\306 \211 \203>
@\315\316\f@!\fA#\210
A\211\204* * \306\211 \211 \203x
@\211@\211 \236\211 \204] \f\202m \317 \"\320\fAA\"B B*
A\211\204I * \244+\207" [map prompt ranges bindings binding --dolist-tail-- nil keymap-prompt keymapp map-keymap #[(key item) ":\203
B\nB\211\207 B B\211\207" [key item ranges bindings] 2] make-keymap make-sparse-keymap define-key vector delq keymap--merge-bindings key oldbind] 5 (#$ . 22486)])
(put 'keyboard-translate-table 'char-table-extra-slots 0)
#@156 Translate character FROM to TO on the current terminal.
This function creates a `keyboard-translate-table' if necessary
and then modifies one entry in it.
(defalias 'keyboard-translate #[(from to) "\303!\204 \304\300\305\" \nI\207" [keyboard-translate-table from to char-table-p make-char-table nil] 3 (#$ . 23373)])
#@505 Give KEY a global binding as COMMAND.
COMMAND is the command definition to use; usually it is
a symbol naming an interactively-callable function.
KEY is a key sequence; noninteractively, it is a string or vector
of characters or event types, and non-ASCII characters with codes
above 127 (such as ISO Latin-1) can be included if you use a vector.
Note that if KEY has a local binding in the current buffer,
that local binding will continue to shadow any global binding
that you make with this function.
(defalias 'global-set-key #[(key command) "\302!\204 ;\204 \303\304\305D\"\210\306\307 #\207" [key command vectorp signal wrong-type-argument arrayp define-key current-global-map] 4 (#$ . 23701) "KSet key globally: \nCSet key %s to command: "])
#@477 Give KEY a local binding as COMMAND.
COMMAND is the command definition to use; usually it is
a symbol naming an interactively-callable function.
KEY is a key sequence; noninteractively, it is a string or vector
of characters or event types, and non-ASCII characters with codes
above 127 (such as ISO Latin-1) can be included if you use a vector.
The binding goes in the current buffer's local map,
which in most cases is shared with all other buffers in the same major mode.
(defalias 'local-set-key #[(key command) "\303 \211\204 \304\305 \211!\210\306 !\204 ;\204 \307\310\311 D\"\210\312 \n#)\207" [map key command current-local-map use-local-map make-sparse-keymap vectorp signal wrong-type-argument arrayp define-key] 5 (#$ . 24464) "KSet key locally: \nCSet key %s locally to command: "])
#@96 Remove global binding of KEY.
KEY is a string or vector representing a sequence of keystrokes.
(defalias 'global-unset-key #[(key) "\301\302\"\207" [key global-set-key nil] 3 (#$ . 25273) "kUnset key globally: "])
#@95 Remove local binding of KEY.
KEY is a string or vector representing a sequence of keystrokes.
(defalias 'local-unset-key #[(key) "\301 \203\n \302\303\"\210\303\207" [key current-local-map local-set-key nil] 3 (#$ . 25494) "kUnset key locally: "])
#@49 Used internally by `substitute-key-definition'.
(defvar key-substitution-in-progress nil (#$ . 25749))
#@497 Replace OLDDEF with NEWDEF for any keys in KEYMAP now defined as OLDDEF.
In other words, OLDDEF is replaced with NEWDEF where ever it appears.
Alternatively, if optional fourth argument OLDMAP is specified, we redefine
in KEYMAP as NEWDEF those keys which are defined as OLDDEF in OLDMAP.
If you don't specify OLDMAP, you can usually get the same results
in a cleaner way with command remapping, like this:
(define-key KEYMAP [remap OLDDEF] NEWDEF)
(fn OLDDEF NEWDEF KEYMAP &optional OLDMAP)
(defalias 'substitute-key-definition #[(olddef newdef keymap &optional oldmap prefix) "\204 \306 \206 \n\307\310\"
B \311\312 \"+\207" [prefix oldmap keymap scan prefix1 key-substitution-in-progress "" vconcat [nil] map-keymap #[(char defn) " G\nI\210\306 \f
%\207" [prefix1 prefix char defn olddef newdef substitute-key-definition-key keymap] 6]] 3 (#$ . 25859)])
(defalias 'substitute-key-definition-key #[(defn olddef newdef prefix keymap) "\306\211\211 \242\300=\203 \307 8\2020 \242;\203' \211A@ B\202 \242:\2030 A \f=\204G ;\204A \310 !\203j \f\232\203j \311
\203a \312!\211 AA\240\210)\202f \237\244#\202\245 \313 \314\"\206r \315\n!\205\245 \316
\"\211 ?\206\220 \317!\206\220 \315!)\205\245 \n>?\205\245 \320\f
\n%+\207" [menu-item skipped inner-def defn olddef keymap nil 2 vectorp define-key copy-sequence indirect-function t keymapp lookup-key natnump substitute-key-definition prefix copy newdef elt key-substitution-in-progress] 7])
#@148 Default global keymap mapping Emacs keyboard input into commands.
The value is a keymap which is usually (but not necessarily) Emacs's
global map.
(defvar global-map nil (#$ . 27365))
#@117 Default keymap for ESC (meta) commands.
The normal global definition of the character ESC indirects to this keymap.
(defvar esc-map nil (#$ . 27556))
#@110 Default keymap for C-x commands.
The normal global definition of the character C-x indirects to this keymap.
(defvar ctl-x-map nil (#$ . 27713))
#@34 Keymap for subcommands of C-x 4.
(defvar ctl-x-4-map (make-sparse-keymap) (#$ . 27864))
(byte-code "\302\303\"\210\304 \305\303#\207" [ctl-x-4-map ctl-x-map defalias ctl-x-4-prefix define-key "4"] 4)
#@28 Keymap for frame commands.
(defvar ctl-x-5-map (make-sparse-keymap) (#$ . 28071))
(byte-code "\302\303\"\210\304 \305\303#\207" [ctl-x-5-map ctl-x-map defalias ctl-x-5-prefix define-key "5"] 4)
(defconst listify-key-sequence-1 134217856)
#@45 Convert a key sequence to a list of events.
(defalias 'listify-key-sequence #[(key) "\301!\203 \302\303\"\207\304\305\"\207" [key vectorp append nil mapcar #[(c) "\302V\203 \303 \"\207\207" [c listify-key-sequence-1 127 logxor] 3]] 3 (#$ . 28316)])
#@42 True if the argument is an event object.
(defalias 'eventp #[(obj) "\205! \250\206! 9\203 \203 \301!?\206! :\205! @9\207" [obj keywordp] 2 (#$ . 28579)])
#@430 Return a list of symbols representing the modifier keys in event EVENT.
The elements of the list may include `meta', `control',
`shift', `hyper', `super', `alt', `click', `double', `triple', `drag',
and `down'.
EVENT may be an event or an event type. If EVENT is a symbol
that has never been used in an event that has been read as input
in the current Emacs session, then this function may fail to include
the `click' modifier.
(defalias 'event-modifiers #[(event) "\211<\203\n @ 9\203 \304 !A\202z \305\306 \307\"\310\306 \311\"!\204* \312 B\310\306 \313\"!\2039 \n\314W\203= \315 B\310\306 \316\"!\203M \n\211\227U\204Q \317 B\310\306 \320\"!\204^ \321 B\310\306 \322\"!\204k \323 B\310\306 \324\"!\204x \325 B *)\207" [event type char list internal-event-symbol-parse-modifiers nil logand -264241153 zerop 134217728 meta 67108864 32 control 33554432 shift 16777216 hyper 8388608 super 4194304 alt] 5 (#$ . 28749)])
#@323 Return the basic type of the given event (all modifiers removed).
The value is a printing character (not upper case) or a symbol.
EVENT may be an event or an event type. If EVENT is a symbol
that has never been used in an event that has been read as input
in the current Emacs session, then this function may return nil.
(defalias 'event-basic-type #[(event) ":\203 @9\203 \303N@\207\304\305\"\211\306W\203$ \307 \310\"\202% \311\312\313\217*\207" [event base uncontrolled event-symbol-elements logand 4194303 32 logior 64 nil (downcase uncontrolled) ((error uncontrolled))] 4 (#$ . 29688)])
#@53 Return non-nil if OBJECT is a mouse movement event.
(defalias 'mouse-movement-p #[(object) "\242\301=\207" [object mouse-movement] 2 (#$ . 30298)])
(put 'mouse-movement-p 'byte-optimizer 'byte-compile-inline-expand)
#@50 Return non-nil if OBJECT is a mouse click event.
(defalias 'mouse-event-p #[(object) "\301!\302>\207" [object event-basic-type (mouse-1 mouse-2 mouse-3 mouse-movement)] 2 (#$ . 30521)])
#@589 Return the starting position of EVENT.
EVENT should be a click, drag, or key press event.
If it is a key press event, the return value has the form
(WINDOW POS (0 . 0) 0)
If it is a click or drag event, it has the form
(WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
IMAGE (DX . DY) (WIDTH . HEIGHT))
The `posn-' functions access elements of such lists.
For more information, see Info node `(elisp)Click Events'.
If EVENT is a mouse or key press or a mouse click, this is the
position of the event. If EVENT is a drag, this is the starting
position of the drag.
(defalias 'event-start #[(event) ":\203 A@\207\301 \206 \302 `\303\304F\207" [event posn-at-point selected-window (0 . 0) 0] 4 (#$ . 30715)])
#@671 Return the ending location of EVENT.
EVENT should be a click, drag, or key press event.
If EVENT is a key press event, the return value has the form
(WINDOW POS (0 . 0) 0)
If EVENT is a click event, this function is the same as
`event-start'. For click and drag events, the return value has
the form
(WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
IMAGE (DX . DY) (WIDTH . HEIGHT))
The `posn-' functions access elements of such lists.
For more information, see Info node `(elisp)Click Events'.
If EVENT is a mouse or key press or a mouse click, this is the
position of the event. If EVENT is a drag, this is the starting
position of the drag.
(defalias 'event-end #[(event) ":\203 \3018:\203 \301\202 \3028\207\303 \206 \304 `\305\306F\207" [event 2 1 posn-at-point selected-window (0 . 0) 0] 4 (#$ . 31456)])
#@103 Return the multi-click count of EVENT, a click or drag event.
The return value is a positive integer.
(defalias 'event-click-count #[(event) ":\203 \3018\250\203 \3018\207\302\207" [event 2 1] 2 (#$ . 32307)])
(put 'event-click-count 'byte-optimizer 'byte-compile-inline-expand)
#@60 Return non-nil if OBJ appears to be a valid `posn' object.
(defalias 'posnp #[(obj) "\301\242!\205 A\211\242:?\205 A\211\242\242\250\205 A\242\250\207" [obj windowp] 2 (#$ . 32597)])
#@127 Return the window in POSITION.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.
(defalias 'posn-window #[(position) "@\207" [position] 1 (#$ . 32796)])
(put 'posn-window 'byte-optimizer 'byte-compile-inline-expand)
#@167 Return the window area recorded in POSITION, or nil for the text area.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.
(defalias 'posn-area #[(position) "A@:\203 A@@\202 A@\2119\205 )\207" [position area] 2 (#$ . 33065)])
(put 'posn-area 'byte-optimizer 'byte-compile-inline-expand)
#@136 Return the buffer location in POSITION.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.
(defalias 'posn-point #[(position) "\3018\206 A@:\203 A@@\207A@\207" [position 5] 2 (#$ . 33410)])
(put 'posn-point 'byte-optimizer 'byte-compile-inline-expand)
#@66 Move point to POSITION.
Select the corresponding window as well.
(defalias 'posn-set-point #[(position) "\301\211@)!\204 \302\303!\210\304\211@)!\210\3058\206/ A@:\203, A@@\202/ A@)\247\205O \3058\206M A@:\203J A@@\202M A@)b\207" [position windowp error "Position not in text area of window" select-window 5] 3 (#$ . 33718)])
#@201 Return the x and y coordinates in POSITION.
The return value has the form (X . Y), where X and Y are given in
pixels. POSITION should be a list of the form returned by
`event-start' and `event-end'.
(defalias 'posn-x-y #[(position) "\3018\207" [position 2] 2 (#$ . 34068)])
(put 'posn-x-y 'byte-optimizer 'byte-compile-inline-expand)
#@445 Return the nominal column and row in POSITION, measured in characters.
The column and row values are approximations calculated from the x
and y coordinates in POSITION and the frame's default character width
and height.
For a scroll-bar event, the result column is 0, and the row
corresponds to the vertical position of the click in the scroll bar.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.
(defalias 'posn-col-row #[(position) "\3068)\211@)\211A@:\203 A@@\202 A@\2119\205' *\n\2041 \307\202\270 \310=\203C \311\312 \313\n!S\"B\202\270 \314=\203T \312 \315\n!\"\311B\202\270 \316\n!\203^ \n\202a \317\n! \320\f!\205w r\321\n!q\210
)\206w \322\f\305\" \323!\203\215 \324\325\f!_!\202\225 \204\225 \311 @\326\f!\245 A\325\f!\\\245r\321\n!q\210)\204\264 \311\202\265 \327Z*B+\207" [position pair window area frame line-spacing 2 (0 . 0) vertical-scroll-bar 0 scroll-bar-scale window-height horizontal-scroll-bar window-width framep window-frame display-graphic-p window-buffer frame-parameter floatp truncate frame-char-height frame-char-width 1 spacing header-line-format] 6 (#$ . 34411)])
#@374 Return the actual column and row in POSITION, measured in characters.
These are the actual row number in the window and character number in that row.
Return nil if POSITION does not contain the actual position; in that case
`posn-col-row' can be used to get approximate values.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.
(defalias 'posn-actual-col-row #[(position) "\3018\207" [position 6] 2 (#$ . 35592)])
#@130 Return the timestamp of POSITION.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.
(defalias 'posn-timestamp #[(position) "\3018\207" [position 3] 2 (#$ . 36059)])
(put 'posn-timestamp 'byte-optimizer 'byte-compile-inline-expand)
#@197 Return the string object of POSITION.
Value is a cons (STRING . STRING-POS), or nil if not a string.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.
(defalias 'posn-string #[(position) "\3018\207" [position 4] 2 (#$ . 36343)])
(put 'posn-string 'byte-optimizer 'byte-compile-inline-expand)
#@186 Return the image object of POSITION.
Value is a list (image ...), or nil if not an image.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.
(defalias 'posn-image #[(position) "\3018\207" [position 7] 2 (#$ . 36688)])
(put 'posn-image 'byte-optimizer 'byte-compile-inline-expand)
#@280 Return the object (image or string) of POSITION.
Value is a list (image ...) for an image object, a cons cell
(STRING . STRING-POS) for a string object, and nil for a buffer position.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.
(defalias 'posn-object #[(position) "\3018)\206 \3028)\207" [position 7 4] 2 (#$ . 37020)])
(put 'posn-object 'byte-optimizer 'byte-compile-inline-expand)
#@228 Return the x and y coordinates relative to the object of POSITION.
The return value has the form (DX . DY), where DX and DY are
given in pixels. POSITION should be a list of the form returned
by `event-start' and `event-end'.
(defalias 'posn-object-x-y #[(position) "\3018\207" [position 8] 2 (#$ . 37468)])
(put 'posn-object-x-y 'byte-optimizer 'byte-compile-inline-expand)
#@192 Return the pixel width and height of the object of POSITION.
The return value has the form (WIDTH . HEIGHT). POSITION should
be a list of the form returned by `event-start' and `event-end'.
(defalias 'posn-object-width-height #[(position) "\3018\207" [position 9] 2 (#$ . 37852)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\210\310\305\306\311#\210\304\312\313\307#\210\310\312\313\311#\210\304\314\315\307#\210\310\314\315\311#\210\304\316\317\307#\210\310\316\317\311#\210\304\320\321\307#\210\310\320\321\311#\210\304\322\323\307#\210\310\322\323\311#\210\310\324\325\326#\210\310\327\307\330#\207" [put posn-object-width-height byte-optimizer byte-compile-inline-expand defalias window-dot window-point nil make-obsolete "22.1" set-window-dot set-window-point read-input read-string show-buffer set-window-buffer eval-current-buffer eval-buffer string-to-int string-to-number forward-point "use (+ (point) N) instead." "23.1" buffer-has-markers-at "24.3"] 4)
#@166 Mocklisp-compatibility insert function.
Like the function `insert' except that any argument that is a number
is converted into a string by expressing it in decimal.
(defalias 'insert-string #[(&rest args) "\303\211\205! \n@\211\250\203 \304 !\202 c\210\nA\211\204 \303*\207" [args el --dolist-tail-- nil number-to-string] 3 (#$ . 38832)])
(make-obsolete 'insert-string 'insert "22.1")
(defalias 'makehash #[(&optional test) "\301\302\206 \303\"\207" [test make-hash-table :test eql] 3])
(byte-code "\302\303\304\305#\210\306\307\310\311#\210\302\307\312\305#\210\306\313\310\311#\210\302\313\312\305#\210\302\314\315\316#\210\302\317\320\321#\210\322\320\323\324#\210\322\325\326\324#\210\322\327\330\331#\210\322\332\333\334#\210\335\336\337\321#\210\335\340\341\321#\210\335\342\343\321#\210\335\344\345\321#\210\335\346\347\321#\210\335\350\351\321#\210\335\352\353\321#\210\335\354\355\321#\210\335\356\357\321#\210\335\360\361\321#\210\335\362\363\321#\210\335\364\365\321#\210\335\366\367\321#\210\335\370\371\321#\210\335\372\373\321#\210\335\374\375\321#\210\335\376\377\321#\210\335\201@ \201A \321#\210\335\201B \201C \321#\210\335\201D \201E \321#\210\335\201F \201G \321#\210\335\201H \201I \321#\210\335\201J \201K \321#\210\335\201L \201M \321#\210\335\201N \201O \321#\210\335\201P \201Q \321#\210\335\201R \201S \321#\210\335\201T \201U \321#\210\335\201V \201W \321#\210\335\201X \201Y \321#\210\335\201Z \201[ \324#\210\335\201\\ \201] \201^ #\210\335\201_ \201] \201^ #\210\302\201` \201Y \324#\210\302\201a \201Y \324#\210\302\201b \201Y \324#\210\302\201c \201Y \324#\210\201d \201e \201f \201Y #\210\201g \201Y \211\203\266 @\201e N\203\257\201f N\204\257\201h \201f \201e N#\210 A\211\204\216*\335\201e \201f \201i #\210\201d \201j \201k \201Y #\210\201g \201Y \211\203 @\201j N\203\376\201k N\204\376\201h \201k \201j N#\210 A\211\204\335*\335\201j \201k \305#\210\201d \201l \201m \201Y #\210\201g \201Y \211\203R @\201l N\203K\201m N\204K\201h \201m \201l N#\210 A\211\204**\335\201l \201m \305#\210\335\201n \201Y \324#\210\201d \201o \201p \"\210\306\201q \201r \"\210\306\201s \201t \"\210\306\201u \201v \"\210\306\201w \201x \"\210\306\201y \201z \"\210\306\201{ \201| \"\210\306\201} \201~ \"\210\306\201 \201\200 \"\210\306\201\201 \201\202 \"\210\306\201\203 \201\204 \"\210\306\201\205 \201\206 K\"\210\306\201\207 \201\210 K\"\210\306\201\211 \201\212 \"\210\306\201\213 \201\214 \"\210\306\201\215 \201\216 \"\210\306\201\217 \201\220 \"\210\306\201\221 \201\222 \"\210\306\201\223 \201\224 \"\210\306\201\225 \201\226 \"\207" [prop --dolist-tail-- make-obsolete makehash make-hash-table "22.1" defalias focus-frame ignore "" "it does nothing." unfocus-frame make-variable-frame-local "explicitly check for a frame-parameter instead." "22.2" interactive-p called-interactively-p "23.2" set-advertised-calling-convention (kind) "23.1" all-completions (string collection &optional predicate) unintern (name obarray) "23.3" redirect-frame-focus (frame focus-frame) "24.3" make-obsolete-variable default-mode-line-format mode-line-format default-header-line-format header-line-format default-line-spacing line-spacing default-abbrev-mode abbrev-mode default-ctl-arrow ctl-arrow default-truncate-lines truncate-lines default-left-margin left-margin default-tab-width tab-width default-case-fold-search case-fold-search default-left-margin-width left-margin-width default-right-margin-width right-margin-width default-left-fringe-width left-fringe-width default-right-fringe-width right-fringe-width default-fringes-outside-margins fringes-outside-margins default-scroll-bar-width scroll-bar-width default-vertical-scroll-bar vertical-scroll-bar default-indicate-empty-lines indicate-empty-lines default-indicate-buffer-boundaries indicate-buffer-boundaries default-fringe-indicator-alist fringe-indicator-alist default-fringe-cursor-alist fringe-cursor-alist default-scroll-up-aggressively scroll-up-aggressively default-scroll-down-aggressively scroll-down-aggressively default-fill-column fill-column default-cursor-type cursor-type default-buffer-file-type buffer-file-type default-cursor-in-non-selected-windows cursor-in-non-selected-windows default-buffer-file-coding-system buffer-file-coding-system default-major-mode major-mode default-enable-multibyte-characters "use enable-multibyte-characters or set-buffer-multibyte instead" define-key-rebound-commands nil redisplay-end-trigger-functions jit-lock-register deferred-action-list post-command-hook "24.1" deferred-action-function window-redisplay-end-trigger set-window-redisplay-end-trigger process-filter-multibyte-p set-process-filter-multibyte defvaralias executing-macro executing-kbd-macro (saved-value saved-variable-comment) put "before 19.34" x-lost-selection-hooks x-lost-selection-functions x-sent-selection-hooks x-sent-selection-functions translation-table-for-input messages-buffer-max-lines message-log-max send-string process-send-string send-region process-send-region string= string-equal string< string-lessp move-marker set-marker rplaca setcar rplacd setcdr beep ding indent-to-column indent-to backward-delete-char delete-backward-char search-forward-regexp re-search-forward search-backward-regexp re-search-backward int-to-string number-to-string store-match-data set-match-data chmod set-file-modes mkdir make-directory point-at-eol line-end-position point-at-bol line-beginning-position user-original-login-name user-login-name] 6)
#@743 Add to the value of HOOK the function FUNCTION.
FUNCTION is not added if already present.
FUNCTION is added (if necessary) at the beginning of the hook list
unless the optional argument APPEND is non-nil, in which case
FUNCTION is added at the end.
The optional fourth argument, LOCAL, if non-nil, says to modify
the hook's buffer-local value rather than its global value.
This makes the hook buffer-local, and it makes t a member of the
buffer-local value. That acts as a flag to run the hook
functions of the global value as well as in the local value.
HOOK should be a symbol, and FUNCTION may be any valid function. If
HOOK is void, it is first set to nil. If HOOK's value is a single
function, it is changed to a list of functions.
(defalias 'add-hook #[(hook function &optional append local) "\305!\204\n \306L\210\307!\204 \310\306\"\210 \203) \311!\2048 \312!\313CL\210\2028 J:\2036 \313J>\2048 \313 \203A J\202D \314!\211<\203Q \n@\315=\203T \nC \n\235\204s ;\203c \316 !\f\203o \304\n C\"\202r \nB \203\224 9\203\216 \317N\203\216 \320N\204\216 \321\320\317#\210\nL\202\230 \310\n\")\207" [hook local hook-value function append boundp nil default-boundp set-default local-variable-if-set-p make-local-variable t default-value lambda purecopy permanent-local-hook permanent-local put] 5 (#$ . 44340)])
#@389 Remove from the value of HOOK the function FUNCTION.
HOOK should be a symbol, and FUNCTION may be any valid function. If
FUNCTION isn't the value of HOOK, or, if FUNCTION doesn't appear in the
list of hooks to run in HOOK, then nothing is done. See `add-hook'.
The optional third argument, LOCAL, if non-nil, says to modify
the hook's buffer-local value rather than its default value.
(defalias 'remove-hook #[(hook function &optional local) "\304!\204\n \305L\210\306!\204 \307\305\"\210 \205 \310!??\205| \310!\2036 J:\2034 \311J>\2046 \311 \203? J\202B \312!\211<\203O \n@\313=\203Z \n \232\203a \305\202a \314 \315\n!\" \204l \307\n\"\202{ \n\316\232\203x \317!\202{ \nL)\207" [hook local hook-value function boundp nil default-boundp set-default local-variable-p t default-value lambda delete copy-sequence (t) kill-local-variable] 5 (#$ . 45687)])
#@257 Bind variables according to BINDERS then eval BODY.
The value of the last form in BODY is returned.
Each element of BINDERS is a list (SYMBOL VALUEFORM) which binds
SYMBOL to the value of VALUEFORM.
All symbols are bound before the VALUEFORMs are evalled.
(defalias 'letrec '(macro . #[(binders &rest body) "\302\303\304\"\305\303\306\" \"BB\207" [binders body let mapcar car append #[(binder) "\301B\207" [binder setq] 2]] 6 (#$ . 46570)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put letrec edebug-form-spec let lisp-indent-function 1] 4)
#@1134 Run BODY, using wrapper functions from HOOK with additional ARGS.
HOOK is an abnormal hook. Each hook function in HOOK "wraps"
around the preceding ones, like a set of nested `around' advices.
Each hook function should accept an argument list consisting of a
function FUN, followed by the additional arguments in ARGS.
The first hook function in HOOK is passed a FUN that, if it is called
with arguments ARGS, performs BODY (i.e., the default operation).
The FUN passed to each successive hook function is defined based
on the preceding hook functions; if called with arguments ARGS,
it does what the `with-wrapper-hook' call would do if the
preceding hook functions were the only ones present in HOOK.
Each hook function may call its FUN argument as many times as it wishes,
including never. In that case, such a hook function acts to replace
the default definition altogether, and any preceding hook functions.
Of course, a subsequent hook function may do the same thing.
Each hook function definition is used to construct the FUN passed
to the next hook function, if any. The last (or "outermost")
FUN is then called once.
(defalias 'with-wrapper-hook '(macro . #[(hook args &rest body) "\306\307!\306\310!\306\311!\306\312!\313\314 \n E\315\316 D\315\317\320\321 DE\322\323\n\324 DE\325 \257\326\321 D\327\314 \n\330 F\322 \n \257E\324 D\nF FF\326\314\f
BB EFEDC\322 \2119\205l \315\331\332 DD\333\332 DDE\334\fB\257E,\207" [runrestofhook argssym global funs args body make-symbol "funs" "global" "args" "runrestofhook" letrec lambda if consp eq t car funcall append cdr nil apply apply-partially &rest local-variable-p quote default-value list hook] 19 (#$ . 47139)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put with-wrapper-hook lisp-indent-function 2 edebug-form-spec (form sexp body)] 4)
#@687 Add ELEMENT to the value of LIST-VAR if it isn't there yet.
The test for presence of ELEMENT is done with `equal',
or with COMPARE-FN if that's non-nil.
If ELEMENT is added, it is added at the beginning of the list,
unless the optional argument APPEND is non-nil, in which case
ELEMENT is added at the end.
The return value is the new value of LIST-VAR.
If you want to use `add-to-list' on a variable that is not defined
until a certain package is loaded, you should put the call to `add-to-list'
into a hook function that will be run only after loading the package.
`eval-after-load' provides one way to do this. In some cases
other hooks, such as major mode hooks, can do the job.
(defalias 'add-to-list #[(list-var element &optional append compare-fn) "\204 \nJ\235\202> \305=\203 \nJ>\202> \306=\203& \307 \nJ\"\202> \nJ\211\203< @\"\204< A\211\204- )\203D \nJ\207\n\f\203R \304\nJ C\"\202V \nJBL\207" [compare-fn element list-var lst append eq eql memql] 5 (#$ . 48981)])
#@704 Add ELEMENT to the value of LIST-VAR if it isn't there yet.
The test for presence of ELEMENT is done with `eq'.
The resulting list is reordered so that the elements are in the
order given by each element's numeric list order. Elements
without a numeric list order are placed at the end of the list.
If the third optional argument ORDER is a number (integer or
float), set the element's list order to the given value. If
ORDER is nil or omitted, do not change the numeric order of
ELEMENT. If ORDER has any other value, remove the numeric order
of ELEMENT if it has one.
The list order for each element is stored in LIST-VAR's
`list-order' property.
The return value is the new value of LIST-VAR.
(defalias 'add-to-ordered-list #[(list-var element &optional order) "\304N\211\204 \305\304\306\307\310\311\312$\211#\210\n\203$ \313 \n\247\205! \n #\210 J>\2042 JBL\210\314J\315\"L)\207" [list-var ordering order element list-order put make-hash-table :weakness key :test eq puthash sort #[(a b) "\305 \"\305\n \"\211 \203 \203 \f W\202 \f*\207" [a ordering b ob oa gethash] 5]] 9 (#$ . 49983)])
#@502 Add NEWELT to the history list stored in the variable HISTORY-VAR.
Return the new history list.
If MAXELT is non-nil, it specifies the maximum length of the history.
Otherwise, the maximum history length is the value of the `history-length'
property on symbol HISTORY-VAR, if set, or the value of the `history-length'
variable.
Remove duplicates of NEWELT if `history-delete-duplicates' is non-nil.
If optional fourth arg KEEP-ALL is non-nil, add NEWELT to history even
if it is empty or a duplicate.
(defalias 'add-to-history #[(history-var newelt &optional maxelt keep-all) "\204\f \302N\206 \n J\306\211 <\203b
\204( ;\203( G\307V\203b
\2044 \f@ \232\204b \n\203? \310 \f\" \fB\250\203b \307U\203T \306\202b S\f\233\211:\203b \306\241\210 \fL*\207" [maxelt history-var history-length tail history keep-all nil 0 delete newelt history-delete-duplicates] 4 (#$ . 51107)])
#@62 If non-nil, `run-mode-hooks' should delay running the hooks.
(defvar delay-mode-hooks nil (#$ . 52009))
#@47 List of delayed mode hooks waiting to be run.
(defvar delayed-mode-hooks nil (#$ . 52119))
(byte-code "\300\301!\210\302\303\304\305#\207" [make-variable-buffer-local delayed-mode-hooks put delay-mode-hooks permanent-local t] 4)
#@65 Normal hook run in major mode functions, before the mode hooks.
(defvar change-major-mode-after-body-hook nil (#$ . 52354))
#@58 Normal hook run at the very end of major mode functions.
(defvar after-change-major-mode-hook nil (#$ . 52484))
#@452 Run mode hooks `delayed-mode-hooks' and HOOKS, or delay HOOKS.
If the variable `delay-mode-hooks' is non-nil, does not run any hooks,
just adds the HOOKS to the list `delayed-mode-hooks'.
Otherwise, runs hooks in the sequence: `change-major-mode-after-body-hook',
`delayed-mode-hooks' (in reverse order), HOOKS, and finally
`after-change-major-mode-hook'. Major mode functions should use
this instead of `run-hooks' when running their FOO-mode-hook.
(defalias 'run-mode-hooks #[(&rest hooks) "\203 \305\211\205 @\211\fB A\211\204\f \305*\207\f\237 \244\305\306\307\310 B\"\210\307\311!\207" [delay-mode-hooks hooks hook --dolist-tail-- delayed-mode-hooks nil apply run-hooks change-major-mode-after-body-hook after-change-major-mode-hook] 5 (#$ . 52603)])
#@221 Execute BODY, but delay any `run-mode-hooks'.
These hooks will be executed by the first following call to
`run-mode-hooks' that occurs outside any `delayed-mode-hooks' form.
Only affects hooks run in the current buffer.
(defalias 'delay-mode-hooks '(macro . #[(&rest body) "\301\302\303\304BBE\207" [body progn (make-local-variable 'delay-mode-hooks) let ((delay-mode-hooks t))] 5 (#$ . 53379)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put delay-mode-hooks edebug-form-spec t lisp-indent-function 0] 4)
#@139 Non-nil if the current major mode is derived from one of MODES.
Uses the `derived-mode-parent' property of the symbol to trace backwards.
(defalias 'derived-mode-p #[(&rest modes) " \n>\204 \303N\211\204 )\207" [major-mode parent modes derived-mode-parent] 2 (#$ . 53908)])
#@35 List of all minor mode functions.
(defvar minor-mode-list '(auto-save-mode auto-fill-mode abbrev-mode overwrite-mode view-mode hs-minor-mode) (#$ . 54195))
#@912 Register a new minor mode.
This is an XEmacs-compatibility function. Use `define-minor-mode' instead.
TOGGLE is a symbol which is the name of a buffer-local variable that
is toggled on or off to say whether the minor mode is active or not.
NAME specifies what will appear in the mode line when the minor mode
is active. NAME should be either a string starting with a space, or a
symbol whose value is such a string.
Optional KEYMAP is the keymap for the minor mode that will be added
to `minor-mode-map-alist'.
Optional AFTER specifies that TOGGLE should be added after AFTER
in `minor-mode-alist'.
Optional TOGGLE-FUN is an interactive function to toggle the mode.
It defaults to (and should by convention be) TOGGLE.
If TOGGLE has a non-nil `:included' property, an entry for the mode is
included in the mode-line minor mode menu.
If TOGGLE has a `:menu-tag', that is used for the menu item's label.
(defalias 'add-minor-mode #[(toggle name &optional keymap after toggle-fun) " >\204\n B\n\204 \n=\204 \306\307\n#\210 \203\204 \f\236\211 \2030
C\241\210\202\203 \f\310 \203^ \204^ \211 @@)=\203U \2026 A\211\204; \203| A \310\241\210 DC\244\244\210)\202\202 D\fB*)\311N\203\314 \312 \313!\314\315N\206\243 ;\203\240 \202\243 \316! 9\205\252 J\211 ;\205\301 \317\320 \"\205\301 \321\322\323 \"\324Q)P\n\325\326B\257#\210 \205: \236\211 \203\341
\241\2029 \310 \203\204\211 @@)=\203\202\350 A\211\204\355 \203.A \310\241\210 BC\244\244)\2028 B B\211 *)\207" [toggle minor-mode-list toggle-fun name minor-mode-alist existing put :minor-mode-function nil :included define-key vector menu-item :menu-tag symbol-name string-match "[^ ]+" " (" match-string 0 ")" :button :toggle found tail after x rest mode-line-mode-menu mode-name keymap minor-mode-map-alist] 10 (#$ . 54358)])
#@35 Non-nil if OBJECT is an autoload.
(defalias 'autoloadp #[(object) "\242\301=\207" [object autoload] 2 (#$ . 56263)])
(put 'autoloadp 'byte-optimizer 'byte-compile-inline-expand)
#@456 Return the name of the file that defined SYMBOL.
The value is normally an absolute file name. It can also be nil,
if the definition is not associated with any file. If SYMBOL
specifies an autoloaded function, the value can be a relative
file name without extension.
If TYPE is nil, then any kind of definition is acceptable. If
TYPE is `defun', `defvar', or `defface', that specifies function
definition, variable definition, or face definition only.
(defalias 'symbol-file #[(symbol &optional type) "\203\n \306=\203% 9\203% \307 !\203% K\211\242)\310=\203% KA@\207 \311 \211 \203g \203I \312=\203?
@A\235\202W B
@A\235\202W
@A\235\204Z \313
@A\"\203`
@@\311
A\211\204- \f*\207" [type symbol object load-history file files defun fboundp autoload nil defvar rassq] 4 (#$ . 56449)])
#@768 Show the precise file name of Emacs library LIBRARY.
LIBRARY should be a relative file name of the library, a string.
It can omit the suffix (a.k.a. file-name extension) if NOSUFFIX is
nil (which is the default, see below).
This command searches the directories in `load-path' like `\[load-library]'
to find the file that `\[load-library] RET LIBRARY RET' would load.
Optional second arg NOSUFFIX non-nil means don't add suffixes `load-suffixes'
to the specified name LIBRARY.
If the optional third arg PATH is specified, that list of directories
is used instead of `load-path'.
When called from a program, the file name is normally returned as a
string. When run interactively, the argument INTERACTIVE-CALL is t,
and the file name is displayed in the echo area.
(defalias 'locate-library #[(library &optional nosuffix path interactive-call) "\306 \206 \n\307 ?\205 \310 \f\"#
\203+
\203& \311\312\313
!\"\210\202+ \311\314\"\210
)\207" [library path load-path nosuffix load-file-rep-suffixes file locate-file append get-load-suffixes message "Library is file %s" abbreviate-file-name "No library %s in search path" interactive-call] 6 (#$ . 57261) (list (completing-read "Locate library: " (apply-partially 'locate-file-completion-table load-path (get-load-suffixes))) nil nil t)])
#@111 Form a regexp to find FILE in `load-history'.
FILE, a string, is described in the function `eval-after-load'.
(defalias 'load-history-regexp #[(file) "\303!\203\n \304!\303!\203 \305\202 \306\307!\310!\203\" \311\202* \312\313\307 \314#\315Q\312\313\307\n\314#\316\260\207" [file load-suffixes jka-compr-load-suffixes file-name-absolute-p file-truename "\\`" "\\(\\`\\|/\\)" regexp-quote file-name-extension "" "\\(" mapconcat "\\|" "\\)?" "\\)?\\'"] 8 (#$ . 58562)])
#@99 Get the first elt of `load-history' whose car matches FILE-REGEXP.
Return nil if there isn't one.
(defalias 'load-history-filename-element #[(file-regexp) "\211\205 @\305 \306\216 \203, \n@\203 \307\f\n@\"\204, A\211\205( @\202 *\n*\207" [load-history loads load-elt save-match-data-internal file-regexp match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match] 4 (#$ . 59045)])
(put 'eval-after-load 'lisp-indent-function 1)
#@1368 Arrange that if FILE is loaded, FORM will be run immediately afterwards.
If FILE is already loaded, evaluate FORM right now.
If a matching file is loaded again, FORM will be evaluated again.
If FILE is a string, it may be either an absolute or a relative file
name, and may have an extension (e.g. ".el") or may lack one, and
additionally may or may not have an extension denoting a compressed
format (e.g. ".gz").
When FILE is absolute, this first converts it to a true name by chasing
symbolic links. Only a file of this name (see next paragraph regarding
extensions) will trigger the evaluation of FORM. When FILE is relative,
a file whose absolute true name ends in FILE will trigger evaluation.
When FILE lacks an extension, a file name with any extension will trigger
evaluation. Otherwise, its extension must match FILE's. A further
extension for a compressed format (e.g. ".gz") on FILE will not affect
this name matching.
Alternatively, FILE can be a feature (i.e. a symbol), in which case FORM
is evaluated at the end of any file that `provide's this feature.
If the feature is provided when evaluating code not associated with a
file, FORM is evaluated immediately after the provide statement.
Usually FILE is just a library name like "font-lock" or a feature name
like 'font-lock.
This function makes or adds to an entry on `after-load-alist'.
(defalias 'eval-after-load #[(file form) ";\203 \306\307!!\211\202 \310 \n\"\211\204! C\211\nB\311\312\313\314\315\fE
\"DD;\2038 \316 !\202; \317!\205A \313\f! 9\203f \320\321\322\323\324\325\326\314\327\320\330\315\331\332\312\fDCB\257ECBE\333BBB\fF\f A\235\204r \fC\244\210*\207" [file regexp-or-feature after-load-alist elt form lexical-binding purecopy load-history-regexp assoc funcall quote eval lambda nil load-history-filename-element featurep if load-file-name let ((fun (make-symbol "eval-after-load-helper"))) fset fun \` (file) (not (equal file '(\, load-file-name))) (remove-hook 'after-load-functions '(\, fun)) \, ((add-hook 'after-load-functions fun))] 18 (#$ . 59544)])
#@137 Special hook run after loading a file.
Each function there is called with a single argument, the absolute
name of the file just loaded.
(defvar after-load-functions nil (#$ . 61622))
#@187 Evaluate all `eval-after-load' forms, if any, for ABS-FILE.
ABS-FILE, a string, should be the absolute true name of a file just loaded.
This function is called directly from the C code.
(defalias 'do-after-load-evaluation #[(abs-file) "\306\307\"\210\310 \311 \312 \313\f \n#,\203 \314\315\311\316\317 !$\210\320\321 \"\207" [after-load-alist abs-file start string regexp inhibit-changing-match-data mapc #[(a-l-element) "@;\205 @ \306 \307 \310\f \n#,\205 \311\312A\"\207" [a-l-element abs-file start string regexp inhibit-changing-match-data nil t string-match mapc eval] 4] "/obsolete/[^/]*\\'" nil t string-match run-with-timer 0 #[(file) "\301\302\303\304\305\"O\"\207" [file message "Package %s is obsolete!" 0 string-match "\\.elc?\\>"] 7] file-name-nondirectory run-hook-with-args after-load-functions] 6 (#$ . 61812)])
#@184 Read the following input sexp, and run it whenever FILE is loaded.
This makes or adds to an entry on `after-load-alist'.
FILE should be the name of a library, with no directory name.
(defalias 'eval-next-after-load #[(file) "\301\302 \"\207" [file eval-after-load read] 3 (#$ . 62660)])
(make-obsolete 'eval-next-after-load 'eval-after-load "23.2")
#@103 Display delayed warnings from `delayed-warnings-list'.
Used from `delayed-warnings-hook' (which see).
(defalias 'display-delayed-warnings #[nil "\237\303\211\203 \n@\304\305 \"\210\nA\211\204 *\303\211\207" [delayed-warnings-list warning --dolist-tail-- nil apply display-warning] 4 (#$ . 63017)])
#@156 Remove duplicates from `delayed-warnings-list'.
Collapse identical adjacent warnings into one (plus count).
Used from `delayed-warnings-hook' (which see).
(defalias 'collapse-delayed-warnings #[nil "\305\306\211 \203@ \211A@\211 @\232\203 \nT\202 \n\305V\2039 \307\310\211 A@)\n#\211 AA)B\241\210\305 B\202 \237\211+\207" [warning collapsed count delayed-warnings-list x 1 nil format "%s [%d times]"] 6 (#$ . 63330)])
#@221 Normal hook run to process and display delayed warnings.
By default, this hook contains functions to consolidate the
warnings listed in `delayed-warnings-list', display them, and set
`delayed-warnings-list' back to nil.
(defvar delayed-warnings-hook '(collapse-delayed-warnings display-delayed-warnings) (#$ . 63773))
#@137 Execute PROGRAM with ARGS, returning its output as a list of lines.
Signal an error if the program returns with a non-zero exit status.
(defalias 'process-lines #[(program &rest args) "\305\306!rq\210\307\216\310\311 \312p\312\n&\211\313=\204 \314\315 #\210eb\210\312 m\2048 \316\317 \320 \"\fB\321y\210\202% \f\237-\207" [#1=#:temp-buffer program args status lines generate-new-buffer " *temp*" ((byte-code "\301!\203\n \302!\210\301\207" [#1# buffer-name kill-buffer] 2)) apply call-process nil 0 error "%s exited with status %s" buffer-substring-no-properties line-beginning-position line-end-position 1] 8 (#$ . 64098)])
#@131 Returns non-nil if PROCESS is alive.
A process is considered alive if its status is `run', `open',
`listen', `connect' or `stop'.
(defalias 'process-live-p #[(process) "\301!\302>\207" [process process-status (run open listen connect stop)] 2 (#$ . 64739)])
(make-obsolete 'process-kill-without-query "use `process-query-on-exit-flag' or `set-process-query-on-exit-flag'." "22.1")
#@171 Say no query needed if PROCESS is running when Emacs is exited.
Optional second argument if non-nil says to require a query.
Value is t if a query was formerly required.
(defalias 'process-kill-without-query #[(process &optional _flag) "\302!\303\304\"\210 )\207" [process old process-query-on-exit-flag set-process-query-on-exit-flag nil] 3 (#$ . 65128)])
#@57 Ask before killing a buffer that has a running process.
(defalias 'process-kill-buffer-query-function #[nil "\301p!\211?\206! \302!\303>?\206! \304!?\206! \305\306\307\310p!\"!)\207" [process get-buffer-process process-status (run stop open listen) process-query-on-exit-flag yes-or-no-p format "Buffer %S has a running process; kill it? " buffer-name] 6 (#$ . 65494)])
(add-hook 'kill-buffer-query-functions 'process-kill-buffer-query-function)
#@124 Return the value of PROCESS' PROPNAME property.
This is the last value stored with `(process-put PROCESS PROPNAME VALUE)'.
(defalias 'process-get #[(process propname) "\302\303! \"\207" [process propname plist-get process-plist] 3 (#$ . 65950)])
#@104 Change PROCESS' PROPNAME property to VALUE.
It can be retrieved with `(process-get PROCESS PROPNAME)'.
(defalias 'process-put #[(process propname value) "\303\304\305! \n#\"\207" [process propname value set-process-plist plist-put process-plist] 6 (#$ . 66204)])
#@108 Radix for \[quoted-insert] and other uses of `read-quoted-char'.
Legitimate radix values are 8, 10 and 16.
(defvar read-quoted-char-radix 8 (#$ . 66476))
(custom-declare-variable-early 'read-quoted-char-radix 8 "*Radix for \\[quoted-insert] and other uses of `read-quoted-char'.\nLegitimate radix values are 8, 10 and 16." :type '(choice (const 8) (const 10) (const 16)) :group 'editing-basics)
(defconst read-key-empty-map (make-sparse-keymap))
(defvar read-key-delay 0.01)
#@395 Read a key from the keyboard.
Contrary to `read-event' this will not return a raw event but instead will
obey the input decoding and translations usually done by `read-key-sequence'.
So escape sequences and keyboard encoding are taken into account.
When there's an ambiguity because the key looks like the prefix of
some sort of escape sequence, the ambiguity is resolved via `read-key-delay'.
(defalias 'read-key #[(&optional prompt) "\306\307\310 \311 \312\313# \314\216\315\316 \317\320\321\322\"#\210\317\323\324\236A\2063 \321\325\"#\210)!\210\326\327\215\307H.\207" [read-key-empty-map read-key-delay timer old-global-map echo-keystrokes overriding-local-map nil 0 current-global-map run-with-idle-timer t #[nil "\301 \302G!?\205 \303\304\")\207" [keys this-command-keys-vector zerop throw read-key] 3] ((byte-code "\302!\210\303 !\207" [timer old-global-map cancel-timer use-global-map] 2)) use-global-map make-sparse-keymap define-key [menu-bar] lookup-key [menu-bar] [tool-bar] tool-bar [tool-bar] read-key (read-key-sequence-vector prompt nil t) overriding-terminal-local-map map global-map] 8 (#$ . 66958)])
#@464 Like `read-char', but do not allow quitting.
Also, if the first character read is an octal digit,
we read any number of octal digits and return the
specified character code. Any nondigit terminates the sequence.
If the terminator is RET, it is discarded;
any other terminator is used itself as input.
The optional argument PROMPT specifies a string to use to prompt the user.
The variable `read-quoted-char-radix' controls which radix to use
for numeric input.
(defalias 'read-quoted-char #[(&optional prompt) "\306\211\307\310\306\211 \f\204\373 \306\311 !\312\"\205$ \313\314\"\"\307\"!\203/ \306#+\315$\316 !\" %\317%!\203G %\310H\202H )\250\203S \320!\203\366 \250\204e C&\307\202\366 \321\322\"\310U\204{ \323\321\324\"\325\"\307\202\366 \326X\203\245 \326\327'^\\W\203\245 \n'_\326Z\\\"\203\366 \330\331\"#\"\202\366 \332\227X\203\326 \227\333\332\334\335'^#W\203\326 \n'_\327\227\332Z\\\\\"\203\366 \330\331\"#\"\202\366 \204\345 \336=\203\345 \307\202\366 \204\362 C&\307\202\366 \307\306\202\f \n.\207" [translated char code first done message-log-max nil t 0 "Type the special character you want to use,\nor the octal character code.\nRET terminates the character code and is discarded;\nany other non-digit terminates the character code and is then used as input." read-event format "%s-" lookup-key vector arrayp char-resolve-modifiers logand 134217728 logior -134217729 128 48 10 message "%s %c" 97 + -10 36 13 help-form help-char inhibit-quit prompt quit-flag local-function-key-map translation unread-command-events read-quoted-char-radix] 6 (#$ . 68110)])
#@38 Keymap used while reading passwords.
(defvar read-passwd-map (byte-code "\302 \303 \"\210\304\305\306#\210)\207" [map minibuffer-local-map make-sparse-keymap set-keymap-parent define-key "" delete-minibuffer-contents] 4) (#$ . 69754))
#@356 Read a password, prompting with PROMPT, and return it.
If optional CONFIRM is non-nil, read the password twice to make sure.
Optional DEFAULT is a default password to use instead of empty input.
This function echoes `.' for each character that the user types.
Once the caller uses the password, it can erase the password
by doing (clear-string STRING).
(defalias 'read-passwd #[(prompt &optional confirm default) "\203N \306 \204K \307\n\306 #\307\310\306 # \211 \f\232\203+ \311\f!\203& \312\f!\210
\202G \311
!\2035 \312
!\210\311\f!\203? \312\f!\210\313\314!\210\315\316!\210*\202 )\207\317\306 \306 \320\321\216\322\323\"\210\324\216\325 \326\n\306\325 $.\207" [confirm success prompt default second first nil read-passwd "Confirm password: " arrayp clear-string message "Password not repeated accurately; please start over" sit-for 1 #[(beg end _len) "\304 \210\305 ]^ Z\306\n W\205, \307\n \\\310\311\n #\312\313\314!$\210\nT\211\202 *\207" [end beg i --dotimes-limit-- clear-this-command-keys minibuffer-prompt-end 0 put-text-property + 1 display string 46] 7] #[nil "\306\307\"\210p\310\302!\210\311\310\303!\210\312\310\304!\210\311\313
!\210\314\315\311\316$\207" [#1=#:setup-hook minibuf post-self-insert-hook buffer-undo-list select-active-regions read-passwd-map remove-hook minibuffer-setup-hook make-local-variable nil t use-local-map add-hook after-change-functions local hide-chars-fun] 5] ((byte-code "\301\302\"\207" [#1# remove-hook minibuffer-setup-hook] 3)) add-hook minibuffer-setup-hook ((byte-code "\302!\203 rq\210\303\304 \305#\210\306\307!\210\310 \210)\302\207" [minibuf hide-chars-fun buffer-live-p remove-hook after-change-functions local kill-local-variable post-self-insert-hook erase-buffer] 4)) t read-string minibuf hide-chars-fun #1# enable-recursive-minibuffers] 6 (#$ . 70001)])
#@182 Read a numeric value in the minibuffer, prompting with PROMPT.
DEFAULT specifies a default value to return if the user just types RET.
The value of DEFAULT is inserted into PROMPT.
(defalias 'read-number #[(prompt &optional default) "\305:\203 @\202\f \2031 \306\307 \"\203& \310\311\312 \"\313\211 \314%\2020 \315\316\311\317 \" \313\211%\320 \305\211\211\211\205M :\203J \321\322\323\305\"\"\202M \322!& \305\324\325\217\210)\n\247\204f \326\327!\210\330\314!\210\2021 \n*\207" [default default1 n prompt str nil string-match "\\(\\):[ ]*\\'" replace-match format " (default %s)" t 1 replace-regexp-in-string "[ ]*\\'" " (default %s) " read-from-minibuffer mapcar number-to-string delq (byte-code "\303G!\203 \202 ;\205 \304!\303\207" [str default1 n zerop string-to-number] 2) ((error)) message "Please enter a number." sit-for] 11 (#$ . 71862)])
#@217 Read and return one of CHARS, prompting for PROMPT.
Any input that is not one of CHARS is ignored.
If optional argument INHIBIT-KEYBOARD-QUIT is non-nil, ignore
keyboard-quit events while waiting for a valid input.
(defalias 'read-char-choice #[(prompt chars &optional inhibit-keyboard-quit) ":\204 \306\307!\210\310\211\211\311 \312
\310 \313 \314\216 \204\247 \315\316\317!#\2044 \320!\317\321#!\" #\322!!)\n\203N \323\324 !!\203N \325 !\210\f\247\203 $\203j \f%=\203j \312\211\203j \326 \204 \f>\203v \312\211\202
\203\205 \f\327U\203\205 \310\202 \"\204 \204\233 \f\330=\203\233 \312 \202 \f\331>\203 \332 \210\202 -\333\334!\335\f!#\210\f,\207" [chars helpbuf show-help done char executing-kbd-macro error "Called `read-char-choice' without valid char choices" nil " *Char Help*" t current-window-configuration ((set-window-configuration #1=#:wconfig)) get-text-property 0 face propertize minibuffer-prompt read-key buffer-live-p get-buffer kill-buffer help-form-show -1 27 (7 27) keyboard-quit message "%s%s" char-to-string esc-flag cursor-in-echo-area #1# prompt inhibit-keyboard-quit inhibit-quit help-form help-char] 6 (#$ . 72742)])
#@721 Perform redisplay, then wait for SECONDS seconds or until input is available.
SECONDS may be a floating-point value.
(On operating systems that do not support waiting for fractions of a
second, floating-point values are rounded down to the nearest integer.)
If optional arg NODISP is t, don't redisplay, just wait for input.
Redisplay does not happen if input is available before it starts.
Value is t if waited the full time with no input arriving, and nil otherwise.
An obsolete, but still supported form is
(sit-for SECONDS &optional MILLISECONDS NODISP)
where the optional arg MILLISECONDS specifies an additional wait period,
in milliseconds; this was useful when Emacs was built without
floating point support.
(defalias 'sit-for #[(seconds &optional nodisp obsolete) "\247\203 \306_\\\n\202 \n\203 \n \203 \307 !\210\310\207\311 \203' \312\207 \313X\2034 \206Y \314 \207\204; \314 \210\315\312\211 #\211 ?\206X
=\203Q \310\fB\fB\312)\207" [nodisp seconds obsolete noninteractive read overriding-terminal-local-map 0.001 sleep-for t input-pending-p nil 0 redisplay read-event universal-argument-map unread-command-events] 5 (#$ . 73930)])
(set-advertised-calling-convention 'sit-for '(seconds &optional nodisp) "22.1")
#@942 Ask user a "y or n" question. Return t if answer is "y".
PROMPT is the string to display to ask the question. It should
end in a space; `y-or-n-p' adds "(y or n) " to it.
No confirmation of the answer is requested; a single character is
enough. SPC also means yes, and DEL means no.
To be precise, this function translates user input into responses
by consulting the bindings in `query-replace-map'; see the
documentation of that variable for more information. In this
case, the useful bindings are `act', `skip', `recenter',
`scroll-up', `scroll-down', and `quit'.
An `act' response means yes, and a `skip' response means no.
A `quit' response means to invoke `keyboard-quit'.
If the user enters `recenter', `scroll-up', or `scroll-down'
responses, perform the requested window recentering or scrolling
and ask again.
Under a windowing system a dialog box will be used if `last-nonmenu-event'
is nil and `use-dialog-box' is non-nil.
(defalias 'y-or-n-p #[(prompt) "\306 \203G \n\211\211GSH\307=\203 \310\202 \311\312Q\211\313>\204C \314 !\211 \315\235\2030 \316\202? \f\317\235\203; \320\202? \321\nP)\202 )\202 \322 \203`
<\203` 8\203` \323\324\n\325B\"\202 \n\211\211GSH\307=\203o \310\202p \311\312Q\326 9\324 :;\203\205 \327\330\331 !!\210\332\3339>\203\222 \n\202\225 \321\nP\334\335#!) <\336=\337<!\324#\211\340>\203\260 \341\202\306=\203\275 \306 \210\324\202\342=\203\314 \341\343\344\217\210\324\202\345=\203\333 \341\346\347\217\210\324\202\350=\203\352 \341\351\352\217\210\324\202\353=\203\371 \341\354\355\217\210\324\202\356>\204<\357=\203\360\361\341\"\210\324\202\324*\203 \362 \210\363 \210\202s \316= > \2045\364\365\n>\2032\366\2023\367#\210>*\207" [answer noninteractive prompt temp-prompt str last-nonmenu-event recenter 32 "" " " "(y or n) " (act skip) read-string ("y" "Y") act ("n" "N") skip "Please answer y or n. " display-popup-menus-p x-popup-dialog t (("Yes" . act) ("No" . skip)) (recenter scroll-up scroll-down scroll-other-window scroll-other-window-down) raise-frame window-frame minibuffer-window read-key propertize face minibuffer-prompt lookup-key vector (skip act) nil scroll-up (scroll-up-command) ((error)) scroll-down (scroll-down-command) ((error)) scroll-other-window (scroll-other-window) ((error)) scroll-other-window-down (scroll-other-window-down) ((error)) (exit-prefix quit) 27 signal quit ding discard-input message "%s %s" "y" "n" use-dialog-box scroll-actions cursor-in-echo-area minibuffer-auto-raise key query-replace-map ret] 6 (#$ . 75185)])
#@347 Perform BODY as an atomic change group.
This means that if BODY exits abnormally,
all of its changes to the current buffer are undone.
This works regardless of whether undo is enabled in the buffer.
This mechanism is transparent to ordinary use of undo;
if undo is enabled in the buffer and BODY succeeds, the
user can undo the change normally.
(defalias 'atomic-change-group '(macro . #[(&rest body) "\303\304!\303\305!\306 \307B\310\311\312\313B\257\314\315\316 D\317\n\320\321BBC\"BB\322\323 D\324 DFEE*\207" [success handle body make-symbol "--change-group-handle--" "--change-group-success--" let ((prepare-change-group)) (undo-outer-limit nil) (undo-limit most-positive-fixnum) (undo-strong-limit most-positive-fixnum) (nil) unwind-protect progn activate-change-group append setq (t) if accept-change-group cancel-change-group] 10 (#$ . 77753)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put atomic-change-group lisp-indent-function 0 edebug-form-spec t] 4)
#@1286 Return a handle for the current buffer's state, for a change group.
If you specify BUFFER, make a handle for BUFFER's state instead.
Pass the handle to `activate-change-group' afterward to initiate
the actual changes of the change group.
To finish the change group, call either `accept-change-group' or
`cancel-change-group' passing the same handle as argument. Call
`accept-change-group' to accept the changes in the group as final;
call `cancel-change-group' to undo them all. You should use
`unwind-protect' to make sure the group is always finished. The call
to `activate-change-group' should be inside the `unwind-protect'.
Once you finish the group, don't use the handle again--don't try to
finish the same group twice. For a simple example of correct use, see
the source code of `atomic-change-group'.
The handle records only the specified buffer. To make a multibuffer
change group, call this function once for each buffer you want to
cover, then use `nconc' to combine the returned values, like this:
(nconc (prepare-change-group buffer-1)
(prepare-change-group buffer-2))
You can then activate that multibuffer change group with a single
call to `activate-change-group' and finish it with a single call
to `accept-change-group' or `cancel-change-group'.
(defalias 'prepare-change-group #[(&optional buffer) "\203 rq\210 )BC\207p BC\207" [buffer buffer-undo-list] 2 (#$ . 78748)])
#@71 Activate a change group made with `prepare-change-group' (which see).
(defalias 'activate-change-group #[(handle) "\304\211\205! \n@r @q\210 \305=\203 \304)\nA\211\204 \304*\207" [handle elt --dolist-tail-- buffer-undo-list nil t] 3 (#$ . 80169)])
#@135 Finish a change group made with `prepare-change-group' (which see).
This finishes the change group by accepting its changes as final.
(defalias 'accept-change-group #[(handle) "\304\211\205\" \n@r @q\210 A\305=\203 \305)\nA\211\204 \304*\207" [handle elt --dolist-tail-- buffer-undo-list nil t] 3 (#$ . 80432)])
#@133 Finish a change group made with `prepare-change-group' (which see).
This finishes the change group by reverting all of its changes.
(defalias 'cancel-change-group #[(handle) "\306\211\205v \n@r @q\210 A\214~\210 :\205 @ :\205$ A :\2033 \306\240\210 \306\241\210
\307=\204< \310 \210 :\203N \311!=\204N \312\313!\210\212<\203\\ \314\315!\210\202O ) :\203j \f\240\210 \241\210 ,\nA\211\204 \306*\207" [handle elt --dolist-tail-- old-cdr old-car last-command nil undo undo-start last error "Undoing to some unrelated state" undo-more 1 pending-undo-list buffer-undo-list] 4 (#$ . 80759)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias redraw-modeline force-mode-line-update nil make-obsolete "24.3"] 4)
#@231 Force redisplay of the current buffer's mode line and header line.
With optional non-nil ALL, force redisplay of all mode lines and
header lines. This function also forces recomputation of the
menu bar menus and the frame title.
(defalias 'force-mode-line-update #[(&optional all) "\203\n r\301 q\210)\302\303 !\207" [all other-buffer set-buffer-modified-p buffer-modified-p] 2 (#$ . 81508)])
#@516 Momentarily display STRING in the buffer at POS.
Display remains until next event is input.
If POS is a marker, only its position is used; its buffer is ignored.
Optional third arg EXIT-CHAR can be a character, event or event
description list. EXIT-CHAR defaults to SPC. If the input is
EXIT-CHAR it is swallowed; otherwise it is then available as
input (as a command if nothing else).
Display MESSAGE (optional fourth arg) in the echo area.
If MESSAGE is nil, instructions to type EXIT-CHAR are displayed there.
(defalias 'momentary-string-display #[(string pos &optional exit-char message) "\204 \306\307 \211\"\310\n! \311\216\212\312\f\313 #\210 b\210`\314\315\316\" X\203- \317\320 \321\245!\210)\305
\2064 \322\323!\"\210\324 \211 =\206R \325!=\206R C\211,\207" [exit-char pos string str ol message 32 make-overlay copy-sequence ((delete-overlay ol)) overlay-put after-string window-end nil t recenter window-height 2 "Type %s to continue editing." single-key-description read-event event-convert-list event unread-command-events] 5 (#$ . 81910)])
#@29 Return a copy of overlay O.
(defalias 'copy-overlay #[(o) "\303!\203 \304\305!\306!\303!#\202 \304ee\"\307 !\210 )\310!\n\2039 \311 \n\211A@\n\211A@#\210\202$ *\207" [o o1 props overlay-buffer make-overlay overlay-start overlay-end delete-overlay overlay-properties overlay-put] 5 (#$ . 82987)])
#@173 Clear BEG and END of overlays whose property NAME has value VAL.
Overlays might be moved and/or split.
BEG and END default respectively to the beginning and end of buffer.
(defalias 'remove-overlays #[(&optional beg end name val) "\204 e \204\f d\306 !\210 W\203 \212\307 \"\310\211\205\201 @\311\n\f\"
=\203y \312\n!W\203b \313\n! V\203W \314\315\n!\312\n!#\210\314\n \313\n!#\210\202y \314\n\312\n!#\210\202y \313\n! V\203u \314\n \313\n!#\210\202y \316\n!\210 A\211\204& \310+\207" [beg end o --dolist-tail-- name val overlay-recenter overlays-in nil overlay-get overlay-start overlay-end move-overlay copy-overlay delete-overlay] 6 (#$ . 83303)])
#@56 Normal hook run by `suspend-emacs', before suspending.
(defvar suspend-hook nil (#$ . 83979))
#@63 Normal hook run by `suspend-emacs', after Emacs is continued.
(defvar suspend-resume-hook nil (#$ . 84079))
#@179 Normal hook run by `with-output-to-temp-buffer' after displaying the buffer.
When the hook runs, the temporary buffer is current, and the window it
was displayed in is selected.
(defvar temp-buffer-show-hook nil (#$ . 84194))
#@193 Normal hook run by `with-output-to-temp-buffer' at the start.
When the hook runs, the temporary buffer is current.
This hook is normally set up with a function to put the buffer in Help
mode.
(defvar temp-buffer-setup-hook nil (#$ . 84427))
#@301 Non-nil if the visited file is a binary file.
This variable is meaningful on MS-DOG and MS-Windows.
On those systems, it is automatically local in every buffer.
On other systems, this variable is normally always nil.
WARNING: This variable is obsolete and will disapper Real Soon Now.
Don't use it!
(defvar buffer-file-type nil (#$ . 84675))
(byte-code "\300\301!\210\302\303\304\305#\210\302\303\306\307\310!#\207" [make-variable-buffer-local buffer-file-type put cl-assertion-failed error-conditions (error) error-message purecopy "Assertion failed"] 5)
#@230 Directory beneath which additional per-user Emacs-specific files are placed.
Various programs in Emacs store information in this directory.
Note that this should end with a directory separator.
See also `locate-user-emacs-file'.
(defconst user-emacs-directory (byte-code "\301=\203 \302\207\303\207" [system-type ms-dos "~/_emacs.d/" "~/.emacs.d/"] 2) (#$ . 85239))
#@213 Return an absolute per-user Emacs-specific file name.
If OLD-NAME is non-nil and ~/OLD-NAME exists, return ~/OLD-NAME.
Else return NEW-NAME in `user-emacs-directory', creating the
directory if it does not exist.
(defalias 'locate-user-emacs-file #[(new-name &optional old-name) "\306\307\206 \310P\n\205 \311\n \"\211\203 \312 !\203 \202I \f\204A
\204A \313\314!!\204A \315 \316\216\317\320!\210\321!\210*\322\311\"!*!\207" [init-file-user home old-name at-home noninteractive purify-flag convert-standard-filename "~" "" expand-file-name file-readable-p file-accessible-directory-p directory-file-name default-file-modes ((set-default-file-modes umask)) set-default-file-modes 448 make-directory abbreviate-file-name user-emacs-directory umask new-name] 6 (#$ . 85614)])
#@51 Return non-nil if the current buffer is narrowed.
(defalias 'buffer-narrowed-p #[nil "deZ\300 U?\207" [buffer-size] 2 (#$ . 86411)])
(put 'buffer-narrowed-p 'byte-optimizer 'byte-compile-inline-expand)
#@108 Determine default tag to search for, based on text at point.
If there is no plausible default, return nil.
(defalias 'find-tag-default #[nil "\303\211\211\212\304\305!\210`)\212\306\305!\210`) \nV\204d \212\307 \211\205< \304\310\"\205< `\211V\205< \304\305!\205< `\211)\204d \212\311 \211\205` \306\310\"\205` `\211W\205` \306\305!\205` `\211)\205h \312\n \"+\207" [bound to from nil skip-syntax-backward "w_" skip-syntax-forward line-beginning-position "^w_" line-end-position buffer-substring-no-properties] 3 (#$ . 86620)])
#@666 SOUND is a list of the form `(sound KEYWORD VALUE...)'.
The following keywords are recognized:
:file FILE - read sound data from FILE. If FILE isn't an
absolute file name, it is searched in `data-directory'.
:data DATA - read sound data from string DATA.
Exactly one of :file or :data must be present.
:volume VOL - set volume to VOL. VOL must an integer in the
range 0..100 or a float in the range 0..1.0. If not specified,
don't change the volume setting of the sound device.
:device DEVICE - play sound on DEVICE. If not specified,
a system-dependent default device name is used.
Note: :data and :device are currently not supported on Windows.
(defalias 'play-sound #[(sound) "\301\302!\203\n \302!\207\303\304!\207" [sound fboundp play-sound-internal error "This Emacs binary lacks sound support"] 2 (#$ . 87170)])
#@62 Quote ARGUMENT for passing as argument to an inferior shell.
(defalias 'shell-quote-argument #[(argument) "\305=\203C \306\307\310\311\312\f\"\203 \307\225\fGW\2039 \311\313\f\n#\2039 \307\224 \f\n O\314\f \211TOR T\202 \315 \f\n\310O\315R+\207\316=\203m \317 \203m \320\321\322\320\323\324\f##\311\325\f\"\203h \326\320\327\330\f#\326Q\207\315\f\315Q\207\f\306\232\203u \331\207\320\332\333\320\334\335\f##\207" [system-type end start result argument ms-dos "" 0 nil string-match "[^\"]" "[\"]" "\\" "\"" windows-nt w32-shell-dos-semantics replace-regexp-in-string "\\(\\\\*\\)$" "\\1\\1" "\\(\\\\*\\)\"" "\\1\\1\\\\\"" "[%!\"]" "^\"" "\\([%!()\"<>&|^]\\)" "^\\1" "''" "\n" "'\n'" "[^-0-9a-zA-Z_./\n]" "\\\\\\&"] 7 (#$ . 88014)])
#@63 Return t if OBJECT is a string or nil.
Otherwise, return nil.
(defalias 'string-or-null-p #[(object) ";\206 ?\207" [object] 1 (#$ . 88762)])
#@97 Return t if OBJECT is one of the two canonical boolean values: t or nil.
Otherwise, return nil.
(defalias 'booleanp #[(object) "\301>\205 \302\207" [object (nil t) t] 2 (#$ . 88912)])
#@71 Return the field at position POS, taking stickiness etc into account.
(defalias 'field-at-pos #[(pos) "\302\303!\304\"\211\305=\203 \302\306!S\304\"\202 )\207" [pos raw-field get-char-property field-beginning field boundary field-end] 4 (#$ . 89104)])
#@266 Return the SHA1 (Secure Hash Algorithm) of an OBJECT.
OBJECT is either a string or a buffer. Optional arguments START and
END are character positions specifying which portion of OBJECT for
computing the hash. If BINARY is non-nil, return a string in binary
form.
(defalias 'sha1 #[(object &optional start end binary) "\304\305 \n %\207" [object start end binary secure-hash sha1] 6 (#$ . 89369)])
#@213 Return the value of property PROP of function F.
If AUTOLOAD is non-nil and F is autoloaded, try to autoload it
in the hope that it will set PROP. If AUTOLOAD is `macro', only do it
if it's an autoloaded macro.
(defalias 'function-get #[(f prop &optional autoload) "\306 9\203< \nN\211\204< \307 !\203< K\f\2036 \211 \242)\304=\2036 \310 \f\311=\2051 \311#\232\2038 )\202 )\207" [val f prop fundef autoload object nil fboundp autoload-do-load macro] 7 (#$ . 89776)])
#@196 Process text properties between START and END, inserted for a `yank'.
Perform the handling specified by `yank-handled-properties', then
remove properties specified by `yank-excluded-properties'.
(defalias 'remove-yank-excluded-properties #[(start end) "\306 \307\211\203G @\211@\nA\f \f
W\203? \310
\"\311
\307$ \f
#\210*\202 + A\211\204\n *\306=\203X \312\f\307#\202_ \313\f#)\207" [inhibit-read-only yank-handled-properties handler --dolist-tail-- start run-start t nil get-text-property next-single-property-change set-text-properties remove-list-of-text-properties fun prop end run-end value yank-excluded-properties] 7 (#$ . 90263)])
#@115 Call `insert-for-yank-1' repetitively for each `yank-handler' segment.
See `insert-for-yank-1' for more details.
(defalias 'insert-for-yank #[(string) "\302\303\304\305 #\211\203 \306 \304O!\210 \302O\202 )\306 !\207" [to string nil next-single-property-change 0 yank-handler insert-for-yank-1] 4 (#$ . 90946)])
#@1360 Insert STRING at point for the `yank' command.
This function is like `insert', except it honors the variables
`yank-handled-properties' and `yank-excluded-properties', and the
`yank-handler' text property.
Properties listed in `yank-handled-properties' are processed,
then those listed in `yank-excluded-properties' are discarded.
If STRING has a non-nil `yank-handler' property on its first
character, the normal insert behavior is altered. The value of
the `yank-handler' property must be a list of one to four
elements, of the form (FUNCTION PARAM NOEXCLUDE UNDO).
FUNCTION, if non-nil, should be a function of one argument, an
object to insert; it is called instead of `insert'.
PARAM, if present and non-nil, replaces STRING as the argument to
FUNCTION or `insert'; e.g. if FUNCTION is `yank-rectangle', PARAM
may be a list of strings to insert as a rectangle.
If NOEXCLUDE is present and non-nil, the normal removal of
`yank-excluded-properties' is not performed; instead FUNCTION is
responsible for the removal. This may be necessary if FUNCTION
adjusts point before or after inserting the object.
UNDO, if present and non-nil, should be a function to be called
by `yank-pop' to undo the insertion of the current object. It is
given two arguments, the start and end of the region. FUNCTION
may set `yank-undo-function' to override UNDO.
(defalias 'insert-for-yank-1 #[(string) ";\205\n \306\307\310#\211A@\206 `\f \311 \312 @\203) @\n!\210\202, \nc\210`\312\313 8\204; \314
\"\210
V\203P \315
S!\203P \316
S
\317\312$\210\312=\203\\ \320 8\321 8\205h \321 8\211-\207" [string handler param opoint inhibit-read-only end get-text-property 0 yank-handler nil t 2 remove-yank-excluded-properties text-properties-at put-text-property rear-nonsticky 3 4 yank-undo-function this-command] 6 (#$ . 91274)])
#@253 Insert before point a substring of BUFFER, without text properties.
BUFFER may be a buffer or a buffer name.
Arguments START and END are character positions specifying the substring.
They default to the values of (point-min) and (point-max) in BUFFER.
(defalias 'insert-buffer-substring-no-properties #[(buffer &optional start end) "`\305 \n #\210\306 \307`\310#*\207" [opoint buffer start end inhibit-read-only insert-buffer-substring t set-text-properties nil] 4 (#$ . 93121)])
#@368 Insert before point a part of BUFFER, stripping some text properties.
BUFFER may be a buffer or a buffer name.
Arguments START and END are character positions specifying the substring.
They default to the values of (point-min) and (point-max) in BUFFER.
Before insertion, process text properties according to
`yank-handled-properties' and `yank-excluded-properties'.
(defalias 'insert-buffer-substring-as-yank #[(buffer &optional start end) "`\304 \n #\210\305`\")\207" [opoint buffer start end insert-buffer-substring remove-yank-excluded-properties] 4 (#$ . 93610)])
#@155 If `font-lock-defaults' is nil, apply FACE as a `face' property.
START and END denote the start and end of the text to act on.
Do nothing if FACE is nil.
(defalias 'yank-handle-font-lock-face-property #[(face start end) "\205 ?\205 \304\n \300$\207" [face font-lock-defaults start end put-text-property] 5 (#$ . 94188)])
#@70 Apply property category CATEGORY's properties between START and END.
(defalias 'yank-handle-category-property #[(category start end) "\205+ \n W\205* \306\n\307 #\310\n! \311\n
\312!#\210\313\n
\f#\210
*\202 )\207" [category start start2 end original end2 next-property-change nil text-properties-at set-text-properties symbol-plist add-text-properties] 5 (#$ . 94520)])
#@624 Start a program in a subprocess. Return the process object for it.
NAME is name for process. It is modified if necessary to make it unique.
BUFFER is the buffer (or buffer name) to associate with the process.
Process output goes at end of that buffer, unless you specify
an output stream or filter function to handle the output.
BUFFER may be also nil, meaning that this process is not associated
with any buffer
COMMAND is the shell command to run.
An old calling convention accepted any number of arguments after COMMAND,
which were just concatenated to COMMAND. This is still supported but strongly
discouraged.
(defalias 'start-process-shell-command #[(name buffer &rest args) "\305 \n \306\307\f\310#%\207" [name buffer shell-file-name shell-command-switch args start-process mapconcat identity " "] 9 (#$ . 94905)])
(set-advertised-calling-convention 'start-process-shell-command '(name buffer command) "23.1")
#@143 Start a program in a subprocess. Return the process object for it.
Similar to `start-process-shell-command', but calls `start-file-process'.
(defalias 'start-file-process-shell-command #[(name buffer &rest args) "\306 \307\n!\203
\310\202 \307\n!\203 \311\202 \f\312\313
\314#%\207" [name buffer default-directory shell-file-name shell-command-switch args start-file-process file-remote-p "/bin/sh" "-c" mapconcat identity " "] 9 (#$ . 95838)])
(set-advertised-calling-convention 'start-file-process-shell-command '(name buffer command) "23.1")
#@1096 Execute the shell command COMMAND synchronously in separate process.
The remaining arguments are optional.
The program's input comes from file INFILE (nil means `/dev/null').
Insert output in BUFFER before point; t means current buffer;
nil for BUFFER means discard it; 0 means discard and don't wait.
BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
REAL-BUFFER says what to do with standard output, as above,
while STDERR-FILE says what to do with standard error in the child.
STDERR-FILE may be nil (discard standard error output),
t (mix it with ordinary output), or a file name string.
Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.
Remaining arguments are strings passed as additional arguments for COMMAND.
Wildcards and redirection are handled as usual in the shell.
If BUFFER is 0, `call-process-shell-command' returns immediately with value nil.
Otherwise it waits for COMMAND to terminate and returns a numeric exit
status or a signal description string.
If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
(defalias 'call-process-shell-command #[(command &optional infile buffer display &rest args) "\306 \n \f\307\310
\nB\311#&\207" [shell-file-name infile buffer display shell-command-switch command call-process mapconcat identity " " args] 10 (#$ . 96398)])
#@119 Process files synchronously in a separate process.
Similar to `call-process-shell-command', but calls `process-file'.
(defalias 'process-file-shell-command #[(command &optional infile buffer display &rest args) "\306\307!\203 \310\202\f \n \f\307!\203 \311\202
\312\313
B\314#&\207" [default-directory shell-file-name infile buffer display shell-command-switch process-file file-remote-p "/bin/sh" "-c" mapconcat identity " " command args] 10 (#$ . 97759)])
#@223 Execute the forms in BODY with BUFFER-OR-NAME temporarily current.
BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
The value returned is the value of the last form in BODY. See
also `with-temp-buffer'.
(defalias 'with-current-buffer '(macro . #[(buffer-or-name &rest body) "\302\303D BB\207" [buffer-or-name body save-current-buffer set-buffer] 3 (#$ . 98235)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put with-current-buffer lisp-indent-function 1 edebug-form-spec t] 4)
(defalias 'internal--before-with-selected-window #[(window) "\302!\303 \304 =?\205 \305 !\304 =?\205 \306 !F)\207" [window other-frame window-frame selected-window selected-frame frame-selected-window tty-top-frame] 5])
(defalias 'internal--after-with-selected-window #[(state) "\301\3028!\203' \303\3028\304\"\210\305\3068!\203' \307 \3068=\204' \310\3068\304\"\210\301A@!\2055 \303A@\304\"\207" [state window-live-p 2 select-window norecord frame-live-p 3 tty-top-frame select-frame] 3])
#@735 Execute the forms in BODY with WINDOW as the selected window.
The value returned is the value of the last form in BODY.
This macro saves and restores the selected window, as well as the
selected window of each frame. It does not change the order of
recently selected windows. If the previously selected window of
some frame is no longer live at the end of BODY, that frame's
selected window is left alone. If the selected window is no
longer live, then whatever window is selected at the end of BODY
remains selected.
This macro uses `save-current-buffer' to save and restore the
current buffer, since otherwise its normal operation could
potentially make a different buffer current. It does not alter
the buffer list ordering.
(defalias 'with-selected-window '(macro . #[(window &rest body) "\302\303\304DDC\305\306\307\310 BB\311BBDE\207" [window body let save-selected-window--state internal--before-with-selected-window save-current-buffer unwind-protect progn (select-window (car save-selected-window--state) 'norecord) ((internal--after-with-selected-window save-selected-window--state))] 7 (#$ . 99257)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put with-selected-window lisp-indent-function 1 edebug-form-spec t] 4)
#@269 Execute the forms in BODY with FRAME as the selected frame.
The value returned is the value of the last form in BODY.
This macro saves and restores the selected frame, and changes the
order of neither the recently selected windows nor the buffers in
the buffer list.
(defalias 'with-selected-frame '(macro . #[(frame &rest body) "\304\305!\304\306!\307 \310B\311BD\312\313\314\n\315BB BB\316\317 D\314 \320BBE\316\321D\322DEFE*\207" [old-buffer old-frame frame body make-symbol "old-frame" "old-buffer" let ((selected-frame)) ((current-buffer)) unwind-protect progn select-frame ('norecord) when frame-live-p ('norecord) buffer-live-p set-buffer] 9 (#$ . 100512)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put with-selected-frame lisp-indent-function 1 edebug-form-spec t] 4)
#@573 Execute BODY, then restore previous window configuration.
This macro saves the window configuration on the selected frame,
executes BODY, then calls `set-window-configuration' to restore
the saved window configuration. The return value is the last
form in BODY. The window configuration is also restored if BODY
exits nonlocally.
BEWARE: Most uses of this macro introduce bugs.
E.g. it should not be used to try and prevent some code from opening
a new window, since that window may sometimes appear in another frame,
in which case `save-window-excursion' cannot help.
(defalias 'save-window-excursion '(macro . #[(&rest body) "\302\303!\304\305BC\306\307 B\310DEE)\207" [c body make-symbol "wconfig" let ((current-window-configuration)) unwind-protect progn set-window-configuration] 6 (#$ . 101318)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put save-window-excursion lisp-indent-function 0 edebug-form-spec t] 4)
#@53 Internal function for `with-output-to-temp-buffer'.
(defalias 'internal-temp-output-buffer-show #[(buffer) "rq\210\306\307!\210eb\210) \203 !\210\202u rq\210\n\310=\204+ \n\311=\203/ \203/ \312\2020 \n\313!)\211 \205= \314\f! \f\203t
\315 =\204M \316
!\210\f\317\f\320\"\210\321\fe\312#\210\322\fe\"\210\323\f! r\324\216\325@\326\"\210\327\330!\210++\307\207" [buffer temp-buffer-show-function window-combination-limit temp-buffer-resize-mode window frame set-buffer-modified-p nil temp-buffer temp-buffer-resize t display-buffer window-frame selected-frame make-frame-visible set-window-hscroll 0 set-window-start set-window-point internal--before-with-selected-window ((internal--after-with-selected-window save-selected-window--state)) select-window norecord run-hooks temp-buffer-show-hook minibuffer-scroll-window save-selected-window--state] 5 (#$ . 102263)])
#@1294 Bind `standard-output' to buffer BUFNAME, eval BODY, then show that buffer.
This construct makes buffer BUFNAME empty before running BODY.
It does not make the buffer current for BODY.
Instead it binds `standard-output' to that buffer, so that output
generated with `prin1' and similar functions in BODY goes into
the buffer.
At the end of BODY, this marks buffer BUFNAME unmodified and displays
it in a window, but does not select it. The normal way to do this is
by calling `display-buffer', then running `temp-buffer-show-hook'.
However, if `temp-buffer-show-function' is non-nil, it calls that
function instead (and does not run `temp-buffer-show-hook'). The
function gets one argument, the buffer to display.
The return value of `with-output-to-temp-buffer' is the value of the
last form in BODY. If BODY does not finish normally, the buffer
BUFNAME is not displayed.
This runs the hook `temp-buffer-setup-hook' before BODY,
with the buffer BUFNAME temporarily current. It runs the hook
`temp-buffer-show-hook' after displaying buffer BUFNAME, with that
buffer temporarily current, and the window that was used to display it
temporarily selected. But it doesn't run `temp-buffer-show-hook'
if it uses `temp-buffer-show-function'.
See the related form `with-temp-buffer-window'.
(defalias 'with-output-to-temp-buffer '(macro . #[(bufname &rest body) "\304\305!\304\306!\307 \310B\311\312\nD\313\314\315\316\317 E\320BBBBED\321DE\313\322 B\323DEE*\207" [buf old-dir bufname body make-symbol "old-dir" "buf" let* (default-directory) with-current-buffer get-buffer-create prog1 (current-buffer) (kill-all-local-variables) setq default-directory ((setq buffer-read-only nil) (setq buffer-file-name nil) (setq buffer-undo-list t) (let ((inhibit-read-only t) (inhibit-modification-hooks t)) (erase-buffer) (run-hooks 'temp-buffer-setup-hook))) standard-output progn internal-temp-output-buffer-show] 11 (#$ . 103151)]))
(put 'with-output-to-temp-buffer 'edebug-form-spec t)
#@160 Create a new buffer, evaluate BODY there, and write the buffer to FILE.
The value returned is the value of the last form in BODY.
See also `with-temp-buffer'.
(defalias 'with-temp-file '(macro . #[(file &rest body) "\304\305!\304\306!\307 \nD\310BD\311\312\313 BB\313\314\315\211 \316BBBBEE\317\320D\321DEEE*\207" [temp-buffer temp-file file body make-symbol "temp-file" "temp-buffer" let ((get-buffer-create (generate-new-buffer-name " *temp file*"))) unwind-protect prog1 with-current-buffer write-region nil (nil 0) and buffer-name kill-buffer] 12 (#$ . 105145)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put with-temp-file lisp-indent-function 1 edebug-form-spec t] 4)
#@403 Display MESSAGE temporarily if non-nil while BODY is evaluated.
The original message is restored to the echo area after BODY has finished.
The value returned is the value of the last form in BODY.
MESSAGE is written to the message log buffer if `message-log-max' is non-nil.
If MESSAGE is nil, the echo area and message log buffer are unchanged.
Use a MESSAGE of "" to temporarily clear the echo area.
(defalias 'with-temp-message '(macro . #[(message &rest body) "\304\305!\304\306!\307\nD CD\310\311\312\313 \314BB\302\315EF BB\316\317 \302\315 E\320BBBEEE*\207" [temp-message current-message message body make-symbol "current-message" "with-temp-message" let unwind-protect progn when setq ((current-message)) "%s" and if ((message nil))] 11 (#$ . 105849)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put with-temp-message edebug-form-spec t lisp-indent-function 1] 4)
#@121 Create a temporary buffer, and evaluate BODY there like `progn'.
See also `with-temp-file' and `with-output-to-string'.
(defalias 'with-temp-buffer '(macro . #[(&rest body) "\302\303!\304\305BC\306\307\310 B\311\312D\313DEEEE)\207" [temp-buffer body make-symbol "temp-buffer" let ((generate-new-buffer " *temp*")) with-current-buffer unwind-protect progn and buffer-name kill-buffer] 10 (#$ . 106749)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put with-temp-buffer lisp-indent-function 0 edebug-form-spec t] 4)
#@554 Execute BODY, pretending it does not modify the buffer.
If BODY performs real modifications to the buffer's text, other
than cosmetic ones, undo data may become corrupted.
This macro will run BODY normally, but doesn't count its buffer
modifications as being buffer modifications. This affects things
like buffer-modified-p, checking whether the file is locked by
someone else, running buffer modification hooks, and other things
of that nature.
Typically used around modifications of text-properties which do
not really affect the buffer's content.
(defalias 'with-silent-modifications '(macro . #[(&rest body) "\302\303!\304\305B\306B\307\310 B\311\312BBEE)\207" [modified body make-symbol "modified" let* ((buffer-modified-p)) ((buffer-undo-list t) (inhibit-read-only t) (inhibit-modification-hooks t) deactivate-mark buffer-file-name buffer-file-truename) unwind-protect progn unless ((restore-buffer-modified-p nil))] 7 (#$ . 107289)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put with-silent-modifications edebug-form-spec t lisp-indent-function 0] 4)
#@74 Execute BODY, return the text it sent to `standard-output', as a string.
(defalias 'with-output-to-string '(macro . #[(&rest body) "\301\302\303\304\301\305BB\306BB\307BBE\207" [body let ((standard-output (get-buffer-create (generate-new-buffer-name " *string-output*")))) unwind-protect progn ((standard-output standard-output)) ((with-current-buffer standard-output (buffer-string))) ((kill-buffer standard-output))] 7 (#$ . 108376)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put with-output-to-string lisp-indent-function 0 edebug-form-spec t] 4)
#@272 Execute BODY, allowing quits to terminate BODY but not escape further.
When a quit terminates BODY, `with-local-quit' returns nil but
requests another quit. That quit will be processed as soon as quitting
is allowed once again. (Immediately, if `inhibit-quit' is nil.)
(defalias 'with-local-quit '(macro . #[(&rest body) "\301\302\303\304BB\305BBB\207" [body condition-case nil let ((inhibit-quit nil)) ((quit (setq quit-flag t) (eval '(ignore nil))))] 5 (#$ . 108951)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put with-local-quit edebug-form-spec t lisp-indent-function 0] 4)
#@243 Execute BODY only as long as there's no pending input.
If input arrives, that ends the execution of BODY,
and `while-no-input' returns t. Quitting makes it return nil.
If BODY finishes, `while-no-input' returns whatever value BODY produced.
(defalias 'while-no-input '(macro . #[(&rest body) "\302\303!\304\305\306D\307\310\306DDC\311\312\313 BEEE)D\207" [catch-sym body make-symbol "input" with-local-quit catch quote let throw-on-input or (input-pending-p) progn] 9 (#$ . 109556)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put while-no-input edebug-form-spec t lisp-indent-function 0] 4)
#@159 Like `condition-case' except that it does not catch anything when debugging.
More specifically if `debug-on-error' is set, then it does not catch any signal.
(defalias 'condition-case-unless-debug '(macro . #[(var bodyform &rest handlers) "\304\305!\306\307\310 EDC\311\312\313D\314\n\313D BBBFE)\207" [bodysym bodyform var handlers make-symbol "body" let lambda nil if debug-on-error funcall condition-case] 9 (#$ . 110174)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\306\307\301\310#\210\311\307\301\312#\207" [put condition-case-unless-debug edebug-form-spec condition-case lisp-indent-function 2 defalias condition-case-no-debug nil make-obsolete "24.1"] 4)
#@271 Run BODY and demote any errors to simple messages.
If `debug-on-error' is non-nil, run BODY without catching its errors.
This is to be used around code which is not expected to signal an error
but which should be robust in the unexpected case that an error is signaled.
(defalias 'with-demoted-errors '(macro . #[(&rest body) "\302\303!\304\305 B\306\307\310E\311BBF)\207" [err body make-symbol "err" condition-case-unless-debug progn error message "Error: %S" (nil)] 7 (#$ . 110861)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put with-demoted-errors edebug-form-spec t lisp-indent-function 0] 4)
#@497 Execute BODY, but don't call the after-change functions till the end.
If BODY makes changes in the buffer, they are recorded
and the functions on `after-change-functions' are called several times
when BODY is finished.
The return value is the value of the last form in BODY.
If `before-change-functions' is non-nil, then calls to the after-change
functions can't be deferred, so in that case this macro has no effect.
Do not alter `after-change-functions' or `before-change-functions'
in BODY.
(defalias 'combine-after-change-calls '(macro . #[(&rest body) "\301\302\303BB\304BB\207" [body unwind-protect let ((combine-after-change-calls t)) ((combine-after-change-execute))] 4 (#$ . 111485)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put combine-after-change-calls lisp-indent-function 0 edebug-form-spec t] 4)
#@123 Execute the forms in BODY with TABLE as the current case table.
The value returned is the value of the last form in BODY.
(defalias 'with-case-table '(macro . #[(table &rest body) "\304\305!\304\306!\307 \310B\311BD\312\313\314\nD BB\315\314 DEEE*\207" [old-buffer old-case-table table body make-symbol "table" "buffer" let ((current-case-table)) ((current-buffer)) unwind-protect progn set-case-table with-current-buffer] 8 (#$ . 112324)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put with-case-table lisp-indent-function 1 edebug-form-spec t] 4)
#@129 Execute the BODY forms, restoring the global value of the match data.
The value returned is the value of the last form in BODY.
(defalias 'save-match-data '(macro . #[(&rest body) "\301\302\303\304B\305EE\207" [body let ((save-match-data-internal (match-data))) unwind-protect progn (set-match-data save-match-data-internal 'evaporate)] 5 (#$ . 112900)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put save-match-data lisp-indent-function 0 edebug-form-spec t] 4)
#@434 Return string of text matched by last search.
NUM specifies which parenthesized expression in the last regexp.
Value is nil if NUMth pair didn't match, or there were less than NUM pairs.
Zero means the entire text matched by the whole regexp or whole string.
STRING should be given if the last search was by `string-match' on STRING.
If STRING is nil, the current buffer should be the same buffer
the search/match was performed in.
(defalias 'match-string #[(num &optional string) "\224\205 \203 \224\225O\207\224\225{\207" [num string] 3 (#$ . 113387)])
#@459 Return string of text matched by last search, without text properties.
NUM specifies which parenthesized expression in the last regexp.
Value is nil if NUMth pair didn't match, or there were less than NUM pairs.
Zero means the entire text matched by the whole regexp or whole string.
STRING should be given if the last search was by `string-match' on STRING.
If STRING is nil, the current buffer should be the same buffer
the search/match was performed in.
(defalias 'match-string-no-properties #[(num &optional string) "\224\205 \203 \302 \224\225#\207\303\224\225\"\207" [num string substring-no-properties buffer-substring-no-properties] 4 (#$ . 113959)])
#@282 Return REPLACEMENT as it will be inserted by `replace-match'.
In other words, all back-references in the form `\&' and `\N'
are substituted with actual strings matched by the last search.
Optional FIXEDCASE, LITERAL, STRING and SUBEXP have the same
meaning as for `replace-match'.
(defalias 'match-substitute-replacement #[(replacement &optional fixedcase literal string subexp) "\306\307\"\310 \311\216\312\313\314\310\315!\"!\210\316 \f
%+\207" [string match save-match-data-internal replacement fixedcase literal match-string 0 match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) set-match-data mapcar #[(x) "\247\203\n \301\224Z\207\207" [x 0] 2] t replace-match subexp] 6 (#$ . 114634)])
#@518 Return non-nil if text before point matches regular expression REGEXP.
Like `looking-at' except matches before point, and is slower.
LIMIT if non-nil speeds up the search by specifying a minimum
starting position, to avoid checking matches that would start
before LIMIT.
If GREEDY is non-nil, extend the match backwards as far as
possible, stopping when a single additional previous character
cannot be part of a match for REGEXP. When the match is
extended, its starting position is allowed to occur before
LIMIT.
(defalias 'looking-back #[(regexp &optional limit greedy) "`\212\305\306\307Q \310#\205 `)\f\203H \n\203H \214e }\210\neV\203< \212\nb\210\311u\210\312\306\313Q!)\203< \nS\211\202 \212\nb\210\312\306\313Q!\210*\n*??\207" [regexp limit pos start greedy re-search-backward "\\(?:" "\\)\\=" t -1 looking-at "\\)\\'"] 6 (#$ . 115388)])
#@75 Same as `looking-at' except this function does not change the match data.
(defalias 'looking-at-p #[(regexp) "\302\303 !)\207" [inhibit-changing-match-data regexp t looking-at] 2 (#$ . 116251)])
(put 'looking-at-p 'byte-optimizer 'byte-compile-inline-expand)
#@77 Same as `string-match' except this function does not change the match data.
(defalias 'string-match-p #[(regexp string &optional start) "\304\305 \n #)\207" [inhibit-changing-match-data regexp string start t string-match] 4 (#$ . 116517)])
(put 'string-match-p 'byte-optimizer 'byte-compile-inline-expand)
#@369 Return non-nil if POS is in a normal subregexp context in REGEXP.
A subregexp context is one where a sub-regexp can appear.
A non-subregexp context is for example within brackets, or within a
repetition bounds operator `\=\{...\}', or right after a `\'.
If START is non-nil, it should be a position in REGEXP, smaller
than POS, and known to be in a subregexp context.
(defalias 'subregexp-context-p #[(regexp pos &optional start) "\300\301\302\217\207" [err (byte-code "\303 \206 \304\nO\305\"\210\306\207" [regexp start pos string-match 0 "" t] 4) ((invalid-regexp (byte-code "\211A@)\302\235?\207" [err x ("Unmatched [ or [^" "Unmatched \\{" "Trailing backslash")] 3)))] 3 (#$ . 116831)])
#@290 The default value of separators for `split-string'.
A regexp matching strings of whitespace. May be locale-dependent
(as yet unimplemented). Should not match non-breaking spaces.
Warning: binding this to a different value and using it as default is
likely to have undesired semantics.
(defconst split-string-default-separators "[ \f \n
]+" (#$ . 117533))
#@1149 Split STRING into substrings bounded by matches for SEPARATORS.
The beginning and end of STRING, and each match for SEPARATORS, are
splitting points. The substrings matching SEPARATORS are removed, and
the substrings between the splitting points are collected as a list,
which is returned.
If SEPARATORS is non-nil, it should be a regular expression matching text
which separates, but is not part of, the substrings. If nil it defaults to
`split-string-default-separators', normally "[ \f\t\n\r\v]+", and
OMIT-NULLS is forced to t.
If OMIT-NULLS is t, zero-length substrings are omitted from the list (so
that for the default value of SEPARATORS leading and trailing whitespace
are effectively trimmed). If nil, all zero-length substrings are retained,
which correctly parses CSV format, for example.
Note that the effect of `(split-string STRING)' is the same as
`(split-string STRING split-string-default-separators t)'. In the rare
case that you wish to retain zero-length substrings when splitting on
whitespace, use `(split-string STRING split-string-default-separators)'.
Modifies the match data; use `save-match-data' if necessary.
(defalias 'split-string #[(string &optional separators omit-nulls) "\203 \202 \306?\206 \n\307\310\211 \n \311\n\f\f\2036
\307\224U\2036
\fGW\2036
T\2027
#\203`
\fGW\203` \306 \204Q
\307\224W\203Z \f
\307\224O B\307\225\202 \204m
\fGW\203u \f
\310O B \237-\207" [separators omit-nulls split-string-default-separators list notfirst start t 0 nil string-match rexp keep-nulls string] 5 (#$ . 117901)])
#@234 Concatenate the STRINGS, adding the SEPARATOR (default " ").
This tries to quote the strings to avoid ambiguity such that
(split-string-and-unquote (combine-and-quote-strings strs)) == strs
Only some SEPARATORs will work properly.
(defalias 'combine-and-quote-strings #[(strings &optional separator) "\206 \304\305\306\307 !Q\310\311 #*\207" [separator sep re strings " " "[\\\"]" "\\|" regexp-quote mapconcat #[(str) "\302 \"\203 \303\304\305\306 #\303Q\207 \207" [re str string-match "\"" replace-regexp-in-string "[\\\"]" "\\\\\\&"] 5]] 4 (#$ . 119488)])
#@212 Split the STRING into a list of strings.
It understands Emacs Lisp quoting within STRING, such that
(split-string-and-unquote (combine-and-quote-strings strs)) == strs
The SEPARATOR regexp defaults to "\s-+".
(defalias 'split-string-and-unquote #[(string &optional separator) "\206 \305\306\307 \"\n\204 \310 \311#\2029 \312\n\313=?\205' \310 \313\nO \311#\314 \n\"\211 @\315 \fA\316O \")B\"*\207" [separator string i sep rfs "\\s-+" string-match "\"" split-string t append 0 read-from-string split-string-and-unquote nil] 8 (#$ . 120062)])
#@127 Replace FROMCHAR with TOCHAR in STRING each time it occurs.
Unless optional argument INPLACE is non-nil, return a new string.
(defalias 'subst-char-in-string #[(fromchar tochar string &optional inplace) "G \203\n \202
\306! \307V\203( S\n H\f=\203 \n
I\210\202 \n*\207" [string inplace newstr i fromchar tochar copy-sequence 0] 3 (#$ . 120618)])
#@787 Replace all matches for REGEXP with REP in STRING.
Return a new string containing the replacements.
Optional arguments FIXEDCASE, LITERAL and SUBEXP are like the
arguments with the same names of function `replace-match'. If START
is non-nil, start replacements at that index in STRING.
REP is either a string used as the NEWTEXT arg of `replace-match' or a
function. If it is a function, it is called with the actual text of each
match, and its value is used as the replacement text. When REP is called,
the match data are the result of matching REGEXP against a substring
of STRING.
To replace only the first match (if any), make REGEXP match up to \'
and replace a sub-expression, e.g.
(replace-regexp-in-string "\\(foo\\).*\\'" "bar" " foo foo" nil nil 1)
=> " bar foo"
(defalias 'replace-regexp-in-string #[(regexp rep string &optional fixedcase literal subexp start) "G \206 \306\307\211\211\211 \310 \311\216 W\203n \312 #\203n \306\224\306\225\211 U\203: T^\312 \nO\211\"\210\313;\203Q \202X \314\306\f\"!\f% O
BB\n\211\202 O
B\315\316
\237\".\207" [string start me mb str matches 0 nil match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match replace-match match-string apply concat l save-match-data-internal regexp rep fixedcase literal subexp] 7 (#$ . 120982)])
#@141 Return non-nil if STR1 is a prefix of STR2.
If IGNORE-CASE is non-nil, the comparison is done without paying attention
to case differences.
(defalias 'string-prefix-p #[(str1 str2 &optional ignore-case) "\303\304\211 \305G\n&\306=\207" [str1 str2 ignore-case compare-strings nil 0 t] 8 (#$ . 122376)])
#@553 Return a string that can be safely inserted in left-to-right text.
Normally, inserting a string with right-to-left (RTL) script into
a buffer may cause some subsequent text to be displayed as part
of the RTL segment (usually this affects punctuation characters).
This function returns a string which displays as STR but forces
subsequent text to be displayed as left-to-right.
If STR contains any RTL character, this function returns a string
consisting of STR followed by an invisible left-to-right mark
(LRM) character. Otherwise, it returns STR.
(defalias 'bidi-string-mark-left-to-right #[(str) ";\204\f \301\302\303D\"\210\304\305\"\203 \306\307\310!\311\312#P\207\207" [str signal wrong-type-argument stringp string-match "\\cR" propertize string 8206 invisible t] 5 (#$ . 122688)])
#@137 Add ELEMENT to `buffer-invisibility-spec'.
See documentation for `buffer-invisibility-spec' for the kind of elements
that can be added.
(defalias 'add-to-invisibility-spec #[(element) "\302=\203 \302C B\211\207" [buffer-invisibility-spec element t] 2 (#$ . 123493)])
#@49 Remove ELEMENT from `buffer-invisibility-spec'.
(defalias 'remove-from-invisibility-spec #[(element) ":\205 \302 \"\211\207" [buffer-invisibility-spec element delete] 3 (#$ . 123771)])
#@228 Evaluate BODY with syntax table of current buffer set to TABLE.
The syntax table of the current buffer is saved, BODY is evaluated, and the
saved table is restored, even in case of an abnormal exit.
Value is what BODY returns.
(defalias 'with-syntax-table '(macro . #[(table &rest body) "\304\305!\304\306!\307 \310B\311BD\312\313\314\nD BB\315\316D\314 DEEE*\207" [old-buffer old-table table body make-symbol "table" "buffer" let ((syntax-table)) ((current-buffer)) unwind-protect progn set-syntax-table save-current-buffer set-buffer] 8 (#$ . 123967)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put with-syntax-table edebug-form-spec t lisp-indent-function 1] 4)
#@135 Return a new syntax table.
Create a syntax table which inherits from OLDTABLE (if non-nil) or
from `standard-syntax-table' otherwise.
(defalias 'make-syntax-table #[(&optional oldtable) "\302\303\304\"\305 \206
\306 \"\210)\207" [table oldtable make-char-table syntax-table nil set-char-table-parent standard-syntax-table] 3 (#$ . 124659)])
#@121 Return the raw syntax descriptor for the char after POS.
If POS is outside the buffer's accessible portion, return nil.
(defalias 'syntax-after #[(pos) "eW\206 dY?\205) \205 \303\304\"\211:\203 \n\202( \n\206% \304 fH)\207" [pos parse-sexp-lookup-properties st get-char-property syntax-table] 4 (#$ . 125011)])
#@277 Return the code for the syntax class described by SYNTAX.
SYNTAX should be a raw syntax descriptor; the return value is a
integer which encodes the corresponding syntax class. See Info
node `(elisp)Syntax Table Internals' for a list of codes.
If SYNTAX is nil, return nil.
(defalias 'syntax-class #[(syntax) "\205 \301@\302\"\207" [syntax logand 65535] 3 (#$ . 125338)])
#@137 Propagate the changes made under the overlay OL1 to the other clones.
This is used on the `modification-hooks' property of text clones.
(defalias 'text-clone-maintain #[(ol1 after beg end &optional _len) "\205 ?\205\306\n!\205\307\n\310\"\203 \311\202 \312\f\306\n! \\]
\313\n! Z^\f
X\205\212\307\n\314\"\203\227 \306\n! \\\313\n! Z \211 b\210\315 \316\216\317\307\n\314\"\320#\204f \321\n\322\323#\210\202\226 \312\225W\203~
\312\225^\324\n\306\n!\312\225 \\#\210\312\224V\203\226 \312\224\f]\324\n\312\224 Z\313\n!#\210,\f\306\n!Z\313\n!
Z\f
{\320\211 \307\n\322\"\323 \211 \203 @ \313 ! \n =\204\374 \203\374 \323\306 ! \\ !\313 ! Zb\210!`V\204\373 \212c\210)!`|\210)) A\211 \204\275 *\205\325\n!.)\207" [after undo-in-progress ol1 margin beg end overlay-start overlay-get text-clone-spreadp 1 0 overlay-end text-clone-syntax match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) re-search-forward t overlay-put text-clones nil move-overlay delete-overlay cend cbeg save-match-data-internal inhibit-modification-hooks nothing-left str tail head ol2 --dolist-tail-- oe mod-beg] 6 (#$ . 125722)])
#@585 Create a text clone of START...END at point.
Text clones are chunks of text that are automatically kept identical:
changes done to one of the clones will be immediately propagated to the other.
The buffer's content at point is assumed to be already identical to
the one between START and END.
If SYNTAX is provided it's a regexp that describes the possible text of
the clones; the clone will be shrunk or killed if necessary to ensure that
its text matches the regexp.
If SPREADP is non-nil it indicates that text inserted before/after the
clone should be incorporated in the clone.
(defalias 'text-clone-create #[(start end &optional spreadp syntax) "` Z\\ \203 o\204 eX\203 \306\202 \307 \203* \ndY\204* dY\203. \306\202/ \307 \310 \fZ
\\\311\312$ \310`\fZ\n
\\\311\312$ D \313\314\315#\210 \203a \313\316\312#\210\203n \313\317#\210\313\320\312#\210\313\321#\210\313\314\322#\210 \203\217 \313\316\312#\210\203\234 \313\317#\210\313\320\312#\210\313\321#.\207" [end start pt-end spreadp start-margin end-margin 0 1 make-overlay nil t overlay-put modification-hooks (text-clone-maintain) text-clone-spreadp text-clone-syntax evaporate text-clones (text-clone-maintain) ol1 ol2 dups syntax] 5 (#$ . 126934)])
#@1296 Define a symbol to identify a mail-sending package for `mail-user-agent'.
SYMBOL can be any Lisp symbol. Its function definition and/or
value as a variable do not matter for this usage; we use only certain
properties on its property list, to encode the rest of the arguments.
COMPOSEFUNC is program callable function that composes an outgoing
mail message buffer. This function should set up the basics of the
buffer without requiring user interaction. It should populate the
standard mail headers, leaving the `to:' and `subject:' headers blank
by default.
COMPOSEFUNC should accept several optional arguments--the same
arguments that `compose-mail' takes. See that function's documentation.
SENDFUNC is the command a user would run to send the message.
Optional ABORTFUNC is the command a user would run to abort the
message. For mail packages that don't have a separate abort function,
this can be `kill-buffer' (the equivalent of omitting this argument).
Optional HOOKVAR is a hook variable that gets run before the message
is actually sent. Callers that use the `mail-user-agent' may
install a hook function temporarily on this hook variable.
If HOOKVAR is nil, `mail-send-hook' is used.
The properties used on SYMBOL are `composefunc', `sendfunc',
`abortfunc', and `hookvar'.
(defalias 'define-mail-user-agent #[(symbol composefunc sendfunc &optional abortfunc hookvar) "\305\301 #\210\305\302\n#\210\305\303 \206 \306#\210\305\304\f\206 \307#\207" [symbol composefunc sendfunc abortfunc hookvar put kill-buffer mail-send-hook] 4 (#$ . 128203)])
#@554 Set MAP as a temporary keymap taking precedence over most other keymaps.
Note that this does NOT take precedence over the "overriding" maps
`overriding-terminal-local-map' and `overriding-local-map' (or the
`keymap' text property). Unlike those maps, if no match for a key is
found in MAP, the normal key lookup sequence then continues.
Normally, MAP is used only once. If the optional argument
KEEP-PRED is t, MAP stays active if a key from MAP is used.
KEEP-PRED can also be a function of no arguments: if it returns
non-nil then MAP stays active.
(defalias 'set-temporary-overlay-map #[(map &optional keep-pred) "\306\307!\306\310!\211\nBC\311\312\313\f\204 \312\2020 \f\314=\203+ \315\316\317\320\nD\321BBE\2020 \322\320\fDD\323\320 D\324BB\325\326\320DE\327\330\331\320 D\332BBE\257E \211L\210
M\210\333\334\"\210 B\211,\207" [clearfunsym overlaysym map alist keep-pred clearfun make-symbol "clear-temporary-overlay-map" "t" lambda nil unless t eq this-command lookup-key quote ((this-command-keys-vector)) funcall set (nil) remove-hook 'pre-command-hook setq emulation-mode-map-alists delq (emulation-mode-map-alists) add-hook pre-command-hook] 12 (#$ . 129781)])
#@533 Report progress of an operation in the echo area.
REPORTER should be the result of a call to `make-progress-reporter'.
If REPORTER is a numerical progress reporter---i.e. if it was
made using non-nil MIN-VALUE and MAX-VALUE arguments to
`make-progress-reporter'---then VALUE should be a number between
MIN-VALUE and MAX-VALUE.
If REPORTER is a non-numerical reporter, VALUE should be nil.
This function is relatively inexpensive. If the change since
last update is too small or insufficient time has passed, it does
nothing.
(defalias 'progress-reporter-update #[(reporter &optional value) "\247\203\f @Y\205 \302 \"\207" [value reporter progress-reporter-do-update] 3 (#$ . 130974)])
(put 'progress-reporter-update 'byte-optimizer 'byte-compile-inline-expand)
#@1200 Return progress reporter object for use with `progress-reporter-update'.
MESSAGE is shown in the echo area, with a status indicator
appended to the end. When you call `progress-reporter-done', the
word "done" is printed after the MESSAGE. You can change the
MESSAGE of an existing progress reporter by calling
`progress-reporter-force-update'.
MIN-VALUE and MAX-VALUE, if non-nil, are starting (0% complete)
and final (100% complete) states of operation; the latter should
be larger. In this case, the status message shows the percentage
progress.
If MIN-VALUE and/or MAX-VALUE is omitted or nil, the status
message shows a "spinning", non-numeric indicator.
Optional CURRENT-VALUE is the initial progress; the default is
MIN-VALUE.
Optional MIN-CHANGE is the minimal change in percents to report;
the default is 1%.
CURRENT-VALUE and MIN-CHANGE do not have any effect if MIN-VALUE
and/or MAX-VALUE are nil.
Optional MIN-TIME specifies the minimum interval time between
echo area updates (default is 0.2 seconds.) If the function
`float-time' is not present, time is not tracked at all. If the
OS is not capable of measuring fractions of seconds, this
parameter is effectively rounded up.
(defalias 'make-progress-reporter #[(message &optional min-value max-value current-value min-change min-time) "\306\307\"\203 \310P \204 \311\n\206 \312\313\314\315!\205% \316Y\205% \315 \n \f\2034 \f\317^\320]\2025 \320 &B\211 \206A \n \247\203R
@Y\205W \321
\"*\210
)\207" [message min-time min-value max-value min-change reporter string-match "[[:alnum:]]\\'" "..." 0.2 0 vector fboundp float-time 0.02 50 1 progress-reporter-do-update current-value value] 9 (#$ . 131755)])
#@201 Report progress of an operation in the echo area unconditionally.
The first two arguments are the same as in `progress-reporter-update'.
NEW-MESSAGE, if non-nil, sets a new message for the reporter.
(defalias 'progress-reporter-force-update #[(reporter &optional value new-message) "A\n\203\f \304\nI\210 \305H\203 \305\306 I\210\307 \")\207" [reporter parameters new-message value 3 0 float-time progress-reporter-do-update] 3 (#$ . 133460)])
#@51 Characters to use for pulsing progress reporters.
(defvar progress-reporter--pulse-characters ["-" "\\" "|" "/"] (#$ . 133917))
(defalias 'progress-reporter-do-update #[(reporter value) "A\211\306H \307H \310H \311H \312 \n?\206+ \nY\205+ \306\n \313H\\I \203\224 \f\203\224 \f Z\314\245 \f U\203F \306\202O \315 Z\245! \203` \316H\202a \307\\_\\\f^\240\210\250\203w \317@!\240\210\205\220 \306V\203\214 \320\321
#\202\220 \320\322
\"*\202\263 \205\263 \323@T\316\"\324 \240\210\320\325
H#*.\207" [reporter parameters update-time min-value max-value text 0 1 2 3 float-time 5 100.0 truncate 4 ceiling message "%s%d%%" "%s" mod nil "%s %s" current-time enough-time-passed one-percent value percentage message-log-max index progress-reporter--pulse-characters] 6])
#@64 Print reporter's message followed by word "done" in echo area.
(defalias 'progress-reporter-done #[(reporter) "\301\302A\303H\"\207" [reporter message "%sdone" 3] 4 (#$ . 134737)])
#@530 Loop a certain number of times and report progress in the echo area.
Evaluate BODY with VAR bound to successive integers running from
0, inclusive, to COUNT, exclusive. Then evaluate RESULT to get
the return value (nil if RESULT is omitted).
At each iteration MESSAGE followed by progress percentage is
printed in the echo area. After the loop is finished, MESSAGE
followed by word "done" is printed. This macro is a
convenience wrapper around `make-progress-reporter' and friends.
(fn (VAR COUNT [RESULT]) MESSAGE BODY...)
(defalias 'dotimes-with-progress-reporter '(macro . #[(spec message &rest body) "\306\307!\306\310!\311A@ \312\f D@\nD \313
\n FDE\314\315@\fE\316\317 \320@\321@DEEC\"BB\322 D\323AA,BBBBB\207" [spec end start temp2 temp message make-symbol "--dotimes-temp--" "--dotimes-temp2--" 0 let make-progress-reporter while < append progress-reporter-update setq 1+ progress-reporter-done nil body] 12 (#$ . 134926)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put dotimes-with-progress-reporter lisp-indent-function 2 edebug-form-spec ((symbolp form &optional form) form body)] 4)
#@122 Specify the string used to separate the version elements.
Usually the separator is ".", but it can be any other string.
(defconst version-separator "." (#$ . 136060))
#@890 Specify association between non-numeric version and its priority.
This association is used to handle version string like "1.0pre2",
"0.9alpha1", etc. It's used by `version-to-list' (which see) to convert the
non-numeric part of a version string to an integer. For example:
String Version Integer List Version
"1.0pre2" (1 0 -1 2)
"1.0PRE2" (1 0 -1 2)
"22.8beta3" (22 8 -2 3)
"22.8 Beta3" (22 8 -2 3)
"0.9alpha1" (0 9 -3 1)
"0.9AlphA1" (0 9 -3 1)
"0.9 alpha" (0 9 -3)
Each element has the following form:
(REGEXP . PRIORITY)
Where:
REGEXP regexp used to match non-numeric part of a version string.
It should begin with the `^' anchor and end with a `$' to
prevent false hits. Letter-case is ignored while matching
REGEXP.
PRIORITY a negative integer specifying non-numeric priority of REGEXP.
(defconst version-regexp-alist '(("^[-_+ ]?alpha$" . -3) ("^[-_+]$" . -3) ("^[-_+ ]cvs$" . -3) ("^[-_+ ]?beta$" . -2) ("^[-_+ ]?\\(pre\\|rcc\\)$" . -1)) (#$ . 136235))
#@981 Convert version string VER into a list of integers.
The version syntax is given by the following EBNF:
VERSION ::= NUMBER ( SEPARATOR NUMBER )*.
NUMBER ::= (0|1|2|3|4|5|6|7|8|9)+.
SEPARATOR ::= `version-separator' (which see)
| `version-regexp-alist' (which see).
The NUMBER part is optional if SEPARATOR is a match for an element
in `version-regexp-alist'.
Examples of valid version syntax:
1.0pre2 1.0.7.5 22.8beta3 0.9alpha1 6.9.30Beta
Examples of invalid version syntax:
1.0prepre2 1.0..7.5 22.8X3 alpha3.2 .5
Examples of version conversion:
Version String Version as a List of Integers
"1.0.7.5" (1 0 7 5)
"1.0pre2" (1 0 -1 2)
"1.0PRE2" (1 0 -1 2)
"22.8beta3" (22 8 -2 3)
"22.8Beta3" (22 8 -2 3)
"0.9alpha1" (0 9 -3 1)
"0.9AlphA1" (0 9 -3 1)
"0.9alpha" (0 9 -3)
See documentation for `version-separator' and `version-regexp-alist'.
(defalias 'version-to-list #[(ver) ";\203\f G\306V\204 \307\310\"\210G GY\203' \306 GO \230\203' \311P\312 \313\216\306\314\315\211\211 \316\317#\211\203\310 \fU\203\310 \320\306\225O!
B\306\225\316\321#\211\2038 \fU\2038 \306\225O\306\225\f \230\2048 \211\203\227 \316 \211 @@)\f\"\204\227 A\211\204\203 \203\250 \211 @A)
B\2028 \316\322\f\"\203\300 \323\324\325\f\"\227\306H\326\327#
B\2028 \307\330\"\210\2028
\204\323 \307\330\"\202\325
\237.\207" [ver version-separator save-match-data-internal al s lst 0 error "Invalid version string: '%s'" "0" match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) t nil string-match "[0-9]+" string-to-number "[^0-9]+" "^[-_+ ]?\\([a-zA-Z]\\)$" - match-string 1 97 -1 "Invalid version syntax: '%s'" case-fold-search i version-regexp-alist x] 6 (#$ . 137299)])
#@336 Return t if L1, a list specification of a version, is lower than L2.
Note that a version specified by the list (1) is equal to (1 0),
(1 0 0), (1 0 0 0), etc. That is, the trailing zeros are insignificant.
Also, a version given by the list (1) is higher than (1 -1), which in
turn is higher than (1 -2), which is higher than (1 -3).
(defalias 'version-list-< #[(l1 l2) "\203 \203 @ @U\203 A A\202 \203' \203' @ @W\207\2041 \2041 \302\207\203; \303!\304W\207\304\303 !W\207" [l1 l2 nil version-list-not-zero 0] 3 (#$ . 139186)])
#@334 Return t if L1, a list specification of a version, is equal to L2.
Note that a version specified by the list (1) is equal to (1 0),
(1 0 0), (1 0 0 0), etc. That is, the trailing zeros are insignificant.
Also, a version given by the list (1) is higher than (1 -1), which in
turn is higher than (1 -2), which is higher than (1 -3).
(defalias 'version-list-= #[(l1 l2) "\203 \203 @ @U\203 A A\202 \203# \203# \302\207\204, ?\206; \2036 \303\304!!\207\303\304 !!\207" [l1 l2 nil zerop version-list-not-zero] 3 (#$ . 139740)])
#@304 Return t if L1, a list specification of a version, is lower or equal to L2.
Note that integer list (1) is equal to (1 0), (1 0 0), (1 0 0 0),
etc. That is, the trailing zeroes are insignificant. Also, integer
list (1) is greater than (1 -1) which is greater than (1 -2)
which is greater than (1 -3).
(defalias 'version-list-<= #[(l1 l2) "\203 \203 @ @U\203 A A\202 \203' \203' @ @W\207\2040 ?\206? \203: \302!\303X\207\303\302 !X\207" [l1 l2 version-list-not-zero 0] 3 (#$ . 140288)])
#@131 Return the first non-zero element of LST, which is a list of integers.
If all LST elements are zeros or LST is nil, return zero.
(defalias 'version-list-not-zero #[(lst) "\203 \301@!\203 A\211\204 \203 @\207\302\207" [lst zerop 0] 3 (#$ . 140800)])
#@346 Return t if version V1 is lower (older) than V2.
Note that version string "1" is equal to "1.0", "1.0.0", "1.0.0.0",
etc. That is, the trailing ".0"s are insignificant. Also, version
string "1" is higher (newer) than "1pre", which is higher than "1beta",
which is higher than "1alpha". Also, "-CVS" and "-NNN" are treated
as alpha versions.
(defalias 'version< #[(v1 v2) "\302\303!\303 !\"\207" [v1 v2 version-list-< version-to-list] 4 (#$ . 141067)])
#@358 Return t if version V1 is lower (older) than or equal to V2.
Note that version string "1" is equal to "1.0", "1.0.0", "1.0.0.0",
etc. That is, the trailing ".0"s are insignificant. Also, version
string "1" is higher (newer) than "1pre", which is higher than "1beta",
which is higher than "1alpha". Also, "-CVS" and "-NNN" are treated
as alpha versions.
(defalias 'version<= #[(v1 v2) "\302\303!\303 !\"\207" [v1 v2 version-list-<= version-to-list] 4 (#$ . 141531)])
#@336 Return t if version V1 is equal to V2.
Note that version string "1" is equal to "1.0", "1.0.0", "1.0.0.0",
etc. That is, the trailing ".0"s are insignificant. Also, version
string "1" is higher (newer) than "1pre", which is higher than "1beta",
which is higher than "1alpha". Also, "-CVS" and "-NNN" are treated
as alpha versions.
(defalias 'version= #[(v1 v2) "\302\303!\303 !\"\207" [v1 v2 version-list-= version-to-list] 4 (#$ . 142009)])
#@22 Separator for menus.
(defconst menu-bar-separator '("--") (#$ . 142462))
(byte-code "\300\301\302\303 !!@!\203 \304\305!\210\300\207" [hash-table-p read-from-string prin1-to-string make-hash-table provide hashtable-print-readable] 4)