%PDF- %PDF- Mini Shell
Mini Shell

Direktori : /usr/local/share/emacs/27.2/lisp/emacs-lisp/
Current File : //usr/local/share/emacs/27.2/lisp/emacs-lisp/eieio-core.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\303\304#\207" [require cl-lib eieio-loaddefs nil t] 4)
#@69 This hook is executed, then cleared each time `defclass' is called.
(defvar eieio-hook nil (#$ . 497))
#@184 Non-nil to throw an error if an encountered tag is unsupported.
This may prevent classes from CLOS applications from being used with EIEIO
since EIEIO does not support all CLOS tags.
(defvar eieio-error-unsupported-class-tags nil (#$ . 607))
#@223 If non-nil, skip all slot typechecking.
Set this to t permanently if a program is functioning well to get a
small speed increase.  This variable is also used internally to handle
default setting for optimization purposes.
(defvar eieio-skip-typecheck nil (#$ . 856))
#@67 Non-nil means to optimize the method dispatch on primary methods.
(defvar eieio-optimize-primary-methods-flag t (#$ . 1129))
#@263 If nil, drop support for some behaviors of older versions of EIEIO.
Currently under control of this var:
- Define every class as a var whose value is the class symbol.
- Define <class>-child-p and <class>-list-p predicates.
- Allow object names in constructors.
(defvar eieio-backward-compatibility t (#$ . 1261))
#@62 Uninterned symbol representing an unbound slot in an object.
(defconst eieio-unbound (byte-code "\301\300!\203
9\203
\207\302\303!\207" [eieio-unbound boundp make-symbol "unbound"] 2) (#$ . 1581))
(defvar eieio-default-superclass nil)
#@71 compiler-macro for inlining `eieio--class-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'eieio--class-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block eieio--class-p (and (memq (type-of cl-x) cl-struct-eieio--class-tags) t)) nil] 9 (#$ . 1826)])
(put 'eieio--class-p 'compiler-macro 'eieio--class-p--cmacro)
#@13 

(fn CL-X)
(defalias 'eieio--class-p #[257 "\301!>\205	\302\207" [cl-struct-eieio--class-tags type-of t] 3 (#$ . 2172)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put eieio--class-p side-effect-free error-free put eieio--class cl-deftype-satisfies] 5)
#@74 compiler-macro for inlining `eieio--class-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'eieio--class-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block eieio--class-name (progn (aref cl-x 1))) nil] 9 (#$ . 2454)])
(put 'eieio--class-name 'compiler-macro 'eieio--class-name--cmacro)
#@62 Access slot "name" of `eieio--class' struct CL-X.

(fn CL-X)
(defalias 'eieio--class-name #[257 "\211\300H\207" [1] 3 (#$ . 2779)])
(byte-code "\300\301\302\303#\300\207" [function-put eieio--class-name side-effect-free t] 4)
#@79 compiler-macro for inlining `eieio--class-docstring'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'eieio--class-docstring--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block eieio--class-docstring (progn (aref cl-x 2))) nil] 9 (#$ . 3011)])
(put 'eieio--class-docstring 'compiler-macro 'eieio--class-docstring--cmacro)
#@67 Access slot "docstring" of `eieio--class' struct CL-X.

(fn CL-X)
(defalias 'eieio--class-docstring #[257 "\211\300H\207" [2] 3 (#$ . 3361)])
(byte-code "\300\301\302\303#\300\207" [function-put eieio--class-docstring side-effect-free t] 4)
#@77 compiler-macro for inlining `eieio--class-parents'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'eieio--class-parents--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block eieio--class-parents (progn (aref cl-x 3))) nil] 9 (#$ . 3608)])
(put 'eieio--class-parents 'compiler-macro 'eieio--class-parents--cmacro)
#@65 Access slot "parents" of `eieio--class' struct CL-X.

(fn CL-X)
(defalias 'eieio--class-parents #[257 "\211\300H\207" [3] 3 (#$ . 3948)])
(byte-code "\300\301\302\303#\300\207" [function-put eieio--class-parents side-effect-free t] 4)
#@75 compiler-macro for inlining `eieio--class-slots'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'eieio--class-slots--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block eieio--class-slots (progn (aref cl-x 4))) nil] 9 (#$ . 4189)])
(put 'eieio--class-slots 'compiler-macro 'eieio--class-slots--cmacro)
#@63 Access slot "slots" of `eieio--class' struct CL-X.

(fn CL-X)
(defalias 'eieio--class-slots #[257 "\211\300H\207" [4] 3 (#$ . 4519)])
(byte-code "\300\301\302\303#\300\207" [function-put eieio--class-slots side-effect-free t] 4)
#@81 compiler-macro for inlining `eieio--class-index-table'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'eieio--class-index-table--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block eieio--class-index-table (progn (aref cl-x 5))) nil] 9 (#$ . 4754)])
(put 'eieio--class-index-table 'compiler-macro 'eieio--class-index-table--cmacro)
#@69 Access slot "index-table" of `eieio--class' struct CL-X.

(fn CL-X)
(defalias 'eieio--class-index-table #[257 "\211\300H\207" [5] 3 (#$ . 5114)])
(byte-code "\300\301\302\303#\300\207" [function-put eieio--class-index-table side-effect-free t] 4)
#@78 compiler-macro for inlining `eieio--class-children'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'eieio--class-children--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block eieio--class-children (progn (aref cl-x 6))) nil] 9 (#$ . 5367)])
(put 'eieio--class-children 'compiler-macro 'eieio--class-children--cmacro)
#@66 Access slot "children" of `eieio--class' struct CL-X.

(fn CL-X)
(defalias 'eieio--class-children #[257 "\211\300H\207" [6] 3 (#$ . 5712)])
(byte-code "\300\301\302\303#\300\207" [function-put eieio--class-children side-effect-free t] 4)
#@84 compiler-macro for inlining `eieio--class-initarg-tuples'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'eieio--class-initarg-tuples--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block eieio--class-initarg-tuples (progn (aref cl-x 7))) nil] 9 (#$ . 5956)])
(put 'eieio--class-initarg-tuples 'compiler-macro 'eieio--class-initarg-tuples--cmacro)
#@72 Access slot "initarg-tuples" of `eieio--class' struct CL-X.

(fn CL-X)
(defalias 'eieio--class-initarg-tuples #[257 "\211\300H\207" [7] 3 (#$ . 6331)])
(byte-code "\300\301\302\303#\300\207" [function-put eieio--class-initarg-tuples side-effect-free t] 4)
#@81 compiler-macro for inlining `eieio--class-class-slots'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'eieio--class-class-slots--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block eieio--class-class-slots (progn (aref cl-x 8))) nil] 9 (#$ . 6593)])
(put 'eieio--class-class-slots 'compiler-macro 'eieio--class-class-slots--cmacro)
#@69 Access slot "class-slots" of `eieio--class' struct CL-X.

(fn CL-X)
(defalias 'eieio--class-class-slots #[257 "\211\300H\207" [8] 3 (#$ . 6953)])
(byte-code "\300\301\302\303#\300\207" [function-put eieio--class-class-slots side-effect-free t] 4)
#@93 compiler-macro for inlining `eieio--class-class-allocation-values'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'eieio--class-class-allocation-values--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block eieio--class-class-allocation-values (progn (aref cl-x 9))) nil] 9 (#$ . 7206)])
(put 'eieio--class-class-allocation-values 'compiler-macro 'eieio--class-class-allocation-values--cmacro)
#@81 Access slot "class-allocation-values" of `eieio--class' struct CL-X.

(fn CL-X)
(defalias 'eieio--class-class-allocation-values #[257 "\211\300H\207" [9] 3 (#$ . 7626)])
(byte-code "\300\301\302\303#\300\207" [function-put eieio--class-class-allocation-values side-effect-free t] 4)
#@90 compiler-macro for inlining `eieio--class-default-object-cache'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'eieio--class-default-object-cache--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block eieio--class-default-object-cache (progn (aref cl-x 10))) nil] 9 (#$ . 7915)])
(put 'eieio--class-default-object-cache 'compiler-macro 'eieio--class-default-object-cache--cmacro)
#@78 Access slot "default-object-cache" of `eieio--class' struct CL-X.

(fn CL-X)
(defalias 'eieio--class-default-object-cache #[257 "\211\300H\207" [10] 3 (#$ . 8321)])
(byte-code "\300\301\302\303#\300\207" [function-put eieio--class-default-object-cache side-effect-free t] 4)
#@77 compiler-macro for inlining `eieio--class-options'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'eieio--class-options--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block eieio--class-options (progn (aref cl-x 11))) nil] 9 (#$ . 8602)])
(put 'eieio--class-options 'compiler-macro 'eieio--class-options--cmacro)
#@65 Access slot "options" of `eieio--class' struct CL-X.

(fn CL-X)
(defalias 'eieio--class-options #[257 "\211\300H\207" [11] 3 (#$ . 8943)])
(byte-code "\300\301\302\303#\300\207" [function-put eieio--class-options side-effect-free t] 4)
#@74 compiler-macro for inlining `eieio--class-make'.

(fn CL-WHOLE-ARG NAME)
(defalias 'eieio--class-make--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (name) (cl-block eieio--class-make (record 'eieio--class name nil nil nil nil nil nil nil nil nil nil)) nil] 9 (#$ . 9185)])
(put 'eieio--class-make 'compiler-macro 'eieio--class-make--cmacro)
#@60 Constructor for objects of type `eieio--class'.

(fn NAME)
(defalias 'eieio--class-make #[257 "\300\301\302\211\211\211\211\211\211\211\211\211&\f\207" [record eieio--class nil] 14 (#$ . 9556)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put eieio--class-make side-effect-free t cl-struct-define eieio--class nil cl--class record ((cl-tag-slot) (name nil :type symbol) (docstring nil :type string) (parents nil :type (list-of cl--class)) (slots nil :type (vector cl-slot-descriptor)) (index-table nil :type hash-table) (children) (initarg-tuples) (class-slots nil :type eieio--slot) (class-allocation-values) (default-object-cache) (options)) cl-struct-eieio--class-tags] 11)
(defconst eieio--object-num-slots 1)
#@12 

(fn OBJ)
(defalias 'eieio--object-class-tag #[257 "\211\300H\207" [0] 3 (#$ . 10320)])
(byte-code "\300\301\302\303#\210\304\305!\207" [put eieio--object-class-tag byte-optimizer byte-compile-inline-expand require cl-macs] 4)
#@38 Return the class object.

(fn CLASS)
(defalias 'eieio--class-object #[257 "\2119\203\f\211\300N\206
\207\211\207" [cl--class] 3 (#$ . 10554)])
(put 'eieio--class-object 'byte-optimizer 'byte-compile-inline-expand)
#@12 

(fn OBJ)
(defalias 'eieio--object-class #[257 "\211\211\301H\262\203\211\2119\203\211\302N\206\202 \211\262\202 \211\207" [eieio-backward-compatibility 0 cl--class] 5 (#$ . 10776)])
(put 'eieio--object-class 'byte-optimizer 'byte-compile-inline-expand)
#@81 Return non-nil if X is a valid class vector.
X can also be is a symbol.

(fn X)
(defalias 'class-p #[257 "\2119\203\211\301N\202\f\211\302!>\205\303\207" [cl-struct-eieio--class-tags cl--class type-of t] 4 (#$ . 11048)])
#@55 Return a printed representation of CLASS.

(fn CLASS)
(defalias 'eieio--class-print-name #[257 "\300\301\302!\"\207" [format "#<class %s>" eieio-class-name] 5 (#$ . 11282)])
#@55 Return a Lisp like symbol name for CLASS.

(fn CLASS)
(defalias 'eieio-class-name #[257 "\211\2119\203\211\301N\206\202\211\262\262\302!>\204$\303\304\305\306E\"\210\211\307H\207" [cl-struct-eieio--class-tags cl--class type-of signal wrong-type-argument eieio--class class 1] 6 (#$ . 11463)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\210\300\306\307\310#\207" [defalias class-name eieio-class-name nil make-obsolete "24.4" eieio--class-constructor identity "Return the symbol representing the constructor of CLASS."] 4)
#@82 Return from LIST the found OPTION, or nil if it doesn't exist.

(fn LIST OPTION)
(defalias 'eieio--class-option-assoc '(macro . #[514 "\300\301\302EDD\207" [car-safe cdr memq] 7 (#$ . 12011)]))
#@104 Return the value stored for CLASS' OPTION.
Return nil if that option doesn't exist.

(fn CLASS OPTION)
(defalias 'eieio--class-option #[514 "\211\300H>A\242\207" [11] 5 (#$ . 12214)])
(put 'eieio--class-option 'byte-optimizer 'byte-compile-inline-expand)
#@53 Return non-nil if OBJ is an EIEIO object.

(fn OBJ)
(defalias 'eieio-object-p #[257 "\302!\2054\211\211\211\303H\262\203&\211\2119\203 \211\304N\206!\202'\211\262\202'\211\266\202\305!	>\2052\306\262\207" [eieio-backward-compatibility cl-struct-eieio--class-tags recordp 0 cl--class type-of t] 6 (#$ . 12476)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias object-p eieio-object-p nil make-obsolete "25.1"] 4)
#@91 Return non-nil if CLASS is abstract.
Abstract classes cannot be instantiated.

(fn CLASS)
(defalias 'class-abstract-p #[257 "\211\300N\301\211\302H>A\242\207" [cl--class :abstract 11] 6 (#$ . 12925)])
#@92 Return the invocation order of CLASS.
Abstract classes cannot be instantiated.

(fn CLASS)
(defalias 'eieio--class-method-invocation-order #[257 "\211\300\211\301H>A\242\266\202\206\302\207" [:method-invocation-order 11 :breadth-first] 6 (#$ . 13133)])
(put 'eieio--class-method-invocation-order 'byte-optimizer 'byte-compile-inline-expand)
#@50 Symbol map of superclasses we find in autoloads.
(defvar eieio-defclass-autoload-map (make-hash-table) (#$ . 13483))
#@327 Create autoload symbols for the EIEIO class CNAME.
SUPERCLASSES are the superclasses that CNAME inherits from.
DOC is the docstring for CNAME.
This function creates a mock-class for CNAME and adds it into
SUPERCLASSES as children.
It creates an autoload function for CNAME's constructor.

(fn CNAME SUPERCLASSES FILENAME DOC)
(defalias 'eieio-defclass-autoload #[1028 "\302N\303\304\305\211\211\211\211\211\211\211\211\211&\f\306!>\205\307?\205q	\2033\211L\210\310\311\312	\"\313#\210\314\302#\266\315\305\211%\210\315\316\311\317	\"!\320\305\211%\210	\205q\315\316\311\321	\"!\320\305\211%\210\315\316\311\322	\"!\320\305\211%\207" [cl-struct-eieio--class-tags eieio-backward-compatibility cl--class record eieio--class nil type-of t make-obsolete-variable format "use \\='%s instead" "25.1" put autoload intern "%s-p" "" "%s-child-p" "%s-list-p"] 18 (#$ . 13607)])
#@71 Like `eieio--class-object' but loads the class if needed.

(fn CLASS)
(defalias 'eieio--full-class-object #[257 "\211\2119\203\211\300N\206\202\211\262\2119\204$\211\301H\204$\302\303HK!\210\211\207" [cl--class 10 autoload-do-load 1] 5 (#$ . 14508)])
(put 'list-of 'cl-deftype-handler #[257 "\300\301\302\303\304\305\303\306\307\310\311DEE\312BBEDE\207" [and list satisfies lambda (list) cl-every (elem) cl-typep elem quote (list)] 13 "\n\n(fn ELEM-TYPE)"])
#@14 

(fn CLASS)
(defalias 'eieio-make-class-predicate #[257 "\300\301\302\303\304!\305\"\306\307\310\"%\207" [make-byte-code 257 "\301!\205\n\302\300\"\207" vconcat vector [eieio-object-p same-class-p] 4 format "Return non-nil if OBJ is an object of type `%S'.\n\n(fn OBJ)"] 9 (#$ . 14984)])
#@14 

(fn CLASS)
(defalias 'eieio-make-child-predicate #[257 "\300\301\302\303\304!\305\"\306\307\310\"%\207" [make-byte-code 257 "\301!\205\n\302\300\"\207" vconcat vector [eieio-object-p object-of-class-p] 4 format "Return non-nil if OBJ is an object of type `%S' or a subclass.\n\n(fn OBJ)"] 9 (#$ . 15285)])
(defvar eieio--known-slot-names nil)
#@217 Define CNAME as a new subclass of SUPERCLASSES.
SLOTS are the slots residing in that class definition, and OPTIONS
holds the class options.
See `defclass' for more information.

(fn CNAME SUPERCLASSES SLOTS OPTIONS)
(defalias 'eieio-defclass-internal #[1028 "\306\300!\210\307\310N\311!	>\205\211\262\211\206(\312\313\307\211\211\211\211\211\211\211\211\211&\f\307C\307\203X=\2049\314\315!\210\211\316\307I\266\211\317\307I\266\211\320\307I\266\211\321\307I\266\202o\322\n\"\211\203n\211\323I\266\324	\n\"\210\210\203\367\211\203\351\211@\211\203\205\2119\204\215\325\326\"\210\202\342\211\310N\311!	>\204\240\325\327\"\210\202\341\211\211\323\323H\330\"\203\262\211\202\266B\262I\266\331\332\333\334\335\336\n!\337\"\317\340%\341\211\342H>A\242\266\202\"\210\211\316\316HBI\266\210A\266\202\202v\210\211\316\316H\237I\266\202$\303=\204$\343\262\211\323\323H\330\f\"\203\211\202B\262I\266\211\316CI\266\f\2038\211L\210\344\345\346\"\347#\210\f\203u\350\351	!\352P!\353\354\355\345\356\"\357\360\361\362\363\364\365\366\367\370\371\372EEE\373BBB\374BBBEF\"\210\375\345\376\f\"\347#\266\377!\210\201B\310#\266\211\203%\211@\211@A\211\201C\201D\"\206\247\201D>?\205\247
\201C\201E\"\201C\201F\"\201C\201G\"\201C\201H\"\201C\201I\"\201C\201J\"\201C	\201K\"\201C\n\201L\"\201C\201M\"\201N>A\242\201O\267\202\307\202#\201P\202#\201Q\202#\201R\201S\201G\nD\"\262\204,\343\262\f\203N	\203N\201T\n!\204N	\211L\210\344\n\345\346
\"\347#\210\204^\203^\201U\262\202g<\204gC\262\211\203\207\211@\2119\204\200\201R\201S\201LD\"\210A\266\202\202h\210\201V

	\201W\205\242\201FBC\205\256\201J\fBC\205\272\201K\fBC\205\306\201L\fBC\205\322\201M\fBC\205\336\201GBC&\312\201X%\266\204\f\n\201Y&\210\211\203\211@\242\235\203\242\202\242B\240\210A\266\202\202\370\266A\266\202\202\206\210\211\317\317H\201Z\336\237\"\262I\266\211\320\320H\237I\266\211\321\321H\201Z\336\"\262I\266\321H\211G\201[\307\"\201\\\211W\203\242\211\201]\311H!@>\204\216\201R\201^\201X
	HD\"\210\nH\201_H!I\266\211T\262\202b\266\211\201`I\266\317H\201a\201b\201c\"G\201\\\211W\203\371\211\311H!@>\204\341\201R\201^\201XHD\"\210H\201dH\201e#\266\211T\262\202\277\266\211\201fI\266\201F>A\242\211\201_I\266\f\203#\201B	\201g#\210\210\201h\201i\201j\nB\"\210\341>A\242C\331\332\333\334\335\336!\337\"\317\201k%\242\"\210\341>\203_\341>A\242\240\210\202h\341\242BB\262\210\211\342I\266\211\203|\211\316\307I\266\201l\201m\317HG\201d\201n#\307#\343A\201o\343\"\210)\211\201pI\266\207" [eieio-hook cl-struct-eieio--class-tags eieio-defclass-autoload-map eieio-default-superclass eieio-backward-compatibility eieio-unbound run-hooks nil cl--class type-of record eieio--class cl--assertion-failed (eq newc oldc) 3 4 7 8 gethash 6 remhash error "Invalid parent class %S" "Given parent class %S is not a class" memql mapc make-byte-code 257 "\300\300\242\235\203
\300\242\202\300\242B\240\207" vconcat vector [] "\n\n(fn G)" :custom-groups 11 t make-obsolete-variable format "use \\='%s instead" "25.1" intern symbol-name "-list-p" defalias lambda (obj) "Test OBJ to see if it a list of objects which are a child of type %s" when (listp obj) let ((ans t)) while (and obj ans) setq ans and (eieio-object-p (car obj)) object-of-class-p (car obj) ((setq obj (cdr obj))) (ans) make-obsolete "use (cl-typep ... \\='(list-of %s)) instead" eieio-copy-parents-into-subclass cl-struct-cl-slot-descriptor-tags eieio-skip-typecheck put plist-get :initform :initarg :documentation :protection :allocation :type :custom :label :group :printer :allow-nil-initform #s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:public 518 public 518 nil 518 :protected 522 protected 522 :private 528 private 528)) protected private signal invalid-slot-type keywordp (default) eieio--add-new-slot append cl-slot-descriptor defaultoverride apply make-vector 0 eieio-default-eval-maybe wrong-type-argument 2 9 make-hash-table :test eq 1 puthash 5 variable-documentation add-to-list current-load-list define-type "\n\n(fn CG)" make-record + -1 eieio-set-defaults 10] 38 (#$ . 15643)])
#@70 Whether the default value VAL should be evaluated for use.

(fn VAL)
(defalias 'eieio-eval-default-p #[257 "\211:\205\211@9\205\300@!\207" [fboundp] 3 (#$ . 20103)])
(put 'eieio-eval-default-p 'byte-optimizer 'byte-compile-inline-expand)
#@153 For SLOT, signal if its type does not match its default value.
If SKIPNIL is non-nil, then if default value is nil return t instead.

(fn SLOT SKIPNIL)
(defalias 'eieio--perform-slot-validation-for-default #[514 "\302!>\204\303\304\305D\"\210\306H\302!>\204!\303\304\305D\"\210\307H\211:\2054\211@9\2054\310@!\262\206J	\206J\203F?\206J\311\"?\205h\303\312\302!>\204a\303\304\305D\"\210\313HE\"\207" [cl-struct-cl-slot-descriptor-tags eieio-skip-typecheck type-of signal wrong-type-argument cl-slot-descriptor 2 3 fboundp eieio--perform-slot-validation invalid-slot-type 1] 10 (#$ . 20353)])
#@24 

(fn OLD NEW SKIPNIL)
(defalias 'eieio--slot-override #[771 "\302!>\204\303\304\305D\"\210\306H\302!>\204!\303\304\305D\"\210\306H=\204,\307\310!\210\302!>\204;\303\304\305D\"\210\306H\302!>\204N\303\304\305D\"\210\311H\302!>\204a\303\304\305D\"\210\312H\302!>\204t\303\304\305D\"\210\311H\302!>\204\210\303\304\305	D\"\210\313H\302!>\204\235\303\304\305	D\"\210\313H\314\315\"\316=\204\276\232\204\330\317\320\n$\210\202\330\302	!>\204\317\303\304\305D\"\210\211\311I\266	=\204\377\321		\"\210\302\n!>\204\366\303\304\305\fD\"\210	\211\312I\266\314\322\"\314\322\"\211=\204\317\323\f$\210\266\211\203m\314\315\"\211\2038\211@\211>\2041\211B\262A\266\202\202 \210\302!>\204J\303\304\305
D\"\210\n\315\313H\236\203]\241\210\202k\313\315B\211\262\313HBI\210\266\324\211\205\341\211@\314\302
!>\204\207\303\304\305D\"\210\f\313H\"\203\332\302\f!>\204\240\303\304\305D\"\210\313H\236\314\302!>\204\272\303\304\305D\"\210\313H\"\203\312\241\210\202\330\313B\211\262\313HBI\210\266A\266\202\202n\262\207" [cl-struct-cl-slot-descriptor-tags eieio-unbound type-of signal wrong-type-argument cl-slot-descriptor 1 cl--assertion-failed (eq (cl--slot-descriptor-name old) (cl--slot-descriptor-name new)) 3 2 4 alist-get :group t error "Child slot type `%s' does not match inherited type `%s' for `%s'" eieio--perform-slot-validation-for-default :protection "Child slot protection `%s' does not match inherited protection `%s' for `%s'" (:custom :label :documentation :printer)] 20 (#$ . 20984)])
#@489 Add into NEWC attribute SLOT.
If a slot of that name already exists in NEWC, then do nothing.  If it doesn't exist,
INIT is the initarg, if any.
Argument ALLOC specifies if the slot is allocated per instance, or per class.
If optional DEFAULTOVERRIDE is non-nil, then if A exists in NEWC,
we must override its value for a default.
Optional argument SKIPNIL indicates if type checking should be skipped
if default value is nil.

(fn NEWC SLOT INIT ALLOC &optional DEFAULTOVERRIDE SKIPNIL)
(defalias 'eieio--add-new-slot #[1540 "\302!>\204\303\304\305D\"\210\306H\302!>\204$\303\304\305D\"\210\307H\310	\311H\312\313$@\310\n\314H\312\313$@\315	\"\204G\211	B\210\3161\\\317!\205X\320!\211\2620\202`\210\202a\210\211\203h\321\262\322>\203\275\204\212\323	\"\210	\211\311\311HBI\266\202\226\203\226\324\n#\210\205\343	\211\325\nB
\325H\235\203\262\211\202\265B\266\202I\262\202\343\211\204\330\323	\"\210	\211\314\314HBI\262\202\343\205\343\324\n#\207" [cl-struct-cl-slot-descriptor-tags eieio--known-slot-names type-of signal wrong-type-argument cl-slot-descriptor 1 2 cl-member 4 :key cl--slot-descriptor-name 8 memql (error) sequencep copy-sequence :class (nil :instance) eieio--perform-slot-validation-for-default eieio--slot-override 7] 17 (#$ . 22637)])
#@137 Copy into NEWC the slots of PARENTS.
Follow the rules of not overwriting early parents when applying to
the new child class.

(fn NEWC)
(defalias 'eieio-copy-parents-into-subclass #[257 "\301\302H>A\242\303H\211\205\211@\211\304H\305HG\306\211W\203P\211\307H!\310\311!>\2045\312\313\314D\"\210\315H\"@\316\317\211&\266\211T\262\202\266\211\320H\211G\306\211W\203v\211\316\307H!\317\321%\266\211T\262\202X\266A\266\202\202\n\262\207" [cl-struct-cl-slot-descriptor-tags :allow-nil-initform 11 3 4 7 0 cl--copy-slot-descriptor rassq type-of signal wrong-type-argument cl-slot-descriptor 1 eieio--add-new-slot nil 8 :class] 18 (#$ . 23982)])
#@63 Return non-nil if SPEC does not match VALUE.

(fn SPEC VALUE)
(defalias 'eieio--perform-slot-validation #[514 "\301=\206\211=\206\302\"\207" [eieio-unbound t cl-typep] 5 (#$ . 24671)])
#@205 Make sure that for CLASS referencing SLOT-IDX, VALUE is valid.
Checks the :type specifier.
SLOT is the slot that is being checked, and is only used when throwing
an error.

(fn CLASS SLOT-IDX VALUE SLOT)
(defalias 'eieio--validate-slot-value #[1028 "?\205?S\262\302\303HH!	>\204\"\304\305\306\303HHD\"\210\303HH\307H\310\"?\205=\304\311\312HF\"\262\207" [eieio-skip-typecheck cl-struct-cl-slot-descriptor-tags type-of 4 signal wrong-type-argument cl-slot-descriptor 3 eieio--perform-slot-validation invalid-slot-type 1] 11 (#$ . 24871)])
#@205 Make sure that for CLASS referencing SLOT-IDX, VALUE is valid.
Checks the :type specifier.
SLOT is the slot that is being checked, and is only used when throwing
an error.

(fn CLASS SLOT-IDX VALUE SLOT)
(defalias 'eieio--validate-class-slot-value #[1028 "?\205;\302\303HH!	>\204\304\305\306\303HHD\"\210\303HH\307H\310\"?\2059\304\311\312HF\"\262\207" [eieio-skip-typecheck cl-struct-cl-slot-descriptor-tags type-of 8 signal wrong-type-argument cl-slot-descriptor 3 eieio--perform-slot-validation invalid-slot-type 1] 11 (#$ . 25439)])
#@257 Throw a signal if VALUE is a representation of an UNBOUND slot.
INSTANCE is the object being referenced.  SLOTNAME is the offending
slot.  If the slot is ok, return VALUE.
Argument FN is the function calling this verifier.

(fn VALUE INSTANCE SLOTNAME FN)
(defalias 'eieio-barf-if-slot-unbound #[1028 "=\2033	\2043\303\211\211\211\304H\262\n\203,\211\2119\203&\211\305N\206'\202-\211\262\202-\211\266\202$\207\207" [eieio-unbound eieio-skip-typecheck eieio-backward-compatibility slot-unbound 0 cl--class] 11 (#$ . 26005)])
#@70 Return the value in OBJ at SLOT in the object vector.

(fn OBJ SLOT)
(defalias 'eieio-oref #[514 "\2119\204
\301\302\303\304E\"\210\305!\204!\306!\204!\301\302\307\310E\"\2109\2031\311\312\"\210\313!\202T\211\211\314H\262\203Q\211\2119\203K\211\315N\206L\202R\211\262\202R\211\266\202\316\"\211\204v\317\"\211\262\203n\320HH\202\215\321\322#\202\215\305!\204\205\301\302\323\310E\"\210\324H\322$\207" [eieio-backward-compatibility signal wrong-type-argument symbol slot eieio-object-p class-p (or eieio-object class) obj error "eieio-oref called on a class: %s" eieio--full-class-object 0 cl--class eieio--slot-name-index eieio--class-slot-name-index 9 slot-missing oref eieio-object eieio-barf-if-slot-unbound] 9 (#$ . 26550)])
(byte-code "\300\301\302\303#\300\207" [function-put eieio-oref compiler-macro eieio-oref--anon-cmacro] 4)
#@21 

(fn EXP OBJ SLOT)
(defalias 'eieio-oref--anon-cmacro #[771 "\301:\203\252@\211\302=\203\215A\211:\203o\211@A\211\204N\211>?\262\203/\"\202j\303!\203@\211>?\262\204E\202j\"\202j\303!\203_\211>?\262\204d\202j\"\266\202\202\210\303!\203\211>?\262\204\203\202\210\"\262\202\245\303!\203\235\211>?\262\204\241\202\245\"\262\202\302\303!\203\272\211>?\262\204\276\202\302\211\"\207" [eieio--known-slot-names #[514 "\300\301\302\"\303#\207" [macroexp--warn-and-return format-message "Unknown slot `%S'" compile-only] 6 "\n\n(fn EXP NAME)"] quote keywordp] 11 (#$ . 27434)])
#@126 Do the work for the macro `oref-default' with similar parameters.
Fills in OBJ's SLOT with its default value.

(fn OBJ SLOT)
(defalias 'eieio-oref-default #[514 "\302!\204\303!\204\304\305\306\307E\"\210\2119\204!\304\305\310\311E\"\2109\203,\312N\202Y\302!\203X\211\211\313H\262\203R\211\2119\203L\211\312N\206M\202S\211\262\202S\211\266\202\202Y\314\"\211\204{\315\"\211\262\203s\316HH\202\241\317\320#\202\241\321\322HSH\323!	>\204\221\304\305\324D\"\210\211\325H\262\326!\262\327H\320$\207" [eieio-backward-compatibility cl-struct-cl-slot-descriptor-tags eieio-object-p class-p signal wrong-type-argument (or eieio-object class) obj symbol slot cl--class 0 eieio--slot-name-index eieio--class-slot-name-index 9 slot-missing oref-default eieio-barf-if-slot-unbound 4 type-of cl-slot-descriptor 2 eieio-default-eval-maybe 1] 10 (#$ . 28099)])
#@68 Check VAL, and return what `oref-default' would provide.

(fn VAL)
(defalias 'eieio-default-eval-maybe #[257 "\211\211:\205\211@9\205\300@!\262\203\301!\207\207" [fboundp eval] 4 (#$ . 28999)])
#@88 Do the work for the macro `oset'.
Fills in OBJ's SLOT with VALUE.

(fn OBJ SLOT VALUE)
(defalias 'eieio-oset #[771 "\301!\204\302\303\304\305E\"\2109\204\302\303\306\307E\"\210\211\211\310H\262\203;\211\2119\2035\211\311N\2066\202<\211\262\202<\211\266\202\312\"\211\204k\313\"\211\262\203a\314$\210\315HI\202w\316\317$\202w\320$\210I\207" [eieio-backward-compatibility eieio-object-p signal wrong-type-argument eieio-object obj symbol slot 0 cl--class eieio--slot-name-index eieio--class-slot-name-index eieio--validate-class-slot-value 9 slot-missing oset eieio--validate-slot-value] 10 (#$ . 29208)])
#@123 Do the work for the macro `oset-default'.
Fills in the default value in CLASS' in SLOT with VALUE.

(fn CLASS SLOT VALUE)
(defalias 'eieio-oset-default #[771 "\2119\203\211\302N\206\202\211\262\262\303!>\204$\304\305\306\307E\"\2109\2041\304\305\310\311E\"\210\312\"\211\204_\313\"\211\262\203T\314$\210\315HI\202\243\304\316\317HD\"\202\243\320$\210\211:\205w\211@9\205w\321@!\262\203\200\322\323!\210\324HSH\303!	>\204\225\304\305\325D\"\210\211\211\326I\266\327\330H#\207" [cl-struct-eieio--class-tags cl-struct-cl-slot-descriptor-tags cl--class type-of signal wrong-type-argument eieio--class class symbol slot eieio--slot-name-index eieio--class-slot-name-index eieio--validate-class-slot-value 9 invalid-slot-name 1 eieio--validate-slot-value fboundp error "Can't set default to a sexp that gets evaluated again" 4 cl-slot-descriptor 2 eieio-oset 10] 9 (#$ . 29865)])
#@256 In CLASS find the index of the named SLOT.
The slot is a symbol which is installed in CLASS by the `defclass' call.
If SLOT is the value created with :initarg instead,
reverse-lookup that name, and recurse with the associated slot value.

(fn CLASS SLOT)
(defalias 'eieio--slot-name-index #[514 "\300\301H\"\211\250\203\211T\202\302\"\211\205\303\"\262\207" [gethash 5 eieio--initarg-to-attribute eieio--slot-name-index] 7 (#$ . 30802)])
#@257 In CLASS find the index of the named SLOT.
The slot is a symbol which is installed in CLASS by the `defclass'
call.  If SLOT is the value created with :initarg instead,
reverse-lookup that name, and recurse with the associated slot value.

(fn CLASS SLOT)
(defalias 'eieio--class-slot-name-index #[514 "\301\302H\211G\303\211W\2037\211\304H!>\204#\305\306\307HD\"\210H\310H=\203/\211\262\210\211T\262\202\266\207" [cl-struct-cl-slot-descriptor-tags nil 8 0 type-of signal wrong-type-argument cl-slot-descriptor 1] 13 (#$ . 31260)])
#@229 Take object OBJ, and reset all slots to their defaults.
If SET-ALL is non-nil, then when a default is nil, that value is
reset.  If SET-ALL is nil, the slots are only reset if the default is
not nil.

(fn OBJ &optional SET-ALL)
(defalias 'eieio-set-defaults #[513 "\211\211\302H\262\203 \211\2119\203\211\303N\206\202!\211\262\202!\211\266\202\211\304H\262\211G\302\211W\205i\211\305H!	>\204F\306\307\310HD\"\210H\311H\312\"\211\204Y\203`\313#\210\266\211T\262\202+\266\202\207" [eieio-backward-compatibility cl-struct-cl-slot-descriptor-tags 0 cl--class 4 type-of signal wrong-type-argument cl-slot-descriptor 1 eieio-oref-default eieio-oset] 12 (#$ . 31819)])
#@183 For CLASS, convert INITARG to the actual attribute name.
If there is no translation, pass it in directly (so we can cheat if
need be... May remove that later...)

(fn CLASS INITARG)
(defalias 'eieio--initarg-to-attribute #[514 "\300\301H\"\211\205\f\211A\207" [assoc 7] 6 (#$ . 32524)])
#@90 Return CLASS if it can go in the result now, otherwise nil.

(fn CLASS REMAINING-INPUTS)
(defalias 'eieio--c3-candidate #[514 "\300\203\211\204@A\235\262A\262\202\211\262?\205\207" [nil] 5 (#$ . 32820)])
#@186 Merge REVERSED-PARTIAL-RESULT REMAINING-INPUTS in a consistent order, if possible.
If a consistent order does not exist, signal an error.

(fn REVERSED-PARTIAL-RESULT REMAINING-INPUTS)
(defalias 'eieio--c3-merge-lists #[514 "\300\301\"\262\211\204
\237\207\301\211\203&\204&\302@@\"\262\211A\262\202\211\203E\303B\304\305\306\307\310\311!\312\"\313\314%\"\"\202J\315\316C\"\207" [delq nil eieio--c3-candidate eieio--c3-merge-lists mapcar make-byte-code 257 "\211@\300=\203\n\211A\207\207" vconcat vector [] 3 "\n\n(fn L)" signal inconsistent-class-hierarchy] 14 (#$ . 33047)])
#@14 

(fn CLASS)
(defalias 'eieio--class/struct-parents #[257 "\211\301H\206C\207" [eieio-default-superclass 3] 3 (#$ . 33656)])
(put 'eieio--class/struct-parents 'byte-optimizer 'byte-compile-inline-expand)
#@54 Return all parents of CLASS in c3 order.

(fn CLASS)
(defalias 'eieio--class-precedence-c3 #[257 "\211\301H\302C\303\304\305\"\206CCC\"\"\207" [eieio-default-superclass 3 eieio--c3-merge-lists append mapcar eieio--class-precedence-c3] 8 (#$ . 33869)])
#@63 Return all parents of CLASS in depth-first order.

(fn CLASS)
(defalias 'eieio--class-precedence-dfs #[257 "\211\301H\302\303\304C\305\306\"\206CC#!\211\211\203*\211\307@A\"\241\210\211A\262\202\207" [eieio-default-superclass 3 copy-sequence apply append mapcar #[257 "\211\300!B\207" [eieio--class-precedence-dfs] 4 "\n\n(fn PARENT)"] delq] 9 (#$ . 34133)])
#@65 Return all parents of CLASS in breadth-first order.

(fn CLASS)
(defalias 'eieio--class-precedence-bfs #[257 "\301\211\302H\206\nC\262\211\203;\211A\262\242\211\235\2047\211B\262\211=\2047\303\211\302H\2062C\262\"\262\210\202\f\237B\207" [eieio-default-superclass nil 3 append] 9 (#$ . 34512)])
#@178 Return (transitively closed) list of parents of CLASS.
The order, in which the parents are returned depends on the
method invocation orders of the involved classes.

(fn CLASS)
(defalias 'eieio--class-precedence-list #[257 "\211?\206\211=?\205>\301!\211\211\302\211\303H>A\242\266\202\206\304\262\211\305\267\2029\306!\202:\307!\202:\310!\202:\311\262\262\207" [eieio-default-superclass eieio--full-class-object :method-invocation-order 11 :breadth-first #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:depth-first 39 :breadth-first 45 :c3 51)) eieio--class-precedence-dfs eieio--class-precedence-bfs eieio--class-precedence-c3 nil] 8 (#$ . 34836)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\210\306\307\310\"\210\306\311\312\"\210\306\313\314\"\210\306\315\316\"\210\317\320!\207" [defalias class-precedence-list eieio--class-precedence-list nil make-obsolete "24.4" define-error invalid-slot-name "Invalid slot name" invalid-slot-type "Invalid slot type" unbound-slot "Unbound slot" inconsistent-class-hierarchy "Inconsistent class hierarchy" require cl-generic] 4)
(defconst eieio--generic-generalizer (byte-code "\300\301\302\303\304\305%\207" [#[385 "\301N\302!>\205\303\304\305!\"\207" [cl-struct-eieio--class-tags cl--class type-of mapcar eieio--class-name eieio--class-precedence-list] 7 "\n\n(fn TAG &rest _)"] record cl--generic-generalizer eieio--generic-generalizer 50 cl--generic-struct-tag] 7))
(cl-generic-define-method 'cl-generic-generalizers '(:extra "class") '(specializer) t #[514 "\211\2119\203\211\302N\206\202\211\262\303!>\205\304\262\203%	C\206' \207" [cl-struct-eieio--class-tags eieio--generic-generalizer cl--class type-of t] 5 "Support for dispatch on types defined by EIEIO's `defclass'.\n\n(fn CL--CNM SPECIALIZER)"])
#@20 

(fn TAG &rest _)
(defalias 'eieio--generic-subclass-specializers #[385 "\301!>\205\302\303\304!\"\207" [cl-struct-eieio--class-tags type-of mapcar #[257 "\300\301HD\207" [subclass 1] 4 "\n\n(fn CLASS)"] eieio--class-precedence-list] 6 (#$ . 36679)])
(defconst eieio--generic-subclass-generalizer (byte-code "\300\301\302\303\304\305%\207" [#[385 "\300\301D\302DE\207" [and symbolp cl--find-class] 6 "\n\n(fn NAME &rest _)"] record cl--generic-generalizer eieio--generic-subclass-generalizer 60 eieio--generic-subclass-specializers] 7))
(cl-generic-define-method 'cl-generic-generalizers nil '((_specializer (head subclass))) nil #[257 "C\207" [eieio--generic-subclass-generalizer] 2 "Support for (subclass CLASS) specializers.\nThese match if the argument is the name of a subclass of CLASS.\n\n(fn SPECIALIZER)"])
#@73 Declare that SLOTS are known eieio object slot names.

(fn &rest SLOTS)
(defalias 'eieio-declare-slots '(macro . #[128 "\300\301\302\303\304D\305BBED\207" [eval-when-compile setq eieio--known-slot-names append quote (eieio--known-slot-names)] 7 (#$ . 37512)]))
(provide 'eieio-core)
Zerion Mini Shell 1.0