Current File : //usr/local/share/emacs/27.2/lisp/emacs-lisp/cl-macs.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(byte-code "\300\301!\210\300\302!\210\300\303!\207" [require cl-lib macroexp gv] 2)
#@14
(fn PLACE)
(defalias 'cl--pop2 '(macro . #[257 "\300\301\302DD\303\302\211DDEE\207" [prog1 car cdr setq] 8 (#$ . 493)]))
(put 'cl--pop2 'edebug-form-spec 'edebug-sexps)
#@30
(fn FORM ARG &rest OTHERS)
(defalias 'cl--compiler-macro-list* #[642 "\300B!\211@A\211\262\203 \301@E\262\202 \207" [reverse cons] 8 (#$ . 674)])
(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 "\211\204 \301\262:\203K @\302>\204K @9\205S @>\204' @\303N\205S \211S\262A\211\262\203> \304@\"\211\262\204+ ?\205J \211\305Y\205J \211\207\211\305V\205S \211S\207" [cl--simple-funcs 10 (quote function cl-function) side-effect-free cl--simple-expr-p 0] 5 (#$ . 1187)])
#@11
(fn XS)
(defalias 'cl--simple-exprs-p #[257 "\211\203 \300@!\203 \211A\262\202 \211?\207" [cl--simple-expr-p] 3 (#$ . 1584)])
#@35 Check if no side effects.
(fn X)
(defalias 'cl--safe-expr-p #[257 "\211:\205\n \211@\302>??\206: \211@9\205: \211@>\204) \211@ >\204) \211@\303N\205: \211A\211\262\2038 \304@!\204) \211?\207" [cl--simple-funcs cl--safe-funcs (quote function cl-function) side-effect-free cl--safe-expr-p] 3 (#$ . 1723)])
#@10
(fn X)
(defalias 'cl--const-expr-p #[257 "\211:\203% \211@\300=\2063 \211@\301>\205$ \211A@9\206$ \211A@\242\302=\205$ \303\207\2119\2032 \211\304>\2053 \305\207\305\207" [quote #'cl-function lambda func (nil t) t] 3 (#$ . 2037)])
#@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 "\301\"\302!\205 \211:\203 \211A@\202 \211\207" [macroexpand-all-environment macroexpand-all macroexp-const-p] 4 (#$ . 2277)])
#@73 Count number of times X refers to Y. Return nil for 0 times.
(fn X Y)
(defalias 'cl--expr-contains #[514 "\211\232\203 \300\207:\203B @\301>\204B \302:\203. \211\303\211A\262\242\"\206( \302\\\262\202 \211\303\"\2067 \302\\\262\211\302V\205A \211\207\304\207" [1 (quote function cl-function) 0 cl--expr-contains nil] 7 (#$ . 2664)])
#@12
(fn X Y)
(defalias 'cl--expr-contains-any #[514 "\211\203 \300@\"\204 \211A\266\202\202 \207" [cl--expr-contains] 5 (#$ . 3018)])
#@66 Check whether X may depend on any of the symbols in Y.
(fn X Y)
(defalias 'cl--expr-depends-p #[514 "\300!?\205 \301!?\206 \302\"\207" [macroexp-const-p cl--safe-expr-p cl--expr-contains-any] 5 (#$ . 3162)])
(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 "\211;\203 \211\202\n \301\250\203 \202 \211T\302\303\304#!\207" [cl--gensym-counter "G" make-symbol format "%s%d"] 8 (#$ . 3414)])
(defvar cl--gentemp-counter 0)
#@138 Generate a new interned symbol with a unique name.
The name is made by appending a number to PREFIX, default "T".
(fn &optional PREFIX)
(defalias 'cl-gentemp #[256 "\211;\203 \211\202\n \301\302\303\304\305#\211\262!\203 T\202 \306!\207" [cl--gentemp-counter "T" nil intern-soft format "%s%d" intern] 8 (#$ . 3740)])
(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#\210\300\316\302\317#\210\300\320\302\321#\207" [put cl-declarations edebug-form-spec (&rest ("cl-declare" &rest sexp)) cl-declarations-or-string (&or lambda-doc cl-declarations) cl-lambda-list (([&rest cl-lambda-arg] [&optional ["&optional" cl-&optional-arg &rest cl-&optional-arg]] [&optional ["&rest" cl-lambda-arg]] [&optional ["&key" [cl-&key-arg &rest cl-&key-arg] &optional "&allow-other-keys"]] [&optional ["&aux" &rest &or (symbolp &optional def-form) symbolp]] . [&or arg nil])) cl-&optional-arg (&or (cl-lambda-arg &optional def-form arg) arg) cl-&key-arg (&or ([&or (symbolp cl-lambda-arg) arg] &optional def-form arg) arg) cl-lambda-arg (&or arg cl-lambda-list1) cl-lambda-list1 (([&optional ["&whole" arg]] [&rest cl-lambda-arg] [&optional ["&optional" cl-&optional-arg &rest cl-&optional-arg]] [&optional ["&rest" cl-lambda-arg]] [&optional ["&key" cl-&key-arg &rest cl-&key-arg &optional "&allow-other-keys"]] [&optional ["&aux" &rest &or (symbolp &optional def-form) symbolp]] . [&or arg nil])) 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 "@A\306\211\307!\211@\306A\262<\203! \310!\202% \311D\262\312!\211A\2037 \211\311AD\241\210\210\313>\211\203Q \211A@\211AA\241\210\314\313\"\262\210\315>\211\203b \314\315\"\262\316>\203m \317\320!\210\321>\211A@\203\211 \314@\314 \"\"\322\323BD\244\262\266\306\203\321 @9\203\321 @\324>\204\321 \211\203\257 @ A\236A@\204\321 @\325=\203\303 \326\211\262\203\303 @\204\321 \211A\262\242B\262\202\214 \211\203\353 \203\340 \325B\262@\325=\203\353 A\262\210\327=\204\373 \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] 20 (#$ . 5351)])
#@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 may be replaced recursively with an argument list for
destructuring, `&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 "\300B\"\301ABB@\203 \302@E\202 \211\207" [cl--transform-lambda defun progn] 8 (#$ . 7161)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\304\301\307\310#\300\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] 5)
#@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 "\300\301!\210\302B\"\303ABB@\203 \304@E\202 \211\207" [require generator cl--transform-lambda iter-defun progn] 8 (#$ . 8311)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\304\301\307\310#\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]))] 6)
#@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 may be replaced recursively with an argument list for
destructuring, `&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 "\300B\"\301ABB@\203 \302@E\202 \211\207" [cl--transform-lambda defmacro progn] 8 (#$ . 9972)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\304\301\307\310#\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 cl-declarations-or-string [&optional ("interactive" interactive)] def-body)) function-form (&or ([&or "quote" "function"] &or symbolp lambda-expr) ("cl-function" cl-function) form)] 6)
#@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 "\211\242\300=\203! \301A\302\"\303\300ABD@\203 \304@E\202 \211\207\303D\207" [lambda cl--transform-lambda cl-none function progn] 6 (#$ . 11343)]))
(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 "\2119\203\f \300\301!\226!\207\211:\203 \302!\207\207" [make-symbol symbol-name cl--make-usage-args] 4 (#$ . 11766)])
#@16
(fn ARGLIST)
(defalias 'cl--make-usage-args #[257 "\3001\f \301\302\"0\202 \210\303\211\203 \304\305#\262\210\306!\204A \307!\211A\310\305\311\312\313\"\314\"\315$\216\303\241\210\316!\317!\244)\207\320>\211\203T \321@\322A@\"\"\262\210\303C\323\310\324\325\312\313!\326\"\327\330%\"\207" [(error) cl-position &aux nil cl-subseq 0 proper-list-p 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, \301!\302H\211\303=\203 \300\240\202+ \304\305=\203& \306\301!\307\"\202) \301!\226!\207\211:\2042 \207\300\242\310>\203= \311!\207\211@:\203W \300\242\312=\203W \211@@\313@A@!D\202[ \313@!A@\311AA!BB\207" [symbol-name 0 38 make-symbol 95 substring 1 (nil &rest) cl--make-usage-args &key cl--make-usage-var] 6 "\n\n(fn X)"] 10 (#$ . 11987)])
#@13
(fn ARGS)
(defalias 'cl--do-&aux #[257 "\211@\302=\203] \211A\262\242\203] \211\203 \211@>\204 \211@:\203P \203? \211@A@\203? \303@@\304\211A\262\242A@D\"\210\202 \303@@\211A\262\242A@\"\210\202 \303\211A\262\242\305\"\210\202 \211\205e \306\307\"\207" [cl--lambda-list-keywords cl--bind-enquote &aux cl--do-arglist quote nil error "Malformed argument list ends with: %S"] 6 (#$ . 12856)])
#@32
(fn ARGS EXPR &optional NUM)
(defalias 'cl--do-arglist #[770 "<\204 >\204 9\204 \306\307\"\207D B\211\207\310!\262\311!\211A\2031 \211\312AD\241\210\210\313>\211\203= \211\312\240\210\210\314>\203H \306\315!\210\312>\316 \203T \n\202U \317\320\321\211\211\204a \322\262A@<\203n \323\324!\202q A@\262D B@\325=\203\222 A@ AA\262\nD B\262\211\203\266 \211@>\204\266 \211\n=\204\257 \326D\262\211A\262\202\230 \211@\327>\203\322 \330\331D\332\f\"GE\262 =?\262\210\203.@>\204.A\204\352 \204\356 \333\202\357 \334D\335\n\211A\262\f\242\204\322U\203 \202 \336\337\340\341 \342=?\205\343 D\331DEEF\"\266T\262\320\262\202\323 @\344=\203\264\211A\262\n\242\203\264\203.@>\204.\211A\262\n\242\211:\204]\211C\262\211AA\203o\335\3458\346 \347BB\"\210\211A\203z\211A@\202\205\f@\206\205\211@\f\236A@\333D\203\226
\203\226\343D\262\335@\203\247\336 F\202\250\"\210 T\262\n\266\202@@\312=\203\325A@ AA\262\n\211:\203\321\335\"\210\210\202@\350=\204\322U\204\204\336\337\351\341 \342=?\205\367\343 D\352
\331DEEEE@B@@\350=\203\211A\262\n\242\203<\204!\321\262\203@>\204\211A\262\n\242\211:\204>\211C\262\211@:\203J\211@@\202d\353@!\211\322H\354=\203\\\355\356\"\262\357\360\361\"!\262@:\203q@A@\202s@A\203~A@\202\210\f@\206\210\211\f\236A@\362\n\343DE\203\234
\203\234\343D\262AA\203\313\3458\206\253\323\363!\334\326DD\335\"\210\335\336\364\365\366BBEF\"\266\202\367\335\334\326\204\327\202\363\367\370!\320=\203\355\343\321\371\n!DD\202\362\341\321 EEDD\"\210 B\262 \266\202!:\203 \237\262@\372=\203 \211A\262\n\242\204\241\322U\204\241\320=\204\241\204D\373\306\360\374\"\334\nDEE@B@\202\241\323\375!\376\377\201A \201B \334D\343\201C \f\"DE\365\326\211 DDED\334\326\201B \343BEDD\365\201D BBD\320\306\360\374\"\334\nDEDFE\201E \nDCE@B@\266\201F !\210\321\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 t 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 &optional 2 and (t) &key 'wrong-number-of-arguments + symbol-name 95 substring 1 intern format ":%s" plist-member "--cl-var--" prog1 setq (t) or cl--const-expr-p cl--const-expr-val &allow-other-keys when "Keyword argument %%s not one of %s" "--cl-keys--" (:allow-other-keys) while cl--bind-forms cond memq append (nil) let cl--do-&aux] 25 (#$ . 13272)])
#@13
(fn ARGS)
(defalias 'cl--arglist-args #[257 "\211<\204 \211C\207\301\211\211:\203_ \211A\262\242\262\211>\203$ \211\262\202 \211\302=\2033 \211A\262\210\202 \211:\203@ \203@ \211@\262\211:\203U \211A\203U \303=\203U \211A@\262\304!\244\262\202 \205f C\244\207" [cl--lambda-list-keywords nil &cl-defs &key cl--arglist-args] 7 (#$ . 16059)])
#@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 "\305\211\305\305 \306\206 \307\"\210\310\237\311\312 \237\"!\"-\207" [cl--bind-lets cl--bind-forms cl--bind-defs cl--bind-block cl--bind-enquote nil cl--do-arglist (&aux) macroexp-let* macroexp-progn append] 10 (#$ . 16429)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-destructuring-bind lisp-indent-function 2 put edebug-form-spec (&define cl-macro-list1 def-form cl-declarations def-body)] 5)
(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 "\301\302!\203P \302 \203P \204P \303\304!\204P \305>\206 \306>\307\310>\204, \311>\203C \211\2039 \312\313\314\"B\202N \315\316\211BBB\202N \211\203M \317\312B!\210\316)\207\317>\204\\ \320>\205_ \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] 7 (#$ . 17042)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-eval-when lisp-indent-function 1 put edebug-form-spec (sexp body)] 5)
#@13
(fn FORM)
(defalias 'cl--compile-time-too #[257 "\211\2429\203
\211\242\301N\204 \302\303B\"\262\211\242\304=\203$ \304\305\306A\"B\207\211\242\307=\203H \211A@\310>\204: \311>\203F \307\312BAABB\202G \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] 5 (#$ . 17915)])
#@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 "\301 \203> \302\303!\304E\305\306!\2037 \307\310!\2037 \307\311!\2037 \312\211K\313\314\315\316\317\"\320\"\321\322%\262M\210\202< \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] 13 (#$ . 18320)]))
(put 'cl-load-time-value 'edebug-form-spec '(form &optional sexp))
#@485 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, this macro returns nil. A
single non-nil 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 "\300!\203 \211\202 \301\302!\303C\304\305\306\307\310\311\312\"\313\"\314\315%\"B\262=\2031 \211\2028 \316DC\"\207" [macroexp-copyable-p make-symbol "temp" nil cond mapcar make-byte-code 257 "\211@\302>\203 \303\202U \211@\304=\203 \305\306\300\307\310\301\242!DF\202U \211@<\2038 \301\311@\301\242\"\240\210\312\300\307@DE\202U \211@\301\242>\203F \305\313@\"\210\301@\301\242B\240\210\314\300\307@DEA\206[ \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*] 14 (#$ . 19086)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-case lisp-indent-function 1 put edebug-form-spec (form &rest (sexp body))] 5)
#@113 Like `cl-case', but error if no case fits.
`otherwise'-clauses are not allowed.
(fn EXPR (KEYLIST BODY...)...)
(defalias 'cl-ecase '(macro . #[385 "\300\301\302\"BB\207" [cl-case append ((cl--ecase-error-flag))] 7 (#$ . 20407)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-ecase lisp-indent-function 1 put edebug-form-spec cl-case] 5)
#@351 Eval EXPR and choose 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,
this macro 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 "\300!\203 \211\202 \301\302!\303C\304\305\306\307\310\311\312\"\313\"\314\315%\"B\262=\2031 \211\2028 \316DC\"\207" [macroexp-copyable-p make-symbol "temp" nil cond mapcar make-byte-code 257 "\211@\302=\203 \303\202. \211@\304=\203 \305\306\300\307\310\301\242!DF\202. \301@\301\242B\240\210\311\300\307@DEA\2064 \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*] 14 (#$ . 20778)]))
(byte-code "\300\301\302\303#\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))] 5)
#@114 Like `cl-typecase', but error if no case fits.
`otherwise'-clauses are not allowed.
(fn EXPR (TYPE BODY...)...)
(defalias 'cl-etypecase '(macro . #[385 "\300\301\302\"BB\207" [cl-typecase append ((cl--ecase-error-flag))] 7 (#$ . 21861)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-etypecase lisp-indent-function 1 put edebug-form-spec cl-typecase] 5)
#@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 "\300\301B!\203\f \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--"] 9 (#$ . 22249)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-block lisp-indent-function 1 put edebug-form-spec (symbolp body)] 5)
#@110 Return from the block named nil.
This is equivalent to `(cl-return-from nil RESULT)'.
(fn &optional RESULT)
(defalias 'cl-return '(macro . #[256 "\300\301E\207" [cl-return-from nil] 4 (#$ . 23131)]))
(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 "\300\301\302\"!\303\304DE\207" [intern format "--cl-block-%s--" cl--block-throw quote] 6 (#$ . 23393)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-return-from lisp-indent-function 1 put edebug-form-spec (symbolp &optional form)] 5)
#@22
(fn KIND ITERATOR)
(defalias 'cl--loop-set-iterator-function #[514 "\203 \301\302\"\207\211\211\207" [cl--loop-iterator-function error "Iteration on %S does not support this combination"] 5 (#$ . 24030)])
#@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 "\306\307\310\311\312\311\306\313!\"\"\">\204 \314\312\315\306BBE\207\211\312\211\211\211\211\211\211\211\211\211\211\211\211\211\211 ! \" # $ % & ' (\316(\317\"((@\320=\204Z \321 \210\202L \203i \322BC&B& \203\200 \323BC&B&\324 \325BB$B$ \237\"\206\211 #C\244\326%\237!\211A@$\237\244\316\f\237\n\203\274 \314\327\n@\306=\203\255 \202\267 \330@\331BBB!E\202\302 \315@BBC \203\342 \332\232\203\324 !C\202\343 \333 \334B!FC\202\343 #!\203\361 !C&B&&\2035&@A\203\335&\211A&\242\306#C\262\202\361 \312&\203*&@A\204*&\211A&\242@B\262\202\335\312#C\266\202\202\361 \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] 17 (#$ . 24249)]))
(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] ["using" (symbolp symbolp)] symbolp form))
(defalias 'cl--parse-loop-clause #[0 "\211A\242C\306\307\204 \310\311!\210\202\"
\242\312=\203# \211A\242\202\"
\242\313=\203Q @\314>\2036 \210A@:\204@ \310\315!\210@:\203\"
\211A\242\nB\202@ \242\316=\203\260 @\317=\203n A@AA\206j \320\202\"
@\321>\203z \210A@:\204\204 \310\322!\210@@\317=\203\237 \204\237 \211A\242A@\206\233 \323\202\"
@:\203\"
\211A\242\fB\202\237 \242\324>\203\324\325\211\211\211\211A\242\206\306 \326\327!C\211A\242\240\210\242\330=\203\341 \211A\242\240\210\242\331>\203\362 \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\201H !\351\201I !\211A\242DB\262\211\201J DB\262\356\201K \201L DE\201M DE
B \242\201N =\203t\242\201O ED@B@\202\213\242\325DB\262\242\201O EDB\262\266\202a\242\201P >\203|@\201Q >\206\262@\201R >?\205\262\310\201S !A@AA\351\201T !@\201U =\203\357A@G\341U\203\347A@@\201V =\203\347A@AAA@\202\364\310\201W !\202\364\351\201I !D B\262 \211\352D B\262 \2032\351\201X !\211\201M DD\nB\262\n\242\201Y ED@B@\356E
B\210\202k\242\325D B\262 \375\201Z \365D\356\201M DEEE
B\242\376\365D\201[ D\201O EFDB\262\211\201L DDB\262\266\202a\242>\203@\201\\ >\204\224\310\201S !\210A@AA\211@\201U =\203\326A@G\341U\203\316A@@>\203\316A@@ \242=\204\316A@AAA@\202\331\310\201W !\202\331\351\327!C \242\201] >\203\356\242\242\240\210\240\210\201^ \201_ \201` \201a \201b \201c \201d #\201e \"\201f \201g %\"\266\202a\242\201h >\203`@\201i >\2055A@AA\201^ \201j \201` \201a \201k \201c \201d \"\201l \"\201f \201g %\"\266\202a\242\201m >\203\341\325C\325C\325C@\201n >\203\262@\201o =\203\217A@AA\240\210\202p@\201p =\203\245\211A@AA\240\210\202pA@AA\240\210\202p\201^ \201q \201` \201a \201r \201c \201d \n\n\n\n$\201s \"\201t \201g %\"\266\202a\242\201u >\203\304\325C\325C\325C\325C\351\201v !C\351\201w !C@\201x >\203W@\201o =\203 A@AA\240\210\202\377@\201p =\2034A@AA\240\210\202\377@\201y =\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\201z \242\242ED\nB\262\n\201^ \201{ \201` \201a \201| \201c \201d \f\f\f\f\f\f&\201} \"\201~ \201g %\"\266\202a\242>\203e@\201 >\204\334\310\201S !\210A@AA\211@\201U =\203 A@G\341U\203A@@>\203A@@ \242=\204A@AAA@\202!\310\201W !\202!\351\327!C \242\201\200 >\2036\242\242\240\210\240\210\201^ \201\201 \201` \201a \201\202 \201c \201d \n\n\n$\201\203 \"\201f \201g %\"\266\202a\242\201\204 >\203\265\351\327!\242\201\205 DB\262\211\325DB\262\201\206 \201\207 \201\210 \242ED\201Z \201K \242EEE
B\242\201\211 \242DDB\262\210\202a\242\201\212 >\203=@\201\213 >\205\317A@AA\351\327!\351\201\214 !\242\203\345\201\215 D\202\350\201\216 DB\262\211\201\217 \201\220 \242DDDB\262\325DB\262\201\206 \201\207 \201\210 \242ED\201Z \201K \242EEE
B\242\201\221 \242EDB\262\266\202a\2429\205K\242\201\222 N\211\203W\211\242!\210\202`\310\201\223 \n\242\"\210\210@\375=\262\203w\201\224 \262\211A\210\202\273 \211\203\211\203\211\237BBB\202\226\201\225 \201\226 \"B\244B\203\257\201\227 \201\230 \237\201K #\201\231 BB
B\203\317\211\203\275\201\232 \202\300\201K \201\233 \201\234 \237\"BCBC\266\202\"
\242\201\235 =\203 \351\327!\211\211A\242DCBBB\355\201K \201\236 DE\201\237 BB
B\210\202\"
\242\201\240 >\203U \211A\242\201\241 \325\201\242 \"\211D=\2035 \201\227 \201\243 E\201\244 BB
B\202P \201\227 \201K \201\245 \201\226 DEE\201\246 BB
B\266\202\"
\242\201\247 >\203\274 \211A\242\201\241 \325\201\242 \"\201\227 \201K \211D=\203\227 \201\245 \242\201\250 >\203\214 \201\242 \202\217 \201\251 DE\202\256 \242\201\252 >\203\247 \201\245 \202\252 \201\234 EE\201\253 BB
B\266\202\"
\242\201\254 >\203\352 \211A\242\201\241 \201\255 !\201\227 \201\256 \201\257 F\201\260 BB
B\266\202\"
\242\201\261 >\203\n\211A\242\201\241 \201\262 !\201\227 \201\256 \201c F\201\263 BB
B\266\202\"
\242\201\264 >\203A\n\211A\242\201\241 \352!\201\227 \201\265 E\201\266 BB
B\266\202\"
\242\201\267 >\203l\n\211A\242\201\241 \352!\201\227 \376\201\265 DE\201\270 BB
B\266\202\"
\242\201\271 >\203\330\n\201\227 \211A\242\201\272 !\203\211\n\211\202\216\n\351\201\273 !\201\241 \325!\201\274 \201\275 \201\276 \242!\352\201\277 #!\201K \376EFE\266\202=\203\302\n\211\202\313\n\201\300 DC\"\266\203\201\301 BB
B\202\"
\242\201\302 =\203 \325\211A\242@\373=\205\365\nA@AADB\262@\375=\203 \211A\210\202\342\n\211\237BBB\210\202\"
\242\201\303 =\203( \211A\242
B\202\"
\242\201\304 =\203@ \201\207 \211A\242D
B\202\"
\242\201\305 =\203k E\204U \351\201\306 !E\201K E\211A\242E
B\201\224 F\202\"
\242\201\307 =\203\232 E\204\200 \351\201\306 !E\201K E\201\207 \211A\242DE
B\201\224 F\202\"
\242\201\310 =\203\324 E\204\257 \351\201\306 !EG\204\271 \351\327!G\201K E\201\207 \201K G\211A\242EDE
B\202\"
\242\201\311 >\203\231\f\211A\242\325 \201\312 \210\201\313
\237!)\325 @\201\314 =\203\f\210A\201\312 \210\201\313
\237!)@\201\224 =\205\f\211@\201\224 =@\201\315 =\203)\f\210A\242\201\316 =\2039\f\262\262\211\203G\f\201\227 A@B\202J\f\3418\203T\fA@\202X\f\3418CB\201\317 \201\320 \"\203y\f\201\321 \201\320 DC\376\201\320 BBE\202~\f\376BB\262\203\220\f\201\227 \201\322 BB\202\221\f\211
B\266\202\"
\242\201\323 >\203\322\f\325@:\204\257\f\310\201\324 !\210@:\203\301\f\211A\242B\262\202\257\f\201\227 \201\224 B\237B
B\210\202\"
\242\317=\203
E\204\343\f\351\327!EG\204\355\f\351\327!G\201K G\211A\242E\201\325 BBBB
B\202\"
\2429\205
\242\201\326 N\211\204
\310\201\327 \242\"\210\211 \266@\375=\2052
\210A\201\312 \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 \305\202\f \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 substring 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"] 28])
#@12
(fn SYM)
(defalias 'cl--unused-var-p #[257 "\211?\206\f \300!\301H\302=\207" [symbol-name 0 95] 3 (#$ . 37302)])
#@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 "\301\211\203R \211\203 \211@\2429\204 \211@A@\204 \211A\262\202 \211\203Q \301\262\211\203P \211@\302A@!\204I \303\304!\211A@DB\262A\240\266A\266\202\202( \210\210\203\343 \211A\262\242\211\242:\203\331 \211:\204n \305!\203\331 \301\243@\306\307\"\305!\203\200 \203\253 \211\203\221 \310=\203\243 \305!\203\243 \303\304!\262\310=\203\243 \211CCB\211DB\262:\203\315 \211A\262\242\205\305 \203\302 \311\202\303 \312DDB\262\202\253 \237\n\244\262\n\266\202\336 B\262\266\202R \310=\203\n\203\361 \313\202\362 \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] 13 (#$ . 37425)])
#@27
(fn DEF &optional FUNC)
(defalias 'cl--loop-handle-accum #[513 "@\305=\203! A@AA\211 >\204 \211DC\nB\211 B\211\207 \206= \306\307!\211DC\nB\211\203: \211 D\202; \207" [cl--loop-args cl--loop-accum-vars cl--loop-bindings cl--loop-accum-var cl--loop-result into make-symbol "--cl-var--"] 5 (#$ . 38611)])
#@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 "\300\211\203Z @\242\301=\203M \302@!@\303=\203M A\203? \304@!A@\242\301=\2031 A@A\2025 A@C\244AAB\262\202 \304\211A\262\242!A\262\202 \211A\262\242B\262\202 \237\206a \303C\262A\203n \305B\202p @\211\203\203 \306\301\306\307\"BC\"\202\204 \211A\203\217 \305B\202\221 \211@\262E\207" [nil progn last t butlast and append (t)] 11 (#$ . 38937)])
#@936 Bind variables and run BODY forms until END-TEST returns non-nil.
First, each VAR is bound to the associated INIT value as if by a `let' form.
Then, in each iteration of the loop, the END-TEST is evaluated; if true,
the loop is finished. Otherwise, the BODY forms are evaluated, then each
VAR is set to the associated STEP expression (as if by a `cl-psetq' form)
and the next iteration begins.
Once the END-TEST becomes true, the RESULT forms are evaluated (with
the VARs still bound to their values) to produce the result
returned by `cl-do'.
Note that the entire loop is enclosed in an implicit `nil' block, so
that you can use `cl-return' to exit at any time.
Also note that END-TEST is checked before evaluating BODY. If END-TEST
is initially non-nil, `cl-do' will exit without running BODY.
For more details, see `cl-do' description in Info node `(cl) Iteration'.
(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)
(defalias 'cl-do '(macro . #[642 "\300\301$\207" [cl--expand-do-loop nil] 8 (#$ . 39648)]))
(byte-code "\300\301\302\303#\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)] 5)
#@980 Bind variables and run BODY forms until END-TEST returns non-nil.
First, each VAR is bound to the associated INIT value as if by a `let*' form.
Then, in each iteration of the loop, the END-TEST is evaluated; if true,
the loop is finished. Otherwise, the BODY forms are evaluated, then each
VAR is set to the associated STEP expression (as if by a `setq'
form) and the next iteration begins.
Once the END-TEST becomes true, the RESULT forms are evaluated (with
the VARs still bound to their values) to produce the result
returned by `cl-do*'.
Note that the entire loop is enclosed in an implicit `nil' block, so
that you can use `cl-return' to exit at any time.
Also note that END-TEST is checked before evaluating BODY. If END-TEST
is initially non-nil, `cl-do*' will exit without running BODY.
This is to `cl-do' what `let*' is to `let'.
For more details, see `cl-do*' description in Info node `(cl) Iteration'.
(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)
(defalias 'cl-do* '(macro . #[642 "\300\301$\207" [cl--expand-do-loop t] 8 (#$ . 40890)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-do* lisp-indent-function 2 put edebug-form-spec cl-do] 5)
#@32
(fn STEPS ENDTEST BODY STAR)
(defalias 'cl--expand-do-loop #[1028 "\300\301\203\n \302\202 \303\304\305\"\306\307@D\310\304\311
\"\312\301\"\262\211\205= \2042 \211A\2046 \313\2027 \314\315\310\"BC\262\"BBA\206I \316BBBE\207" [cl-block nil let* let mapcar #[257 "\211:\203\f \211@A@D\207\207" [] 3 "\n\n(fn C)"] while not append #[257 "\211:\205 \211AA\205 \211@\3008D\207" [2] 4 "\n\n(fn C)"] delq setq cl-psetq apply (nil)] 17 (#$ . 42096)])
#@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 "\300BB\301\302\300\"\203 \211\202 \303\304E\207" [dolist advice-member-p cl--wrap-in-nil-block cl-block nil] 6 (#$ . 42570)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\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 "\300BB\301\302\300\"\203 \211\202 \303\304E\207" [dotimes advice-member-p cl--wrap-in-nil-block cl-block nil] 6 (#$ . 43156)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\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 "\302@:\203 \303\202 \211A\262\242\211C\211\203G \211@\211:\203' \211B\262\202@ \242\242\304=\2046 \304DB\262\237B\262\211C\262A\266\202\202 \210\211\242\242\304=\204U \305B\262\211\237B\262\210\306\307!\310BB\211\203| \211@\211@BBA\266\202\202h \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
\301\302\"\210\303\304D\304DE\207" [cl--tagbody-alist error "Unknown cl-tagbody go label `%S'" throw quote] 6 "\n\n(fn LABEL)"]] 17 (#$ . 43724)]))
#@29
(fn BINDER BINDINGS BODY)
(defalias 'cl--prog #[771 "\300@\242\301=\203 \211A\262\242B\262\202 \302\300\303\237\304BC\"BBE\207" [nil declare cl-block append cl-tagbody] 12 (#$ . 45131)])
#@149 Run BODY like a `cl-tagbody' after setting up the BINDINGS.
Shorthand for (cl-block nil (let BINDINGS (cl-tagbody BODY)))
(fn BINDINGS &rest BODY)
(defalias 'cl-prog '(macro . #[385 "\300\301#\207" [cl--prog let] 6 (#$ . 45339)]))
#@150 Run BODY like a `cl-tagbody' after setting up the BINDINGS.
Shorthand for (cl-block nil (let* BINDINGS (cl-tagbody BODY)))
(fn BINDINGS &rest BODY)
(defalias 'cl-prog* '(macro . #[385 "\300\301#\207" [cl--prog let*] 6 (#$ . 45580)]))
#@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 "\300\301\302@C\303\304\305@CBBDA@\205 A@CBB\3068FE\207" [cl-block nil let mapatoms function lambda 2] 11 (#$ . 45824)]))
(byte-code "\300\301\302\303#\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)] 5)
#@81 Like `cl-do-symbols', but use the default obarray.
(fn (VAR [RESULT]) BODY...)
(defalias 'cl-do-all-symbols '(macro . #[385 "\300@\301A@EBB\207" [cl-do-symbols nil] 6 (#$ . 46334)]))
(byte-code "\300\301\302\303#\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)] 5)
#@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 "\300B\207" [cl-psetf] 3 (#$ . 46708)]))
(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 "\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] 20 (#$ . 47034)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-progv lisp-indent-function 2 put edebug-form-spec (form form body)] 5)
(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 "\211@=\203\n A\207\211 \236\211\205 \3031 \211A\n!0\202 \210\304\211\2030 \n@=\2030 \211A@\202: \305DB\211\262\207" [cl--labels-convert-cache macroexpand-all-environment cl--labels-magic (error) nil function] 6 (#$ . 48056)])
#@531 Make local function definitions.
Each definition 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)).
FUNC is defined only within FORM, not BODY, so you can't write
recursive function definitions. Use `cl-labels' for that. See
info node `(cl) Function Bindings' for details.
(fn ((FUNC ARGLIST BODY...) ...) FORM...)
(defalias 'cl-flet '(macro . #[385 "\301\211\203^ \211@\302\303\304@\"!CA\211G\305U\203( \211@9\203( @\240\210\202A \242G\305U\2036 @\202; \306\307BDDB\262@\310\311\312\313\314!\315\"\316\317%BB\262\266A\266\202\202 \210\320\237\321\322B\323\236\203q \202v \323\324BB\"\"\207" [macroexpand-all-environment nil make-symbol format "--cl-%s--" 1 cl-function lambda make-byte-code 128 "\211@ =\203\f \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] 15 (#$ . 48418)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-flet lisp-indent-function 1 put edebug-form-spec ((&rest [&or (&define name function-form) (cl-defun)]) cl-declarations body)] 5)
#@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 "\204 \300!\207A\204 \301BB\207\301\211A\262\242C\302BBE\207" [macroexp-progn cl-flet cl-flet*] 7 (#$ . 49762)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-flet* lisp-indent-function 1 put edebug-form-spec cl-flet] 5)
#@415 Make local (recursive) function definitions.
Each definition can take the form (FUNC ARGLIST BODY...) where
FUNC is the function name, ARGLIST its arguments, and BODY the
forms of the function body. FUNC is defined in any BODY, as well
as FORM, so you can write recursive and mutually recursive
function definitions. See info node `(cl) Function Bindings' for
details.
(fn ((FUNC ARGLIST BODY...) ...) FORM...)
(defalias 'cl-labels '(macro . #[385 "\301\211\2038 \211@\302\303\304@\"!\211\305\306ABDDB\262@\307\310\311\312\313!\314\"\315\316%BB\262\210A\266\202\202 \210\317\320\237BB\321\236\203J \202O \321\322BB\"\207" [macroexpand-all-environment nil make-symbol format "--cl-%s--" cl-function lambda make-byte-code 128 "\211@ =\203 \300D\207\302\300BB\207" vconcat vector [cl--labels-magic funcall] 4 "\n\n(fn &rest ARGS)" macroexpand-all letrec function cl--labels-convert] 14 (#$ . 50200)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-labels lisp-indent-function 1 put edebug-form-spec cl-flet] 5)
#@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 "A\203 \301@C\301ABBE\207\204 \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] 11 (#$ . 51262)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-macrolet lisp-indent-function 1 put edebug-form-spec (cl-macrolet-expr)] 5)
#@219 Special macro expander advice used inside `cl-symbol-macrolet'.
This function extends `macroexpand' during macro expansion
of `cl-symbol-macrolet' to additionally expand symbol macros.
(fn ORIG-FUN EXP &optional ENV)
(defalias 'cl--sm-macroexpand #[770 "\211CC\242\301\302\242\"C\242\242\"\240\210\303\2429\2033 \242\242\236\211\205. A@\240\262\202\352\242:\203\351\242@\211\304\267\202\343\242A\211\305\211\203\204 \211A\262\242\211\242\236\211\205m \211A@\2629\203i \306\202m \306\262\305\262\204R \211B\262\211A\262\242B\266\202\202H \203\216 \307\202\217 \310\237B\240\210\266\202\262\262\202\344\242A\211:\203\272 \211@A\n%\266\202\202\304 \305\211%\262\202\344\242A\211:\205o\211@\211:\205m\211@\211\311=\205kA\211:\205i\211@AA\211?\205g\305\211\211\203A\211@\211\312>\203\211\2026\211\242\236\2035\313\314!!\306\262D\242B\240\210\302\242B\242B\240\210\211\262\2026\211B\262A\266\202\202\367 \210\211\203b\315\311\237\316\317\320\321\322\323!\324\"\325\326% \"BBD\240\210\305\266\202\266\202\266\203\262\262\262\262\202\344\242A\211:\205\336\211@A\211:\205\334\211@A\211 \242\236\262\205\332\211\f\313\314!!\fD\242B\240\210\302\242B\242B\240\210\327\330\242\"\316\317\320\331\322\323!\332\"\333\334% \"BBB\262\305\262\266\204\266\202\266\202\262\202\344\305\262\202\352\305\262\204 \242)\266\202\207" [macroexpand-all-environment alist-get :cl-symbol-macros #[1285 "\300\211\211\203} \211@\2119\203 \211\202 \211@\205/ :\205/ \242@\301=\205/ \302A@\n\242\"C \242\236\203d \303\304!!\305\262 D \242B\240\210\n\306 \242B\f\242B\240\210\211\206^ \243B\262\202o \211\203n B\202o B\262\266A\266\202\202 \210\211\203\230 \211\242@\237\307\302\310 ! \242\"!BB\240\210\300\207" [nil let* macroexpand-all make-symbol symbol-name t :cl-symbol-macros macroexp-unprogn macroexp-progn] 15 "\n\n(fn EXP ENV VENV BODY BINDINGS)"] #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (setq 66 let* 158 let 158 function 201 condition-case 372)) nil t setf setq lambda (&optional &rest) make-symbol symbol-name function mapcar make-byte-code 257 "\301\300\242\"\207" vconcat vector [macroexpand-all] 4 "\n\n(fn EXP)" condition-case macroexpand-all "\211@\301\302\303\304\305\306\300!\307\"\310\311%A\"B\207" [mapcar make-byte-code 257 "\301\300\242\"\207" vconcat vector [macroexpand-all] 4 "\n\n(fn EXP)"] 9 "\n\n(fn CLAUSE)"] 31 (#$ . 51846)])
#@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 "\301\302\303\304\"\211\203/ \211@\211:\203# \211@9\203# \211A:\203# \211AA\203( \211B\262A\266\202\202 \210\305\306\307\310\311!\312\"\313$\216\211\204F \314\304\315\303#\210\316\236A\317\320!\316\321\"BB\"\203h \322\323\324\237\"\"\202i \211\266\202)\207" [macroexpand-all-environment nil advice-member-p cl--sm-macroexpand macroexpand make-byte-code 0 "\300?\205 \301\302\303\"\207" vconcat vector [advice-remove macroexpand cl--sm-macroexpand] 3 advice-add :around :cl-symbol-macros macroexpand-all macroexp-progn append macroexp--warn-and-return format-message "Malformed `cl-symbol-macrolet' binding(s): %S"] 11 (#$ . 54416)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-symbol-macrolet lisp-indent-function 1 put edebug-form-spec ((&rest (symbolp sexp)) cl-declarations body)] 5)
#@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 "\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)"] 15 (#$ . 55509)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-multiple-value-bind lisp-indent-function 2 put edebug-form-spec ((&rest symbolp) form body)] 5)
#@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 "\204\n \300\301BB\207A\204 \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)"] 19 (#$ . 56358)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-multiple-value-setq lisp-indent-function 1 put edebug-form-spec ((&rest symbolp) form)] 5)
#@41 Equivalent to `progn'.
(fn &rest BODY)
(defalias 'cl-locally '(macro . #[128 "\300B\207" [progn] 3 (#$ . 57288)]))
(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 "\302 \203 \303W\204 \303U\204 \207\211\304!\203 \211\202 \305\306!\307\310\311\312DE\313\314\315\312\nD\312 DFEEE=\203E \211\202L \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*] 14 (#$ . 57449)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-the lisp-indent-function 1 put edebug-form-spec (cl-type-spec form)] 5)
(defvar cl--proclaim-history t)
(defvar cl--declare-stack t)
#@18
(fn SPEC HIST)
(defalias 'cl--do-proclaim #[514 "\211\203
<\203
B\242\306=\203# \307\301!\203\325 \310A \"\202\325 \242\311=\203K A\211\262\203\325 @\312N\313>\204A \314\315@\"\210\316@\312\317#\210\202* \242\320=\203m A\211\262\203\325 @\312N\317=\203R \316@\312\321#\210\202R \242\322=\203\237 \323A\236A@\324\236\325A\236A@\326\236\203\217 @A@\211\203\232 \211@\211A@\266\202\325 \242\327=\203\325 \307\330!\203\325 A\211\262\203\325 @:\203\254 @A@\331=\203\314 \332@@!\210\202\254 \333@@!\210\202\254 \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] 6 (#$ . 58138)])
(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 "\301 \203 \211\203 <\203 \211@B\302\211A\262\242\303\"\210\202 \303\207" [cl--declare-stack cl--compiling-file cl--do-proclaim nil] 4 (#$ . 59329)]))
#@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 "\211\300\301\203A @9\203 \302A@\"\203 \301\262@>\203& \303\304@\"\210\211A\262\242B\262\2048 \303\305!\210\211A\262\210\202 \203O \306\307B\310BB\202{ \311!\262\312A@@EAA\211\262\203t \312A@\313@EE\262\202[ \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)] 10 (#$ . 59748)]))
(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 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [gv-get make-byte-code 514 "\300\301!\203 \211\202 \302\303!\304\305\306DE\307\310D!\311BB\312EF=\2030 \211\2027 \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)"] 10 (#$ . 60464)]))
(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 "\211\204 \2079\203 \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)"] 10 (#$ . 61092)]))
(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 "\300\301\302\">\2040 \211A\205m \300@A\203& \211A\262\242@D\244\262\202 \303\304@D\"B\207\305!\306\307!\211CA\203X \211\310\211A\262\242\311\312\313\314\315!\316\"\317\320%\"\240\210\2028 \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] 13 (#$ . 61625)]))
(put 'cl-rotatef 'edebug-form-spec '(&rest place))
#@40
(fn BINDINGS SIMPLEBINDS BINDS BODY)
(defalias 'cl--letf #[1028 "\2040 \204 \204 \301!\207\302\303\304\305\"\"\306\301\303\307\310\304\311\n\"\"\"!\304\312\"BBE\207@\313@\"\314\315\316\317\320\321\f\f\f\f\f\f&\322\"\323\324%\"\207" [macroexpand-all-environment 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< \211@A\211:\205: \211@A\211:\2058 \211@A\211:\2056 \211@A\211?\2054 \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)"] macroexpand gv-get make-byte-code 514 "\304A@\306!\203
\211\202 \307\310!\3059\203- \311\300A\304A\203\" \202$ D\301B\302\303$\202G \311\300A\301\307\312!\304A\205@ CBBB\302B\303$=\203Q \211\202X \313DC\"\207" vconcat vector [macroexp-const-p make-symbol "vnew" cl--letf "old" macroexp-let*] 11 "\n\n(fn GETTER SETTER)"] 19 (#$ . 62446)])
#@584 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.
See info node `(cl) Function Bindings' for details.
(fn ((PLACE VALUE) ...) BODY...)
(defalias 'cl-letf '(macro . #[385 "A\204# @A\203# @@9\203# @@\301\302\"\236\204# \303BB\207\304\305\211$\207" [macroexpand-all-environment alist-get :cl-symbol-macros let cl--letf nil] 7 (#$ . 63487)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-letf lisp-indent-function 1 put edebug-form-spec ((&rest [&or (symbolp form) (gate gv-place &optional form)]) body)] 5)
#@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 "\300!\211\203 \211@\301CBBC\262A\266\202\202 \210\302!\207" [reverse cl-letf macroexp-progn] 7 (#$ . 64479)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-letf* lisp-indent-function 1 put edebug-form-spec cl-letf] 5)
#@199 Set PLACE to (FUNC PLACE ARGS...).
FUNC should be an unquoted function name or a lambda expression.
PLACE may be a symbol, or any generalized variable allowed by
`setf'.
(fn FUNC PLACE &rest ARGS)
(defalias 'cl-callf '(macro . #[642 "\300\301\302\303\304\305 \"\306\"\307\310%\"\207" [gv-get make-byte-code 514 "\301B\3009\203 \300B\202 \302\303\300DBB!\207" vconcat vector [funcall function] 7 "\n\n(fn GETTER SETTER)"] 12 (#$ . 64964)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-callf lisp-indent-function 2 put edebug-form-spec (cl-function place &rest form)] 5)
#@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 "\300!\203 \301!\203 9\203 \302BBBE\207\303!\203' \211\202* \304\305!\306\307\310\311\312\313\f\n #\314\"\315\316%\"=\203H \211\202O \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\203 \300B\202 \303\304\300DBB!\207" vconcat vector [funcall function] 7 "\n\n(fn GETTER SETTER)" macroexp-let*] 16 (#$ . 65576)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-callf2 lisp-indent-function 3 put edebug-form-spec (cl-function form place &rest form)] 5)
#@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 "\300!@\301=\203 AA\202 \211\203( \302@\"\303=\203( \211A\266\202\202 \304?\205q \305\306>\203C \307\310\311\nBBB\202G \311B\312\313 \"\314\315 D\315\316\317!ABBD\320\306>\205f \310\320
BBBBBB\257\321BBBE\207" [cl--arglist-args &cl-defs cl--expr-contains 1 progn cl-define-compiler-macro &key &whole cl-whole &cl-quote format "compiler-macro for inlining `%s'." cl--defsubst-expand quote cl-block macroexp-parse-body nil cl-defun] 18 (#$ . 66347)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put cl-defsubst edebug-form-spec cl-defun function-put lisp-indent-function 2] 4)
#@51
(fn ARGNS BODY SIMPLE WHOLE UNSAFE &rest ARGVS)
(defalias 'cl--defsubst-expand #[1413 "C\203 \300\301B!\204 \202m \302!\203 \211\303\240\210\304C\305\304\306\307\310\311\312\313 \"\314\"\315\316% #\"\242\204@ \202[ \242A\204U \317\242@A\242@@\n#\202[ \320\242 \"\262\211\203i \321 E\202k \266\202\207" [cl--safe-expr-p progn cl--simple-exprs-p t nil delq cl-mapcar make-byte-code 514 "\300\242\204 \302!\203 \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] 18 (#$ . 67348)])
#@88 Perform substitutions indicated by ALIST in TREE (non-destructively).
(fn ALIST TREE)
(defalias 'cl--sublis #[514 "\211\236\211\203\f \211A\202 :\203 \300@\"\300A\"B\202 \207" [cl--sublis] 7 (#$ . 67940)])
#@13
(fn TYPE)
(defalias 'cl--find-class '(macro . #[257 "\300\301BB\207" [get ('cl--class)] 4 (#$ . 68163)]))
(defvar cl--struct-default-parent nil)
#@61 If non-nil, `cl-defstruct' will define inlinable functions.
(defvar cl--struct-inline t (#$ . 68317))
#@1100 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', `:noinline', or `:include'. See Info
node `(cl)Structures' for the description of the options.
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.
Supported keywords for slots are:
- `:read-only': If this has a non-nil value, that slot cannot be set via `setf'.
- `:documentation': this is a docstring describing the slot.
- `:type': the type of the field; currently only used for documentation.
(fn NAME &optional DOCSTRING &rest SLOTS)
(defalias 'cl-defstruct '(macro . #[385 ":\203\n @\202 \243\304\211\305!\306P\307\310\311\"!\304\307\310\312 \"!\307\310\313\n\"!\304\211\314 \2035 \2026 \315\304\f\307\310\316\"!\304\211\211\211 \203L \317\202M \320 \203U \317\202V \321\304@;\205e \211A\262\242\304\211\322!\204w \323\324\325\326E\"\210\327\330\331 \"B\262\203L@:\203\223 @@\202\226 @\211A\262\242\243\332\267\202B\211\203G\211@\203\264 \305@!\202\265 \333\262\202G\211A\203\323 \211@=\203\312 \304\262\211B\262\202G\211\203G\211@\262\202G\211\203G\211@\262\202G\211\203G\211@\262\202G\n\203\375 \334\335!\210\211@\262 \330\336A\"\262\f\202G\211@\262\202G\211@\262\n \337>\204G\334\340 \"\210\202G\341\262 \202G\321\262\320\262\202G\342@\343\" \244\262 \202G\334\344\"\210\266\202\200 \204Y\204Y\n\262 \203d\345 !\262
\203z\346\347\350D\351BB\352BB\262\202\274\204\274\f\203\234\353
! >\204\225\323\324\354D\"\210\f\355H\203\274\341\262\f\204\251\203\257?\205\272\346\356\310\357 \"\360BBD\262\f\203R\353
! >\204\322\323\324\354D\"\210\f\361H\362! \203\354\n=\204\354\334\363 \"\210 \203 @@\236\206\334\364
@@#>\f\211A\262\242\240\210\202\354\365\366\367 \236 \"\"\262 \262\n \370>\203/\367 \236\2020\371\262 \353! >\204C\323\324\354D\"\210\372H\203M\341\262 \266\202Z\204Z\371\262\204i\366\367\236\"\262\204|\203|\307\310\373\"!\262\205\346G\367\236>GZ\204\232\374\375
E\202\344\376=\203\300\377\201@ \201A \201B GE\374\201C \201D EEF\202\344\211\201E U\203\322\374\201F
E\202\344\377\201G \374\201H \201I BBEE\262\262\205
\201E V\205A@@\201J =\203
\201K U\203\377AAAB\202\201L B\262\203]\201M \201N @\377=\2038\365\201O \"\202@\377\201P BB\257B\262\201Q \201R D\201S \201R DFB\262\201E \211\203 \211A\262\242\211A\262\242\211\201T >\203\224\304B\262\211\367=\205\214\201R DB\262\202\211\236\203\243\334\201U #\210\307\310\201V #!\211A\262\242\201W \201X \"\346\365 \205\334\201Y \n\323\201Z \201[ \201R 'D\201\\ BBEEC\201] >\203\361\201C \201D E\202\n \201E U\203 \201^ \202\n\201H \n\201_ BBC\"B B\262 B\262 \f\201` \310\201a &\2035\201b P\2026\333$\201c \257\fB\262\f\201d G!\203\231\201e \310\201f \201g !@%$\304\"\fB\262\f\201h @!\203\231\201h @!\204\231 @\201e \310\201i \"\304\"
B\262
\211B\262 \304\240\266\f\321=\203\307\201W \201j \"\204\357\321\201k !\201l \201m \201n BBF\fB\262\f\202\357\201W \201j \"\203\357\201o \201p \201q \334\201r \201R \nDEEE\fB\262\f\203\356\310\201s \"\201t BB\201u \201v B\201w BBD\244\210\266\266T\262\202b\266\237\262\237\262\203B\201x \201R D\201y BBB\262\203\\\201z \366\304\201{ !\"BDB\262\211\203\357\211@\211@A\211@A\211@A\201| !\201} \201~ \201 \201\200 \201\201 \376!\201\202 \"\201\203 \201\204 %$$#\201\205 \304*BBB;\203\265\202\274\310\201\206 *\"\365\201\207 \346\330\201\210 /\"B!\205\320\201\211 \206\330\201\212 BC\"BBBBB\262\266 A\266\202\202^\210\203\376\201\213 \341D\244\210\346\201\214 \fD\365\237\201\215 \201\216 \201\217 \201R D\n\201R D\201R \206+\201\212 D\341=\201R &D\201R D\201R D\201R D\257\nD\201R DE\"BB\207" [cl--optimize-safety cl--struct-inline 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-tags" cl-defsubst cl-defun defun cl--struct-name-p signal wrong-type-argument cl-struct-name-p name (cl-tag-slot) mapcar #[257 "\211:\203 \207\211C\207" #1=[] 2 "\n\n(fn X)"] #s(hash-table size 10 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:conc-name 164 :constructor 186 :copier 222 :predicate 233 :include 244 :print-function 267 :type 274 :named 294 :noinline 300 :initial-offset 309)) "" error "Can't :include more than once" #[257 "\211:\203 \207\211C\207" #1# 2 "\n\n(fn X)"] (vector list) "Invalid :type specifier: %s" t make-list (cl-skip-slot) "Structure option %s unrecognized" cl--struct-get-class progn funcall function (cl-x cl-s cl-n) (t) type-of 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 (vector list) true 8 "cl--struct-%s-p" memq (type-of cl-x) vector and (vectorp cl-x) >= (length cl-x) aref cl-x 0 (car-safe cl-x) (consp cl-x) nth (cl-x) vectorp 1 (cl-x) (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" plist-get :documentation or 'wrong-type-argument list (cl-x) (nil vector) (car cl-x) (cl-x) (cl-x) "Access slot \"%s\" of `%s' struct CL-X.%s" "\n" (declare (side-effect-free t)) cl-oddp macroexp--warn-and-return "Missing value for option `%S' of slot `%s' in struct %s!" last keywordp " I'll take `%s' to be an option rather than a default value." :read-only gv-setter (val cl-x) setf (val) 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>\203 \207\207" vconcat #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))) record (princ ")" cl-s) defvar :autoload-end eval-and-compile cl-struct-define] 50 (#$ . 68427)]))
(byte-code "\300\301\302\303#\300\301\304\305#\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 symbolp (&or [":conc-name" symbolp] [":constructor" symbolp &optional cl-lambda-list] [":copier" symbolp] [":predicate" symbolp] [":include" symbolp &rest sexp] [":print-function" sexp] [":type" symbolp] [":named"] [":initial-offset" natnump])])] [&optional stringp] &rest &or symbolp (symbolp &optional def-form &rest sexp))] 6)
#@14
(fn CLASS)
(defalias 'cl--struct-all-parents #[257 "\302!>\2057 \303C\211A\262\242\211B\262\304\302! >\204' \305\306\307D\"\210\310H\"\211\262\262\204 \237\266\202\207" [cl-struct-cl-structure-class-tags cl-struct-cl--class-tags type-of nil append signal wrong-type-argument cl--class 3] 10 (#$ . 75691)])
#@266 Pcase patterns that match cl-struct EXPVAL of type TYPE.
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 "\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\n \211@\202 \211:\203 A@\202 \301\302\300!\303=\203) \304\305\300\"D\2021 \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)"] 11 (#$ . 76021)])
(byte-code "\300\301\302\303#\300\304\305\301#\300\207" [define-symbol-prop cl-struct--pcase-macroexpander edebug-form-spec (sexp &rest [&or (sexp pcase-PAT) sexp]) cl-struct pcase-macroexpander] 5)
#@13
(fn TYPE)
(defalias 'cl--defstruct-predicate #[257 "\300!\301\236\211\203 \211A\202 \302\207" [cl-struct-sequence-type ((list . consp) (vector . vectorp) (nil . recordp)) recordp] 3 (#$ . 76933)])
#@71 Extra special cases for `cl-typep' predicates.
(fn ORIG PRED1 PRED2)
(defalias 'cl--pcase-mutually-exclusive-p #[771 "\242\301=\2058 A\211\262\2058 \242\302=\2058 A\211\262\2058 \243?\2058 @\211\262\2058 \242\303=\2058 A@\242\301=\205n A\211\262\205n \242\302=\205n A\211\262\205n \243?\205n @\211\262\205n \242\303=\205n A@9\203\231 \2119\203\231 \304N\304N\205\224 \211\205\224 \305!>\206\223 \211\305!>?\266\202\206\342 9\205\241 \304N\211\205\265 \306!>\205\265 \307!\"\262\206\342 \2119\205\302 \211\304N\211\205\326 \306!>\205\326 \307!\"\262\206\342 \"\207" [cl-struct-cl-structure-class-tags pcase--flip cl-typep quote cl--class cl--struct-all-parents type-of cl--defstruct-predicate] 12 (#$ . 77141)])
(advice-add 'pcase--mutually-exclusive-p :around 'cl--pcase-mutually-exclusive-p)
#@198 Return the sequence used to build STRUCT-TYPE.
STRUCT-TYPE is a symbol naming a struct type. Return `record',
`vector`, or `list' if STRUCT-TYPE is a struct type, nil otherwise.
(fn STRUCT-TYPE)
(defalias 'cl-struct-sequence-type #[257 "\301!\302!>\204 \303\304\305D\"\210\211\306H\207" [cl-struct-cl-structure-class-tags cl--struct-get-class type-of signal wrong-type-argument cl-structure-class 7] 6 (#$ . 77997)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put cl-struct-sequence-type side-effect-free t pure] 5)
#@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 "\302!\303!>\204 \304\305\306D\"\210\211\307H\303!>\204$ \304\305\306D\"\210\310H\211?\205. \311CG\312\211W\203\261 \211H\303! >\204J \304\305\313D\"\210\211\314H\303! >\204\\ \304\305\313D\"\210\315H\316\303! >\204p \304\305\313D\"\210\317H\320=?\205\216 \321\303! >\204\212 \304\305\313D\"\210\317HD\303! >\204\236 \304\305\313D\"\210\307H\"BBB\262\266\211T\262\2021 \266\211\237\207" [cl-struct-cl-structure-class-tags cl-struct-cl-slot-descriptor-tags cl--struct-get-class type-of signal wrong-type-argument cl-structure-class 4 7 (cl-tag-slot) 0 cl-slot-descriptor 1 2 append 3 t :type] 17 (#$ . 78550)])
(byte-code "\300\301\302\303#\300\301\304\303#\305\306\307\"\207" [function-put cl-struct-slot-info side-effect-free t pure define-error cl-struct-unknown-slot "struct has no slot"] 5)
#@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 "\301\302!\303!>\204 \304\305\306D\"\210\211\307H\262\"\206# \304\310D\"\207" [cl-struct-cl--class-tags gethash cl--struct-get-class type-of signal wrong-type-argument cl--class 5 cl-struct-unknown-slot] 9 (#$ . 79737)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put cl-struct-slot-offset side-effect-free t pure] 5)
#@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 "\302!\206 \303 \205 \211\236A\206 \211 \236A\207" [byte-compile-function-environment byte-compile-macro-environment fboundp cl--compiling-file] 3 (#$ . 80430)])
(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)
#@17
(fn VAL TYPE)
(defalias 'cl-typep #[514 "\211\211:\203i\211@A\211\300N\262\203$ \211\301\302\300N\"\"\266\202\202d\303\267\2024\211@A\211@A\301\f\"\205s \304>\204X :\203Q @V\202U Y\205s \305>\203b \306\202s :\203o @W\202s X\266\203\266\204\202d\211:\203\237 \211@A\211\204\223 \301\"?\262\202\232 \307\310\"\262\266\202\202d\307\310\"\262\202d\211\204\265 \211\311=\202\356 A\204\303 \301@\"\202\356 @AB\311=\203\337 \301 \"\205\354 \301 \"\202\354 \301 \"\206\354 \301 \"\266\202\266\202\202d\211:\203\211@A\211\204\312\"\205\n\306\262\202\307\310\"\262\266\202\202d\307\310\"\262\202d\211\313\"\205/\306\262\202d\314=\203?\211:\204I\307\310\"\262\202d\211@A\211\204[\211!\262\202b\307\310\"\262\266\202\266\202\202\356\2119\204x\211\307\310\"\262\202\356\211\211\300N\262\203\216\211\301\300N \"\262\202\356\211\211\315N\262\203\242\211\211\315N!\262\202\356\211\316>\203\257\211\211\262\202\356\211\317!\320\321P!\322!\203\305\211!\202\352\322\320\323P!\211\262!\203\331\211!\202\352\322!\203\346!\202\352\307\324\"\266\202\262\207" [cl-deftype-handler cl-typep apply #s(hash-table size 9 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (number 42 real 42 float 42 integer 42 not 122 or 169 and 169 eql 243 member 293)) (* nil) (* nil) t error "Bad type spec: %s" and eql memql satisfies cl-deftype-satisfies (t nil) symbol-name intern "p" cl--macroexp-fboundp "-p" "Unknown type %S"] 15 (#$ . 81030)])
(byte-code "\300\301\302\303#\300\207" [function-put cl-typep compiler-macro cl-typep--inliner] 4)
#@30
(fn INLINE--FORM VAL TYPE)
(defalias 'cl-typep--inliner #[771 "\3002m\301!\203 \211\202 \302\303!\304!\204' \242\305=\204' \306\300\"\2023 :\2032 A@\2023 \211:\203\302\211@A\211\307N\262\203Y \211\310\311\312\307N\"DE\266\202\202\275\313\267\202\212\211@A\211@A\314\310\f\311DE\315>\203} \316\202\226 :\203\216 \317
\311@DE\202\226 \320
\311DE\321>\203\240 \316\202\271 :\203\261 \322\311@DE\202\271 \323\311DEF\266\203\266\204\202\275\211:\203\351 \211@A\211\204\335 \324\310\311DED\262\202\344 \325\326\"\262\266\202\202\275\325\326\"\262\202\275\211\204\311\314=D\202BA\204\310\311@DE\202B@AB\314=\2030\314\310 \311DE\310\n\311DEE\202@\327\310 \311DE\310\n\311DEE\266\202\266\202\202\275\211:\203p\211@A\211\204d\314\330\311DE\316E\262\202k\325\326\"\262\266\202\202\275\325\326\"\262\202\275\211\314\331\311DE\316E\262\202\275\332=\203\225\211:\204\237\325\326\"\262\202\275\211@A\211\204\264\333\305DE\262\202\273\325\326\"\262\266\202\266\202\202W\2119\204\321\211\325\326\"\262\202W\211\211\307N\262\203\351\211\310\311\307N DE\262\202W\211\211\334N\262\203 \211\333\305\334NDE\262\202W\211\335>\203\211\311D\262\202W\211\336!\337\340P!\341!\203(\333\305DE\202S\341\337\342P!\211\262!\203?\333\305DE\202S\341!\203O\333\305DE\202S\325\343\"\266\202\262\262=\203c\211\202j\344DC\"\266\2030\207" [inline--just-use macroexp-copyable-p make-symbol "val" macroexp-const-p function throw cl-deftype-handler cl-typep quote apply #s(hash-table size 9 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (number 95 real 95 float 95 integer 95 not 193 or 243 and 243 eql 327 member 378)) and (* nil) t > >= (* nil) < <= not error "Bad type spec: %s" or eql memql satisfies funcall cl-deftype-satisfies (t nil) symbol-name intern "p" cl--macroexp-fboundp "-p" "Unknown type %S" macroexp-let*] 22 (#$ . 82713)])
#@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 "\302 \203 \303W\204 \303U\205S \304!\203 \211\202 \305\306!\307\310\311\312DE\313\314\315\2064 \312\nD\312
DFEE\316BB=\203J \211\202Q \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*] 15 (#$ . 84727)]))
(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 "\302 \203 \303W\204 \303U\205H \205 \304\305\306\307\243\"\"\310\311\312\313 D\2045 \2045 \205@ \314B\314 BEBBE\315BB\262\207" [cl--optimize-speed cl--optimize-safety cl--compiling-file 3 delq nil mapcar #[257 "\300!?\205 \211\207" [macroexp-const-p] 3 "\n\n(fn X)"] progn or cl--assertion-failed quote list (nil)] 14 (#$ . 85376)]))
(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 "\300:\203 \211A\262\242B\262\202 \211\237\205 \301D\244\262\266\302\303!\304P!\305\306\307>\203; \310\307\"\202? \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] 11 (#$ . 86198)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\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 "\211\242\3009\2031 \301N\211\262\2041 \302!\2031 K\211\242\303=\262\203* \304K\"\2031 K\262\202 \211\205A \305\211A#\211\262=?\266\202\204 \207" [nil compiler-macro fboundp autoload autoload-do-load apply] 8 (#$ . 87402)])
(defvar cl--active-block-names nil)
#@29
(fn CL-WHOLE-ARG CL-FORM)
(defalias 'cl--block-wrapper--cmacro #[514 "\211A@A@\302B\211B\303\304AA! \"A\203$ \305A@\306!BB\202% \211)\207" [cl--active-block-names macroexpand-all-environment nil macroexpand-all macroexp-progn catch macroexp-unprogn] 8 (#$ . 87954)])
(put 'cl--block-wrapper 'compiler-macro 'cl--block-wrapper--cmacro)
#@37
(fn CL-WHOLE-ARG CL-TAG CL-VALUE)
(defalias 'cl--block-throw--cmacro #[771 "A@\236\211\203
\211\301\241\210\210\302E\207" [cl--active-block-names t throw] 6 (#$ . 88303)])
(put 'cl--block-throw 'compiler-macro 'cl--block-throw--cmacro)
#@31
(fn FORM A LIST &rest KEYS)
(defalias 'cl--compiler-macro-member #[899 "\211G\300U\205 \211@\301=\205 \302A@!\211\303\267\202' \304E\2029 \305E\2029 \2031 \211\306=\2038 \307E\2029 \207" [2 :test cl--const-expr-val #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (eq 25 equal 32)) memq member eql memql] 8 (#$ . 88552)])
#@31
(fn FORM A LIST &rest KEYS)
(defalias 'cl--compiler-macro-assoc #[899 "\211G\300U\205 \211@\301=\205 \302A@!\211\303\267\202' \304E\202N \305E\202N \306!\203M \2037 \211\307=\203M \310\302!!\203F \305E\202N \304E\202N \207" [2 :test cl--const-expr-val #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (eq 25 equal 32)) assq assoc macroexp-const-p eql floatp] 8 (#$ . 88929)])
#@31
(fn FORM A LIST &rest KEYS)
(defalias 'cl--compiler-macro-adjoin #[899 "\300>\203 \207\301!\203 \211\202 \302\303!\301!\203! \211\202$ \302\304!\305\306BBB\307EF=\203> \211\202E \310DC\"\266\203=\203Q \211\202X \310DC\"\207" [:key macroexp-copyable-p make-symbol "va" "vlist" if cl-member cons macroexp-let*] 14 (#$ . 89364)])
#@36
(fn FORM SYM PROP &optional DEF)
(defalias 'cl--compiler-macro-get #[1027 "\211\203\f \300\301DF\207\302E\207" [cl-getf symbol-plist get] 8 (#$ . 89726)])
(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 "\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 ('*)] 13 (#$ . 90942)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\304\301\307\310#\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]] 6)
#@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 "\300\"\204 \301\302D\"\210\303!\304=\203 \305\"8\207\211\305\"H\207" [cl-typep signal wrong-type-argument cl-struct-sequence-type list cl-struct-slot-offset] 7 (#$ . 91572)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put cl-struct-slot-value compiler-macro cl-struct-slot-value--inliner side-effect-free t] 5)
#@48
(fn INLINE--FORM STRUCT-TYPE SLOT-NAME INST)
(defalias 'cl-struct-slot-value--inliner #[1028 "\3002\233 \301!\203 \211\202 \302\303!\301!\203 \211\202 \302\304!\301!\203+ \211\202. \302\305!\306\307\310E\311\312\313D\314\nEEE\315\316\317 D\312\314DE\320\321\n EE\322\321\f EEFE=\203k \211\202r \323DC\"\266\203=\203~ \211\202\205 \323DC\"\266\203=\203\221 \211\202\230 \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*] 20 (#$ . 92120)])
(byte-code "\300\301!\210\302\303!\207" [run-hooks cl-macs-load-hook provide cl-macs] 2)
Mini Shell