ikan Uploader :
Directory : /usr/share/emacs/25.2/lisp/emacs-lisp/
Upload File : |
| Current File : //usr/share/emacs/25.2/lisp/emacs-lisp/cl-macs.elc |
;ELC
;;; Compiled
;;; in Emacs version 25.2.1
;;; with all optimizations.
;;; Function definitions are lazy-loaded.
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(byte-code "\300\301!\210\300\302!\210\300\303!\207" [require cl-lib macroexp gv] 2)
(defalias 'cl--pop2 '(macro . #[257 #@67 ("\300\301\302DD\303\302\211DDEE\207" . [prog1 car cdr setq]) (#$ . 573) nil 8 "\n\n(fn PLACE)"]))
(put 'cl--pop2 'edebug-form-spec 'edebug-sexps)
(defalias 'cl--compiler-macro-list* #[642 #@80 ("\300B!\211@A\211\262\2030\301@E\262\2020\207" . [reverse cons]) (#$ . 771) nil 8 "\n\n(fn FORM ARG &rest OTHERS)"])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias cl--compiler-macro-cXXr internal--compiler-macro-cXXr nil make-obsolete "25.1"] 4)
(defconst cl--simple-funcs '(car cdr nth aref elt if and or + - 1+ 1- min max car-safe cdr-safe progn prog1 prog2))
(defconst cl--safe-funcs '(* / % length memq list vector vectorp < > <= >= = error))
#@72 Check if no side effects, and executes quickly.
(fn X &optional SIZE)
(defalias 'cl--simple-expr-p #[513 #@294 ("\211\2040\301\262:\203K0@\302>\204K0@9\205S0@>\204'0@\303N\205S0\211S\262A\211\262\203>0\304@\"\211\262\204+0?\205J0\211\305Y\205J0\211\207\211\305V\205S0\211S\207" . [cl--simple-funcs 10 (quote function cl-function) side-effect-free cl--simple-expr-p 0]) (#$ . 1370) nil 5 (#$ . 1257)])
(defalias 'cl--simple-exprs-p #[257 #@82 ("\211\2030\300@!\2030\211A\262\20200\211?\207" . [cl--simple-expr-p]) (#$ . 1736) nil 3 "\n\n(fn XS)"])
#@35 Check if no side effects.
(fn X)
(defalias 'cl--safe-expr-p #[257 #@239 ("\211:\205\n0\211@\302>??\206:0\211@9\205:0\211@>\204)0\211@ >\204)0\211@\303N\205:0\211A\211\262\20380\304@!\204)0\211?\207" . [cl--simple-funcs cl--safe-funcs (quote function cl-function) side-effect-free cl--safe-expr-p]) (#$ . 1930) nil 3 (#$ . 1856)])
(defalias 'cl--const-expr-p #[257 #@186 ("\211:\203%0\211@\300=\20630\211@\301>\205$0\211A@9\206$0\211A@\242\302=\205$0\303\207\2119\20320\211\304>\20530\305\207\305\207" . [quote #'cl-function lambda func (nil t) t]) (#$ . 2240) nil 3 "\n\n(fn X)"])
#@213 Return the value of X known at compile-time.
If X is not known at compile time, return nil. Before testing
whether X is known at compile time, macroexpand it completely in
`macroexpand-all-environment'.
(fn X)
(defalias 'cl--const-expr-val #[257 #@127 ("\301\"\302!\2050\211:\2030\211A@\2020\211\207" . [macroexpand-all-environment macroexpand-all macroexp-const-p]) (#$ . 2719) nil 4 (#$ . 2464)])
#@73 Count number of times X refers to Y. Return nil for 0 times.
(fn X Y)
(defalias 'cl--expr-contains #[514 #@242 ("\211\232\2030\300\207:\203B0@\301>\204B0\302:\203.0\211\303\211A\262\242\"\206(0\302\\\262\2020\211\303\"\20670\302\\\262\211\302V\205A0\211\207\304\207" . [1 (quote function cl-function) 0 cl--expr-contains nil]) (#$ . 2996) nil 7 (#$ . 2882)])
(defalias 'cl--expr-contains-any #[514 #@82 ("\211\2030\300@\"\2040\211A\266\202\20200\207" . [cl--expr-contains]) (#$ . 3313) nil 5 "\n\n(fn X Y)"])
#@66 Check whether X may depend on any of the symbols in Y.
(fn X Y)
(defalias 'cl--expr-depends-p #[514 #@105 ("\300!?\2050\301!?\2060\302\"\207" . [macroexp-const-p cl--safe-expr-p cl--expr-contains-any]) (#$ . 3542) nil 5 (#$ . 3434)])
(defvar cl--gensym-counter 0)
#@121 Generate a new uninterned symbol.
The name is made by appending a number to PREFIX, default "G".
(fn &optional PREFIX)
(defalias 'cl-gensym #[256 #@136 ("\211;\203 0\211\202\n0\301\250\2030\2020\211T\302\303\304#!\207" . [cl--gensym-counter "G" make-symbol format "%s%d"]) (#$ . 3868) nil 8 (#$ . 3714)])
#@138 Generate a new interned symbol with a unique name.
The name is made by appending a number to PREFIX, default "G".
(fn &optional PREFIX)
(defalias 'cl-gentemp #[256 #@155 ("\211;\203 0\211\202\n0\301\302\303\304\305#\211\262!\203 0T\202 0\306!\207" . [cl--gensym-counter "G" nil intern-soft format "%s%d" intern]) (#$ . 4213) nil 8 (#$ . 4041)])
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\210\300\310\302\311#\210\300\312\302\313#\210\300\314\302\315#\207" [put cl-declarations edebug-form-spec (&rest ("cl-declare" &rest sexp)) cl-declarations-or-string (&or stringp cl-declarations) cl-lambda-list (([&rest arg] [&optional ["&optional" cl-&optional-arg &rest cl-&optional-arg]] [&optional ["&rest" arg]] [&optional ["&key" [cl-&key-arg &rest cl-&key-arg] &optional "&allow-other-keys"]] [&optional ["&aux" &rest &or (symbolp &optional def-form) symbolp]])) cl-&optional-arg (&or (arg &optional def-form arg) arg) cl-&key-arg (&or ([&or (symbolp arg) arg] &optional def-form arg) arg) cl-type-spec sexp] 4)
(defconst cl--lambda-list-keywords '(&optional &rest &key &allow-other-keys &aux &whole &body &environment))
#@270 Transform a function form FORM of name BIND-BLOCK.
BIND-BLOCK is the name of the symbol to which the function will be bound,
and which will be used for the name of the `cl-block' surrounding the
function's body.
FORM is of the form (ARGS . BODY).
(fn FORM BIND-BLOCK)
(defalias 'cl--transform-lambda #[514 #@1520 ("@A\306\211\307!\211@\306A\262<\203!0\310!\202%0\311D\262\312!\211A\20370\211\311AD\241\210\210\313>\211\203Q0\211A@\211AA\241\210\314\313\"\262\210\315>\211\203b0\314\315\"\262\316>\203m0\317\320!\210\321>\211A@\203\2110\314@\314 \"\"\322\323BD\244\262\266\306\203\3210@9\203\3210@\324>\204\3210\211\203\2570@ A\236A@\204\3210@\325=\203\3030\326\211\262\203\3030 @\204\3210\211A\262\242B\262\202\2140\211\203\3530\203\3400\325B\262@\325=\203\3530A\262\210\327=\204\3730\330BBC\262\306\211 \204\306\202q@\322=\203\331!\210 \237\306\202q\211G\325>\203&\211S\262\332 \333\334\335\336\337!\340\"\341$\216\342@;\205A\211A\262\242\343\306\326\211 - .\344\345\346\347\f!B\"+!\")B\262\262\350\351#\210 \237\311 \211A\242@D\262\306\352\237\"\352\353 \354\352\f\237\"!\"C\"*BB\262+\207" . [cl--bind-block cl--bind-defs cl--bind-enquote cl--bind-lets cl--bind-forms print-escape-newlines nil macroexp-parse-body cl-copy-list &rest last &cl-defs delq &cl-quote &whole error "&whole not currently implemented" &environment &aux (macroexpand-all-environment) (nil &rest &body &key &aux) &optional t cl-none cl-block cl--do-&aux match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 help-add-fundoc-usage help--docstring-quote format "%S" fn cl--make-usage-args cl--do-arglist :dummy append macroexp-let* macroexp-progn print-quoted print-gensym]) (#$ . 5520) nil 20 (#$ . 5205)])
#@703 Define NAME as a function.
Like normal `defun', except ARGLIST allows full Common Lisp conventions,
and BODY is implicitly surrounded by (cl-block NAME ...).
The full form of a Common Lisp function argument list is
(VAR...
[&optional (VAR [INITFORM [SVAR]])...]
[&rest|&body VAR]
[&key (([KEYWORD] VAR) [INITFORM [SVAR]])... [&allow-other-keys]]
[&aux (VAR [INITFORM])...])
VAR maybe be replaced recursively with an argument list for
destructing, `&whole' is supported within these sublists. If
SVAR, INITFORM, and KEYWORD are all omitted, then `(VAR)' may be
written simply `VAR'. See the Info node `(cl)Argument Lists' for
more details.
(fn NAME ARGLIST [DOCSTRING] BODY...)
(defalias 'cl-defun '(macro . #[642 #@95 ("\300B\"\301ABB@\2030\302@E\2020\211\207" . [cl--transform-lambda defun progn]) (#$ . 7822) nil 8 (#$ . 7078)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\210\304\301\307\310#\207" [put cl-defun edebug-form-spec (&define [&or name ("setf" :name setf name)] cl-lambda-list cl-declarations-or-string [&optional ("interactive" interactive)] def-body) function-put doc-string-elt 3 lisp-indent-function 2] 4)
#@213 Define NAME as a generator function.
Like normal `iter-defun', except ARGLIST allows full Common Lisp conventions,
and BODY is implicitly surrounded by (cl-block NAME ...).
(fn NAME ARGLIST [DOCSTRING] BODY...)
(defalias 'cl-iter-defun '(macro . #[642 #@131 ("\300\301!\210\302B\"\303ABB@\203 0\304@E\202 0\211\207" . [require generator cl--transform-lambda iter-defun progn]) (#$ . 8516) nil 8 (#$ . 8256)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\210\304\301\307\310#\210\300\311\302\312#\210\300\313\302\314#\210\300\315\302\316#\207" [put cl-iter-defun edebug-form-spec (&define [&or name ("setf" :name setf name)] cl-lambda-list cl-declarations-or-string [&optional ("interactive" interactive)] def-body) function-put doc-string-elt 3 lisp-indent-function 2 cl-macro-list (([&optional "&environment" arg] [&rest cl-macro-arg] [&optional ["&optional" &rest &or (cl-macro-arg &optional def-form cl-macro-arg) arg]] [&optional [[&or "&rest" "&body"] cl-macro-arg]] [&optional ["&key" [&rest [&or ([&or (symbolp cl-macro-arg) arg] &optional def-form cl-macro-arg) arg]] &optional "&allow-other-keys"]] [&optional ["&aux" &rest &or (symbolp &optional def-form) symbolp]] [&optional "&environment" arg])) cl-macro-arg (&or arg cl-macro-list1) cl-macro-list1 (([&optional "&whole" arg] [&rest cl-macro-arg] [&optional ["&optional" &rest &or (cl-macro-arg &optional def-form cl-macro-arg) arg]] [&optional [[&or "&rest" "&body"] cl-macro-arg]] [&optional ["&key" [&rest [&or ([&or (symbolp cl-macro-arg) arg] &optional def-form cl-macro-arg) arg]] &optional "&allow-other-keys"]] [&optional ["&aux" &rest &or (symbolp &optional def-form) symbolp]] . [&or arg nil]))] 4)
#@723 Define NAME as a macro.
Like normal `defmacro', except ARGLIST allows full Common Lisp conventions,
and BODY is implicitly surrounded by (cl-block NAME ...).
The full form of a Common Lisp macro argument list is
(VAR...
[&optional (VAR [INITFORM [SVAR]])...]
[&rest|&body VAR]
[&key (([KEYWORD] VAR) [INITFORM [SVAR]])... [&allow-other-keys]]
[&aux (VAR [INITFORM])...]
[&environment VAR])
VAR maybe be replaced recursively with an argument list for
destructing, `&whole' is supported within these sublists. If
SVAR, INITFORM, and KEYWORD are all omitted, then `(VAR)' may be
written simply `VAR'. See the Info node `(cl)Argument Lists' for
more details.
(fn NAME ARGLIST [DOCSTRING] BODY...)
(defalias 'cl-defmacro '(macro . #[642 #@98 ("\300B\"\301ABB@\2030\302@E\2020\211\207" . [cl--transform-lambda defmacro progn]) (#$ . 10721) nil 8 (#$ . 9954)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\210\304\301\307\310#\210\300\311\302\312#\210\300\313\302\314#\207" [put cl-defmacro edebug-form-spec (&define name cl-macro-list cl-declarations-or-string def-body) function-put doc-string-elt 3 lisp-indent-function 2 cl-lambda-expr (&define ("lambda" cl-lambda-list def-body)) function-form (&or ([&or "quote" "function"] &or symbolp lambda-expr) ("cl-function" cl-function) form)] 4)
#@155 Introduce a function.
Like normal `function', except that if argument is a lambda form,
its argument list allows full Common Lisp conventions.
(fn FUNC)
(defalias 'cl-function '(macro . #[257 #@151 ("\211\242\300=\203!0\301A\302\"\303\300ABD@\203_0\304@E\202 0\211\207\303D\207" . [lambda cl--transform-lambda cl-none function progn]) (#$ . 11496) nil 6 (#$ . 11296)]))
(put 'cl-function 'edebug-form-spec '(&or symbolp cl-lambda-expr))
#@58 X can be a var or a (destructuring) lambda-list.
(fn X)
(defalias 'cl--make-usage-var #[257 #@113 ("\2119\203\f0\300\301!\226!\207\211:\2030\302!\207\207" . [make-symbol symbol-name cl--make-usage-args]) (#$ . 11853) nil 4 (#$ . 11753)])
(defalias 'cl--make-usage-args #[257 #@806 ("\3001\f0\301\302\"0\2020\210\303\211\2030\304\305#\262\210\306!\243\203B0\306!\211A\307\305\310\311\312\"\313\"\314$\216\303\241\210\315!\316!\244)\207\317>\211\203U0\320@\321A@\"\"\262\210\303C\322\307\323\324\311\312!\325\"\326\327%\"\207" . [(error) cl-position &aux nil cl-subseq 0 last make-byte-code "\300\301\241\207" vconcat vector [] 2 cl--make-usage-args cl--make-usage-var &cl-defs delq remq mapcar 257 "\2119\203,0\301!\302H\211\303=\2030\300\240\202+0\304\305=\203&0\301!\306\307O\202)0\301!\226!\207\211:\20420\207\300\242\310>\203=0\311!\207\211@:\203W0\300\242\312=\203W0\211@@\313@A@!D\202[0\313@!A@\311AA!BB\207" [symbol-name 0 38 make-symbol 95 1 nil (nil &rest) cl--make-usage-args &key cl--make-usage-var] 6 "\n\n(fn X)"]) (#$ . 12042) nil 10 "\n\n(fn ARGLIST)"])
(defalias 'cl--do-&aux #[257 #@374 ("\211@\302=\203]0\211A\262\242\203]0\211\20300\211@>\20400\211@:\203P0 \203?0\211@A@\203?0\303@@\304\211A\262\242A@D\"\210\2020\303@@\211A\262\242A@\"\210\2020\303\211A\262\242\305\"\210\2020\211\205e0\306\307\"\207" . [cl--lambda-list-keywords cl--bind-enquote &aux cl--do-arglist quote nil error "Malformed argument list ends with: %S"]) (#$ . 12923) nil 6 "\n\n(fn ARGS)"])
(defalias 'cl--do-arglist #[770 #@2663 ("<\204 0>\20409\2040\306\307\"\207D B\211\207\310!\262\311!\211A\20310\211\312AD\241\210\210\313>\211\203=0\211\312\240\210\210\314>\203H0\306\315!\210\312>\316 \203T0\n\202U0\317\320\211\211\211\204a0\321\262A@<\203n0\322\323!\202q0A@\262D B@\324=\203\2220A@ AA\262\nD B\262\211\203\2660\211@>\204\2660\211\n=\204\2570\325D\262\211A\262\202\2300\211@\326>\203\3220\327\330D\331\f\"GE\262 =?\262\210\203.@>\204.A\204\3520\204\3560\332\202\3570\333D\334\n\211A\262\f\242\204\321U\203 \202 \335\336\337\340 \341=?\205\342 D\330DEEF\"\266T\262\343\262\202\3230@\344=\203\264\211A\262\n\242\203\264\203.@>\204.\211A\262\n\242\211:\204]\211C\262\211AA\203o\334\3458\346 \347BB\"\210\211A\203z\211A@\202\205\f@\206\205\211@\f\236A@\332D\203\226
\203\226\342D\262\334@\203\247\335 F\202\250\"\210 T\262\n\266\202@@\312=\203\325A@ AA\262\n\211:\203\321\334\"\210\210\202@\350=\204\321U\204\204\335\336\351\340 \341=?\205\367\342 D\352
\330DEEEE@B@@\350=\203\372\211A\262\n\242\203\372\203@>\204\211A\262\n\242\211:\2046\211C\262\211@:\203B\211@@\202\\\353@!\211\321H\354=\203T\211\355\320O\262\356\357\360\"!\262@:\203i@A@\202k@A\203vA@\202\200\f@\206\200\211\f\236A@\361\n\342DE\203\224
\203\224\342D\262AA\203\303\3458\206\243\322\362!\333\325DD\334\"\210\334\335\363\364\365BBEF\"\266\202\357\334\333\325\204\317\202\353\366\367!\343=\203\345\342\320\370\n!DD\202\352\340\320 EEDD\"\210 B\262 \266\202\237\262@\371=\203\211A\262\n\242\204q\203q\321U\204q\322\372!\373\374\375\376\333D\342\377\f\"DE\364\325\211 DDED\333\325\376\342BEDD\364\201A0BBD\343\306\357\201B0\"\333\nDEDFE\201C0\nDCE@B@\266\201D0 !\210\320\207" . [cl--lambda-list-keywords cl--bind-lets cl--optimize-safety cl--bind-block cl--bind-defs cl--bind-enquote error "Invalid argument name: %s" cl-copy-list last &rest &body &environment "&environment used incorrectly" cl--compiling-file 3 nil 0 make-symbol "--cl-rest--" &whole cdr (nil &aux) = length cl-ldiff pop car cl--do-arglist if signal 'wrong-number-of-arguments list cl-none quote t &optional 2 and (t) &key 'wrong-number-of-arguments + symbol-name 95 1 intern format ":%s" plist-member "--cl-var--" prog1 setq (t) or cl--const-expr-p cl--const-expr-val &allow-other-keys "--cl-keys--" (:allow-other-keys) while cond memq append cl--bind-forms (nil) "Keyword argument %%s not one of %s" let cl--do-&aux]) (#$ . 13372) nil 25 "\n\n(fn ARGS EXPR &optional NUM)"])
(defalias 'cl--arglist-args #[257 #@324 ("\211<\2040\211C\207\301\211\211:\203_0\211A\262\242\262\211>\203$0\211\262\202 0\211\302=\20330\211A\262\210\202 0\211:\203@0\203@0\211@\262\211:\203U0\211A\203U0\303=\203U0\211A@\262\304!\244\262\202 0\205f0C\244\207" . [cl--lambda-list-keywords nil &cl-defs &key cl--arglist-args]) (#$ . 16131) nil 7 "\n\n(fn ARGS)"])
#@95 Bind the variables in ARGS to the result of EXPR and execute BODY.
(fn ARGS EXPR &rest BODY)
(defalias 'cl-destructuring-bind '(macro . #[642 #@236 ("\305\211\305\306\305 \307\2060\310\"\210\311\237\312\313 \237\"!\"-\207" . [cl--bind-lets cl--bind-forms cl--bind-defs cl--bind-block cl--bind-enquote nil cl-none cl--do-arglist (&aux) macroexp-let* macroexp-progn append]) (#$ . 16646) nil 10 (#$ . 16496)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-destructuring-bind lisp-indent-function 2 put edebug-form-spec (&define cl-macro-list def-form cl-declarations def-body)] 4)
(defvar cl--not-toplevel nil)
#@283 Control when BODY is evaluated.
If `compile' is in WHEN, BODY is evaluated when compiled at top-level.
If `load' is in WHEN, BODY is evaluated when loaded after top-level compile.
If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level.
(fn (WHEN...) BODY...)
(defalias 'cl-eval-when '(macro . #[385 #@407 ("\301\302!\203P0\302 \203P0\204P0\303\304!\204P0\305>\206 0\306>\307\310>\204,0\311>\203C0\211\20390\312\313\314\"B\202N0\315\316\211BBB\202N0\211\203M0\317\312B!\210\316)\207\317>\204\\0\320>\205_0\312B\207" . [cl--not-toplevel fboundp cl--compiling-file boundp for-effect compile :compile-toplevel t load :load-toplevel progn mapcar cl--compile-time-too if nil eval :execute]) (#$ . 17480) nil 7 (#$ . 17151)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-eval-when lisp-indent-function 1 put edebug-form-spec (sexp body)] 4)
(defalias 'cl--compile-time-too #[257 #@349 ("\211\2429\203
0\211\242\301N\2040\302\303B\"\262\211\242\304=\203$0\304\305\306A\"B\207\211\242\307=\203H0\211A@\310>\204:0\311>\203F0\307\312BAABB\202G0\207\310!\210\207" . [byte-compile-macro-environment byte-hunk-handler macroexpand (cl-eval-when) progn mapcar cl--compile-time-too cl-eval-when eval :execute compile]) (#$ . 18108) nil 5 "\n\n(fn FORM)"])
#@152 Like `progn', but evaluates the body at load time.
The result of the body appears to the compiler as a quoted constant.
(fn FORM &optional READ-ONLY)
(defalias 'cl-load-time-value '(macro . #[513 #@491 ("\301 \203>0\302\303!\304E\305\306!\20370\307\310!\20370\307\311!\20370\312\211K\313\314\315\316\317\"\320\"\321\322%\262M\210\202<0\323\"\210\207\324\325!D\207" . [byte-compile--outbuffer cl--compiling-file cl-gentemp "--cl-load-time--" setq fboundp byte-compile-file-form-defmumble boundp this-kind that-one byte-compile-file-form make-byte-code 257 "\302\301M\210\302\300!\210\302!\207" vconcat vector [byte-compile-file-form] 3 "\n\n(fn FORM)" print quote eval]) (#$ . 18703) nil 13 (#$ . 18499)]))
(put 'cl-load-time-value 'edebug-form-spec '(form &optional sexp))
#@472 Eval EXPR and choose among clauses on that value.
Each clause looks like (KEYLIST BODY...). EXPR is evaluated and compared
against each key in each KEYLIST; the corresponding BODY is evaluated.
If no clause succeeds, cl-case returns nil. A single atom may be used in
place of a KEYLIST of one atom. A KEYLIST of t or `otherwise' is
allowed only in the final clause, and matches if no other keys match.
Key values are compared by `eql'.
(fn EXPR (KEYLIST BODY...)...)
(defalias 'cl-case '(macro . #[385 #@653 ("\300!\203 0\211\2020\301\302!\303C\304\305\306\307\310\311\312\"\313\"\314\315%\"B\262=\20310\211\20280\316DC\"\207" . [macroexp-copyable-p make-symbol "temp" nil cond mapcar make-byte-code 257 "\211@\302>\203 0\303\202U0\211@\304=\203_0\305\306\300\307\310\301\242!DF\202U0\211@<\20380\301\311@\301\242\"\240\210\312\300\307@DE\202U0\211@\301\242>\203F0\305\313@\"\210\301@\301\242B\240\210\314\300\307@DEA\206[0\315B\207" vconcat vector [(t otherwise) t cl--ecase-error-flag error "cl-ecase failed: %s, %s" quote reverse append cl-member "Duplicate key in case: %s" eql (nil)] 7 "\n\n(fn C)" macroexp-let*]) (#$ . 19815) nil 14 (#$ . 19302)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-case lisp-indent-function 1 put edebug-form-spec (form &rest (sexp body))] 4)
#@113 Like `cl-case', but error if no case fits.
`otherwise'-clauses are not allowed.
(fn EXPR (KEYLIST BODY...)...)
(defalias 'cl-ecase '(macro . #[385 #@72 ("\300\301\302\"BB\207" . [cl-case append ((cl--ecase-error-flag))]) (#$ . 20814) nil 7 (#$ . 20660)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-ecase lisp-indent-function 1 put edebug-form-spec cl-case] 4)
#@351 Evals EXPR, chooses among clauses on that value.
Each clause looks like (TYPE BODY...). EXPR is evaluated and, if it
satisfies TYPE, the corresponding BODY is evaluated. If no clause succeeds,
cl-typecase returns nil. A TYPE of t or `otherwise' is allowed only in the
final clause, and matches if no other keys match.
(fn EXPR (TYPE BODY...)...)
(defalias 'cl-typecase '(macro . #[385 #@512 ("\300!\203 0\211\2020\301\302!\303C\304\305\306\307\310\311\312\"\313\"\314\315%\"B\262=\20310\211\20280\316DC\"\207" . [macroexp-copyable-p make-symbol "temp" nil cond mapcar make-byte-code 257 "\211@\302=\203 0\303\202.0\211@\304=\203_0\305\306\300\307\310\301\242!DF\202.0\301@\301\242B\240\210\311\300\307@DEA\20640\312B\207" vconcat vector [otherwise t cl--ecase-error-flag error "cl-etypecase failed: %s, %s" quote reverse cl-typep (nil)] 7 "\n\n(fn C)" macroexp-let*]) (#$ . 21457) nil 14 (#$ . 21061)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-typecase lisp-indent-function 1 put edebug-form-spec (form &rest ([&or cl-type-spec "otherwise"] body))] 4)
#@114 Like `cl-typecase', but error if no case fits.
`otherwise'-clauses are not allowed.
(fn EXPR (TYPE BODY...)...)
(defalias 'cl-etypecase '(macro . #[385 #@76 ("\300\301\302\"BB\207" . [cl-typecase append ((cl--ecase-error-flag))]) (#$ . 22350) nil 7 (#$ . 22191)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-etypecase lisp-indent-function 1 put edebug-form-spec cl-typecase] 4)
#@529 Define a lexically-scoped block named NAME.
NAME may be any symbol. Code inside the BODY forms can call `cl-return-from'
to jump prematurely out of the block. This differs from `catch' and `throw'
in two respects: First, the NAME is an unevaluated symbol rather than a
quoted symbol or other form; and second, NAME is lexically rather than
dynamically scoped: Only references to it within BODY will work. These
references may appear inside macro expansions, but not inside functions
called from BODY.
(fn NAME &rest BODY)
(defalias 'cl-block '(macro . #[385 #@162 ("\300\301B!\203\f0\301B\207\302\303\304\305\306\307\"!DBBD\207" . [cl--safe-expr-p progn cl--block-wrapper catch quote intern format "--cl-block-%s--"]) (#$ . 23180) nil 9 (#$ . 22609)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-block lisp-indent-function 1 put edebug-form-spec (symbolp body)] 4)
#@110 Return from the block named nil.
This is equivalent to `(cl-return-from nil RESULT)'.
(fn &optional RESULT)
(defalias 'cl-return '(macro . #[256 #@43 ("\300\301E\207" . [cl-return-from nil]) (#$ . 23676) nil 4 (#$ . 23524)]))
(put 'cl-return 'edebug-form-spec '(&optional form))
#@327 Return from the block named NAME.
This jumps out to the innermost enclosing `(cl-block NAME ...)' form,
returning RESULT from that form (or nil if RESULT is omitted).
This is compatible with Common Lisp, but note that `defun' and
`defmacro' do not create implicit blocks as they do in Common Lisp.
(fn NAME &optional RESULT)
(defalias 'cl-return-from '(macro . #[513 #@96 ("\300\301\302\"!\303\304DE\207" . [intern format "--cl-block-%s--" cl--block-throw quote]) (#$ . 24186) nil 6 (#$ . 23812)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-return-from lisp-indent-function 1 put edebug-form-spec (symbolp &optional form)] 4)
(defalias 'cl--loop-set-iterator-function #[514 #@131 ("\203 0\301\302\"\207\211\211\207" . [cl--loop-iterator-function error "Iteration on %S does not support this combination"]) (#$ . 24528) nil 5 "\n\n(fn KIND ITERATOR)"])
#@1130 The Common Lisp `loop' macro.
Valid clauses include:
For clauses:
for VAR from/upfrom/downfrom EXPR1 to/upto/downto/above/below EXPR2 [by EXPR3]
for VAR = EXPR1 then EXPR2
for VAR in/on/in-ref LIST [by FUNC]
for VAR across/across-ref ARRAY
for VAR being:
the elements of/of-ref SEQUENCE [using (index VAR2)]
the symbols [of OBARRAY]
the hash-keys/hash-values of HASH-TABLE [using (hash-values/hash-keys V2)]
the key-codes/key-bindings/key-seqs of KEYMAP [using (key-bindings VAR2)]
the overlays/intervals [of BUFFER] [from POS1] [to POS2]
the frames/buffers
the windows [of FRAME]
Iteration clauses:
repeat INTEGER
while/until/always/never/thereis CONDITION
Accumulation clauses:
collect/append/nconc/concat/vconcat/count/sum/maximize/minimize FORM
[into VAR]
Miscellaneous clauses:
with VAR = INIT
if/when/unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...]
named NAME
initially/finally [do] EXPRS...
do EXPRS...
[finally] return EXPR
For more details, see Info node `(cl)Loop Facility'.
(fn CLAUSE...)
(defalias 'cl-loop '(macro . #[128 #@1265 ("\306\307\310\311\312\311\306\313!\"\"\">\2040\314\312\315\306BBE\207\211\312\211\211\211\211\211\211\211\211\211\211\211\211\211\211 _ ! \" # $ % & ' (\316(\317\"((@\320=\204Z0\321 \210\202L0 \203i0 \322BC&B& \203\2000 \323BC&B&\324 \325BB$B$ \237\"\206\2110#C\244\326%\237!\211A@$\237\244\316\f\237\n\203\2740\314\327\n@\306=\203\2550\202\2670\330@\331BBB!E\202\3020\315@BBC \203\3420\332\232\203\3240!C\202\3430\333 \334B!FC\202\3430#!\203\3610!C&B&&\2035&@A\203\335&\211A&\242\306#C\262\202\3610\312&\203*&@A\204*&\211A&\242@B\262\202\335\312#C\266\202\202\3610\203A\336BBC\262\314'BB\266\204.\207" . [cl--loop-symbol-macs cl--loop-first-flag cl--loop-iterator-function cl--loop-finally cl--loop-initially cl--loop-accum-vars t mapcar symbolp delq nil cl-copy-list cl-block while append (cl-end-loop) cl-end-loop cl--parse-loop-clause (t) (t) setq (nil) cl--loop-build-ands --cl-finish-- or ((cl-return-from --cl-finish-- nil)) (nil) if progn cl--loop-let cl-symbol-macrolet cl--loop-accum-var cl--loop-finish-flag cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-steps cl--loop-body cl--loop-bindings cl--loop-name cl--loop-args]) (#$ . 25883) nil 17 (#$ . 24711)]))
(put 'cl-loop 'edebug-form-spec '(&rest &or [[&or "for" "as" "with" "and"] sexp] [[&or "from" "upfrom" "downfrom" "to" "upto" "downto" "above" "below" "by" "in" "on" "=" "across" "repeat" "while" "until" "always" "never" "thereis" "collect" "append" "nconc" "sum" "count" "maximize" "minimize" "if" "unless" "return"] form] symbolp form))
(defalias 'cl--parse-loop-clause #[0 #@10532 ("\211A\242C\306\307\2040\310\311!\210\202_
\242\312=\203#0\211A\242\202_
\242\313=\203Q0@\314>\20360\210A@:\204@0\310\315!\210@:\203_
\211A\242\nB\202@0\242\316=\203\2600@\317=\203n0A@AA\206j0\320\202_
@\321>\203z0\210A@:\204\2040\310\322!\210@@\317=\203\2370 \204\2370\211A\242A@\206\2330\323\202_
@:\203_
\211A\242\fB\202\2370\242\324>\203\324\325\211\211\211\211A\242\206\3060\326\327!C\211A\242\240\210\242\330=\203\3410\211A\242\240\210\242\331>\203\3620\211A\242\240\210\242\332>\203\333\240\210\334B\242\335>\203\373\242B\211@\336>\203 \310\337!\210@\340=\206(\3418\342>@\343>\2064\3418\344>@\345>\205BA@AA@\346>\205PA@AA@\347=\205^A@AA\350!?\205h\351\327!\350!?\205r\351\327!\203\206\247\203\206\352X\203\206\310\353\"\210\242\206\216\352D\fB\262\f\203\240D\fB\262\f\211\203\254\211D\fB\262\f\203\326\203\301\203\275\354\202\312\355\202\312\203\311\356\202\312\357\242\206\322E
B\242\203\342\360\202\343\361 \242\206\357\206\357\362ED\nB\262\n\266\202a\242\363>\203\240\242\364=\211\203\2429\203\242\202\351\327!\211\211A\242DB\262\365D
B \242\366=\203B\242\367DD@B@\202e\211\242=\204e\242\325DB\262\242\203\\\202_\367DDB\262\211@\347=\203\223A@AA\211\242\370>\203\212\211A@9\203\212\211A@D\202\216\371E\262\202\226\372DDB\262\266\202a\242\373=\203 \211A\242@\374=\203\276A@AA\202\277\211\242\325DB\262\204\323@\375=\203\367\242\376A\206\341\351\327!\211A\242FDB\262\242DB\262\202\242=\203\202\376A\206\351\327!\211AFDB\262\266\202a\242\377>\203\220\351\201H0!\351\201I0!\211A\242DB\262\211\201J0DB\262\356\201K0\201L0DE\201M0DE
B \242\201N0=\203t\242\201O0ED@B@\202\213\242\325DB\262\242\201O0EDB\262\266\202a\242\201P0>\203|@\201Q0>\206\262@\201R0>?\205\262\310\201S0!A@AA\351\201T0!@\201U0=\203\357A@G\341U\203\347A@@\201V0=\203\347A@AAA@\202\364\310\201W0!\202\364\351\201I0!D B\262 \211\352D B\262 \2032\351\201X0!\211\201M0DD\nB\262\n\242\201Y0ED@B@\356E
B\210\202k\242\325D B\262 \375\201Z0\365D\356\201M0DEEE
B\242\376\365D\201[0D\201O0EFDB\262\211\201L0DDB\262\266\202a\242>\203@\201\\0>\204\224\310\201S0!\210A@AA\211@\201U0=\203\326A@G\341U\203\316A@@>\203\316A@@ \242=\204\316A@AAA@\202\331\310\201W0!\202\331\351\327!C \242\201]0>\203\356\242\242\240\210\240\210\201^0\201_0\201`0\201a0\201b0\201c0\201d0 #\201e0\"\201f0\201g0%\"\266\202a\242\201h0>\203`@\201i0>\2055A@AA\201^0\201j0\201`0\201a0\201k0\201c0\201d0\"\201l0\"\201f0\201g0%\"\266\202a\242\201m0>\203\341\325C\325C\325C@\201n0>\203\262@\201o0=\203\217A@AA\240\210\202p@\201p0=\203\245\211A@AA\240\210\202pA@AA\240\210\202p\201^0\201q0\201`0\201a0\201r0\201c0\201d0\n\n\n\n$\201s0\"\201t0\201g0%\"\266\202a\242\201u0>\203\304\325C\325C\325C\325C\351\201v0!C\351\201w0!C@\201x0>\203W@\201o0=\203 A@AA\240\210\202\377@\201p0=\2034A@AA\240\210\202\377@\201y0=\203JA@AA\240\210\202\377A@AA\240\210\202\377\242:\203\242@9\203\242A9\203\242@\240\210\211\242A\240\210\202\220\242\201z0\242\242ED\nB\262\n\201^0\201{0\201`0\201a0\201|0\201c0\201d0\f\f\f\f\f\f&\201}0\"\201~0\201g0%\"\266\202a\242>\203e@\2010>\204\334\310\201S0!\210A@AA\211@\201U0=\203 A@G\341U\203A@@>\203A@@ \242=\204A@AAA@\202!\310\201W0!\202!\351\327!C \242\201\2000>\2036\242\242\240\210\240\210\201^0\201\2010\201`0\201a0\201\2020\201c0\201d0\n\n\n$\201\2030\"\201f0\201g0%\"\266\202a\242\201\2040>\203\265\351\327!\242\201\2050DB\262\211\325DB\262\201\2060\201\2070\201\2100\242ED\201Z0\201K0\242EEE
B\242\201\2110\242DDB\262\210\202a\242\201\2120>\203=@\201\2130>\205\317A@AA\351\327!\351\201\2140!\242\203\345\201\2150D\202\350\201\2160DB\262\211\201\2170\201\2200\242DDDB\262\325DB\262\201\2060\201\2070\201\2100\242ED\201Z0\201K0 \242EEE
B\242\201\2210\242EDB\262\266\202a\2429\205K\242\201\2220N\211\203W\211\242!\210\202`\310\201\2230\n\242\"\210\210@\375=\262\203w\201\2240\262\211A\210\202\2730\211\203\211\203\211\237BBB\202\226\201\2250\201\2260\"B\244B\203\257\201\2270\201\2300\237\201K0#\201\2310BB
B\203\317\211\203\275\201\2320\202\300\201K0\201\2330\201\2340\237\"BCBC\266\202_
\242\201\2350=\203 \351\327!\211\211A\242DCBBB\355\201K0\201\2360DE\201\2370BB
B\210\202_
\242\201\2400>\203U \211A\242\201\2410\325\201\2420\"\211D=\2035 \201\2270\201\2430E\201\2440BB
B\202P \201\2270\201K0\201\2450\201\2260DEE\201\2460BB
B\266\202_
\242\201\2470>\203\274 \211A\242\201\2410\325\201\2420\"\201\2270\201K0\211D=\203\227 \201\2450\242\201\2500>\203\214 \201\2420\202\217 \201\2510DE\202\256 \242\201\2520>\203\247 \201\2450\202\252 \201\2340EE\201\2530BB
B\266\202_
\242\201\2540>\203\352 \211A\242\201\2410\201\2550!\201\2270\201\2560\201\2570F\201\2600BB
B\266\202_
\242\201\2610>\203\n\211A\242\201\2410\201\2620!\201\2270\201\2560\201c0F\201\2630BB
B\266\202_
\242\201\2640>\203A\n\211A\242\201\2410\352!\201\2270\201\2650E\201\2660BB
B\266\202_
\242\201\2670>\203l\n\211A\242\201\2410\352!\201\2270\376\201\2650DE\201\2700BB
B\266\202_
\242\201\2710>\203\325\n\201\2270\211A\242\201\2720!\203\211\n\211\202\216\n\351\201\2730!\201\2410\325!\201\2740\201\2750\242!\352\201\2760O!\201K0\376EFE\266\202=\203\277\n\211\202\310\n\201\2770DC\"\266\203\201\3000BB
B\202_
\242\201\3010=\203 \325\211A\242@\373=\205\362\nA@AADB\262@\375=\203 \211A\210\202\337\n\211\237BBB\210\202_
\242\201\3020=\203% \211A\242
B\202_
\242\201\3030=\203= \201\2070\211A\242D
B\202_
\242\201\3040=\203h E\204R \351\201\3050!E\201K0E\211A\242E
B\201\2240F\202_
\242\201\3060=\203\227 E\204} \351\201\3050!E\201K0E\201\2070\211A\242DE
B\201\2240F\202_
\242\201\3070=\203\321 E\204\254 \351\201\3050!EG\204\266 \351\327!G\201K0E\201\2070\201K0G\211A\242EDE
B\202_
\242\201\3100>\203\226\f\211A\242\325 \201\3110 \210\201\3120
\237!)\325 @\201\3130=\203\f\210A\201\3110 \210\201\3120
\237!)@\201\2240=\205\f\211@\201\2240=@\201\3140=\203&\f\210A\242\201\3150=\2036\f\262\262\211\203D\f\201\2270A@B\202G\f\3418\203Q\fA@\202U\f\3418CB\201\3160\201\3170\"\203v\f\201\3200\201\3170DC\376\201\3170BBE\202{\f\376BB\262\203\215\f\201\2270\201\3210BB\202\216\f\211
B\266\202_
\242\201\3220>\203\317\f\325@:\204\254\f\310\201\3230!\210@:\203\276\f\211A\242B\262\202\254\f\201\2270\201\2240B\237B
B\210\202_
\242\317=\203
E\204\340\f\351\327!EG\204\352\f\351\327!G\201K0G\211A\242E\201\3240BBBB
B\202_
\2429\205
\242\201\3250N\211\204
\310\201\3260\242\"\210\211 \266@\375=\205/
\210A\201\3110 \207" . [cl--loop-args cl--loop-name cl--loop-initially cl--loop-result-explicit cl--loop-finally cl--loop-body (hash-key hash-keys hash-value hash-values) (key-code key-codes key-seq key-seqs key-binding key-bindings) error "Malformed `cl-loop' macro" named initially (do doing) "Syntax error on `initially' clause" finally return 'nil (do doing) "Syntax error on `finally' clause" 'nil (for as) nil cl-gensym "--cl-var--" being (the each) (buffer buffers) in (buffer-list) (from downfrom upfrom to downto upto above below by) (downto above) "Must specify `from' value for downward cl-loop" downfrom 2 (downto above) (above below) (above below) (from upfrom downfrom) (to upto downto above below) by macroexp-const-p make-symbol 0 "Loop `by' value is not positive: %s" > >= < <= - + 1 (in in-ref on) on consp in-ref car (quote function cl-function) funcall cdr = then and if (across across-ref) cl--loop-symbol-macs cl--loop-first-flag cl--loop-bindings cl--loop-steps cl--loop-accum-var cl--loop-finish-flag cl--loop-result cl--loop-result-var "--cl-vec--" "--cl-idx--" -1 setq 1+ length across-ref aref (element elements) (in-ref of-ref) (in of) "Expected `of'" "--cl-seq--" using index "Bad `using' clause" "--cl-len--" elt or pop (in of) (hash-value hash-values) cl--loop-set-iterator-function hash-tables make-byte-code 257 "\303\304\300\242\302\242DBB\301E\207" vconcat vector [maphash lambda] 5 "\n\n(fn BODY)" (symbol present-symbol external-symbol symbols present-symbols external-symbols) (in of) symbols "\302\303\300\242CBB\301E\207" [mapatoms lambda] (overlay overlays extent extents) (in of from to) from to overlays "\304\305\300\242\306\307!D\310B\311BBB\301\242\302\242\303\242\257\207" [cl--map-overlays lambda make-symbol "--cl-var--" progn (nil)] 6 (interval intervals) "--cl-var1--" "--cl-var2--" (in of property from to) property cons intervals "\306\307\304\242\305\242DBB\300\242\301\242\302\242\303\242\257\207" [cl--map-intervals lambda] 7 (in of) (key-binding key-bindings) keys "\300\242\304>\203 0\305\202\f0\306\307\301\242\303\242DBB\302E\207" [(key-seq key-seqs) cl--map-keymap-recursively map-keymap lambda] (frame frames screen screens) (selected-frame) prog1 not eq next-frame (window windows) (in of) "--cl-minip--" frame-selected-window (selected-window) minibufferp window-buffer next-window cl-loop-for-handler "Expected a `for' preposition, found %s" t mapcar list progn cl--loop-let (t) cl-psetq apply append repeat 1- (0) (collect collecting) cl--loop-handle-accum nreverse push (t) nconc (t) (nconc nconcing append appending) (nconc nconcing) reverse (nconc nconcing) (t) (concat concating) "" cl-callf concat (t) (vconcat vconcating) [] (t) (sum summing) cl-incf (t) (count counting) (t) (minimize minimizing maximize maximizing) macroexp-copyable-p "temp" intern symbol-name 3 macroexp-let* (t) with while until always "--cl-flag--" never thereis (if when unless) cl--parse-loop-clause cl--loop-build-ands else end unless cl--expr-contains it let (t) (do doing) "Syntax error on `do' clause" (nil) cl-loop-handler "Expected a cl-loop keyword, found %s"]) (#$ . 27567) nil 28])
(defalias 'cl--unused-var-p #[257 #@61 ("\211?\206\f0\300!\301H\302=\207" . [symbol-name 0 95]) (#$ . 38159) nil 3 "\n\n(fn SYM)"])
#@333 Build an expression equivalent to (let SPECS BODY).
SPECS can include bindings using `cl-loop's destructuring (not to be
confused with the patterns of `cl-destructuring-bind').
If PAR is nil, do the bindings step by step, like `let*'.
If BODY is `setq', then use SPECS for assignments rather than for bindings.
(fn SPECS BODY PAR)
(defalias 'cl--loop-let #[771 #@852 ("\301\211\203R0\211\203 0\211@\2429\2040\211@A@\204 0\211A\262\2020\211\203Q0\301\262\211\203P0\211@\302A@!\204I0\303\304!\211A@DB\262A\240\266A\266\202\202(0\210\210\203\3430\211A\262\242\211\242:\203\3310\211:\204n0\305!\203\3310\301\243@\306\307\"\305!\203\2000\203\2530\211\203\2210\310=\203\2430\305!\203\2430\303\304!\262\310=\203\2430\211CCB\211DB\262:\203\3150\211A\262\242\205\3050\203\3020\311\202\3030\312DDB\262\202\2530\237\n\244\262\n\266\202\3360B\262\266\202R0\310=\203\n\203\3610\313\202\3620\310\314\315\237\"B\203\316\237E\202\211\262\202\203\317\202\316\237\237\244BB\207" . [cl--loop-bindings nil macroexp-const-p make-symbol "--cl-var--" cl--unused-var-p last 0 setq pop car cl-psetq apply nconc let* let]) (#$ . 38630) nil 13 (#$ . 38261)])
(defalias 'cl--loop-handle-accum #[513 #@248 ("@\305=\203!0A@AA\211 >\204_0\211DC\nB\211 B\211\207 \206=0\306\307!\211DC\nB\211\203:0\211 D\202;0 \207" . [cl--loop-args cl--loop-accum-vars cl--loop-bindings cl--loop-accum-var cl--loop-result into make-symbol "--cl-var--"]) (#$ . 39561) nil 5 "\n\n(fn DEF &optional FUNC)"])
#@292 Return various representations of (and . CLAUSES).
CLAUSES is a list of Elisp expressions, where clauses of the form
(progn E1 E2 E3 .. t) are the focus of particular optimizations.
The return value has shape (COND BODY COMBO)
such that COMBO is equivalent to (and . CLAUSES).
(fn CLAUSES)
(defalias 'cl--loop-build-ands #[257 #@386 ("\300\211\203Z0@\242\301=\203M0\302@!@\303=\203M0A\203?0\304@!A@\242\301=\20310A@A\20250A@C\244AAB\262\2020\304\211A\262\242!A\262\2020\211A\262\242B\262\2020\237\206a0\303C\262A\203n0\305B\202p0@\211\203\2030\306\301\306\307\"BC\"\202\2040\211A\203\2170\305B\202\2210\211@\262E\207" . [nil progn last t butlast and append (t)]) (#$ . 40200) nil 11 (#$ . 39865)])
#@88 The Common Lisp `do' loop.
(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)
(defalias 'cl-do '(macro . #[642 #@49 ("\300\301$\207" . [cl--expand-do-loop nil]) (#$ . 40751) nil 8 (#$ . 40625)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-do lisp-indent-function 2 put edebug-form-spec ((&rest &or symbolp (symbolp &optional form form)) (form body) cl-declarations body)] 4)
#@89 The Common Lisp `do*' loop.
(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)
(defalias 'cl-do* '(macro . #[642 #@47 ("\300\301$\207" . [cl--expand-do-loop t]) (#$ . 41176) nil 8 (#$ . 41048)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-do* lisp-indent-function 2 put edebug-form-spec cl-do] 4)
(defalias 'cl--expand-do-loop #[1028 #@399 ("\300\301\203\n0\302\202 0\303\304\305\"\306\307@D\310\304\311
\"\312\301\"\262\211\205=0 \20420\211A\20460\313\20270\314\315\310\"BC\262\"BBA\206I0\316BBBE\207" . [cl-block nil let* let mapcar #[257 "\211:\203\f0\211@A@D\207\207" [] 3 "\n\n(fn C)"] while not append #[257 "\211:\2050\211AA\2050\211@\3008D\207" [2] 4 "\n\n(fn C)"] delq setq cl-psetq apply (nil)]) (#$ . 41431) nil 17 "\n\n(fn STEPS ENDTEST BODY STAR)"])
#@225 Loop over a list.
Evaluate BODY with VAR bound to each `car' from LIST, in turn.
Then evaluate RESULT to get return value, default nil.
An implicit nil block is established around the loop.
(fn (VAR LIST [RESULT]) BODY...)
(defalias 'cl-dolist '(macro . #[385 #@122 ("\300BB\301\302\300\"\2030\211\2020\303\304E\207" . [dolist advice-member-p cl--wrap-in-nil-block cl-block nil]) (#$ . 42160) nil 6 (#$ . 41892)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [put cl-dolist edebug-form-spec ((symbolp form &optional form) cl-declarations body) function-put lisp-indent-function 1] 4)
#@216 Loop a certain number of times.
Evaluate BODY with VAR bound to successive integers from 0, inclusive,
to COUNT, exclusive. Then evaluate RESULT to get return value, default
nil.
(fn (VAR COUNT [RESULT]) BODY...)
(defalias 'cl-dotimes '(macro . #[385 #@123 ("\300BB\301\302\300\"\2030\211\2020\303\304E\207" . [dotimes advice-member-p cl--wrap-in-nil-block cl-block nil]) (#$ . 42763) nil 6 (#$ . 42503)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [put cl-dotimes edebug-form-spec cl-dolist function-put lisp-indent-function 1] 4)
(defvar cl--tagbody-alist nil)
#@603 Execute statements while providing for control transfers to labels.
Each element of LABELS-OR-STMTS can be either a label (integer or symbol)
or a `cons' cell, in which case it's taken to be a statement.
This distinction is made before performing macroexpansion.
Statements are executed in sequence left to right, discarding any return value,
stopping only when reaching the end of LABELS-OR-STMTS.
Any statement can transfer control at any time to the statements that follow
one of the labels with the special form (go LABEL).
Labels have lexical scope and dynamic extent.
(fn &rest LABELS-OR-STMTS)
(defalias 'cl-tagbody '(macro . #[128 #@767 ("\302@:\203 0\303\2020\211A\262\242\211C\211\203G0\211@\211:\203'0\211B\262\202@0\242\242\304=\20460\304DB\262\237B\262\211C\262A\266\202\2020\210\211\242\242\304=\204U0\305B\262\211\237B\262\210\306\307!\310BB\211\203|0\211@\211@BBA\266\202\202h0\210\311\312\313\314DDC\315\316\317\320\313\321\314\nD\322\313BBEE\323BBDDE\304\324B B\")\262\207" . [cl--tagbody-alist macroexpand-all-environment nil cl--preamble go (go cl--exit) make-symbol "cl--tagbody-tag" cl--exit macroexpand-all let next-label quote while not eq setq catch cl-case ('cl--exit) #[257 "\211\236A\211\204
0\301\302\"\210\303\304D\304DE\207" [cl--tagbody-alist error "Unknown cl-tagbody go label `%S'" throw quote] 6 "\n\n(fn LABEL)"]]) (#$ . 43743) nil 17 (#$ . 43096)]))
#@149 Loop over all symbols.
Evaluate BODY with VAR bound to each interned symbol, or to each symbol
from OBARRAY.
(fn (VAR [OBARRAY [RESULT]]) BODY...)
(defalias 'cl-do-symbols '(macro . #[385 #@121 ("\300\301\302@C\303\304\305@CBBDA@\205 0A@CBB\3068FE\207" . [cl-block nil let mapatoms function lambda 2]) (#$ . 44747) nil 11 (#$ . 44551)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-do-symbols lisp-indent-function 1 put edebug-form-spec ((symbolp &optional form form) cl-declarations body)] 4)
#@81 Like `cl-do-symbols', but use the default obarray.
(fn (VAR [RESULT]) BODY...)
(defalias 'cl-do-all-symbols '(macro . #[385 #@49 ("\300@\301A@EBB\207" . [cl-do-symbols nil]) (#$ . 45224) nil 6 (#$ . 45093)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-do-all-symbols lisp-indent-function 1 put edebug-form-spec ((symbolp &optional form) cl-declarations body)] 4)
#@202 Set SYMs to the values VALs in parallel.
This is like `setq', except that all VAL forms are evaluated (in order)
before assigning any symbols SYM to the corresponding values.
(fn SYM VAL SYM VAL ...)
(defalias 'cl-psetq '(macro . #[128 #@30 ("\300B\207" . [cl-psetf]) (#$ . 45740) nil 3 (#$ . 45497)]))
(put 'cl-psetq 'edebug-form-spec 'setq)
#@438 Bind SYMBOLS to VALUES dynamically in BODY.
The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists.
Each symbol in the first list is bound to the corresponding value in the
second list (or to nil if VALUES is shorter than SYMBOLS); then the
BODY forms are executed and their result is returned. This is much like
a `let' form, except that the list of symbols can be computed at run-time.
(fn SYMBOLS VALUES &rest BODY)
(defalias 'cl-progv '(macro . #[642 #@290 ("\300\301!\300\302!\300\303!\300\304!\305\306 D D\307\310 BBD\311BF\312\313\314\315 D\314\316\315 DEE EE\317\314\320 \314\321\314\322EEFDFD\207" . [make-symbol "body" "binds" "syms" "vals" progn let* lambda nil (nil) while push list pop 'quote eval 'let 'funcall 'quote]) (#$ . 46330) nil 20 (#$ . 45850)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-progv lisp-indent-function 2 put edebug-form-spec (form form body)] 4)
(defconst cl--labels-magic (make-symbol "cl--labels-magic"))
(defvar cl--labels-convert-cache nil)
#@82 Special macro-expander to rename (function F) references in `cl-labels'.
(fn F)
(defalias 'cl--labels-convert #[257 #@238 ("\211@=\203\n0A\207\211 \236\211\205_0\3031 0\211A\n!0\202_0\210\304\211\20300\n@=\20300\211A@\202:0\305DB\211\262\207" . [cl--labels-convert-cache macroexpand-all-environment cl--labels-magic (error) nil function]) (#$ . 47027) nil 6 (#$ . 46903)])
#@408 Make local function definitions.
Like `cl-labels' but the definitions are not recursive.
Each binding can take the form (FUNC EXP) where
FUNC is the function name, and EXP is an expression that returns the
function value to which it should be bound, or it can take the more common
form (FUNC ARGLIST BODY...) which is a shorthand
for (FUNC (lambda ARGLIST BODY)).
(fn ((FUNC ARGLIST BODY...) ...) FORM...)
(defalias 'cl-flet '(macro . #[385 #@576 ("\301\211\203^0\211@\302\303\304@\"!CA\211G\305U\203(0\211@9\203(0@\240\210\202A0\242G\305U\20360@\202;0\306\307BDDB\262@\310\311\312\313\314!\315\"\316\317%BB\262\266A\266\202\2020\210\320\237\321\322B\323\236\203q0\202v0\323\324BB\"\"\207" . [macroexpand-all-environment nil make-symbol format "--cl-%s--" 1 cl-function lambda make-byte-code 128 "\211@ =\203\f0 \300\242D\207\302\300\242BB\207" vconcat vector [cl--labels-magic funcall] 4 "\n\n(fn &rest ARGS)" macroexp-let* macroexpand-all progn function cl--labels-convert]) (#$ . 47753) nil 15 (#$ . 47304)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-flet lisp-indent-function 1 put edebug-form-spec ((&rest (cl-defun)) cl-declarations body)] 4)
#@140 Make local function definitions.
Like `cl-flet' but the definitions can refer to previous ones.
(fn ((FUNC ARGLIST BODY...) ...) FORM...)
(defalias 'cl-flet* '(macro . #[385 #@117 ("\2040\300!\207A\2040\301BB\207\301\211A\262\242C\302BBE\207" . [macroexp-progn cl-flet cl-flet*]) (#$ . 48720) nil 7 (#$ . 48538)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-flet* lisp-indent-function 1 put edebug-form-spec cl-flet] 4)
#@214 Make temporary function bindings.
The bindings can be recursive and the scoping is lexical, but capturing them
in closures will only work if `lexical-binding' is in use.
(fn ((FUNC ARGLIST BODY...) ...) FORM...)
(defalias 'cl-labels '(macro . #[385 #@465 ("\301\211\20380\211@\302\303\304@\"!\211\305\306ABDDB\262@\307\310\311\312\313!\314\"\315\316%BB\262\210A\266\202\2020\210\317\320\237BB\321\236\203J0\202O0\321\322BB\"\207" . [macroexpand-all-environment nil make-symbol format "--cl-%s--" cl-function lambda make-byte-code 128 "\211@ =\203 0 \300D\207\302\300BB\207" vconcat vector [cl--labels-magic funcall] 4 "\n\n(fn &rest ARGS)" macroexpand-all letrec function cl--labels-convert]) (#$ . 49269) nil 14 (#$ . 49012)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-labels lisp-indent-function 1 put edebug-form-spec cl-flet] 4)
#@139 Make temporary macro definitions.
This is like `cl-flet', but for macros instead of functions.
(fn ((NAME ARGLIST BODY...) ...) FORM...)
(defalias 'cl-macrolet '(macro . #[385 #@248 ("A\2030\301@C\301ABBE\207\2040\302!\207@@\303@A\"\304@!\210\305\302!\304\306\307ABD\310\"BB\"\207" . [macroexpand-all-environment cl-macrolet macroexp-progn cl--transform-lambda eval macroexpand-all cl-function lambda t]) (#$ . 50095) nil 11 (#$ . 49911)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-macrolet lisp-indent-function 1 put edebug-form-spec ((&rest (&define name (&rest arg) cl-declarations-or-string def-body)) cl-declarations body)] 4)
(defconst cl--old-macroexpand (byte-code "\301\300!\203 \302K\303=\203 \207\302K\207" [cl--old-macroexpand boundp macroexpand cl--sm-macroexpand] 2))
#@259 Special macro expander used inside `cl-symbol-macrolet'.
This function replaces `macroexpand' during macro expansion
of `cl-symbol-macrolet', and does the same thing as `macroexpand'
except that it additionally expands symbol macros.
(fn EXP &optional ENV)
(defalias 'cl--sm-macroexpand #[513 #@999 ("C\211 \242\"\240\210\302\2429\203*0\303\242!\236A\205\2500\303\242!\236A@\240\202\2500\242:\203\2470\242@\211\304=\203v0\305\306\307\310\311\312 !\313\"\314\315%\242A\"\211\211\203^0\211@9\203^0\211AA\262\202L0\211\203j0\316B\240\202q0\304B\240\210\317\266\202\202\2420\211\320>\203\2410\242A\211:\203\2250\211@A$\266\202\202\2340\317\211$\262\202\2420\317\262\202\2500\317\262\2040\211\242)\207" . [macroexpand-all-environment cl--old-macroexpand #[1028 "\300\211\211\211\203E0\211@\2119\2030\211\2020\211@\301! \236\211A\204$0\20280\211A@\302\262\2119\20420\302\262\211\243B\262B\262\266A\266\202\2020\210\205l0\203a0\242@\303=\203]0\304\202e0\305\202e0\242@\237BB\240\207" [nil symbol-name t let cl-letf cl-letf*] 14 "\n\n(fn EXP ENV BODY BINDINGS)"] symbol-name setq mapcar make-byte-code 257 "\301\300\"\207" vconcat vector [cl--sm-macroexpand] 4 "\n\n(fn F)" setf nil (let* let)]) (#$ . 51061) nil 13 (#$ . 50760)])
#@211 Make symbol macro definitions.
Within the body FORMs, references to the variable NAME will be replaced
by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...).
(fn ((NAME EXPANSION) ...) FORM...)
(defalias 'cl-symbol-macrolet '(macro . #[385 #@477 ("A\2030\301@C\301ABBE\207\2040\302!\207\303K\304\305\306\307\310!\311\"\312$\216\303\313M\210\314\302!\315@@!@A@DB\"@A\203I0@AA\203U0\316\317\320@\"\"\202V0\211\262)\207" . [macroexpand-all-environment cl-symbol-macrolet macroexp-progn macroexpand make-byte-code 0 "\301\300M\207" vconcat vector [macroexpand] 2 cl--sm-macroexpand macroexpand-all symbol-name macroexp--warn-and-return format-message "Malformed `cl-symbol-macrolet' binding: %S"]) (#$ . 52363) nil 9 (#$ . 52100)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-symbol-macrolet lisp-indent-function 1 put edebug-form-spec ((&rest (symbol sexp)) cl-declarations body)] 4)
#@393 Collect multiple return values.
FORM must return a list; the BODY is then executed with the first N elements
of this list bound (`let'-style) to each of the symbols SYM in turn. This
is analogous to the Common Lisp `multiple-value-bind' macro, using lists to
simulate true multiple return values. For compatibility, (cl-values A B C) is
a synonym for (list A B C).
(fn (SYM...) FORM BODY)
(defalias 'cl-multiple-value-bind '(macro . #[642 #@221 ("\300\301!\302C\303D\304\305\306\307\310\311 \"\312\"\313\314%\"BBB\207" . [make-symbol "--cl-var--" -1 let* mapcar make-byte-code 257 "\211\302\301\211\242T\240\300ED\207" vconcat vector [nth] 5 "\n\n(fn V)"]) (#$ . 53511) nil 15 (#$ . 53062)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-multiple-value-bind lisp-indent-function 2 put edebug-form-spec ((&rest symbolp) form body)] 4)
#@348 Collect multiple return values.
FORM must return a list; the first N elements of this list are stored in
each of the symbols SYM in turn. This is analogous to the Common Lisp
`multiple-value-setq' macro, using lists to simulate true multiple return
values. For compatibility, (cl-values A B C) is a synonym for (list A B C).
(fn (SYM...) FORM)
(defalias 'cl-multiple-value-setq '(macro . #[514 #@358 ("\204\n0\300\301BB\207A\2040\302@\303DE\207\304\305!\306C\307DC\310\302\211A\262 \242\303DE\302\311\312\313\314\315\316\317\320\"\321\"\322\323%\f\"\"BEE\207" . [progn (nil) setq car make-symbol "--cl-var--" 0 let prog1 apply nconc mapcar make-byte-code 257 "\211\302\301\211\242T\240\300ED\207" vconcat vector [nth] 5 "\n\n(fn V)"]) (#$ . 54346) nil 19 (#$ . 53942)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-multiple-value-setq lisp-indent-function 1 put edebug-form-spec ((&rest symbolp) form)] 4)
#@41 Equivalent to `progn'.
(fn &rest BODY)
(defalias 'cl-locally '(macro . #[128 #@27 ("\300B\207" . [progn]) (#$ . 54992) nil 3 (#$ . 54908)]))
(put 'cl-locally 'edebug-form-spec t)
#@87 Return FORM. If type-checking is enabled, assert that it is of TYPE.
(fn TYPE FORM)
(defalias 'cl-the '(macro . #[514 #@356 ("\302 \2030\303W\2040 \303U\2040\207\211\304!\203 0\211\202 0\305\306!\307\310\311\312DE\313\314\315\312\nD\312 DFEEE=\203E0\211\202L0\316DC\"\207" . [cl--optimize-speed cl--optimize-safety cl--compiling-file 3 macroexp-copyable-p make-symbol "temp" progn unless cl-typep quote signal 'wrong-type-argument list macroexp-let*]) (#$ . 55223) nil 14 (#$ . 55096)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-the lisp-indent-function 1 put edebug-form-spec (cl-type-spec form)] 4)
(defvar cl--proclaim-history t)
(defvar cl--declare-stack t)
(defalias 'cl--do-proclaim #[514 #@1030 ("\211\203
0<\203
0B\242\306=\203#0\307\301!\203\3250\310A \"\202\3250\242\311=\203K0A\211\262\203\3250@\312N\313>\204A0\314\315@\"\210\316@\312\317#\210\202*0\242\320=\203m0A\211\262\203\3250@\312N\317=\203R0\316@\312\321#\210\202R0\242\322=\203\2370\323A\236A@\324\236\325A\236A@\326\236\203\2170@A@\211\203\2320\211@\211A@\266\202\3250\242\327=\203\3250\307\330!\203\3250A\211\262\203\3250@:\203\2540@A@\331=\203\3140\332@@!\210\202\2540\333@@!\210\202\2540\321\207" . [cl--proclaim-history byte-compile-bound-variables cl--optimize-speed byte-optimize cl--optimize-safety byte-compile-delete-errors special boundp append inline byte-optimizer (nil byte-compile-inline-expand) error "%s already has a byte-optimizer, can't make it inline" put byte-compile-inline-expand notinline nil optimize speed ((0 nil) (1 t) (2 t) (3 t)) safety ((0 t) (1 t) (2 t) (3 nil)) warn byte-compile-warnings 0 byte-compile-disable-warning byte-compile-enable-warning]) (#$ . 55860) nil 6 "\n\n(fn SPEC HIST)"])
(byte-code "\301!\211\203 \302\211A\262\242\303\"\210\202 \304\207" [cl--proclaims-deferred reverse cl--do-proclaim t nil] 4)
#@215 Declare SPECS about the current function while compiling.
For instance
(cl-declare (warn 0))
will turn off byte-compile warnings in the function.
See Info node `(cl)Declarations' for details.
(fn &rest SPECS)
(defalias 'cl-declare '(macro . #[128 #@152 ("\301 \203 0\211\203 0<\2030\211@B\302\211A\262\242\303\"\210\2020\303\207" . [cl--declare-stack cl--compiling-file cl--do-proclaim nil]) (#$ . 57328) nil 4 (#$ . 57069)]))
#@203 Set PLACEs to the values VALs in parallel.
This is like `setf', except that all VAL forms are evaluated (in order)
before assigning any PLACEs to the corresponding values.
(fn PLACE VAL PLACE VAL ...)
(defalias 'cl-psetf '(macro . #[128 #@434 ("\211\300\301\203A0@9\2030\302A@\"\2030\301\262@>\203&0\303\304@\"\210\211A\262\242B\262\20480\303\305!\210\211A\262\210\2020\203O0\306\307B\310BB\202{0\311!\262\312A@@EAA\211\262\203t0\312A@\313@EE\262\202[0\306\314BB\262\207" . [t nil cl--expr-depends-p error "Destination duplicated in psetf: %s" "Odd number of arguments to cl-psetf" progn setq (nil) reverse setf prog1 (nil)]) (#$ . 57765) nil 10 (#$ . 57520)]))
(put 'cl-psetf 'edebug-form-spec 'setf)
#@191 Remove TAG from property list PLACE.
PLACE may be a symbol, or any generalized variable allowed by `setf'.
The form returns true if TAG was found and removed, nil otherwise.
(fn PLACE TAG)
(defalias 'cl-remf '(macro . #[514 #@341 ("\300\301\302\303\304\305!\306\"\307\310%\"\207" . [gv-get make-byte-code 514 "\300\301!\203 0\211\2020\302\303!\304\305\306DE\307\310D!\311BB\312EF=\20300\211\20270\313DC\"\207" vconcat vector [macroexp-copyable-p make-symbol "ttag" if eq car progn cddr (t) cl--do-remf macroexp-let*] 10 "\n\n(fn TVAL SETTER)"]) (#$ . 58512) nil 10 (#$ . 58280)]))
(put 'cl-remf 'edebug-form-spec '(place form))
#@191 Shift left among PLACEs.
Example: (cl-shiftf A B C) sets A to B, B to C, and returns the old A.
Each PLACE may be a symbol, or any generalized variable allowed by `setf'.
(fn PLACE... VAL)
(defalias 'cl-shiftf '(macro . #[385 #@239 ("\211\2040\2079\2030\300\301\302BEE\207\303\304\305\306\307\310!\311\"\312\313%\"\207" . [prog1 setq cl-shiftf gv-get make-byte-code 514 "\301\302\300B!E\207" vconcat vector [prog1 cl-shiftf] 7 "\n\n(fn GETTER SETTER)"]) (#$ . 59175) nil 10 (#$ . 58941)]))
(put 'cl-shiftf 'edebug-form-spec '(&rest place))
#@195 Rotate left among PLACEs.
Example: (cl-rotatef A B C) sets A to B, B to C, and C to A. It returns nil.
Each PLACE may be a symbol, or any generalized variable allowed by `setf'.
(fn PLACE...)
(defalias 'cl-rotatef '(macro . #[128 #@527 ("\300\301\302\">\20400\211A\205m0\300@A\203&0\211A\262\242@D\244\262\2020\303\304@D\"B\207\305!\306\307!\211CA\203X0\211\310\211A\262\242\311\312\313\314\315!\316\"\317\320%\"\240\210\20280\310@\311\312\321\314\315\"\322\"\323\320%\"\266\203\207" . [nil mapcar symbolp cl-psetf append reverse make-symbol "--cl-rotatef--" gv-get make-byte-code 514 "\301\300\242!E\207" vconcat vector [prog1] 6 "\n\n(fn GETTER SETTER)" "\302\300DC\303\301\242!\304BB\"\207" [macroexp-let* progn (nil)] 7]) (#$ . 59744) nil 13 (#$ . 59505)]))
(put 'cl-rotatef 'edebug-form-spec '(&rest place))
(defalias 'cl--letf #[1028 #@936 ("\20400\2040\2040\300!\207\301\302\303\304\"\"\305\300\302\306\307\303\310\n\"\"\"!\303\311\"BBE\207@\312@\313\314\315\316\317 %\320\"\321\322%\"\207" . [macroexp-progn let* append mapcar #[257 "\211@A\211@A\211@A\211@A\n\211D\266\204\207" #1=[] 15 "\n\n(fn X)"] unwind-protect delq nil #[257 "\211:\205<0\211@A\211:\205:0\211@A\211:\20580\211@A\211:\20560\211@A\211?\20540\n!\266\204\266\202\266\202\266\202\266\202\207" #1# 15 "\n\n(fn X)"] #[257 "\211@A\211@A\211@A\211@A\n!\266\204\207" #1# 15 "\n\n(fn X)"] gv-get make-byte-code 514 "\304A@\305!\203
0\211\2020\306\307!\304@9\203.0\310\300A\304A\203#0\202%0D\301B\302\303$\202H0\310\300A\301\306\311!\304A\205A0CBBB\302B\303$=\203R0\211\202Y0\312DC\"\207" vconcat vector [macroexp-const-p make-symbol "vnew" cl--letf "old" macroexp-let*] 11 "\n\n(fn GETTER SETTER)"]) (#$ . 60390) nil 17 "\n\n(fn BINDINGS SIMPLEBINDS BINDS BODY)"])
#@531 Temporarily bind to PLACEs.
This is the analogue of `let', but with generalized variables (in the
sense of `setf') for the PLACEs. Each PLACE is set to the corresponding
VALUE, then the BODY forms are executed. On exit, either normally or
because of a `throw' or error, the PLACEs are set back to their original
values. Note that this macro is *not* available in Common Lisp.
As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
the PLACE is not modified before executing BODY.
(fn ((PLACE VALUE) ...) BODY...)
(defalias 'cl-letf '(macro . #[385 #@91 ("A\2040@A\2030@@9\2030\300BB\207\301\302\211$\207" . [let cl--letf nil]) (#$ . 61967) nil 7 (#$ . 61396)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-letf lisp-indent-function 1 put edebug-form-spec ((&rest (gate gv-place &optional form)) body)] 4)
#@192 Temporarily bind to PLACEs.
Like `cl-letf' but where the bindings are performed one at a time,
rather than all at the end (i.e. like `let*' rather than like `let').
(fn BINDINGS &rest BODY)
(defalias 'cl-letf* '(macro . #[385 #@112 ("\300!\211\2030\211@\301CBBC\262A\266\202\2020\210\302!\207" . [reverse cl-letf macroexp-progn]) (#$ . 62504) nil 7 (#$ . 62270)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-letf* lisp-indent-function 1 put edebug-form-spec cl-letf] 4)
#@177 Set PLACE to (FUNC PLACE ARGS...).
FUNC should be an unquoted function name. PLACE may be a symbol,
or any generalized variable allowed by `setf'.
(fn FUNC PLACE &rest ARGS)
(defalias 'cl-callf '(macro . #[642 #@207 ("\300\301\302\303\304\305 \"\306\"\307\310%\"\207" . [gv-get make-byte-code 514 "\301B\3009\2030\300B\2020\302\303\300DBB!\207" vconcat vector [funcall function] 7 "\n\n(fn GETTER SETTER)"]) (#$ . 63010) nil 12 (#$ . 62791)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-callf lisp-indent-function 2 put edebug-form-spec (cl-function place &rest form)] 4)
#@145 Set PLACE to (FUNC ARG1 PLACE ARGS...).
Like `cl-callf', but PLACE is the second argument of FUNC, not the first.
(fn FUNC ARG1 PLACE ARGS...)
(defalias 'cl-callf2 '(macro . #[899 #@421 ("\300!\203 0\301!\203 09\203 0\302BBBE\207\303!\203'0\211\202*0\304\305!\306\307\310\311\312\313\f\n #\314\"\315\316%\"=\203H0\211\202O0\317DC\"\207" . [cl--safe-expr-p cl--simple-expr-p setf macroexp-const-p make-symbol "a1" gv-get make-byte-code 514 "\302\301BB\3009\2030\300B\2020\303\304\300DBB!\207" vconcat vector [funcall function] 7 "\n\n(fn GETTER SETTER)" macroexp-let*]) (#$ . 63604) nil 16 (#$ . 63416)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put cl-callf2 lisp-indent-function 3 put edebug-form-spec (cl-function form place &rest form)] 4)
#@329 Define NAME as a function.
Like `defun', except the function is automatically declared `inline' and
the arguments are immutable.
ARGLIST allows full Common Lisp conventions, and BODY is implicitly
surrounded by (cl-block NAME ...).
The function's arguments should be treated as immutable.
(fn NAME ARGLIST [DOCSTRING] BODY...)
(defalias 'cl-defsubst '(macro . #[642 #@400 ("\300!@\301=\2030AA\2020\211\203(0\302@\"\303=\203(0\211A\266\202\2020\304?\205h0\305\306>\203C0\307\310\311\nBBB\202G0\311B\312\313D\313\314
\fBBD\315\306
>\205^0\310\315\fBBBBBBF\316BBBE\207" . [cl--arglist-args &cl-defs cl--expr-contains 1 progn cl-define-compiler-macro &key &whole cl-whole &cl-quote cl--defsubst-expand quote cl-block nil cl-defun]) (#$ . 64604) nil 17 (#$ . 64230)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [put cl-defsubst edebug-form-spec cl-defun function-put lisp-indent-function 2] 4)
(defalias 'cl--defsubst-expand #[1413 #@503 ("C\2030\300\301B!\2040\202m0\302!\203 0\211\303\240\210\304C\305\304\306\307\310\311\312\313 \"\314\"\315\316% #\"\242\204@0\202[0\242A\204U0\317\242@A\242@@\n#\202[0\320\242 \"\262\211\203i0\321 E\202k0\266\202\207" . [cl--safe-expr-p progn cl--simple-exprs-p t nil delq cl-mapcar make-byte-code 514 "\300\242\204 0\302!\2030\301B\301\242B\240\210\303\207D\207" vconcat vector [macroexp-const-p nil] 5 "\n\n(fn ARGN ARGV)" cl-subst cl--sublis let]) (#$ . 65222) nil 18 "\n\n(fn ARGNS BODY SIMPLE WHOLE UNSAFE &rest ARGVS)"])
#@88 Perform substitutions indicated by ALIST in TREE (non-destructively).
(fn ALIST TREE)
(defalias 'cl--sublis #[514 #@97 ("\211\236\211\203\f0\211A\202 0:\203_0\300@\"\300A\"B\202 0\207" . [cl--sublis]) (#$ . 65926) nil 7 (#$ . 65805)])
(defalias 'cl--find-class '(macro . #[257 #@43 ("\300\301BB\207" . [get ('cl--class)]) (#$ . 66103) nil 4 "\n\n(fn TYPE)"]))
(defvar cl--struct-default-parent nil)
#@850 Define a struct type.
This macro defines a new data type called NAME that stores data
in SLOTs. It defines a `make-NAME' constructor, a `copy-NAME'
copier, a `NAME-p' predicate, and slot accessors named `NAME-SLOT'.
You can use the accessors to set the corresponding slots, via `setf'.
NAME may instead take the form (NAME OPTIONS...), where each
OPTION is either a single keyword or (KEYWORD VALUE) where
KEYWORD can be one of :conc-name, :constructor, :copier, :predicate,
:type, :named, :initial-offset, :print-function, or :include.
Each SLOT may instead take the form (SNAME SDEFAULT SOPTIONS...), where
SDEFAULT is the default value of that slot and SOPTIONS are keyword-value
pairs for that slot.
Currently, only one keyword is supported, `:read-only'. If this has a
non-nil value, that slot cannot be set via `setf'.
(fn NAME SLOTS...)
(defalias 'cl-defstruct '(macro . #[385 #@4801 (":\203\n0@\202 0\243\303\211\304!\305P\306\307\310\"!\303\306\307\311 \"!\306\307\312\n\"!\303\211\313 \20350\20260\314\303\306\307\315\"!\306\307\316\"!\303\211\211\211\211@;\205X0\211A\262\242\303\211\317\320\321\"B\262\203I@:\203v0@@\202y0@\211A\262\242\243\322=\203\2350\211\203D\211@\203\2270\304@!\202\2300\323\262\202D\324=\203\3070\211A\203\2740\211@=\203\2630\303\262\211B\262\202D\211\203D\211@\262\202D\325=\203\3300\211\203D\211@\262\202D\326=\203\3510\211\203D\211@\262\202D\327=\203\203\3700\330\331!\210\211@\262 \320\332A\"\262\n\202D\333=\203\211@\262\202D\334=\203 \211@\262\202D\335=\203,\336\262\202D\337=\203?\340@\341\"\244\262\202D\330\342\"\210\266\202c0\204U\204U \262\203`\343!\262
\203v\344\345\346D\347BB\350BB\262\202\266\204\266\n\203\227\n\351H\n>\204\220\352\353\354
D\"\210\n\355H\203\266\336\262
\n\204\243\203\251
?\205\264\344\356\307\357\"\360BBD\262\n\203N\n\351H\n>\204\314\352\353\354
D\"\210\n\361H\362\f!\203\346=\204\346\330\363\"\210 \203 @@\236\206\375\330\364 @@#>\n\211A\262\f\242\240\210\202\346\365\366\367 \236 \"\"\262\262\203'\367\236\202(\370\262\f\351H\n>\204;\352\353\354D\"\210\f\371H\203I\262\f\336\262\266\202l\203i\372>\204^\330\373\"\210\203l\262\n\202l\370\262\204z\366\367\236\"\262\204\214\203\214\306\307\374\"!\262\205\352G\367\236>GZ\375>\203\302\376\377\201@0\201A0 GE\201B0\201C0\201D0EEF\202\350\211\351U\203\324\201B0\201E0 E\202\350\376\201F0\201B0\201G0\201H0BB
EE\262\262\205 \351V\205A@@\201I0=\203 \201J0U\203\376AAAB\202\201K0B\262\203a\201L0\201M0\201N0@\376=\203<\365\201O0\"\202D\376\201P0BB\257B\262\201Q0\201R0D\201S0\201R0DFB\262\351\211\203o\211A\262\242\211@\211\201T0>\203\222\303B\262\211\367=\205\212\201R0DB\262\202f\211\236\203\241\330\201U0 #\210\306\307\201V0#!B\262A@B\262\201L0\201W0\201X0\365\n\205\343\201Y0 \352\201Z0\201[0\201R0&D\201\\0BBEEC\201]0>\203\370\201C0\201D0\fE\202\n\351U\203\201^0\202\201G0 \201_0BBC\"BBBB B\262 \201`0AA>A@\203B\201a0\201b0\201c0\330\201d0\201R0DEEE B\262 \203e\356\307\201e0\"\201f0BB\201g0\201h0B\201i0BBD\244\210\210\266T\262\202d\266\237\262\237\262\203\222\201j0\201R0D\201k0BBB\262\203\254\201l0\366\303\201m0!\"BDB\262\211\203B\211@\211@A\211@A\211@A\201n0!\201o0\201p0\201q0\201r0\201s0\201t0!\201u0\"\201v0\201w0%\"\"#\201L0\201x0\303(BBB;\203\202\307\201y0(\"\365\201z0\344\320\201{0-\"B!\205#\201|0\206+\201t0BC\"BBBBB\262\266 A\266\202\202\256\210\f\203Q
\201}0\336D\244\210\344\201~0\nD\365\237\2010\201\2000\201R0 D \201R0D\201R0D\336=\201R0#D\201R0D\201R0D\201R0D\257\nD\201R0 DD\"BB\207" . [cl--optimize-safety cl--struct-default-parent cl-struct-cl-structure-class-tags nil symbol-name "-" intern format "make-%s" "copy-%s" "%s-p" cl--compiling-file 3 "cl-struct-%s" "cl-struct-%s-tags" (cl-tag-slot) mapcar #[257 "\211:\2030\207\211C\207" #1=[] 2 "\n\n(fn X)"] :conc-name "" :constructor :copier :predicate :include error "Can't :include more than once" #[257 "\211:\2030\207\211C\207" #1# 2 "\n\n(fn X)"] :print-function :type :named t :initial-offset make-list (cl-skip-slot) "Slot option %s unrecognized" cl--struct-get-class progn funcall function (cl-x cl-s cl-n) (t) 0 signal wrong-type-argument cl-structure-class 9 princ "#S(%s" (cl-s) 7 cl-struct-slot-info ":type disagrees with :include for %s" "No slot %s in included struct %s" append delq cl-tag-slot true 8 (vector list) "Invalid :type specifier: %s" "cl--struct-%s-p" (nil vector) and (vectorp cl-x) >= (length cl-x) memq aref cl-x (car-safe cl-x) (consp cl-x) nth (cl-x) vectorp 1 (cl-x) cl-defsubst (cl-x) (declare (side-effect-free error-free)) (t) (t) put quote 'cl-deftype-satisfies (cl-tag-slot cl-skip-slot) "Duplicate slots named %s in %s" "%s%s" (cl-x) (declare (side-effect-free t)) or 'wrong-type-argument list (cl-x) (nil vector) (car cl-x) (cl-x) :read-only gv-define-expander lambda (_cl-do _cl-x) "%s is a read-only slot" " %s" (cl-s) prin1 (cl-x) (cl-s) defalias (#'copy-sequence) &key copy-sequence cl--arglist-args cl-mapcar make-byte-code 514 "\300>\2030\207\207" vconcat vector #1# 4 "\n\n(fn S D)" &cl-defs "Constructor for objects of type `%s'." cl--safe-expr-p cl-second ((declare (side-effect-free t))) (princ ")" cl-s) defvar eval-and-compile cl-struct-define]) (#$ . 67125) nil 48 (#$ . 66228)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\306\301\307\310#\207" [function-put cl-defstruct doc-string-elt 2 lisp-indent-function 1 put edebug-form-spec (&define [&or symbolp (gate symbolp &rest (&or [":conc-name" symbolp] [":constructor" symbolp &optional cl-lambda-list] [":copier" symbolp] [":predicate" symbolp] [":include" symbolp &rest sexp]))] [&optional stringp] &rest &or symbolp (symbolp def-form &optional ":read-only" sexp))] 4)
(defalias 'cl--struct-all-parents #[257 #@303 ("\302!\205D0\211G\303Y\205D0\211\304H>\205D0\305C\211A\262\242\211B\262\306\304H >\20440\307\310\311D\"\210\312H\"\211\262\262\2040\237\266\202\207" . [cl-struct-cl-structure-class-tags cl-struct-cl--class-tags vectorp 11 0 nil append signal wrong-type-argument cl--class 3]) (#$ . 72460) nil 10 "\n\n(fn CLASS)"])
#@245 Pcase patterns to match cl-structs.
Elements of FIELDS can be of the form (NAME PAT) in which case the contents of
field NAME is matched against PAT, or they can be of the form NAME which
is a shorthand for (NAME NAME).
(fn TYPE &rest FIELDS)
(defalias 'cl-struct--pcase-macroexpander #[385 #@390 ("\300\301\302\303\304DED\305\306\307\310\311\312 !\313\"\314\315%\"BB\207" . [and pred pcase--flip cl-typep quote mapcar make-byte-code 257 "\211:\203\n0\211@\202 0\211:\2030A@\2020\301\302\300!\303=\203)0\304\305\300\"D\20210\306\307\305\300\"EE\207" vconcat vector [app cl-struct-sequence-type list nth cl-struct-slot-offset pcase--flip aref] 9 "\n\n(fn FIELD)"]) (#$ . 73106) nil 11 (#$ . 72807)])
(byte-code "\300\301\302\303#\210\300\304\305\301#\207" [put cl-struct--pcase-macroexpander edebug-form-spec (sexp &rest [&or (sexp pcase-PAT) sexp]) cl-struct pcase-macroexpander] 4)
#@71 Extra special cases for `cl-typep' predicates.
(fn ORIG PRED1 PRED2)
(defalias 'cl--pcase-mutually-exclusive-p #[771 #@826 ("\242\301=\20580A\211\262\20580\242\302=\20580A\211\262\20580\243?\20580@\211\262\20580\242\303=\20580A@\242\301=\205n0A\211\262\205n0\242\302=\205n0A\211\262\205n0\243?\205n0@\211\262\205n0\242\303=\205n0A@9\203\2310\2119\203\2310\304N\304N\205\2240\211\205\2240\305!>\206\2230\211\305!>?\266\202\2069\205\2410\304N\211\205\3140\306!\205\3140\211G\307Y\205\3140\211\310H>\205\3140\311!\312=\203\3100\313\202\3110\306\"\262\206\2119\205\3310\211\304N\211\205\306!\205\211G\307Y\205\211\310H>\205\311!\312=\203\313\202\306\"\262\206\"\207" . [cl-struct-cl-structure-class-tags pcase--flip cl-typep quote cl--class cl--struct-all-parents vectorp 11 0 cl-struct-sequence-type list consp]) (#$ . 73844) nil 12 (#$ . 73719)])
(advice-add 'pcase--mutually-exclusive-p :around 'cl--pcase-mutually-exclusive-p)
#@185 Return the sequence used to build STRUCT-TYPE.
STRUCT-TYPE is a symbol naming a struct type. Return `vector' or
`list', or nil if STRUCT-TYPE is not a struct type.
(fn STRUCT-TYPE)
(defalias 'cl-struct-sequence-type #[257 #@173 ("\301!\211\302H>\2040\303\304\305D\"\210\211\306H\207" . [cl-struct-cl-structure-class-tags cl--struct-get-class 0 signal wrong-type-argument cl-structure-class 7]) (#$ . 75024) nil 6 (#$ . 74792)])
(byte-code "\300\301\302\303#\210\300\301\304\303#\207" [function-put cl-struct-sequence-type side-effect-free t pure] 4)
#@314 Return a list of slot names of struct STRUCT-TYPE.
Each entry is a list (SLOT-NAME . OPTS), where SLOT-NAME is a
slot name symbol and OPTS is a list of slot options given to
`cl-defstruct'. Dummy slots that represent the struct name and
slots skipped by :initial-offset may appear in the list.
(fn STRUCT-TYPE)
(defalias 'cl-struct-slot-info #[257 #@648 ("\302!\211\303H>\2040\304\305\306D\"\210\211\307H\303H>\204$0\304\305\306D\"\210\310H\211?\205.0\311CG\303\211W\203\2610\211H\211\303H >\204J0\304\305\312D\"\210\211\313H\303H >\204\\0\304\305\312D\"\210\314H\315\303H >\204p0\304\305\312D\"\210\316H\317=?\205\2160\320\303H >\204\2120\304\305\312D\"\210\316HD\303H >\204\2360\304\305\312D\"\210\307H\"BBB\262\266\211T\262\20210\266\211\237\207" . [cl-struct-cl-structure-class-tags cl-struct-cl-slot-descriptor-tags cl--struct-get-class 0 signal wrong-type-argument cl-structure-class 4 7 (cl-tag-slot) cl-slot-descriptor 1 2 append 3 t :type]) (#$ . 75715) nil 17 (#$ . 75358)])
(byte-code "\300\301\302\303#\210\300\301\304\303#\210\305\306\307\"\207" [function-put cl-struct-slot-info side-effect-free t pure define-error cl-struct-unknown-slot "struct %S has no slot %S"] 4)
#@298 Return the offset of slot SLOT-NAME in STRUCT-TYPE.
The returned zero-based slot index is relative to the start of
the structure data type and is adjusted for any structure name
and :initial-offset slots. Signal error if struct STRUCT-TYPE
does not contain SLOT-NAME.
(fn STRUCT-TYPE SLOT-NAME)
(defalias 'cl-struct-slot-offset #[514 #@219 ("\301\302!\211\303H>\2040\304\305\306D\"\210\211\307H\262\"\206#0\304\310D\"\207" . [cl-struct-cl--class-tags gethash cl--struct-get-class 0 signal wrong-type-argument cl--class 5 cl-struct-unknown-slot]) (#$ . 76945) nil 9 (#$ . 76602)])
(byte-code "\300\301\302\303#\210\300\301\304\303#\207" [function-put cl-struct-slot-offset side-effect-free t pure] 4)
#@142 Return non-nil if SYM will be bound when we run the code.
Of course, we really can't know that for sure, so it's just a heuristic.
(fn SYM)
(defalias 'cl--macroexp-fboundp #[257 #@159 ("\302!\2060\303 \2050\211\236A\2060\211 \236A\207" . [byte-compile-function-environment byte-compile-macro-environment fboundp cl--compiling-file]) (#$ . 77509) nil 3 (#$ . 77323)])
(byte-code "\300\301\302\301#\210\300\303\302\303#\210\300\304\302\305#\210\300\306\302\307#\210\300\310\302\311#\210\300\312\302\313#\207" [put null cl-deftype-satisfies atom real numberp fixnum integerp base-char characterp character natnump] 4)
(defalias 'cl-typep #[514 #@1531 ("\211\211:\203\201\211@A\211\300N\262\203$0\211\301\302\300N\"\"\266\202\202|\303>\203z0\211@A\211@A\301\f\"\205s0\304>\204X0:\203Q0 @V\202U0 Y\205s0\305>\203b0\306\202s0:\203o0 @W\202s0 X\266\203\266\204\202|\307=\203\2570\211:\203\2450\211@A\211\204\2310\301\"?\262\202\2400\310\311\"\262\266\202\202|\310\311\"\262\202|\312>\203\3770\211\204\3010\211\313=\202\3720A\204\3170\301@\"\202\3720@AB\313=\203\3530\301 \"\205\3700\301 \"\202\3700\301 \"\206\3700\301 \"\266\202\266\202\202|\314=\2037\211:\203-\211@A\211\204!\314\"\205 \306\262\202(\310\311\"\262\266\202\202|\310\311\"\262\202|\315=\203L\211\316\"\205G\306\262\202|\317=\203W\211:\204a\310\311\"\262\202|\211@A\211\204s\211!\262\202z\310\311\"\262\266\202\266\202\202\2119\204\220\211\310\311\"\262\202\211\211\300N\262\203\246\211\301\300N \"\262\202\211\211\320N\262\203\272\211\211\320N!\262\202\211\321>\203\307\211\211\262\202\211\322!\323\324P!\325!\203\335\211!\202\325\323\326P!\211\262!\203\361\211!\202\325!\203\376!\202\310\327\"\266\202\262\207" . [cl-deftype-handler cl-typep apply (number real float integer) (* nil) (* nil) t not error "Bad type spec: %s" (or and) and eql member memql satisfies cl-deftype-satisfies (t nil) symbol-name intern "p" cl--macroexp-fboundp "-p" "Unknown type %S"]) (#$ . 77982) nil 15 "\n\n(fn VAL TYPE)"])
(function-put 'cl-typep 'compiler-macro 'cl-typep--inliner)
(defalias 'cl-typep--inliner #[771 #@1963 ("\3002\205\301!\2030\211\2020\302\303!\304!\204'0\242\305=\204'0\306\300\"\20230:\20320A@\20230\211:\203\332\211@A\211\307N\262\203Y0\211\310\311\312\307N\"DE\266\202\202\325\313>\203\3010\211@A\211@A\314\310\f\311DE\315>\203}0\316\202\2260:\203\2160\317
\311@DE\202\2260\320
\311DE\321>\203\2400\316\202\2710:\203\2610\322\311@DE\202\2710\323\311DEF\266\203\266\204\202\325\324=\203\3710\211:\203\3570\211@A\211\204\3430\324\310\311DED\262\202\3520\325\326\"\262\266\202\202\325\325\326\"\262\202\325\327>\203S\211\204
\311\314=D\202NA\204 \310\311@DE\202N@AB\314=\203<\314\310 \311DE\310\n\311DEE\202L\330\310 \311DE\310\n\311DEE\266\202\266\202\202\325\331=\203\214\211:\203\202\211@A\211\204v\314\331\311DE\316E\262\202}\325\326\"\262\266\202\202\325\325\326\"\262\202\325\332=\203\242\211\314\333\311DE\316E\262\202\325\334=\203\255\211:\204\267\325\326\"\262\202\325\211@A\211\204\314\335\305DE\262\202\323\325\326\"\262\266\202\266\202\202o\2119\204\351\211\325\326\"\262\202o\211\211\307N\262\203\211\310\311\307N DE\262\202o\211\211\336N\262\203\211\335\305\336NDE\262\202o\211\337>\203'\211\311D\262\202o\211\340!\341\342P!\343!\203@\335\305DE\202k\343\341\344P!\211\262!\203W\335\305DE\202k\343!\203g\335\305DE\202k\325\345\"\266\202\262\262=\203{\211\202\202\346DC\"\266\2030\207" . [inline--just-use macroexp-copyable-p make-symbol "val" macroexp-const-p function throw cl-deftype-handler cl-typep quote apply (number real float integer) and (* nil) t > >= (* nil) < <= not error "Bad type spec: %s" (or and) or eql member memql satisfies funcall cl-deftype-satisfies (t nil) symbol-name intern "p" cl--macroexp-fboundp "-p" "Unknown type %S" macroexp-let*]) (#$ . 79656) nil 22 "\n\n(fn INLINE--FORM VAL TYPE)"])
#@147 Verify that FORM is of type TYPE; signal an error if not.
STRING is an optional description of the desired type.
(fn FORM TYPE &optional STRING)
(defalias 'cl-check-type '(macro . #[770 #@373 ("\302 \2030\303W\2040 \303U\205S0\304!\203 0\211\202_0\305\306!\307\310\311\312DE\313\314\315\20640\312\nD\312
DFEE\316BB=\203J0\211\202Q0\317DC\"\266\203\207" . [cl--optimize-speed cl--optimize-safety cl--compiling-file 3 macroexp-copyable-p make-symbol "temp" progn or cl-typep quote signal 'wrong-type-argument list (nil) macroexp-let*]) (#$ . 81873) nil 15 (#$ . 81679)]))
(put 'cl-check-type 'edebug-form-spec '(place cl-type-spec &optional stringp))
#@366 Verify that FORM returns non-nil; signal an error if not.
Second arg SHOW-ARGS means to include arguments of FORM in message.
Other args STRING and ARGS... are arguments to be passed to `error'.
They are not evaluated unless the assertion fails. If STRING is
omitted, a default message listing FORM itself is used.
(fn FORM &optional SHOW-ARGS STRING &rest ARGS)
(defalias 'cl-assert '(macro . #[897 #@352 ("\302 \2030\303W\2040 \303U\205H0\205 0\304\305\306\307A\"\"\310\311\312\313 D\20450\20450\205@0\314B\314 BEBBE\315BB\262\207" . [cl--optimize-speed cl--optimize-safety cl--compiling-file 3 delq nil mapcar #[257 "\300!?\2050\211\207" [macroexp-const-p] 3 "\n\n(fn X)"] progn or cl--assertion-failed quote list (nil)]) (#$ . 82775) nil 14 (#$ . 82366)]))
(put 'cl-assert 'edebug-form-spec '(form &rest form))
#@665 Define a compiler-only macro.
This is like `defmacro', but macro expansion occurs only if the call to
FUNC is compiled (i.e., not interpreted). Compiler macros should be used
for optimizing the way calls to FUNC are compiled; the form returned by
BODY should do the same thing as a call to the normal function called
FUNC, though possibly more efficiently. Note that, like regular macros,
compiler macros are expanded repeatedly until no further expansions are
possible. Unlike regular macros, BODY can decide to "punt" and leave the
original function call alone by declaring an initial `&whole foo' parameter
and then returning foo.
(fn FUNC ARGS &rest BODY)
(defalias 'cl-define-compiler-macro '(macro . #[642 #@318 ("\300:\2030\211A\262\242B\262\2020\211\237\205 0\301D\244\262\266\302\303!\304P!\305\306\307>\203;0\310\307\"\202?0\311BBBB\312\313D\314\315DFE\207" . [nil &rest intern symbol-name "--cmacro" eval-and-compile cl-defun &whole delq _cl-whole-arg put quote 'compiler-macro function]) (#$ . 83945) nil 11 (#$ . 83222)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [put cl-define-compiler-macro edebug-form-spec cl-defmacro function-put lisp-indent-function 2] 4)
#@230 Like `macroexpand', but for compiler macros.
Expands FORM repeatedly until no further expansion is possible.
Returns FORM unchanged if it has no compiler macro, or if it has a
macro that returns its `&whole' argument.
(fn FORM)
(defalias 'cl-compiler-macroexpand #[257 #@242 ("\211\242\3009\20310\301N\211\262\20410\302!\20310K\211\242\303=\262\203*0\304K\"\20310K\262\2020\211\205A0\305\211A#\211\262=?\266\202\20400\207" . [nil compiler-macro fboundp autoload autoload-do-load apply]) (#$ . 84736) nil 8 (#$ . 84459)])
(defvar cl--active-block-names nil)
(defalias 'cl--block-wrapper--cmacro #[514 #@195 ("\211A@A@\302B\211B\303\304AA! \"A\203$0\305A@\306!BB\202%0\211)\207" . [cl--active-block-names macroexpand-all-environment nil macroexpand-all macroexp-progn catch macroexp-unprogn]) (#$ . 85096) nil 8 "\n\n(fn CL-WHOLE-ARG CL-FORM)"])
(put 'cl--block-wrapper 'compiler-macro 'cl--block-wrapper--cmacro)
(defalias 'cl--block-throw--cmacro #[771 #@92 ("A@\236\211\203
0\211\301\241\210\210\302E\207" . [cl--active-block-names t throw]) (#$ . 85457) nil 6 "\n\n(fn CL-WHOLE-ARG CL-TAG CL-VALUE)"])
(put 'cl--block-throw 'compiler-macro 'cl--block-throw--cmacro)
(defalias 'cl--compiler-macro-member #[899 #@215 ("\211G\300U\2050\211@\301=\2050\302A@!\211\303=\203 0\304E\202?0\211\305=\203-0\306E\202?0\20370\211\307=\203>0\310E\202?0\207" . [2 :test cl--const-expr-val eq memq equal member eql memql]) (#$ . 85722) nil 8 "\n\n(fn FORM A LIST &rest KEYS)"])
(defalias 'cl--compiler-macro-assoc #[899 #@277 ("\211G\300U\2050\211@\301=\2050\302A@!\211\303=\203 0\304E\202T0\211\305=\203-0\306E\202T0\307!\203S0\203=0\211\310=\203S0\311\302!!\203L0\306E\202T0\304E\202T0\207" . [2 :test cl--const-expr-val eq assq equal assoc macroexp-const-p eql floatp]) (#$ . 86039) nil 8 "\n\n(fn FORM A LIST &rest KEYS)"])
(defalias 'cl--compiler-macro-adjoin #[899 #@284 ("\300>\2030\207\301!\2030\211\2020\302\303!\301!\203!0\211\202$0\302\304!\305\306BBB\307EF=\203>0\211\202E0\310DC\"\266\203=\203Q0\211\202X0\310DC\"\207" . [:key macroexp-copyable-p make-symbol "va" "vlist" if cl-member cons macroexp-let*]) (#$ . 86419) nil 14 "\n\n(fn FORM A LIST &rest KEYS)"])
(defalias 'cl--compiler-macro-get #[1027 #@75 ("\211\203\f0\300\301DF\207\302E\207" . [cl-getf symbol-plist get]) (#$ . 86804) nil 8 "\n\n(fn FORM SYM PROP &optional DEF)"])
(byte-code "\300\211\203 \211@\301\302\303#\210A\266\202\202 \210\304\305!\210\306\307\310\"\210\306\311\312\"\207" [(cl-first cl-second cl-third cl-fourth cl-fifth cl-sixth cl-seventh cl-eighth cl-ninth cl-tenth cl-rest cl-endp cl-plusp cl-minusp cl-caaar cl-caadr cl-cadar cl-caddr cl-cdaar cl-cdadr cl-cddar cl-cdddr cl-caaaar cl-caaadr cl-caadar cl-caaddr cl-cadaar cl-cadadr cl-caddar cl-cadddr cl-cdaaar cl-cdaadr cl-cdadar cl-cdaddr cl-cddaar cl-cddadr cl-cdddar cl-cddddr) put side-effect-free t cl-proclaim (inline cl-acons cl-map cl-concatenate cl-notany cl-notevery cl-revappend cl-nreconc gethash) mapc #[257 "\300\301\302#\207" [function-put side-effect-free t] 5 "\n\n(fn X)"] (cl-oddp cl-evenp cl-signum last butlast cl-ldiff cl-pairlis cl-gcd cl-lcm cl-isqrt cl-floor cl-ceiling cl-truncate cl-round cl-mod cl-rem cl-subseq cl-list-length cl-get cl-getf) #[257 "\300\301\302#\207" [function-put side-effect-free error-free] 5 "\n\n(fn X)"] (eql cl-list* cl-subst cl-acons cl-equalp cl-random-state-p copy-tree cl-sublis)] 6)
#@134 Define NAME as a new data type.
The type name can then be used in `cl-typecase', `cl-check-type', etc.
(fn NAME ARGLIST &rest BODY)
(defalias 'cl-deftype '(macro . #[642 #@161 ("\300\301\302\303D\304\305\306\307\310\nBBBBDFE\207" . [cl-eval-when (compile load eval) put quote 'cl-deftype-handler cl-function lambda &cl-defs ('*)]) (#$ . 88169) nil 13 (#$ . 87991)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\210\304\301\307\310#\210\300\311\312\313#\207" [put cl-deftype edebug-form-spec cl-defmacro function-put doc-string-elt 3 lisp-indent-function 2 extended-char cl-deftype-handler #[0 "\300\207" [(and character (not base-char))] 1]] 4)
#@158 Return the value of slot SLOT-NAME in INST of STRUCT-TYPE.
STRUCT and SLOT-NAME are symbols. INST is a structure instance.
(fn STRUCT-TYPE SLOT-NAME INST)
(defalias 'cl-struct-slot-value #[771 #@180 ("\300\"\2040\301\302D\"\210\303!\304=\203 0\305\"8\207\211\305\"H\207" . [cl-typep signal wrong-type-argument cl-struct-sequence-type list cl-struct-slot-offset]) (#$ . 88858) nil 7 (#$ . 88656)])
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [function-put cl-struct-slot-value compiler-macro cl-struct-slot-value--inliner side-effect-free t] 4)
(defalias 'cl-struct-slot-value--inliner #[1028 #@582 ("\3002\2330\301!\2030\211\2020\302\303!\301!\203 0\211\202 0\302\304!\301!\203+0\211\202.0\302\305!\306\307\310E\311\312\313D\314\nEEE\315\316\317 D\312\314DE\320\321\n EE\322\321\f EEFE=\203k0\211\202r0\323DC\"\266\203=\203~0\211\202\2050\323DC\"\266\203=\203\2210\211\202\2300\323DC\"\266\2030\207" . [inline--just-use macroexp-copyable-p make-symbol "struct-type" "slot-name" "inst" progn unless cl-typep signal quote wrong-type-argument list if eq cl-struct-sequence-type nth cl-struct-slot-offset aref macroexp-let*]) (#$ . 89284) nil 20 "\n\n(fn INLINE--FORM STRUCT-TYPE SLOT-NAME INST)"])
(byte-code "\300\301!\210\302\303!\207" [run-hooks cl-macs-load-hook provide cl-macs] 2)
Kontol Shell Bypass