Current File : //proc/thread-self/root/kunden/usr/share/emacs/27.2/lisp/emacs-lisp/ewoc.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.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


#@72 compiler-macro for inlining `ewoc--node-left'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ewoc--node-left--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ewoc--node-left (progn (aref cl-x 0))) nil] 9 (#$ . 408)])
(put 'ewoc--node-left 'compiler-macro 'ewoc--node-left--cmacro)
#@60 Access slot "left" of `ewoc--node' struct CL-X.

(fn CL-X)
(defalias 'ewoc--node-left #[257 "\211\300H\207" [0] 3 (#$ . 722)])
(byte-code "\300\301\302\303#\300\207" [function-put ewoc--node-left side-effect-free t] 4)
#@73 compiler-macro for inlining `ewoc--node-right'.

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

(fn CL-X)
(defalias 'ewoc--node-right #[257 "\211\300H\207" [1] 3 (#$ . 1266)])
(byte-code "\300\301\302\303#\300\207" [function-put ewoc--node-right side-effect-free t] 4)
#@72 compiler-macro for inlining `ewoc--node-data'.

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

(fn CL-X)
(defalias 'ewoc--node-data #[257 "\211\300H\207" [2] 3 (#$ . 1810)])
(byte-code "\300\301\302\303#\300\207" [function-put ewoc--node-data side-effect-free t] 4)
#@80 compiler-macro for inlining `ewoc--node-start-marker'.

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

(fn CL-X)
(defalias 'ewoc--node-start-marker #[257 "\211\300H\207" [3] 3 (#$ . 2391)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ewoc--node-start-marker side-effect-free t defalias copy-ewoc--node copy-sequence] 4)
#@87 compiler-macro for inlining `ewoc--node-create'.

(fn CL-WHOLE-ARG START-MARKER DATA)
(defalias 'ewoc--node-create--cmacro #[771 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (start-marker data) (cl-block ewoc--node-create (vector nil nil data start-marker)) nil] 11 (#$ . 2690)])
(put 'ewoc--node-create 'compiler-macro 'ewoc--node-create--cmacro)
#@71 Constructor for objects of type `ewoc--node'.

(fn START-MARKER DATA)
(defalias 'ewoc--node-create #[514 "\300\301\211$\207" [vector nil] 7 (#$ . 3057)])
(byte-code "\300\301\302\303#\304\305\306\211\307\306\310\311\305\306&	\207" [function-put ewoc--node-create side-effect-free t cl-struct-define ewoc--node nil vector ((left) (right) (data) (start-marker)) cl-struct-ewoc--node-tags] 11)
#@77 Return the node after NODE, or nil if NODE is the last node.

(fn DLL NODE)
(defalias 'ewoc--node-next #[514 "\211\300H
=?\205\211\207" [1] 5 (#$ . 3456)])
#@79 Return the node before NODE, or nil if NODE is the first node.

(fn DLL NODE)
(defalias 'ewoc--node-prev #[514 "\211\300H
=?\205\211\207" [0] 5 (#$ . 3621)])
#@279 Return the Nth node from the doubly linked list `dll'.
N counts from zero.  If N is negative, return the -(N+1)th last element.
If N is out of range, return nil.
Thus, (ewoc--node-nth dll 0) returns the first node,
and (ewoc--node-nth dll -1) returns the last node.

(fn DLL N)
(defalias 'ewoc--node-nth #[514 "\211\300W\203\n\300\202\301
H\300W\203\302Z\262
=\2041\300V\2031\211H\262
S\262\202
=?\2059\211\207" [0 1 -1] 6 (#$ . 3789)])
#@47 Return the start location of NODE.

(fn NODE)
(defalias 'ewoc-location #[257 "\211\300H\207" [3] 3 (#$ . 4252)])
#@63 compiler-macro for inlining `ewoc-p'.

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

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

(fn CL-WHOLE-ARG CL-X)
(defalias 'ewoc--buffer--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ewoc--buffer (progn (or (ewoc-p cl-x) (signal 'wrong-type-argument (list 'ewoc cl-x))) (aref cl-x 1))) nil] 9 (#$ . 4919)])
(put 'ewoc--buffer 'compiler-macro 'ewoc--buffer--cmacro)
#@56 Access slot "buffer" of `ewoc' struct CL-X.

(fn CL-X)
(defalias 'ewoc--buffer #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 1] 5 (#$ . 5286)])
(byte-code "\300\301\302\303#\300\207" [function-put ewoc--buffer side-effect-free t] 4)
#@77 compiler-macro for inlining `ewoc--pretty-printer'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ewoc--pretty-printer--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ewoc--pretty-printer (progn (or (ewoc-p cl-x) (signal 'wrong-type-argument (list 'ewoc cl-x))) (aref cl-x 2))) nil] 9 (#$ . 5596)])
(put 'ewoc--pretty-printer 'compiler-macro 'ewoc--pretty-printer--cmacro)
#@64 Access slot "pretty-printer" of `ewoc' struct CL-X.

(fn CL-X)
(defalias 'ewoc--pretty-printer #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 2] 5 (#$ . 6003)])
(byte-code "\300\301\302\303#\300\207" [function-put ewoc--pretty-printer side-effect-free t] 4)
#@69 compiler-macro for inlining `ewoc--header'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ewoc--header--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ewoc--header (progn (or (ewoc-p cl-x) (signal 'wrong-type-argument (list 'ewoc cl-x))) (aref cl-x 3))) nil] 9 (#$ . 6337)])
(put 'ewoc--header 'compiler-macro 'ewoc--header--cmacro)
#@56 Access slot "header" of `ewoc' struct CL-X.

(fn CL-X)
(defalias 'ewoc--header #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 3] 5 (#$ . 6704)])
(byte-code "\300\301\302\303#\300\207" [function-put ewoc--header side-effect-free t] 4)
#@69 compiler-macro for inlining `ewoc--footer'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ewoc--footer--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ewoc--footer (progn (or (ewoc-p cl-x) (signal 'wrong-type-argument (list 'ewoc cl-x))) (aref cl-x 4))) nil] 9 (#$ . 7014)])
(put 'ewoc--footer 'compiler-macro 'ewoc--footer--cmacro)
#@56 Access slot "footer" of `ewoc' struct CL-X.

(fn CL-X)
(defalias 'ewoc--footer #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 4] 5 (#$ . 7381)])
(byte-code "\300\301\302\303#\300\207" [function-put ewoc--footer side-effect-free t] 4)
#@66 compiler-macro for inlining `ewoc--dll'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ewoc--dll--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ewoc--dll (progn (or (ewoc-p cl-x) (signal 'wrong-type-argument (list 'ewoc cl-x))) (aref cl-x 5))) nil] 9 (#$ . 7691)])
(put 'ewoc--dll 'compiler-macro 'ewoc--dll--cmacro)
#@53 Access slot "dll" of `ewoc' struct CL-X.

(fn CL-X)
(defalias 'ewoc--dll #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 5] 5 (#$ . 8043)])
(byte-code "\300\301\302\303#\300\207" [function-put ewoc--dll side-effect-free t] 4)
#@72 compiler-macro for inlining `ewoc--last-node'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ewoc--last-node--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ewoc--last-node (progn (or (ewoc-p cl-x) (signal 'wrong-type-argument (list 'ewoc cl-x))) (aref cl-x 6))) nil] 9 (#$ . 8344)])
(put 'ewoc--last-node 'compiler-macro 'ewoc--last-node--cmacro)
#@59 Access slot "last-node" of `ewoc' struct CL-X.

(fn CL-X)
(defalias 'ewoc--last-node #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 6] 5 (#$ . 8726)])
(byte-code "\300\301\302\303#\300\207" [function-put ewoc--last-node side-effect-free t] 4)
#@68 compiler-macro for inlining `ewoc--hf-pp'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ewoc--hf-pp--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ewoc--hf-pp (progn (or (ewoc-p cl-x) (signal 'wrong-type-argument (list 'ewoc cl-x))) (aref cl-x 7))) nil] 9 (#$ . 9045)])
(put 'ewoc--hf-pp 'compiler-macro 'ewoc--hf-pp--cmacro)
#@55 Access slot "hf-pp" of `ewoc' struct CL-X.

(fn CL-X)
(defalias 'ewoc--hf-pp #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 7] 5 (#$ . 9407)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ewoc--hf-pp side-effect-free t defalias copy-ewoc copy-sequence] 4)
#@90 compiler-macro for inlining `ewoc--create'.

(fn CL-WHOLE-ARG BUFFER PRETTY-PRINTER DLL)
(defalias 'ewoc--create--cmacro #[1028 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (buffer pretty-printer dll) (cl-block ewoc--create (record 'ewoc buffer pretty-printer nil nil dll nil nil)) nil] 13 (#$ . 9757)])
(put 'ewoc--create 'compiler-macro 'ewoc--create--cmacro)
#@73 Constructor for objects of type `ewoc'.

(fn BUFFER PRETTY-PRINTER DLL)
(defalias 'ewoc--create #[771 "\300\301\302\211\302\211&\207" [record ewoc nil] 12 (#$ . 10140)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put ewoc--create side-effect-free t cl-struct-define ewoc nil cl-structure-object record ((cl-tag-slot) (buffer) (pretty-printer) (header) (footer) (dll) (last-node) (hf-pp)) cl-struct-ewoc-tags] 11)
#@286 Execute FORMS with ewoc--buffer selected as current buffer,
`dll' bound to the dll, and VARLIST bound as in a let*.
`dll' will be bound when VARLIST is initialized, but
the current buffer will *not* have been changed.
Return value of last form in FORMS.

(fn EWOC VARLIST &rest FORMS)
(defalias 'ewoc--set-buffer-bind-dll-let* '(macro . #[642 "\300\301!\302
D\303\304DDBB\305\306DBBE\207" [make-symbol "ewoc" let* dll ewoc--dll with-current-buffer ewoc--buffer] 9 (#$ . 10609)]))
#@25 

(fn EWOC &rest FORMS)
(defalias 'ewoc--set-buffer-bind-dll '(macro . #[385 "\300\301BBB\207" [ewoc--set-buffer-bind-dll-let* nil] 6 (#$ . 11100)]))
#@117 Evaluate NODE once and return it.
BUT if it is the header or the footer in EWOC return nil instead.

(fn EWOC NODE)
(defalias 'ewoc--filter-hf-nodes #[514 "\211\301!>\204\302\303\304D\"\210\305H=\206+\211\301!>\204'\302\303\304D\"\210\306H=?\2050\211\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 3 4] 7 (#$ . 11259)])
(put 'ewoc--filter-hf-nodes 'byte-optimizer 'byte-compile-inline-expand)
#@25 

(fn BEG END NODE DLL)
(defalias 'ewoc--adjust #[1028 "W\205(\300\301H\211\262U\205&\211\300\223\210
=?\205&\302H\262\202\262
\207" [nil 3 1] 8 (#$ . 11690)])
#@309 Insert before NODE a new node for DATA, displayed by PRETTY-PRINTER.
Fourth arg DLL -- from `(ewoc--dll EWOC)' -- is for internal purposes.
Call PRETTY-PRINTER with point at NODE's start, thus pushing back
NODE and leaving the new node's start there.  Return the new node.

(fn NODE DATA PRETTY-PRINTER DLL)
(defalias 'ewoc--insert-new-node #[1028 "\212\300\301\211\302\303H!$\211\211\304\304HI\266\211\211\305I\266\304H\211\305I\266\211\304I\266\306#\210\211\262
)\207" [vector nil copy-marker 3 0 1 ewoc--refresh-node] 11 (#$ . 11871)])
#@90 Redisplay the element represented by NODE using the pretty-printer PP.

(fn PP NODE DLL)
(defalias 'ewoc--refresh-node #[771 "\301\302H\303H

\302H|\210
b\210\304H!\210\305`$)\207" [inhibit-read-only t 3 1 2 ewoc--adjust] 11 (#$ . 12434)])
#@13 

(fn FUNC)
(defalias 'ewoc--wrap #[257 "\300\301\302\303\304!\305\"\306\307%\207" [make-byte-code 257 "\300
!\210\301c\207" vconcat vector ["\n"] 3 "\n\n(fn DATA)"] 7 (#$ . 12690)])
#@759 Create an empty ewoc.

The ewoc will be inserted in the current buffer at the current position.

PRETTY-PRINTER should be a function that takes one argument, an
element, and inserts a string representing it in the buffer (at
point).  The string PRETTY-PRINTER inserts may be empty or span
several lines.  The PRETTY-PRINTER should use `insert', and not
`insert-before-markers'.

Optional second and third arguments HEADER and FOOTER are strings,
possibly empty, that will always be present at the top and bottom,
respectively, of the ewoc.

Normally, a newline is automatically inserted after the header,
the footer and every node's printed representation.  Optional
fourth arg NOSEP non-nil inhibits this.

(fn PRETTY-PRINTER &optional HEADER FOOTER NOSEP)
(defalias 'ewoc-create #[1025 "\301\302\211\303\211$\211\211\304I\266\211\211\305I\266\211\203\306\202\307p
!\310\311\302\211\302\211&\266\203
\312!`\302\211\313
!>\204H\314\315\311D\"\210\211\316Hr\313!>\204[\314\315\311D\"\210
\304Hq\210\f\204h\317\262
\204p\317\262\f\211\211\320\321!I\266\322

$\262\322$\262\313!>\204\237\314\315\311	D\"\210\211\323I\266\313!>\204\271\314\315\311	D\"\210\211\324I\266\313!>\204\322\314\315\311	D\"\210\211\320I\266)\266\207" [cl-struct-ewoc-tags vector nil DL-LIST 1 0 identity ewoc--wrap record ewoc insert type-of signal wrong-type-argument 5 "" 3 copy-marker ewoc--insert-new-node 7 4] 19 (#$ . 12881)])
(defalias 'ewoc-data 'ewoc--node-data "Extract the data encapsulated by NODE and return it.\n\n(fn NODE)")
#@47 Set NODE to encapsulate DATA.

(fn NODE DATA)
(defalias 'ewoc-set-data #[514 "
\211\300I\207" [2] 6 (#$ . 14474)])
#@64 Enter DATA first in EWOC.
Return the new node.

(fn EWOC DATA)
(defalias 'ewoc-enter-first #[514 "
\301
!>\204\302\303\304D\"\210\211\305Hr\301!>\204#\302\303\304D\"\210
\306Hq\210\307\310\311\"#)\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 5 1 ewoc-enter-after ewoc--node-nth 0] 9 (#$ . 14596)])
#@63 Enter DATA last in EWOC.
Return the new node.

(fn EWOC DATA)
(defalias 'ewoc-enter-last #[514 "
\301
!>\204\302\303\304D\"\210\211\305Hr\301!>\204#\302\303\304D\"\210
\306Hq\210\307\310\311\"#)\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 5 1 ewoc-enter-before ewoc--node-nth -1] 9 (#$ . 14932)])
#@88 Enter a new element DATA after NODE in EWOC.
Return the new node.

(fn EWOC NODE DATA)
(defalias 'ewoc-enter-after #[771 "\301
!>\204\302\303\304D\"\210\211\305Hr\301!>\204#\302\303\304D\"\210
\306Hq\210\307\310\"#)\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 5 1 ewoc-enter-before ewoc--node-next] 10 (#$ . 15268)])
#@89 Enter a new element DATA before NODE in EWOC.
Return the new node.

(fn EWOC NODE DATA)
(defalias 'ewoc-enter-before #[771 "\301
!>\204\302\303\304D\"\210\211\305Hr\301!>\204#\302\303\304D\"\210
\306Hq\210\307\301!>\204<\302\303\304\nD\"\210\310H$)\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 5 1 ewoc--insert-new-node 2] 12 (#$ . 15627)])
#@107 Return the node in EWOC that follows NODE.
Return nil if NODE is nil or the last element.

(fn EWOC NODE)
(defalias 'ewoc-next #[514 "\211\205M
\301\302!>\204\303\304\305D\"\210\306H\"\211\302!>\204+\303\304\305D\"\210\307H=\206F\211\302!>\204B\303\304\305D\"\210\310H=?\205K\211\266\202\207" [cl-struct-ewoc-tags ewoc--node-next type-of signal wrong-type-argument ewoc 5 3 4] 9 (#$ . 16015)])
#@109 Return the node in EWOC that precedes NODE.
Return nil if NODE is nil or the first element.

(fn EWOC NODE)
(defalias 'ewoc-prev #[514 "\211\205M
\301\302!>\204\303\304\305D\"\210\306H\"\211\302!>\204+\303\304\305D\"\210\307H=\206F\211\302!>\204B\303\304\305D\"\210\310H=?\205K\211\266\202\207" [cl-struct-ewoc-tags ewoc--node-prev type-of signal wrong-type-argument ewoc 5 3 4] 9 (#$ . 16437)])
#@298 Return the Nth node.
N counts from zero.  Return nil if there is less than N elements.
If N is negative, return the -(N+1)th last element.
Thus, (ewoc-nth ewoc 0) returns the first node,
and (ewoc-nth ewoc -1) returns the last node.
Use `ewoc-data' to extract the data from the node.

(fn EWOC N)
(defalias 'ewoc-nth #[514 "\211\301W\203\211S\202
\211T\262

\302\303!>\204!\304\305\306D\"\210\307H\"\211\303!>\2046\304\305\306D\"\210\310H=\206Q\211\303!>\204M\304\305\306D\"\210\311H=?\205V\211\207" [cl-struct-ewoc-tags 0 ewoc--node-nth type-of signal wrong-type-argument ewoc 5 3 4] 9 (#$ . 16861)])
#@507 Apply MAP-FUNCTION to all elements in EWOC.
MAP-FUNCTION is applied to the first element first.
If MAP-FUNCTION returns non-nil the element will be refreshed (its
pretty-printer will be called once again).

Note that the buffer for EWOC will be the current buffer when
MAP-FUNCTION is called.  MAP-FUNCTION must restore the current
buffer before it returns, if it changes it.

If more than two arguments are given, the remaining
arguments will be passed to MAP-FUNCTION.

(fn MAP-FUNCTION EWOC &rest ARGS)
(defalias 'ewoc-map #[642 "
\301
!>\204\302\303\304D\"\210\211\305H\301!>\204#\302\303\304D\"\210\306H\301!>\2046\302\303\304D\"\210\307H\310\311\"r\301!>\204N\302\303\304D\"\210\311Hq\210\212\211=?\205w\312\307H#\203n\313#\210\314\"\262
\202T*\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 5 4 2 ewoc--node-nth 1 apply ewoc--refresh-node ewoc--node-next] 12 (#$ . 17492)])
#@48 Delete NODES from EWOC.

(fn EWOC &rest NODES)
(defalias 'ewoc-delete #[385 "
\301
!>\204\302\303\304D\"\210\211\305H\306\211\301!>\204&\302\303\304D\"\210\307Hr\301!>\204:\302\303\304D\"\210\310Hq\210\211\205\255\211@
=\203h\306\262\301	!>\204`\302\303\304D\"\210\211\307\306I\266\211\311H\312\"\211\311H\262
|\210\211\311H\306\211\223\210\211\313H\262\211\310H\262\211\310I\266\211\313I\266\211\211\313\306I\266\211\211\310\306I\266
A\266\202\202@\262
)\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 5 nil 6 1 3 ewoc--node-next 0] 13 (#$ . 18436)])
#@377 Remove all elements in EWOC for which PREDICATE returns nil.
Note that the buffer for EWOC will be current-buffer when PREDICATE
is called.  PREDICATE must restore the current buffer before it returns
if it changes it.
The PREDICATE is called with the element as its first argument.  If any
ARGS are given they will be passed to the PREDICATE.

(fn EWOC PREDICATE &rest ARGS)
(defalias 'ewoc-filter #[642 "\302
!>\204\303\304\305D\"\210\211\306H\307
\310\"\302!>\204(\303\304\305D\"\210\311H\312\313r\302!>\204?\303\304\305D\"\210\310Hq\210=\204d\314\315H#\204[
B\262
\316\"\262\202D\314\317	#*\207" [cl-struct-ewoc-tags inhibit-read-only type-of signal wrong-type-argument ewoc 5 ewoc--node-nth 1 4 nil t apply 2 ewoc--node-next ewoc-delete] 12 (#$ . 19060)])
#@376 Return the node that POS (a buffer position) is within.
POS may be a marker or an integer.  It defaults to point.
GUESS should be a node that it is likely to be near POS.

If POS points before the first element, the first node is returned.
If POS points after the last element, the last node is returned.
If the EWOC is empty, nil is returned.

(fn EWOC &optional POS GUESS)
(defalias 'ewoc-locate #[769 "
\204`\262\301
!>\204\302\303\304D\"\210\211\305Hr\301!>\204*\302\303\304D\"\210
\306Hq\210\307
\306\"\307\310\"=\203?\311\202
\307\312\"\211\313H\262
W\203T\307
\306\"\202
\307\314\"\211\313H\262
Y\203i\307
\314\"\202
\307
\306\"\315\313HZ!\203\216\315\313HZ!\211W\203\215\211\262\262\210\307\310\"\315\313HZ!\211W\203\246\211\262
\262\266\301!>\204\271\302\303\304	D\"\210\316H\203\353\301!>\204\321\302\303\304	D\"\210\316H\315\313HZ!\211W\203\351\211\262
\262\266\313HY\203
\313HY\203
\317\"\262\202\363\320\"\202
\313HW\203
\320\"\262\202

\266\202)\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 5 1 ewoc--node-nth -1 nil 2 3 -2 abs 6 ewoc--node-next ewoc--node-prev] 12 (#$ . 19863)])
#@133 Call EWOC's pretty-printer for each element in NODES.
Delete current text first, thus effecting a "refresh".

(fn EWOC &rest NODES)
(defalias 'ewoc-invalidate #[385 "
\301
!>\204\302\303\304D\"\210\211\305H\301!>\204#\302\303\304D\"\210\306Hr\301!>\2046\302\303\304D\"\210\307Hq\210\212\211\205Q\211@\310#\210
A\266\202\202=\262
*\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 5 2 1 ewoc--refresh-node] 11 (#$ . 21074)])
#@159 Move point to the ARGth previous element in EWOC.
Don't move if we are at the first element, or if EWOC is empty.
Return the node we moved to.

(fn EWOC ARG)
(defalias 'ewoc-goto-prev #[514 "
\301
!>\204\302\303\304D\"\210\211\305H\306`\"r\301!>\204'\302\303\304D\"\210\307Hq\210\211\205\226`
\307H\310HY\203>S\262\211\203U\311V\203US\262\312\"\262
\202>
\211\301!>\204g\302\303\304D\"\210\310H=\206\202\211\301!>\204~\302\303\304D\"\210\313H=?\205\207\211\266\202\204\222\314\307\"\262
\315\")\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 5 ewoc-locate 1 3 0 ewoc--node-prev 4 ewoc--node-nth ewoc-goto-node] 12 (#$ . 21544)])
#@120 Move point to the ARGth next element in EWOC.
Return the node (or nil if we just passed the last node).

(fn EWOC ARG)
(defalias 'ewoc-goto-next #[514 "
\301
!>\204\302\303\304D\"\210\211\305H\306`\"r\301!>\204'\302\303\304D\"\210\307Hq\210\211\203C\310V\203CS\262\311\"\262
\202,\211\204K\312\313!\210\314\")\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 5 ewoc-locate 1 0 ewoc--node-next error "No next" ewoc-goto-node] 9 (#$ . 22238)])
#@45 Move point to NODE in EWOC.

(fn EWOC NODE)
(defalias 'ewoc-goto-node #[514 "r\302!>\204\303\304\305D\"\210
\306Hq\210\211\307Hb\210	\203\"\310	!\210\302!>\2041\303\304\305D\"\210
\211\311I\262
)\207" [cl-struct-ewoc-tags goal-column type-of signal wrong-type-argument ewoc 1 3 move-to-column 6] 6 (#$ . 22724)])
#@247 Refresh all data in EWOC.
The pretty-printer that was specified when the EWOC was created
will be called for all elements in EWOC.
Note that `ewoc-invalidate' is more efficient if only a small
number of elements needs to be refreshed.

(fn EWOC)
(defalias 'ewoc-refresh #[257 "\211\302
!>\204\303\304\305D\"\210\211\306H\302!>\204\"\303\304\305D\"\210\307Hr\302!>\2045\303\304\305D\"\210\310Hq\210\311\312\310\"\211\313H\262

\313H|\210\211\313Hb\210\302!>\204_\303\304\305D\"\210\314H\312\310\"\211=\204\202\211\313H`\315\223\210

\314H!\210\316\"\262
\202f\266)\211\313H`\315\223)\207" [cl-struct-ewoc-tags inhibit-read-only type-of signal wrong-type-argument ewoc 5 4 1 t ewoc--node-nth 3 2 nil ewoc--node-next] 9 (#$ . 23055)])
#@563 Select elements from EWOC using PREDICATE.
Return a list of all selected data elements.
PREDICATE is a function that takes a data element as its first
argument.  The elements on the returned list will appear in the
same order as in the buffer.  You should not rely on the order of
calls to PREDICATE.
Note that the buffer the EWOC is displayed in is the current
buffer when PREDICATE is called.  PREDICATE must restore it if it
changes it.
If more than two arguments are given the
remaining arguments will be passed to PREDICATE.

(fn EWOC PREDICATE &rest ARGS)
(defalias 'ewoc-collect #[642 "\301
!>\204\302\303\304D\"\210\211\305H\301!>\204#\302\303\304D\"\210\306H\307\310\"\311r\301!>\204<\302\303\304D\"\210\312Hq\210
=\204c\313\314H#\203Z
\314H
B\262
\315\"\262\202A)\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 5 3 ewoc--node-nth -2 nil 1 apply 2 ewoc--node-prev] 12 (#$ . 23823)])
#@103 Return the buffer that is associated with EWOC.
Return nil if the buffer has been deleted.

(fn EWOC)
(defalias 'ewoc-buffer #[257 "\301
!>\204\302\303\304D\"\210\211\305H\306
!\205\211\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 1 buffer-name] 5 (#$ . 24771)])
#@73 Return a cons cell containing the (HEADER . FOOTER) of EWOC.

(fn EWOC)
(defalias 'ewoc-get-hf #[257 "\301
!>\204\302\303\304D\"\210\211\305H\306H\301!>\204#\302\303\304D\"\210
\307H\306HB\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 3 2 4] 6 (#$ . 25067)])
#@61 Set the HEADER and FOOTER of EWOC.

(fn EWOC HEADER FOOTER)
(defalias 'ewoc-set-hf #[771 "\301
!>\204\302\303\304D\"\210\211\305H\301!>\204#\302\303\304D\"\210\306H\301!>\2047\302\303\304D\"\210\307H\301!>\204K\302\303\304	D\"\210\310Hr\301!>\204`\302\303\304D\"\210\311Hq\210\211\312	I\266
\211\312I\266\212\313
#\210\313
#*\207" [cl-struct-ewoc-tags type-of signal wrong-type-argument ewoc 5 3 4 7 1 2 ewoc--refresh-node] 12 (#$ . 25360)])
(provide 'ewoc)