ikan Uploader :
Directory : /usr/share/emacs/25.2/lisp/emacs-lisp/
Upload File : |
| Current File : //usr/share/emacs/25.2/lisp/emacs-lisp/cl-generic.elc |
;ELC
;;; Compiled
;;; in Emacs version 25.2
;;; with all optimizations.
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(byte-code "\301\302!B\301\207" [package--builtin-versions purecopy (cl-generic 1 0)] 2)
(defalias 'cl--generic-generalizer-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-generalizer-p (declare (side-effect-free error-free)) (and (vectorp cl-x) (>= (length cl-x) 5) (memq (aref cl-x 0) cl-struct-cl--generic-generalizer-tags) t)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'cl--generic-generalizer-p 'compiler-macro 'cl--generic-generalizer-p--cmacro)
(defalias 'cl--generic-generalizer-p #[257 "\301!\205 \211G\302Y\205 \211\303H>\205 \304\207" [cl-struct-cl--generic-generalizer-tags vectorp 5 0 t] 3 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\305\306\301#\207" [function-put cl--generic-generalizer-p side-effect-free error-free put cl--generic-generalizer cl-deftype-satisfies] 4)
(defalias 'cl--generic-generalizer-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-generalizer-name (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-cl--generic-generalizer-tags)) (signal 'wrong-type-argument (list 'cl--generic-generalizer cl-x))) (aref cl-x 1)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'cl--generic-generalizer-name 'compiler-macro 'cl--generic-generalizer-name--cmacro)
(defalias 'cl--generic-generalizer-name #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-generalizer-tags 0 signal wrong-type-argument cl--generic-generalizer 1] 5 "\n\n(fn CL-X)"])
(function-put 'cl--generic-generalizer-name 'side-effect-free t)
(defalias 'cl--generic-generalizer-priority--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-generalizer-priority (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-cl--generic-generalizer-tags)) (signal 'wrong-type-argument (list 'cl--generic-generalizer cl-x))) (aref cl-x 2)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'cl--generic-generalizer-priority 'compiler-macro 'cl--generic-generalizer-priority--cmacro)
(defalias 'cl--generic-generalizer-priority #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-generalizer-tags 0 signal wrong-type-argument cl--generic-generalizer 2] 5 "\n\n(fn CL-X)"])
(function-put 'cl--generic-generalizer-priority 'side-effect-free t)
(defalias 'cl--generic-generalizer-tagcode-function--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-generalizer-tagcode-function (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-cl--generic-generalizer-tags)) (signal 'wrong-type-argument (list 'cl--generic-generalizer cl-x))) (aref cl-x 3)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'cl--generic-generalizer-tagcode-function 'compiler-macro 'cl--generic-generalizer-tagcode-function--cmacro)
(defalias 'cl--generic-generalizer-tagcode-function #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-generalizer-tags 0 signal wrong-type-argument cl--generic-generalizer 3] 5 "\n\n(fn CL-X)"])
(function-put 'cl--generic-generalizer-tagcode-function 'side-effect-free t)
(defalias 'cl--generic-generalizer-specializers-function--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-generalizer-specializers-function (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-cl--generic-generalizer-tags)) (signal 'wrong-type-argument (list 'cl--generic-generalizer cl-x))) (aref cl-x 4)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'cl--generic-generalizer-specializers-function 'compiler-macro 'cl--generic-generalizer-specializers-function--cmacro)
(defalias 'cl--generic-generalizer-specializers-function #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-generalizer-tags 0 signal wrong-type-argument cl--generic-generalizer 4] 5 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [function-put cl--generic-generalizer-specializers-function side-effect-free t defalias copy-cl--generic-generalizer copy-sequence] 4)
(defalias 'cl-generic-make-generalizer--cmacro #[1285 "\300\301\302\303\211\211 & \207" [cl--defsubst-expand (name priority tagcode-function specializers-function) (cl-block cl-generic-make-generalizer "Constructor for objects of type `cl--generic-generalizer'." (declare (side-effect-free t)) (vector 'cl-struct-cl--generic-generalizer name priority tagcode-function specializers-function)) nil] 15 "\n\n(fn CL-WHOLE-ARG NAME PRIORITY TAGCODE-FUNCTION SPECIALIZERS-FUNCTION)"])
(put 'cl-generic-make-generalizer 'compiler-macro 'cl-generic-make-generalizer--cmacro)
#@119 Constructor for objects of type `cl--generic-generalizer'.
(fn NAME PRIORITY TAGCODE-FUNCTION SPECIALIZERS-FUNCTION)
(defalias 'cl-generic-make-generalizer #[1028 "\300\301%\207" [vector cl-struct-cl--generic-generalizer] 10 (#$ . 5138)])
(byte-code "\300\301\302\303#\210\304\305\306\307\306\211\310\311\312\303& \207" [function-put cl-generic-make-generalizer side-effect-free t cl-struct-define cl--generic-generalizer nil cl-structure-object ((cl-tag-slot) (name nil :type string) (priority nil :type integer) (tagcode-function) (specializers-function)) cl-struct-cl--generic-generalizer-tags cl-struct-cl--generic-generalizer] 10)
#@650 Define a new kind of generalizer.
NAME is the name of the variable that will hold it.
PRIORITY defines which generalizer takes precedence.
The catch-all generalizer has priority 0.
Then `eql' generalizer has priority 100.
TAGCODE-FUNCTION takes as first argument a varname and should return
a chunk of code that computes the tag of the value held in that variable.
Further arguments are reserved for future use.
SPECIALIZERS-FUNCTION takes as first argument a tag value TAG
and should return a list of specializers that match TAG.
Further arguments are reserved for future use.
(fn NAME PRIORITY TAGCODE-FUNCTION SPECIALIZERS-FUNCTION)
(defalias 'cl-generic-define-generalizer '(macro . #[1028 "\300\301\302D\257E\207" [defconst cl-generic-make-generalizer quote] 11 (#$ . 5786)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-generic-define-generalizer lisp-indent-function 1 put edebug-form-spec (symbolp body)] 4)
(defconst cl--generic-t-generalizer (byte-code "\300\301\302\303\304\305%\207" [#[385 "\300\207" [nil] 3 "\n\n(fn NAME &rest _)"] #[385 "\300\207" [(t)] 3 "\n\n(fn TAG &rest _)"] vector cl-struct-cl--generic-generalizer cl--generic-t-generalizer 0] 8))
(defalias 'cl--struct-cl--generic-method-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--struct-cl--generic-method-p (declare (side-effect-free error-free)) (and (vectorp cl-x) (>= (length cl-x) 5) (memq (aref cl-x 0) cl-struct-cl--generic-method-tags) t)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'cl--struct-cl--generic-method-p 'compiler-macro 'cl--struct-cl--generic-method-p--cmacro)
(defalias 'cl--struct-cl--generic-method-p #[257 "\301!\205 \211G\302Y\205 \211\303H>\205 \304\207" [cl-struct-cl--generic-method-tags vectorp 5 0 t] 3 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\305\306\301#\207" [function-put cl--struct-cl--generic-method-p side-effect-free error-free put cl--generic-method cl-deftype-satisfies] 4)
(defalias 'cl--generic-method-specializers--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-method-specializers (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-cl--generic-method-tags)) (signal 'wrong-type-argument (list 'cl--generic-method cl-x))) (aref cl-x 1)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'cl--generic-method-specializers 'compiler-macro 'cl--generic-method-specializers--cmacro)
(defalias 'cl--generic-method-specializers #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-method-tags 0 signal wrong-type-argument cl--generic-method 1] 5 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl--generic-method-specializers side-effect-free t put gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" cl--generic-method-specializers] 5 "\n\n(fn CL-DO CL-X)"]] 4)
(defalias 'cl--generic-method-qualifiers--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-method-qualifiers (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-cl--generic-method-tags)) (signal 'wrong-type-argument (list 'cl--generic-method cl-x))) (aref cl-x 2)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'cl--generic-method-qualifiers 'compiler-macro 'cl--generic-method-qualifiers--cmacro)
(defalias 'cl--generic-method-qualifiers #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-method-tags 0 signal wrong-type-argument cl--generic-method 2] 5 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl--generic-method-qualifiers side-effect-free t put gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" cl--generic-method-qualifiers] 5 "\n\n(fn CL-DO CL-X)"]] 4)
(defalias 'cl--generic-method-uses-cnm--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-method-uses-cnm (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-cl--generic-method-tags)) (signal 'wrong-type-argument (list 'cl--generic-method cl-x))) (aref cl-x 3)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'cl--generic-method-uses-cnm 'compiler-macro 'cl--generic-method-uses-cnm--cmacro)
(defalias 'cl--generic-method-uses-cnm #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-method-tags 0 signal wrong-type-argument cl--generic-method 3] 5 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl--generic-method-uses-cnm side-effect-free t put gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" cl--generic-method-uses-cnm] 5 "\n\n(fn CL-DO CL-X)"]] 4)
(defalias 'cl--generic-method-function--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-method-function (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-cl--generic-method-tags)) (signal 'wrong-type-argument (list 'cl--generic-method cl-x))) (aref cl-x 4)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'cl--generic-method-function 'compiler-macro 'cl--generic-method-function--cmacro)
(defalias 'cl--generic-method-function #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-method-tags 0 signal wrong-type-argument cl--generic-method 4] 5 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\301\305\306#\210\307\310\311\"\207" [function-put cl--generic-method-function side-effect-free t put gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" cl--generic-method-function] 5 "\n\n(fn CL-DO CL-X)"] defalias copy-cl--generic-method copy-sequence] 4)
(defalias 'cl--generic-make-method--cmacro #[1285 "\300\301\302\303\211\211 & \207" [cl--defsubst-expand (specializers qualifiers uses-cnm function) (cl-block cl--generic-make-method "Constructor for objects of type `cl--generic-method'." (declare (side-effect-free t)) (vector 'cl-struct-cl--generic-method specializers qualifiers uses-cnm function)) nil] 15 "\n\n(fn CL-WHOLE-ARG SPECIALIZERS QUALIFIERS USES-CNM FUNCTION)"])
(put 'cl--generic-make-method 'compiler-macro 'cl--generic-make-method--cmacro)
#@103 Constructor for objects of type `cl--generic-method'.
(fn SPECIALIZERS QUALIFIERS USES-CNM FUNCTION)
(defalias 'cl--generic-make-method #[1028 "\300\301%\207" [vector cl-struct-cl--generic-method] 10 (#$ . 12059)])
(byte-code "\300\301\302\303#\210\304\305\306\307\306\211\310\311\312\303& \207" [function-put cl--generic-make-method side-effect-free t cl-struct-define cl--generic-method nil cl-structure-object ((cl-tag-slot) (specializers nil :read-only t :type list) (qualifiers nil :read-only t :type (list-of atom)) (uses-cnm nil :read-only t :type boolean) (function nil :read-only t :type function)) cl-struct-cl--generic-method-tags cl-struct-cl--generic-method] 10)
(defalias 'cl--struct-cl--generic-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--struct-cl--generic-p (declare (side-effect-free error-free)) (and (vectorp cl-x) (>= (length cl-x) 5) (memq (aref cl-x 0) cl-struct-cl--generic-tags) t)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'cl--struct-cl--generic-p 'compiler-macro 'cl--struct-cl--generic-p--cmacro)
(defalias 'cl--struct-cl--generic-p #[257 "\301!\205 \211G\302Y\205 \211\303H>\205 \304\207" [cl-struct-cl--generic-tags vectorp 5 0 t] 3 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\305\306\301#\207" [function-put cl--struct-cl--generic-p side-effect-free error-free put cl--generic cl-deftype-satisfies] 4)
(defalias 'cl--generic-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-name (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-cl--generic-tags)) (signal 'wrong-type-argument (list 'cl--generic cl-x))) (aref cl-x 1)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'cl--generic-name 'compiler-macro 'cl--generic-name--cmacro)
(defalias 'cl--generic-name #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-tags 0 signal wrong-type-argument cl--generic 1] 5 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl--generic-name side-effect-free t put gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" cl--generic-name] 5 "\n\n(fn CL-DO CL-X)"]] 4)
(defalias 'cl--generic-dispatches--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-dispatches (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-cl--generic-tags)) (signal 'wrong-type-argument (list 'cl--generic cl-x))) (aref cl-x 2)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'cl--generic-dispatches 'compiler-macro 'cl--generic-dispatches--cmacro)
(defalias 'cl--generic-dispatches #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-tags 0 signal wrong-type-argument cl--generic 2] 5 "\n\n(fn CL-X)"])
(function-put 'cl--generic-dispatches 'side-effect-free t)
(defalias 'cl--generic-method-table--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-method-table (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-cl--generic-tags)) (signal 'wrong-type-argument (list 'cl--generic cl-x))) (aref cl-x 3)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'cl--generic-method-table 'compiler-macro 'cl--generic-method-table--cmacro)
(defalias 'cl--generic-method-table #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-tags 0 signal wrong-type-argument cl--generic 3] 5 "\n\n(fn CL-X)"])
(function-put 'cl--generic-method-table 'side-effect-free t)
(defalias 'cl--generic-options--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-options (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-cl--generic-tags)) (signal 'wrong-type-argument (list 'cl--generic cl-x))) (aref cl-x 4)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'cl--generic-options 'compiler-macro 'cl--generic-options--cmacro)
(defalias 'cl--generic-options #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-tags 0 signal wrong-type-argument cl--generic 4] 5 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [function-put cl--generic-options side-effect-free t defalias copy-cl--generic copy-sequence] 4)
(defalias 'cl--generic-make--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (name) (cl-block cl--generic-make "Constructor for objects of type `cl--generic'." (declare (side-effect-free t)) (vector 'cl-struct-cl--generic name nil nil nil)) nil] 9 "\n\n(fn CL-WHOLE-ARG NAME)"])
(put 'cl--generic-make 'compiler-macro 'cl--generic-make--cmacro)
#@59 Constructor for objects of type `cl--generic'.
(fn NAME)
(defalias 'cl--generic-make #[257 "\300\301\302\211\211%\207" [vector cl-struct-cl--generic nil] 7 (#$ . 16721)])
(byte-code "\300\301\302\303#\210\304\305\306\307\306\211\310\311\312\303& \207" [function-put cl--generic-make side-effect-free t cl-struct-define cl--generic nil cl-structure-object ((cl-tag-slot) (name nil :type symbol :read-only t) (dispatches nil :type (list-of (cons natnum (list-of generalizers)))) (method-table nil :type (list-of cl--generic-method)) (options nil :type list)) cl-struct-cl--generic-tags cl-struct-cl--generic] 10)
#@67 Return the options of the generic function GENERIC.
(fn GENERIC)
(defalias 'cl-generic-function-options #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-tags 0 signal wrong-type-argument cl--generic 4] 5 (#$ . 17340)])
(defalias 'cl--generic '(macro . #[257 "\300\301BB\207" [get ('cl--generic)] 4 "\n\n(fn NAME)"]))
(defalias 'cl-generic-ensure-function #[513 "\301\302N\211\262\204\" \303!\203\" \204\" K9\203\" K\262\202 \303!\203F K\211\242\304=\262\204F \305!\203= \204F \204F \306\307\"\210\203h \310H>\204Z \311\312\302D\"\210\313H=\204\201 \314\315!\210\202\201 \316\302\317\320 \301\211\211%\211\262#\266\321\322!\"\210\207" [cl-struct-cl--generic-tags nil cl--generic fboundp autoload functionp error "%s is already defined as something else than a generic function" 0 signal wrong-type-argument 1 cl--assertion-failed (eq name (cl--generic-name generic)) put vector cl-struct-cl--generic defalias cl--generic-make-function] 14 "\n\n(fn NAME &optional NOERROR)"])
#@619 Create a generic function NAME.
DOC-STRING is the base documentation for this class. A generic
function has no body, as its purpose is to decide which method body
is appropriate to use. Specific methods are defined with `cl-defmethod'.
With this implementation the ARGS are currently ignored.
OPTIONS-AND-METHODS currently understands:
- (:documentation DOCSTRING)
- (declare DECLARATIONS)
- (:argument-precedence-order &rest ARGS)
- (:method [QUALIFIERS...] ARGS &rest BODY)
DEFAULT-BODY, if present, is used as the body of a default method.
(fn NAME ARGS [DOC-STRING] [OPTIONS-AND-METHODS...] &rest DEFAULT-BODY)
(defalias 'cl-defgeneric '(macro . #[642 "C\242;\205 \211A\262\242\300\211\211\211@\242\262\301!\204$ \211\302=\203\203 \211\303=\203C \2035 \304\305\242\"\210\211A\262\242A@\262\202 \211\302=\203` \203T \304\306\242\"\210\211A\262\242\262\202 \211\307=\203u \211A\262\242AB\262\202 \211A\262\242B\262\202 \203\221 BB\262\242\242\310=\203\247 \311\312!\210\313\242A@!\240\210\314\315\316\317\320\321\322\323
\"\324\"\325\326%A\"\327\330\n\242D\331\330\f\242D\330D\330\n\237DF\332 \"FC\316\317\320\333\322\323!\334\"\335\336%\237\"#B\266\205\207" [nil keywordp declare :documentation error "Multiple doc strings for %S" "Multiple `declare' for %S" :method setf require gv gv-setter progn append mapcar make-byte-code 257 "\211@\n\236A\211\203 \303@\300\242\301A$\202 \304\305@\300\242#\210\306\207" vconcat vector [defun-declarations-alist apply message "Warning: Unknown defun property `%S' in %S" nil] 7 "\n\n(fn DECLARATION)" defalias quote cl-generic-define help-add-fundoc-usage "\301\300\242BB\207" [cl-defmethod] 4 "\n\n(fn METHOD)"] 20 (#$ . 18386)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [function-put cl-defgeneric lisp-indent-function 2 doc-string-elt 3] 4)
(defalias 'cl-generic-define #[771 "\301\302\"\303!\211@\211\304\305\"\306\236\307 !\204G \310H>\204) \311\312\313D\"\210\211\314\315I\266\310H>\204@ \311\312\313D\"\210\211\316\315I\266\211\203\250 \211A\211\203\247 \211@\211>\211\204_ \317\320\"\210GGZ \310H>\204u \311\312\313\fD\"\210 \314H\236\206\201 C \310H>\204\222 \311\312\313D\"\210 \211\314\321\"BI\266A\266\202\202M \210\310H>\204\270 \311\312\313D\"\210\211\322 I\266\323!\266\202\262\207" [cl-struct-cl--generic-tags cl-generic-ensure-function noerror cl--generic-split-args mapcar car :argument-precedence-order fboundp 0 signal wrong-type-argument cl--generic 2 nil 3 error "%S is not a mandatory argument" delq 4 cl--generic-make-function] 22 "\n\n(fn NAME ARGS OPTIONS)"])
#@132 List of (VAR . TYPE) where TYPE is var's specializer.
This macro can only be used within the lexical scope of a cl-generic method.
(defalias 'cl-generic-current-method-specializers '(macro . #[0 "\300\301!\207" [error "cl-generic-current-method-specializers used outside of a method"] 2 (#$ . 21062)]))
#@194 Define a special kind of context named NAME.
Whenever a context specializer of the form (NAME . ARGS) appears,
the specializer used will be the one returned by BODY.
(fn NAME ARGS &rest BODY)
(defalias 'cl-generic-define-context-rewriter '(macro . #[642 "\300\301\302D\303\304BBFD\207" [eval-and-compile put quote 'cl-generic--context-rewriter lambda] 10 (#$ . 21372)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [put cl-generic-define-context-rewriter edebug-form-spec (&define name lambda-list def-body) function-put lisp-indent-function defun] 4)
#@65 Check which of the symbols VARS appear in SEXP.
(fn VARS SEXP)
(defalias 'cl--generic-fgrep #[514 "\300:\203+ \301\211A\262\242\"\211\203' \211@\211>\204 \211B\262A\266\202\202 \210\202 >\203< >\204< B\262\211\207" [nil cl--generic-fgrep] 7 (#$ . 21948)])
#@45 Return (SPEC-ARGS . PLAIN-ARGS).
(fn ARGS)
(defalias 'cl--generic-split-args #[257 "\300\211\301\211\203\231 \211@\211\302>\203 \300\262\211\202\216 \211\303=\203, \204% \304\305!\210\306\262\300\202\216 \2044 \211\202\216 \306=\203k \211:\204D \304\307\"\210\211@\2119\205N \211\310N\211\203Y \311A\"\262\266\303@BA@BB\262\300\202\216 \211:\203\206 \211@A\211\211@BB\262\262\266\202\202\216 \211\301BB\262\211B\262A\266\202\202 \210\237\312\300\"\237B\207" [nil t (&key &rest &optional) &context error "&context not immediately after mandatory args" context "Invalid &context arg: %S" cl-generic--context-rewriter apply delq] 12 (#$ . 22229)])
#@77 Make the lambda expression for a method with ARGS and BODY.
(fn ARGS BODY)
(defalias 'cl--generic-lambda #[514 "\301!\211@A\211\302\303BBD\304\305\306\307\310\311!\312\"\313$BB\314\315!\210\316\"\211:\203\211@\211\317=\203\370 A\211:\203\354 \211@\211:\203\340 \211@\211\303=\203\324 A\211:\203\310 \211@AA\211\204\273 \320!\321\322!\321\323!\324\325\326D\327DDABB\"\330D\"\211??\317\303\331\205\213 C\n\"\331 @>\204\237 \202\256 \332 \303\333\334DEDC EC\"BBDB\266\205\266\202\202\303 \335\336\"\262\266\203\202\317 \335\336\"\262\262\202\333 \335\336\"\262\262\202\347 \335\336\"\262\262\202\363 \335\336\"\262\262\202\377 \335\336\"\262\262\202 \211\335\336\"\262\262\266\202\266\202\207" [macroexpand-all-environment cl--generic-split-args cl-function lambda cl-generic-current-method-specializers make-byte-code 0 "\300\207" vconcat vector [] 1 require cl-lib macroexpand function macroexp-parse-body make-symbol "cl--cnm" "cl--nmp" macroexpand-all cl-flet cl-call-next-method cl-next-method-p cl--generic-fgrep append let nil cl--generic-isnot-nnm-p error "Unexpected macroexpansion result: %S"] 37 (#$ . 22912)])
#@1237 Define a new method for generic function NAME.
I.e. it defines the implementation of NAME to use for invocations where the
values of the dispatch arguments match the specified TYPEs.
The dispatch arguments have to be among the mandatory arguments, and
all methods of NAME have to use the same set of arguments for dispatch.
Each dispatch argument and TYPE are specified in ARGS where the corresponding
formal argument appears as (VAR TYPE) rather than just VAR.
The optional second argument QUALIFIER is a specifier that
modifies how the method is combined with other methods, including:
:before - Method will be called before the primary
:after - Method will be called after the primary
:around - Method will be called around everything else
The absence of QUALIFIER means this is a "primary" method.
TYPE can be one of the basic types (see the full list and their
hierarchy in `cl--generic-typeof-types'), CL struct type, or an
EIEIO class.
Other than that, TYPE can also be of the form `(eql VAL)' in
which case this method will be invoked when the argument is `eql'
to VAL, or `(head VAL)', in which case the argument is required
to be a cons with VAL as its head.
(fn NAME [QUALIFIER] ARGS &rest [DOCSTRING] BODY)
(defalias 'cl-defmethod '(macro . #[642 "\300<\204 B\262\211A\262\242\262\202 \242\301=\203( \302\303!\210\304A@!\262\305\"\211@A\211\306 \307N\205U \310\311!\203F \311\312!\205U \307N\313\314\f\315#\300\"\262\316 \317BB\320\321
D\321 \237D\321D \257F\266\202\266\203\207" [nil setf require gv gv-setter cl--generic-lambda progn byte-obsolete-info fboundp byte-compile-warning-enabled-p obsolete macroexp--warn-and-return macroexp--obsolete-warning "generic function" declare-function ("") cl-generic-define-method quote] 18 (#$ . 24111)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\306\301\307\310#\207" [function-put cl-defmethod doc-string-elt 3 lisp-indent-function 2 put edebug-form-spec (&define [&or name ("setf" :name setf name)] [&optional keywordp] list [&optional stringp] def-body)] 4)
(defalias 'cl--generic-member-method #[771 "\211\203> \211@\211\301H>\204 \302\303\304D\"\210\211\305H\232\2051 \211\301H>\204, \302\303\304D\"\210\211\306H\232?\262\203> \211A\262\202 \207" [cl-struct-cl--generic-method-tags 0 signal wrong-type-argument cl--generic-method 1 2] 8 "\n\n(fn SPECIALIZERS QUALIFIERS METHODS)"])
(defalias 'cl-generic-define-method #[1285 "\303!\304!\211@\211\305\306\"\307\310 \n\n%\311H>\204' \312\313\314D\"\210\315H\316\f#\311H>\204A \312\313\314\nD\"\210\317H\311\211\203\277 \211@\211@\242\320=\203[ \211@\202\\ \321A!\322\"\211\204\217 \321\323!B\262\311H>\204\201 \312\313\314D\"\210\211\317\nB\211\262 I\266\211\203\261 \211@\211A\235\204\252 \211\324AB\325\"\241\266A\266\202\202\220 \210T\262\266A\266\202\202H \210 \311H>\204\321 \312\313\314\fD\"\210 \211\315\204\341 B\202\364 \305\326\327\330\331\307
\f\"\332\"\315\333%\"I\266\334\n\311H>\204 \312\313\314
D\"\210\n\335HBB\211 \235\203 \202 \211 B\262\336\n!\337\211\340 \311H>\204;\312\313\314D\"\210 \335H\"*\262\266\206\262\207" [cl-struct-cl--generic-tags current-load-list purify-flag cl-generic-ensure-function cl--generic-split-args mapcar #[257 "\211@\242\300=\203 \207\211A\207" [&context] 3 "\n\n(fn SPEC-ARG)"] vector cl-struct-cl--generic-method 0 signal wrong-type-argument cl--generic 3 cl--generic-member-method 2 &context cl-generic-generalizers assoc t sort #[514 "\301H>\204 \302\303\304D\"\210\305H\301H>\204! \302\303\304D\"\210\305HV\207" [cl-struct-cl--generic-generalizer-tags 0 signal wrong-type-argument cl--generic-generalizer 2] 7 "\n\n(fn X Y)"] make-byte-code 257 "\211\301@=\203 \300\207\207" vconcat [] "\n\n(fn X)" cl-defmethod 1 cl--generic-make-function nil defalias] 28 "\n\n(fn NAME QUALIFIERS ARGS USES-CNM FUNCTION)"])
(defalias 'cl--generic-with-memoization '(macro . #[385 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [gv-get make-byte-code 514 "\301\302\300!\303!\203 \211\202 \304\305!\306!E=\203\" \211\202) \307DC\"\266\203E\207" vconcat vector [or macroexp-progn macroexp-const-p make-symbol "val" progn macroexp-let*] 10 "\n\n(fn GETTER SETTER)"] 10 "\n\n(fn PLACE &rest CODE)"]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl--generic-with-memoization lisp-indent-function 1 put edebug-form-spec t] 4)
(defvar cl--generic-dispatchers (make-hash-table :test 'equal))
(defalias 'cl--generic-get-dispatcher #[257 "\211\302\"\206\256 @A\303\304\305\"\304\306\"\307\310\311!@!\203' \312!\202( B\313\314\242\315=\203B \316ADC\262\314\262\317\262\317\211W\203c \211\320\321\322\323\324#\"!B\262\210\211T\262\202D \266\325\326\327\330\331\326\332 \333\"\330\334\335\302\336BB\337\340\341D\342\343A\203\220 \332B\202\223 @\257E\332\344\"BBEEEE!)\266\210\345#\210\211\262\207" [cl--generic-dispatchers lexical-binding gethash t mapcar #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\306!\207" [cl-struct-cl--generic-generalizer-tags 0 signal wrong-type-argument cl--generic-generalizer 3 arg] 5 "\n\n(fn GENERALIZER)"] #[257 "\301\302\303H>\204 \304\305\306D\"\210\307HD\303H>\204$ \304\305\306D\"\210\310H\311!E\207" [cl-struct-cl--generic-generalizer-tags funcall quote 0 signal wrong-type-argument cl--generic-generalizer 4 3 arg] 7 "\n\n(fn GENERALIZER)"] or macroexp-const-p last butlast (arg) nil &context arg 0 make-symbol format "arg%d" - 1 byte-compile lambda (generic dispatches-left methods) let ((method-cache (make-hash-table :test #'eql))) append (&rest args) apply cl--generic-with-memoization (method-cache) cl--generic-cache-miss generic quote dispatches-left methods (args) puthash] 30 "\n\n(fn DISPATCH)"])
(defalias 'cl--generic-make-function #[257 "\301\211\302H>\204 \303\304\305D\"\210\306H\302H>\204$ \303\304\305D\"\210\307H#\207" [cl-struct-cl--generic-tags cl--generic-make-next-function 0 signal wrong-type-argument cl--generic 2 3] 8 "\n\n(fn GENERIC)"])
(defalias 'cl--generic-make-next-function #[771 "\203 @A@\211?\206 \211\232\262\203 A\262\202 \211A\262\242\211\203* \2041 \301\"\202; \302!\211#\262\207" [cl--generic-t-generalizer cl--generic-build-combined-method cl--generic-get-dispatcher] 9 "\n\n(fn GENERIC DISPATCHES METHODS)"])
#@251 Table storing previously built combined-methods.
This is particularly useful when many different tags select the same set
of methods, since this table then allows us to share a single combined-method
for all those different tags in the method-cache.
(defvar cl--generic-combined-method-memoization (make-hash-table :test 'equal :weakness 'value) (#$ . 30550))
(define-error 'cl--generic-cyclic-definition "Cyclic definition: %S")
(defalias 'cl--generic-build-combined-method #[514 "\211\204 \302\"\207B\303\"\2066 \304B\305#\210\3061( \307\"0\202- \210\302\"\304#\210\211\262\266\202\211\305=\203X \310\311\312H >\204P \310\313\314D\"\210\315HC\"\202Y \211\207" [cl--generic-combined-method-memoization cl-struct-cl--generic-tags cl--generic-standard-method-combination gethash puthash :cl--generic--under-construction (cl--generic-cyclic-definition) cl-generic-combine-methods signal cl--generic-cyclic-definition 0 wrong-type-argument cl--generic 1] 9 "\n\n(fn GENERIC METHODS)"])
(defalias 'cl--generic-no-next-method-function #[514 "\300\301\302\303\304\"\305\"\306\307%\207" [make-byte-code 128 "\302\303\300\301$\207" vconcat vector [apply cl-no-next-method] 6 "\n\n(fn &rest ARGS)"] 9 "\n\n(fn GENERIC METHOD)"])
#@153 Return a function that calls METHOD.
FUN is the function that should be called when METHOD calls
`call-next-method'.
(fn GENERIC METHOD &optional FUN)
(defalias 'cl-generic-call-method #[770 "\301H>\204 \302\303\304D\"\210\305H\204( \301H>\204$ \302\303\304D\"\210\306H\207\301H>\2047 \302\303\304D\"\210\306H\206B \307\"\310\311\312\313\314\"\315\"\316\317%\207" [cl-struct-cl--generic-method-tags 0 signal wrong-type-argument cl--generic-method 3 4 cl--generic-no-next-method-function make-byte-code 128 "\302\300\303\304\305\306\307\301\"\310\"\311\312%#\207" vconcat vector [apply make-byte-code 128 "\302\300\206 \301\"\207" vconcat vector [apply] 4 "\n\n(fn &rest CNM-ARGS)"] 10 "\n\n(fn &rest ARGS)"] 12 (#$ . 31805)])
(defalias 'cl-method-qualifiers 'cl--generic-method-qualifiers)
(defalias 'cl--generic-standard-method-combination #[514 "\302\211\203n \211@\211\303H>\204 \304\305\306D\"\210\211\307H\211@\310=\203& \211AA\262\211\311\235\204F \312\313\303H >\204? \304\305\314\nD\"\210\315H#\210\211@\211\236AB\203Z \241\210\202e B\211\262B\262\266A\266\202\202 \210\211\204\203 \316\317\320\321\322!\323\"\324\325%\202\326\302\"\204\232 \316\317\320\321\322!\327\"\324\325%\202\302\316\330\331\321\322!\332\"\333\334%\335\336\337\340\"A!\"\335\337\341\"A\"\337\302\"A\211\203\330 \211@\342 #\262A\266\202\202\302 \210\211\204\341 \203\366 \316\317\343\321\322#\344\"\345\325%\262\210\337\346\"A\211\203\211@\342 #\262A\266\202\202\374 \210\266\204\207" [cl-struct-cl--generic-method-tags cl-struct-cl--generic-tags nil 0 signal wrong-type-argument cl--generic-method 2 :extra (nil (:after) (:before) (:around)) error "Unsupported qualifiers in function %S: %S" cl--generic 1 make-byte-code 128 "\301\302\300#\207" vconcat vector [apply cl-no-applicable-method] 5 "\n\n(fn &rest ARGS)" alist-get [apply cl-no-primary-method] 257 "\301\300\"\207" [cl-generic-call-method] 4 "\n\n(fn M)" mapcar reverse assoc :before :after cl-generic-call-method "\300\211\203 \211@\303\"\210A\266\202\202 \210\303\302\"\301\211\203+ \211@\303\"\210A\266\202\202 \210\207" [apply] 7 :around] 16 "\n\n(fn GENERIC METHODS)"])
#@87 Like `apply' but takes a cl-generic object rather than a function.
(fn GENERIC ARGS)
(defalias 'cl-generic-apply #[514 "\301\302H>\204 \303\304\305D\"\210\306H\"\207" [cl-struct-cl--generic-tags apply 0 signal wrong-type-argument cl--generic 1] 7 (#$ . 34037)])
(defalias 'cl--generic-arg-specializer #[514 "\211\250\203 \211\301H>\204 \302\303\304D\"\210\305H8\2023 \306\301H>\204. \302\303\304D\"\210\305H\"A\2067 \307\207" [cl-struct-cl--generic-method-tags 0 signal wrong-type-argument cl--generic-method 1 assoc t] 8 "\n\n(fn METHOD DISPATCH-ARG)"])
(defalias 'cl--generic-cache-miss #[1285 "\300\211\203% \211@\301\"\211\235\211\203 \211GBB\262\266A\266\202\202 \210\302\303\304\305\"\"\237\262\306#\207" [nil cl--generic-arg-specializer mapcar cdr sort car-less-than-car cl--generic-make-next-function] 12 "\n\n(fn GENERIC DISPATCH-ARG DISPATCHES-LEFT METHODS-LEFT TYPES)"])
(byte-code "\300\301\302\301\303\304#\305#\210\300\306\302\306\307\304#\310#\210\3111 \301\312!0\202! \210\304\204, \301\313M\210\306\314M\210\315\301\304\316\304\317%\210\315\306\304\320\304\321%\207" [defalias cl-generic-generalizers cl-generic-define (specializer) nil "Return a list of generalizers for a given SPECIALIZER.\nTo each kind of `specializer', corresponds a `generalizer' which describes\nhow to extract a \"tag\" from an object which will then let us check if this\nobject matches the specializer. A typical example of a \"tag\" would be the\ntype of an object. It's called a `generalizer' because it\ntakes a specific object and returns a more general approximation,\ndenoting a set of objects to which it belongs.\nA generalizer gives us the chunk of code which the\ndispatch function needs to use to extract the \"tag\" of an object, as well\nas a function which turns this tag into an ordered list of\n`specializers' that this object matches.\nThe code which extracts the tag should be as fast as possible.\nThe tags should be chosen according to the following rules:\n- The tags should not be too specific: similar objects which match the\n same list of specializers should ideally use the same (`eql') tag.\n This insures that the cached computation of the applicable\n methods for one object can be reused for other objects.\n- Corollary: objects which don't match any of the relevant specializers\n should ideally all use the same tag (typically nil).\n This insures that this cache does not grow unnecessarily large.\n- Two different generalizers G1 and G2 should not use the same tag\n unless they use it for the same set of objects. IOW, if G1.tag(X1) =\n G2.tag(X2) then G1.tag(X1) = G2.tag(X1) = G1.tag(X2) = G2.tag(X2).\n- If G1.priority > G2.priority and G1.tag(X1) = G1.tag(X2) and this tag is\n non-nil, then you have to make sure that the G2.tag(X1) = G2.tag(X2).\n This is because the method-cache is only indexed with the first non-nil\n tag (by order of decreasing priority).\n\n(fn SPECIALIZER)" cl-generic-combine-methods (generic methods) "Build the effective method made of METHODS.\nIt should return a function that expects the same arguments as the methods, and\n calls those methods in some appropriate order.\nGENERIC is the generic function (mostly used for its name).\nMETHODS is the list of the selected methods.\nThe METHODS list is sorted from most specific first to most generic last.\nThe function can use `cl-generic-call-method' to create functions that call those\nmethods.\n\n(fn GENERIC METHODS)" (error) t #[257 "\211\301=\205 C\207" [cl--generic-t-generalizer t] 3 "\n\n(fn SPECIALIZER)"] cl--generic-standard-method-combination cl-generic-define-method (specializer) #[257 "\211\301=\203 C\207\302\303\"\207" [cl--generic-t-generalizer t error "Unknown specializer %S"] 4 "Support for the catch-all t specializer.\n\n(fn SPECIALIZER)"] (generic methods) #[514 "\300\"\207" [cl--generic-standard-method-combination] 5 "Standard support for :after, :before, :around, and `:extra NAME' qualifiers.\n\n(fn GENERIC METHODS)"]] 6)
(defconst cl--generic-nnm-sample (byte-code "\300\301\211\"\207" [cl--generic-no-next-method-function t] 3))
(defconst cl--generic-cnm-sample (byte-code "\300\301\302\303\301\211\304\305%C\" \207" [cl--generic-build-combined-method nil vector cl-struct-cl--generic-method t identity] 8))
#@81 Return non-nil if CNM is the function that calls `cl-no-next-method'.
(fn CNM)
(defalias 'cl--generic-isnot-nnm-p #[257 "\3022\202 \303\"\204 \304\305!\210\306!\203G \211\307H\307H\211G\310\211W\203B \211\303H \"\203: \311\302\303H \"?\"\210\210\211T\262\202 \266\202~ \242\312=\204R \304\313!\210\211A@A@\211\203| \211@\303A \"\203q \311\302\303@A \"?\"\210A\262A\266\202\202X \266\314\315!0\207" [cl--generic-cnm-sample cl--generic-nnm-sample found function-equal cl--assertion-failed (function-equal cnm cl--generic-cnm-sample) byte-code-function-p 2 0 throw closure (eq 'closure (car-safe cl--generic-cnm-sample)) error "Haven't found no-next-method-sample in cnm-sample"] 11 (#$ . 38357)])
(byte-code "\300\301\302\"\210\300\303\304\301#\210\300\305\306\301#\210\300\307\310\301#\210\311\303\312\303\313\314#\315#\210\316\303\314\313\314\317%\210\311\307\312\307\320\314#\321#\210\316\307\314\320\314\322%\210\311\305\312\305\323\314#\324#\210\316\305\314\323\314\325%\207" [define-error cl-no-method "No method" cl-no-next-method "No next method" cl-no-primary-method "No primary method" cl-no-applicable-method "No applicable method" defalias cl-generic-define (generic method &rest args) nil "Function called when `cl-call-next-method' finds no next method.\n\n(fn GENERIC METHOD &rest ARGS)" cl-generic-define-method #[642 "\301\302\303H>\204 \301\304\305D\"\210\306HBB\"\207" [cl-struct-cl--generic-tags signal cl-no-next-method 0 wrong-type-argument cl--generic 1] 9 "\n\n(fn GENERIC METHOD &rest ARGS)"] (generic &rest args) "Function called when a method call finds no applicable method.\n\n(fn GENERIC &rest ARGS)" #[385 "\301\302\303H>\204 \301\304\305D\"\210\306HB\"\207" [cl-struct-cl--generic-tags signal cl-no-applicable-method 0 wrong-type-argument cl--generic 1] 8 "\n\n(fn GENERIC &rest ARGS)"] (generic &rest args) "Function called when a method call finds no primary method.\n\n(fn GENERIC &rest ARGS)" #[385 "\301\302\303H>\204 \301\304\305D\"\210\306HB\"\207" [cl-struct-cl--generic-tags signal cl-no-primary-method 0 wrong-type-argument cl--generic 1] 8 "\n\n(fn GENERIC &rest ARGS)"]] 6)
#@140 Function to call the next applicable method.
Can only be used from within the lexical body of a primary or around method.
(fn &rest ARGS)
(defalias 'cl-call-next-method #[128 "\300\301!\207" [error "cl-call-next-method only allowed inside primary and around methods"] 3 (#$ . 40525)])
#@120 Return non-nil if there is a next method.
Can only be used from within the lexical body of a primary or around method.
(defalias 'cl-next-method-p #[0 "\300\301!\207" [error "cl-next-method-p only allowed inside primary and around methods"] 2 (#$ . 40818)])
(make-obsolete 'cl-next-method-p "make sure there's always a next method, or catch `cl-no-next-method' instead" "25.1")
(defalias 'cl-find-method #[771 "\301\302N\211\303H>\204 \304\305\302D\"\210\211\306H\262#@\207" [cl-struct-cl--generic-tags cl--generic-member-method cl--generic 0 signal wrong-type-argument 3] 11 "\n\n(fn GENERIC QUALIFIERS SPECIALIZERS)"])
#@123 For `find-function-regexp-alist'. Searches for a cl-defmethod.
MET-NAME is a cons (SYMBOL . SPECIALIZERS).
(fn MET-NAME)
(defalias 'cl--generic-search-method #[257 "\300\301\302\303@\"!\304Q\305\306\307\310\311\312A\"\313#Q\314\312#\206# \305\314\312#\207" ["(\\(?:cl-\\)?defmethod[ ]+" regexp-quote format "%s" "\\_>" re-search-forward "[^&\"\n]*" mapconcat #[257 "\300\301\302:\203 A@\202 \"!\207" [regexp-quote format "%S"] 5 "\n\n(fn SPECIALIZER)"] remq t "[ \n]*)[^&\"\n]*" nil] 10 (#$ . 41453)])
(defvar cl--generic-find-defgeneric-regexp "(\\(?:cl-\\)?defgeneric[ ]+%s\\>")
(eval-after-load 'find-func #[0 "\301\302B\211\235\203 \210\202 \211B\210\303\211\235\203 \202# \211B\211\207" [find-function-regexp-alist cl-defmethod cl--generic-search-method (cl-defgeneric . cl--generic-find-defgeneric-regexp)] 3])
(defalias 'cl--generic-method-info #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\301H>\204! \302\303\304D\"\210\306H\301H>\2043 \302\303\304D\"\210\307H\301H>\204F \302\303\304D\"\210\310H\311\312\"\313!\204X \314\202l :\204a \315\316!\210\317!\211\305\320O\321P\262\205\200 \322\323\"\211\203} \211A\202~ \262\323\203\212 A\262\211\203\304 \211@@\324=\203\244 \325\326\327G\"!\202\253 \211A\262\242\330=\203\265 \211\202\270 \211DB\262\210A\266\202\202\214 \210\331\237\"\262E\207" [cl-struct-cl--generic-method-tags 0 signal wrong-type-argument cl--generic-method 1 2 3 4 help-function-arglist names documentation "" cl--assertion-failed (consp qualifiers) prin1-to-string -1 " " help-split-fundoc nil &rest intern format "arg%d" t append] 16 "\n\n(fn METHOD)"])
(add-hook 'help-fns-describe-function-functions 'cl--generic-describe)
(defalias 'cl--generic-describe #[257 "\2119\205 \211\302N\211\205\211 \303\304!\210\212\305c\210\306\307\310\311#c\210\211\312H>\204* \313\314\302D\"\210\211\315H\211\205\206 \211@\316!\317\320@A@#c\210\312H >\204P \313\314\321D\"\210\322HB\323\324\"\211\203p \325\326!c\210\327\330!\331\324%\210\325\332!c\210\266\333\3348\206z \335\336\261\266A\266\202\202- \262)\207" [cl-struct-cl--generic-tags cl-struct-cl--generic-method-tags cl--generic require help-mode "\n\nThis is a generic function.\n\n" propertize "Implementations:\n\n" face bold 0 signal wrong-type-argument 3 cl--generic-method-info format "%s%S" cl--generic-method 1 find-lisp-object-file-name cl-defmethod substitute-command-keys " in `" help-insert-xref-button help-fns-short-filename help-function-def "'.\n" "\n" 2 "Undocumented" "\n\n"] 13 "\n\n(fn FUNCTION)"])
#@87 Return non-nil if a method with SPECIALIZERS applies to TYPE.
(fn SPECIALIZERS TYPE)
(defalias 'cl--generic-specializers-apply-to-type-p #[514 "\300\211\203G \211@\211\242\301>\203 \211A@\262\211\302>\204@ \232\204= \2119\203@ \211\303N\303N\2058 \211\2058 \304!\235\266\202\203@ \305\262A\266\202\202 \210\211\207" [nil (subclass eieio--static) (t eieio-default-superclass) cl--class cl--generic-class-parents t] 10 (#$ . 44048)])
#@145 Return a list of all generic functions.
Optional TYPE argument returns only those functions that contain
methods for TYPE.
(fn &optional TYPE)
(defalias 'cl-generic-all-functions #[256 "\300C\301\302\303\304\305\306\"\307\"\310\311%!\210\211\242\207" [nil mapatoms make-byte-code 257 "\304!\205 \211\305N\211\205b \3062Y \300\204 \307\306\310\"\210\211\311H\n>\204) \312\313\305D\"\210\211\314H\211\205V \211@\315\311H >\204B \312\313\316D\"\210\317H\300\"\203O \307\306\310\"\210A\266\202\202, \2620\205b \301\301\242B\240\207" vconcat vector [cl-struct-cl--generic-tags cl-struct-cl--generic-method-tags fboundp cl--generic found throw t 0 signal wrong-type-argument 3 cl--generic-specializers-apply-to-type-p cl--generic-method 1] 9 "\n\n(fn SYMBOL)"] 10 (#$ . 44500)])
#@168 Return info for all methods of FUNCTION (a symbol) applicable to TYPE.
The value returned is a list of elements of the form
(QUALIFIERS ARGS DOC).
(fn FUNCTION TYPE)
(defalias 'cl--generic-method-documentation #[514 "\302N\303\203H \304H>\204 \305\306\302D\"\210\307H\211\203G \211@\310\304H >\2040 \305\306\311D\"\210\312H\"\203@ \313!B\262A\266\202\202 \210\207" [cl-struct-cl--generic-tags cl-struct-cl--generic-method-tags cl--generic nil 0 signal wrong-type-argument 3 cl--generic-specializers-apply-to-type-p cl--generic-method 1 cl--generic-method-info] 11 (#$ . 45295)])
(defvar cl--generic-head-used (make-hash-table :test 'eql))
(defconst cl--generic-head-generalizer (byte-code "\300\301\302\303\304\305%\207" [#[385 "\300\301D\302BB\207" [gethash car-safe (cl--generic-head-used)] 5 "\n\n(fn NAME &rest _)"] #[385 "\242\300=\205 C\207" [head] 4 "\n\n(fn TAG &rest _)"] vector cl-struct-cl--generic-generalizer cl--generic-head-generalizer 80] 8))
(byte-code "\302\303\304\305\306\307%\210\310\311\303\312!C\"B\313\314 #\210\207" [cl--generic-t-generalizer cl--generic-dispatchers cl-generic-define-method cl-generic-generalizers (:extra "head") (specializer) t #[514 "\211\242\302=\204\n \207\211A@\303\"\204 \304#\266\266 C\207" [cl--generic-head-used cl--generic-head-generalizer head gethash puthash] 9 "Support for the `(head VAL)' specializers.\n\n(fn CL--CNM SPECIALIZER)"] 0 append (head eql) puthash #[771 "\300\301\302\"\303\304\305\306\307$\310\"\311\312%\207" [make-hash-table :test eql make-byte-code 385 "\305\306\242\f\"\303\306\"\206* \307\300\310\301\302\311\312\306\f\242\f\"!\313\314!\"%\315#\210\211\262\266\202#\207" vconcat vector [cl--generic-head-used apply gethash cl--generic-cache-miss 0 append (closure (cl-struct-cl--generic-tags cl-struct-cl--generic-method-tags . #1=(cl-struct-cl--generic-generalizer-tags t)) (tag &rest _) (if (eq (car-safe tag) 'head) (list tag))) (closure #1# (_tag &rest _) '(t)) nil puthash] 15 "\n\n(fn ARG &rest ARGS)"] 13 "\n\n(fn GENERIC DISPATCHES-LEFT METHODS)"]] 6)
(defvar cl--generic-eql-used (make-hash-table :test 'eql))
(defconst cl--generic-eql-generalizer (byte-code "\300\301\302\303\304\305%\207" [#[385 "\300\301BB\207" [gethash (cl--generic-eql-used)] 5 "\n\n(fn NAME &rest _)"] #[385 "\242\300=\205 C\207" [eql] 4 "\n\n(fn TAG &rest _)"] vector cl-struct-cl--generic-generalizer cl--generic-eql-generalizer 100] 8))
(byte-code "\302\303\304\305\304\306%\210\307\310\303\311!C\"B\312\313 #\266\314\310\303\315!C\"B\312\316 #\266\317\310\303\320!C\"B\312\321 #\266\322\310\303\323!C\"B\312\324 #\210\207" [cl--generic-t-generalizer cl--generic-dispatchers cl-generic-define-method cl-generic-generalizers nil ((specializer (head eql))) #[257 "\302A@#\210 C\207" [cl--generic-eql-used cl--generic-eql-generalizer puthash] 5 "Support for the `(eql VAL)' specializers.\n\n(fn SPECIALIZER)"] 0 append (eql nil) puthash #[771 "\300\301\302\"\303\304\305\306\307$\310\"\311\312%\207" [make-hash-table :test eql make-byte-code 385 "\305\306\f\"\303\306\"\206( \307\300\310\301\302\311\312\306\f\f\"!\313\314!\"%\315#\210\211\262\266\202#\207" vconcat vector [cl--generic-eql-used apply gethash cl--generic-cache-miss 0 append #2=(closure (cl-struct-cl--generic-tags cl-struct-cl--generic-method-tags . #1=(cl-struct-cl--generic-generalizer-tags t)) (tag &rest _) (if (eq (car-safe tag) 'eql) (list tag))) #3=(closure #1# (_tag &rest _) '(t)) nil puthash] 15 "\n\n(fn ARG &rest ARGS)"] 13 "\n\n(fn GENERIC DISPATCHES-LEFT METHODS)"] (&context . window-system) (eql nil) #[771 "\300\301\302\"\303\304\305\306\307$\310\"\311\312%\207" [make-hash-table :test eql make-byte-code 128 "\f\306\307
\"\303\307\"\206) \310\300\311\301\302\312\313\307
\"!\314\315!\"%\316#\210\211\262\266\202\"\207" vconcat vector [window-system cl--generic-eql-used apply gethash cl--generic-cache-miss (&context . window-system) append #2# #3# nil puthash] 15 "\n\n(fn &rest ARGS)"] 13 "\n\n(fn GENERIC DISPATCHES-LEFT METHODS)"] (&context terminal-parameter nil 'xterm--get-selection) (eql nil) #[771 "\300\301\302\"\303\304\305\306\307$\310\"\311\312%\207" [make-hash-table :test eql make-byte-code 128 "\305\306\307\"\310\311\f\"\303\311\"\206, \312\300\313\301\302\314\315\311 \f\"!\316\306!\"%\317#\210\211\262\266\202\"\207" vconcat vector [cl--generic-eql-used terminal-parameter nil xterm--get-selection apply gethash cl--generic-cache-miss (&context terminal-parameter nil 'xterm--get-selection) append #2# #3# puthash] 15 "\n\n(fn &rest ARGS)"] 13 "\n\n(fn GENERIC DISPATCHES-LEFT METHODS)"] (&context terminal-parameter nil 'xterm--set-selection) (eql nil) #[771 "\300\301\302\"\303\304\305\306\307$\310\"\311\312%\207" [make-hash-table :test eql make-byte-code 128 "\305\306\307\"\310\311\f\"\303\311\"\206, \312\300\313\301\302\314\315\311 \f\"!\316\306!\"%\317#\210\211\262\266\202\"\207" vconcat vector [cl--generic-eql-used terminal-parameter nil xterm--set-selection apply gethash cl--generic-cache-miss (&context terminal-parameter nil 'xterm--set-selection) append #2# #3# puthash] 15 "\n\n(fn &rest ARGS)"] 13 "\n\n(fn GENERIC DISPATCHES-LEFT METHODS)"]] 6)
(defalias 'cl--generic-struct-tag #[385 "\300\301D\302\303D\304BB\305\306\307\310BBDC\311BBF\207" [and vectorp > length (0) let tag aref (0) ((and (symbolp tag) (eq (symbol-function tag) :quick-object-witness-check) tag))] 10 "\n\n(fn NAME &rest _)"])
(defalias 'cl--generic-class-parents #[257 "\301C\211A\262\242\302!\203 \211G\303Y\203 \211\304H>\204% \305\306\307D\"\210\211\310H\311\"\2044 \211B\262\210\312\302!\203L G\303Y\203L \304H>\204S \305\306\307D\"\210\313H\"\211\262\262\204 \237\207" [cl-struct-cl--class-tags nil vectorp 6 0 signal wrong-type-argument cl--class 1 memql append 3] 10 "\n\n(fn CLASS)"])
(defalias 'cl--generic-struct-specializers #[385 "9\205' \301!\205' J\302!\205% \211G\303Y\205% \211\304H>\205% \305!\262\207" [cl-struct-cl-structure-class-tags boundp vectorp 11 0 cl--generic-class-parents] 5 "\n\n(fn TAG &rest _)"])
(defconst cl--generic-struct-generalizer (vector 'cl-struct-cl--generic-generalizer 'cl--generic-struct-generalizer 50 'cl--generic-struct-tag 'cl--generic-struct-specializers))
(byte-code "\302\303\304\305\306\307%\210\310\311\303\312!C\"B\313\314 #\210\207" [cl--generic-t-generalizer cl--generic-dispatchers cl-generic-define-method cl-generic-generalizers (:extra "cl-struct") (type) t #[514 "\2119\203\223 \211\302N\303!\205\216 \211G\304Y\205\216 \211\305H>\205\216 \303!\2032 \211G\304Y\2032 \211\305H>\2049 \306\307\310D\"\210\211\311H\203f \312\313\303!\203W G\304Y\203W \305H>\204_ \306\307\310D\"\210\311H#\205\216 \303!\203{ \211G\304Y\203{ \211\305H>\204\202 \306\307\310D\"\210\211\314H\203\214 \315\316!\210 C\262\206\225 \207" [cl-struct-cl-structure-class-tags cl--generic-struct-generalizer cl--class vectorp 11 0 signal wrong-type-argument cl-structure-class 7 error "Can't dispatch on cl-struct %S: type is %S" 8 cl--assertion-failed (null (cl--struct-class-named class))] 10 "Support for dispatch on cl-struct types.\n\n(fn CL--CNM TYPE)"] 0 append cl--generic-generalizer puthash #[771 "\300\301\302\"\303\304\305\306\307$\310\"\311\312%\207" [make-hash-table :test eql make-byte-code 385 "\304\305!\205 G\306V\205 \306H\2119\205 \211K\307=\205 \211\262\303\310\"\206` \311\300\306\301\302\312\313\305\f!\205Q G\306V\205Q \306H\2119\205O \211K\307=\205O \211\262!\314\315!\"%\316#\210\211\262\266\202#\207" vconcat vector [apply vectorp 0 :quick-object-witness-check gethash cl--generic-cache-miss append cl--generic-struct-specializers (closure (cl-struct-cl--generic-generalizer-tags t) (_tag &rest _) '(t)) nil puthash] 15 "\n\n(fn ARG &rest ARGS)"] 13 "\n\n(fn GENERIC DISPATCHES-LEFT METHODS)"]] 6)
(defconst cl--generic-typeof-types '((integer number) (symbol) (string array sequence) (cons list sequence) (marker) (overlay) (float number) (window-configuration) (process) (window) (subr) (compiled-function) (buffer) (char-table array sequence) (bool-vector array sequence) (frame) (hash-table) (font-spec) (font-entity) (font-object) (vector array sequence) (null symbol list sequence) (list sequence) (array sequence) (sequence) (number)))
(defconst cl--generic-typeof-generalizer (byte-code "\300\301\302\303\304\305%\207" [#[385 "\300\301D\302BBB\207" [if type-of ('null)] 6 "\n\n(fn NAME &rest _)"] #[385 "9\205 \236\207" [cl--generic-typeof-types] 4 "\n\n(fn TAG &rest _)"] vector cl-struct-cl--generic-generalizer cl--generic-typeof-generalizer 10] 8))
(byte-code "\302\303\304\305\306\307%\210\310\311\303\312!C\"B\313\314 #\210\207" [cl--generic-t-generalizer cl--generic-dispatchers cl-generic-define-method cl-generic-generalizers (:extra "typeof") (type) t #[514 "\211\236\203 C\206
\207" [cl--generic-typeof-types cl--generic-typeof-generalizer] 4 "Support for dispatch on builtin types.\n\n(fn CL--CNM TYPE)"] 0 append integer puthash #[771 "\300\301\302\"\303\304\305\306\307$\310\"\311\312%\207" [make-hash-table :test eql make-byte-code 385 "\304\203 \305!\202\f \306\303\307\"\2067 \310\300\311\301\302\312\313 \203' \305\f!\202( \306!\314\315!\"%\316#\210\211\262\266\202#\207" vconcat vector [apply type-of null gethash cl--generic-cache-miss 0 append (closure (cl-struct-cl--generic-tags cl-struct-cl--generic-method-tags . #1=(cl-struct-cl--generic-generalizer-tags t)) (tag &rest _) (and (symbolp tag) (assq tag cl--generic-typeof-types))) (closure #1# (_tag &rest _) '(t)) nil puthash] 14 "\n\n(fn ARG &rest ARGS)"] 13 "\n\n(fn GENERIC DISPATCHES-LEFT METHODS)"]] 6)
(defalias 'cl--generic-derived-specializers #[385 "\300\203 \301DB\262\302N\262\202 \211\237\207" [nil derived-mode derived-mode-parent] 5 "\n\n(fn MODE &rest _)"])
(defconst cl--generic-derived-generalizer (byte-code "\300\301\302\303\304\305%\207" [#[257 "\300\301D\302DF\207" [and symbolp functionp] 5 "\n\n(fn NAME)"] vector cl-struct-cl--generic-generalizer cl--generic-derived-generalizer 90 cl--generic-derived-specializers] 7))
(byte-code "\300\301\302\303\302\304%\210\305\306\307\310#\210\311\312!\207" [cl-generic-define-method cl-generic-generalizers nil ((_specializer (head derived-mode))) #[257 "C\207" [cl--generic-derived-generalizer] 2 "Support for the `(derived-mode MODE)' specializers.\n\n(fn SPECIALIZER)"] put major-mode cl-generic--context-rewriter #[385 "\300:\203 \203 \301\302!\210\202 \303BBD\207" [major-mode cl--assertion-failed (null modes) derived-mode] 6 "\n\n(fn MODE &rest MODES)"] provide cl-generic] 6)
Kontol Shell Bypass