HOME

;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; 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!\210\300\304!\210\305\306\307\310\311\312%\210\313\314\307\315\311\306\316\317&\210\313\320\307\321\311\306\316\322&\210\313\323\307\324\311\306\316\322&\210\313\325\307\326\311\306\316\322&\210\313\327\330\331\311\306\316\332&\210\305\333\307\334\311\306%\210\313\335\307\336\311\333\316\322&\210\313\337\340\341\311\333\316\342&\210\313\343\344\345\311\333\316\332&\210\313\346\347\350\311\333\316\332&\210\313\351\352\353\311\333\316\332&\210\305\354\307\355\311\306%\210\313\356\357\360\311\354\316\332&\210\313\361\357\362\311\354\316\332&\210\313\363\364\365\311\354\316\342&\210\313\366\307\367\311\354\316\322&\210\305\370\307\371\311\306%\210\372\373\374\375\311\370%\210\372\376\377\201@\311\370%\210\372\201A\201B\201C\311\370%\210\372\201D\201E\201F\311\370%\210\372\201G\201H\201I\311\370%\210\372\201J\201K\201L\311\370%\210\372\201M\201N\201O\311\370%\207" [require cl-lib easymenu view ebuff-menu custom-declare-group ebrowse nil "Settings for the C++ class browser." :group tools custom-declare-variable ebrowse-search-path "List of directories to search for source files in a class tree.\nElements should be directory names; nil as an element means to try\nto find source files relative to the location of the BROWSE file loaded." :type (repeat (choice (const :tag "Default" nil) (string :tag "Directory"))) ebrowse-view/find-hook "Hooks run after finding or viewing a member or class." hook ebrowse-not-found-hook "Hooks run when finding or viewing a member or class was not successful." ebrowse-electric-list-mode-hook "Hook called by `ebrowse-electric-position-mode'." ebrowse-max-positions 50 "Number of markers saved on electric position stack." integer ebrowse-tree "Settings for class tree buffers." ebrowse-tree-mode-hook "Hook run in each new tree buffer." ebrowse-tree-buffer-name "*Tree*" "The default name of class tree buffers." string ebrowse--indentation 4 "The amount by which subclasses are indented in the tree." ebrowse-source-file-column 40 "The column in which source file names are displayed in the tree." ebrowse-tree-left-margin 2 "Amount of space left at the left side of the tree display.\nThis space is used to display markers." ebrowse-member "Settings for member buffers." ebrowse-default-declaration-column 25 "The column in which member declarations are displayed in member buffers." ebrowse-default-column-width "The width of the columns in member buffers (short display form)." ebrowse-member-buffer-name "*Members*" "The name of the buffer for member display." ebrowse-member-mode-hook "Run in each new member buffer." ebrowse-faces "Faces used by Ebrowse." custom-declare-face ebrowse-tree-mark ((((min-colors 88)) :foreground "red1") (t :foreground "red")) "Face for the mark character in the Ebrowse tree." ebrowse-root-class ((((min-colors 88)) :weight bold :foreground "blue1") (t :weight bold :foreground "blue")) "Face for root classes in the Ebrowse tree." ebrowse-file-name ((t :slant italic)) "Face for filenames in the Ebrowse tree." ebrowse-default ((t)) "Face for items in the Ebrowse tree which do not have other faces." ebrowse-member-attribute ((((min-colors 88)) :foreground "red1") (t :foreground "red")) "Face for member attributes." ebrowse-member-class ((t :foreground "purple")) "Face used to display the class title in member buffers." ebrowse-progress ((((min-colors 88)) :background "blue1") (t :background "blue")) "Face for progress indicator."] 8)
#@108 Return true if PREDICATE is true of some element of VECTOR.
If so, return the value returned by PREDICATE.
(defalias 'ebrowse-some #[(predicate vector) "G\305\306\nW\203	\204\f\nH!\nT\211\202	+\207" [vector result i length predicate 0 nil] 4 (#$ . 3914)])
#@62 Return true if PREDICATE is true of every element of VECTOR.
(defalias 'ebrowse-every #[(predicate vector) "G\305\306\nW\203	\203\f\nH!\nT\211\202	+\207" [vector result i length predicate 0 t] 4 (#$ . 4190)])
#@104 Return the position of ITEM in LIST or nil if not found.
Compare items with `eq' or TEST if specified.
(defalias 'ebrowse-position #[(item list &optional test) "\305\306\n\203!\2039\n\f@\"\203	\306A	T\202\2039\f@=\2030	\306A	T\202!*\207" [found i test list item 0 nil] 3 (#$ . 4420)])
#@77 Eval BODY with a writable current buffer.
Preserve buffer's modified state.
(defalias 'ebrowse-output '(macro . #[(&rest body) "\302\303!\304\305\306BD\307\310	B\311DEE)\207" [modified body make-symbol "--ebrowse-output--" let buffer-read-only ((buffer-modified-p)) unwind-protect progn set-buffer-modified-p] 6 (#$ . 4737)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put ebrowse-output lisp-indent-function 0 put edebug-form-spec t] 5)
#@53 Eval BODY with `completion-ignore-case' bound to t.
(defalias 'ebrowse-ignoring-completion-case '(macro . #[(&rest body) "\301\302BB\207" [body let ((completion-ignore-case t))] 3 (#$ . 5204)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put ebrowse-ignoring-completion-case lisp-indent-function 0 put edebug-form-spec t] 5)
#@57 Eval BODY with `selective-display' restored at the end.
(defalias 'ebrowse-save-selective '(macro . #[(&rest body) "\301\302BB\207" [body let ((selective-display selective-display))] 3 (#$ . 5555)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put ebrowse-save-selective lisp-indent-function 0 put edebug-form-spec t] 5)
#@35 For all trees in SPEC, eval BODY.
(defalias 'ebrowse-for-all-trees '(macro . #[(spec &rest body) "\305\306!@A@\307\310\311\312\313\314	\315\n\316\317\320BB\321\322\323\nD\fBB\257+\207" [spec array spec-var var body make-symbol "var" cl-loop for being the symbols of as = get ('ebrowse-root) do when vectorp] 16 (#$ . 5901)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put ebrowse-for-all-trees lisp-indent-function 1 put edebug-form-spec ((sexp form) body)] 5)
#@41 Set face of a region START END to FACE.
(defalias 'ebrowse-set-face #[(start end face) "\303\304	\"\302\n#\207" [start end face overlay-put make-overlay] 4 (#$ . 6396)])
(put 'ebrowse-set-face 'byte-optimizer 'byte-compile-inline-expand)
#@469 Read a string in the minibuffer, with completion.
Case is ignored in completions.

PROMPT is a string to prompt with; normally it ends in a colon and a space.
TABLE is an alist whose elements' cars are strings, or an obarray.
TABLE can also be a function to do the completion itself.
If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.
If it is (STRING . POSITION), the initial input
is STRING, but point is placed POSITION characters into the string.
(defalias 'ebrowse-completing-read-value #[(prompt table initial-input) "\304\305	\n\306\304%)\207" [completion-ignore-case prompt table initial-input t completing-read nil] 6 (#$ . 6642)])
#@100 Rename current buffer to NEW-NAME.
If a buffer with name NEW-NAME already exists, delete it first.
(defalias 'ebrowse-rename-buffer #[(new-name) "\302!\211p=?\205	\203\212\303	!\210)\304!)\207" [new-name old-buffer get-buffer kill-buffer rename-buffer] 3 (#$ . 7309)])
#@110 Return a copy of STRING with leading white space removed.
Replace sequences of newlines with a single space.
(defalias 'ebrowse-trim-string #[(string) "\301\302\"\203
\303\225\304O\301\305\"\203\306\307\304\310$\202
\207" [string string-match "^[ 	\n
]+" 0 nil "[\n]+" replace-match " " t] 5 (#$ . 7592)])
#@164 Return the width of the display area for the current buffer.
If buffer is displayed in a window, use that window's width,
otherwise use the current frame's width.
(defalias 'ebrowse-width-of-drawable-area #[nil "\301p!\211\203\302!\202\303 )\207" [window get-buffer-window window-width frame-width] 3 (#$ . 7916)])
#@45 compiler-macro for inlining `ebrowse-hs-p'.
(defalias 'ebrowse-hs-p--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-hs-p (and (vectorp cl-x) (>= (length cl-x) 5) (memq (aref cl-x 0) cl-struct-ebrowse-hs-tags) t)) nil] 7 (#$ . 8243)])
(put 'ebrowse-hs-p 'compiler-macro 'ebrowse-hs-p--cmacro)
(defalias 'ebrowse-hs-p #[(cl-x) "\302!\205G\303Y\205\304H	>\205\305\207" [cl-x cl-struct-ebrowse-hs-tags vectorp 5 0 t] 2])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ebrowse-hs-p side-effect-free error-free put ebrowse-hs cl-deftype-satisfies] 5)
#@51 compiler-macro for inlining `ebrowse-hs-version'.
(defalias 'ebrowse-hs-version--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-hs-version (or (and (memq (aref cl-x 0) cl-struct-ebrowse-hs-tags)) (signal 'wrong-type-argument (list 'ebrowse-hs cl-x))) (aref cl-x 1)) nil] 7 (#$ . 8890)])
(put 'ebrowse-hs-version 'compiler-macro 'ebrowse-hs-version--cmacro)
#@76 Access slot "version" of `(ebrowse-hs (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-hs-version #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-hs-tags 0 signal wrong-type-argument ebrowse-hs 1] 4 (#$ . 9321)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-hs-version side-effect-free t] 4)
#@64 compiler-macro for inlining `ebrowse-hs-command-line-options'.
(defalias 'ebrowse-hs-command-line-options--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-hs-command-line-options (or (and (memq (aref cl-x 0) cl-struct-ebrowse-hs-tags)) (signal 'wrong-type-argument (list 'ebrowse-hs cl-x))) (aref cl-x 2)) nil] 7 (#$ . 9674)])
(put 'ebrowse-hs-command-line-options 'compiler-macro 'ebrowse-hs-command-line-options--cmacro)
#@89 Access slot "command-line-options" of `(ebrowse-hs (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-hs-command-line-options #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-hs-tags 0 signal wrong-type-argument ebrowse-hs 2] 4 (#$ . 10170)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-hs-command-line-options side-effect-free t] 4)
#@50 compiler-macro for inlining `ebrowse-hs-unused'.
(defalias 'ebrowse-hs-unused--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-hs-unused (or (and (memq (aref cl-x 0) cl-struct-ebrowse-hs-tags)) (signal 'wrong-type-argument (list 'ebrowse-hs cl-x))) (aref cl-x 3)) nil] 7 (#$ . 10563)])
(put 'ebrowse-hs-unused 'compiler-macro 'ebrowse-hs-unused--cmacro)
#@75 Access slot "unused" of `(ebrowse-hs (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-hs-unused #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-hs-tags 0 signal wrong-type-argument ebrowse-hs 3] 4 (#$ . 10990)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-hs-unused side-effect-free t] 4)
#@56 compiler-macro for inlining `ebrowse-hs-member-table'.
(defalias 'ebrowse-hs-member-table--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-hs-member-table (or (and (memq (aref cl-x 0) cl-struct-ebrowse-hs-tags)) (signal 'wrong-type-argument (list 'ebrowse-hs cl-x))) (aref cl-x 4)) nil] 7 (#$ . 11341)])
(put 'ebrowse-hs-member-table 'compiler-macro 'ebrowse-hs-member-table--cmacro)
#@81 Access slot "member-table" of `(ebrowse-hs (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-hs-member-table #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-hs-tags 0 signal wrong-type-argument ebrowse-hs 4] 4 (#$ . 11798)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ebrowse-hs-member-table side-effect-free t defalias copy-ebrowse-hs copy-sequence] 4)
#@127 compiler-macro for inlining `make-ebrowse-hs'.

(fn CL-WHOLE &cl-quote &key VERSION COMMAND-LINE-OPTIONS UNUSED MEMBER-TABLE)
(defalias 'make-ebrowse-hs--cmacro #[(cl-whole &rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\306\311\"A@\306\312\"A@
\203H
@\313>\2031
AA\211\202\314>A@\203?\315\211\202\316\317
@\"\210\202)\320\321\322\315\315	\n\f&	,\207" [#1# version command-line-options unused member-table #2=#:--cl-keys-- plist-member :version :command-line-options :unused :member-table (:version :command-line-options :unused :member-table :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:version :command-line-options :unused :member-table)" cl--defsubst-expand (version command-line-options unused member-table) (cl-block make-ebrowse-hs (vector 'ebrowse-hs version command-line-options unused member-table)) cl-whole] 11 (#$ . 12217)])
(put 'make-ebrowse-hs 'compiler-macro 'make-ebrowse-hs--cmacro)
#@107 Constructor for objects of type `ebrowse-hs'.

(fn &key VERSION COMMAND-LINE-OPTIONS UNUSED MEMBER-TABLE)
(defalias 'make-ebrowse-hs #[(&rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\306\311\"A@\306\312\"A@
\203H
@\313>\2031
AA\211\202\314>A@\203?\315\211\202\316\317
@\"\210\202)\320\321	\n\f%,\207" [#1# version command-line-options unused member-table #2=#:--cl-keys-- plist-member :version :command-line-options :unused :member-table (:version :command-line-options :unused :member-table :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:version :command-line-options :unused :member-table)" vector ebrowse-hs] 7 (#$ . 13189)])
(byte-code "\300\301\302\303#\304\305\306\307\310\303\311\312\305\307&	\207" [function-put make-ebrowse-hs side-effect-free t cl-struct-define ebrowse-hs "Header structure found at the head of BROWSE files." nil vector ((cl-tag-slot) (version) (command-line-options) (unused) (member-table)) cl-struct-ebrowse-hs-tags] 11)
#@45 compiler-macro for inlining `ebrowse-ts-p'.
(defalias 'ebrowse-ts-p--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-p (and (vectorp cl-x) (>= (length cl-x) 11) (memq (aref cl-x 0) cl-struct-ebrowse-ts-tags) t)) nil] 7 (#$ . 14207)])
(put 'ebrowse-ts-p 'compiler-macro 'ebrowse-ts-p--cmacro)
(defalias 'ebrowse-ts-p #[(cl-x) "\302!\205G\303Y\205\304H	>\205\305\207" [cl-x cl-struct-ebrowse-ts-tags vectorp 11 0 t] 2])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ebrowse-ts-p side-effect-free error-free put ebrowse-ts cl-deftype-satisfies] 5)
#@49 compiler-macro for inlining `ebrowse-ts-class'.
(defalias 'ebrowse-ts-class--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-class (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ts-tags)) (signal 'wrong-type-argument (list 'ebrowse-ts cl-x))) (aref cl-x 1)) nil] 7 (#$ . 14857)])
(put 'ebrowse-ts-class 'compiler-macro 'ebrowse-ts-class--cmacro)
#@74 Access slot "class" of `(ebrowse-ts (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ts-class #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 1] 4 (#$ . 15279)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-class side-effect-free t] 4)
#@54 compiler-macro for inlining `ebrowse-ts-subclasses'.
(defalias 'ebrowse-ts-subclasses--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-subclasses (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ts-tags)) (signal 'wrong-type-argument (list 'ebrowse-ts cl-x))) (aref cl-x 2)) nil] 7 (#$ . 15627)])
(put 'ebrowse-ts-subclasses 'compiler-macro 'ebrowse-ts-subclasses--cmacro)
#@79 Access slot "subclasses" of `(ebrowse-ts (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ts-subclasses #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 2] 4 (#$ . 16074)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-subclasses side-effect-free t] 4)
#@60 compiler-macro for inlining `ebrowse-ts-member-variables'.
(defalias 'ebrowse-ts-member-variables--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-member-variables (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ts-tags)) (signal 'wrong-type-argument (list 'ebrowse-ts cl-x))) (aref cl-x 3)) nil] 7 (#$ . 16437)])
(put 'ebrowse-ts-member-variables 'compiler-macro 'ebrowse-ts-member-variables--cmacro)
#@85 Access slot "member-variables" of `(ebrowse-ts (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ts-member-variables #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 3] 4 (#$ . 16914)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-member-variables side-effect-free t] 4)
#@60 compiler-macro for inlining `ebrowse-ts-member-functions'.
(defalias 'ebrowse-ts-member-functions--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-member-functions (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ts-tags)) (signal 'wrong-type-argument (list 'ebrowse-ts cl-x))) (aref cl-x 4)) nil] 7 (#$ . 17295)])
(put 'ebrowse-ts-member-functions 'compiler-macro 'ebrowse-ts-member-functions--cmacro)
#@85 Access slot "member-functions" of `(ebrowse-ts (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ts-member-functions #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 4] 4 (#$ . 17772)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-member-functions side-effect-free t] 4)
#@60 compiler-macro for inlining `ebrowse-ts-static-variables'.
(defalias 'ebrowse-ts-static-variables--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-static-variables (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ts-tags)) (signal 'wrong-type-argument (list 'ebrowse-ts cl-x))) (aref cl-x 5)) nil] 7 (#$ . 18153)])
(put 'ebrowse-ts-static-variables 'compiler-macro 'ebrowse-ts-static-variables--cmacro)
#@85 Access slot "static-variables" of `(ebrowse-ts (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ts-static-variables #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 5] 4 (#$ . 18630)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-static-variables side-effect-free t] 4)
#@60 compiler-macro for inlining `ebrowse-ts-static-functions'.
(defalias 'ebrowse-ts-static-functions--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-static-functions (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ts-tags)) (signal 'wrong-type-argument (list 'ebrowse-ts cl-x))) (aref cl-x 6)) nil] 7 (#$ . 19011)])
(put 'ebrowse-ts-static-functions 'compiler-macro 'ebrowse-ts-static-functions--cmacro)
#@85 Access slot "static-functions" of `(ebrowse-ts (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ts-static-functions #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 6] 4 (#$ . 19488)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-static-functions side-effect-free t] 4)
#@51 compiler-macro for inlining `ebrowse-ts-friends'.
(defalias 'ebrowse-ts-friends--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-friends (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ts-tags)) (signal 'wrong-type-argument (list 'ebrowse-ts cl-x))) (aref cl-x 7)) nil] 7 (#$ . 19869)])
(put 'ebrowse-ts-friends 'compiler-macro 'ebrowse-ts-friends--cmacro)
#@76 Access slot "friends" of `(ebrowse-ts (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ts-friends #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 7] 4 (#$ . 20301)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-friends side-effect-free t] 4)
#@49 compiler-macro for inlining `ebrowse-ts-types'.
(defalias 'ebrowse-ts-types--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-types (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ts-tags)) (signal 'wrong-type-argument (list 'ebrowse-ts cl-x))) (aref cl-x 8)) nil] 7 (#$ . 20655)])
(put 'ebrowse-ts-types 'compiler-macro 'ebrowse-ts-types--cmacro)
#@74 Access slot "types" of `(ebrowse-ts (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ts-types #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 8] 4 (#$ . 21077)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-types side-effect-free t] 4)
#@56 compiler-macro for inlining `ebrowse-ts-base-classes'.
(defalias 'ebrowse-ts-base-classes--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-base-classes (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ts-tags)) (signal 'wrong-type-argument (list 'ebrowse-ts cl-x))) (aref cl-x 9)) nil] 7 (#$ . 21425)])
(put 'ebrowse-ts-base-classes 'compiler-macro 'ebrowse-ts-base-classes--cmacro)
#@81 Access slot "base-classes" of `(ebrowse-ts (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ts-base-classes #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 9] 4 (#$ . 21882)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-base-classes side-effect-free t] 4)
#@48 compiler-macro for inlining `ebrowse-ts-mark'.
(defalias 'ebrowse-ts-mark--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-mark (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ts-tags)) (signal 'wrong-type-argument (list 'ebrowse-ts cl-x))) (aref cl-x 10)) nil] 7 (#$ . 22251)])
(put 'ebrowse-ts-mark 'compiler-macro 'ebrowse-ts-mark--cmacro)
#@73 Access slot "mark" of `(ebrowse-ts (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ts-mark #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 10] 4 (#$ . 22669)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ebrowse-ts-mark side-effect-free t defalias copy-ebrowse-ts copy-sequence] 4)
#@195 compiler-macro for inlining `make-ebrowse-ts'.

(fn CL-WHOLE &cl-quote &key CLASS SUBCLASSES MEMBER-VARIABLES MEMBER-FUNCTIONS STATIC-VARIABLES STATIC-FUNCTIONS FRIENDS TYPES BASE-CLASSES MARK)
(defalias 'make-ebrowse-ts--cmacro #[(cl-whole &rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\306\311\"A@\306\312\"A@\306\313\"A@\306\314\"A@\306\315\"A@\306\316\"A@\306\317\"A@\306\320\"A@\203~@\321>\203eAA\211\202P\322>A@\203t\323\211\202P\324\325@\"\210\202N)\326\327\330\323\323	\n\f
&.\n\207" [#1# class subclasses member-variables member-functions static-variables plist-member :class :subclasses :member-variables :member-functions :static-variables :static-functions :friends :types :base-classes :mark (:class :subclasses :member-variables :member-functions :static-variables :static-functions :friends :types :base-classes :mark :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:class :subclasses :member-variables :member-functions :static-variables :static-functions :friends :types :base-classes :mark)" cl--defsubst-expand (class subclasses member-variables member-functions static-variables static-functions friends types base-classes mark) (cl-block make-ebrowse-ts (vector 'ebrowse-ts class subclasses member-variables member-functions static-variables static-functions friends types base-classes mark)) static-functions friends types base-classes mark #2=#:--cl-keys-- cl-whole] 17 (#$ . 23065)])
(put 'make-ebrowse-ts 'compiler-macro 'make-ebrowse-ts--cmacro)
#@175 Constructor for objects of type `ebrowse-ts'.

(fn &key CLASS SUBCLASSES MEMBER-VARIABLES MEMBER-FUNCTIONS STATIC-VARIABLES STATIC-FUNCTIONS FRIENDS TYPES BASE-CLASSES MARK)
(defalias 'make-ebrowse-ts #[(&rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\306\311\"A@\306\312\"A@\306\313\"A@\306\314\"A@\306\315\"A@\306\316\"A@\306\317\"A@\306\320\"A@\203~@\321>\203eAA\211\202P\322>A@\203t\323\211\202P\324\325@\"\210\202N)\326\327	\n\f
&.\n\207" [#1# class subclasses member-variables member-functions static-variables plist-member :class :subclasses :member-variables :member-functions :static-variables :static-functions :friends :types :base-classes :mark (:class :subclasses :member-variables :member-functions :static-variables :static-functions :friends :types :base-classes :mark :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:class :subclasses :member-variables :member-functions :static-variables :static-functions :friends :types :base-classes :mark)" vector ebrowse-ts static-functions friends types base-classes mark #2=#:--cl-keys--] 13 (#$ . 24640)])
(byte-code "\300\301\302\303#\304\305\306\307\310\303\311\312\305\307&	\207" [function-put make-ebrowse-ts side-effect-free t cl-struct-define ebrowse-ts "Tree structure.\nFollowing the header structure, a BROWSE file contains a number\nof `ebrowse-ts' structures, each one describing one root class of\nthe class hierarchy with all its subclasses." nil vector ((cl-tag-slot) (class) (subclasses) (member-variables) (member-functions) (static-variables) (static-functions) (friends) (types) (base-classes) (mark)) cl-struct-ebrowse-ts-tags] 11)
#@45 compiler-macro for inlining `ebrowse-bs-p'.
(defalias 'ebrowse-bs-p--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-bs-p (and (vectorp cl-x) (>= (length cl-x) 7) (memq (aref cl-x 0) cl-struct-ebrowse-bs-tags) t)) nil] 7 (#$ . 26349)])
(put 'ebrowse-bs-p 'compiler-macro 'ebrowse-bs-p--cmacro)
(defalias 'ebrowse-bs-p #[(cl-x) "\302!\205G\303Y\205\304H	>\205\305\207" [cl-x cl-struct-ebrowse-bs-tags vectorp 7 0 t] 2])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ebrowse-bs-p side-effect-free error-free put ebrowse-bs cl-deftype-satisfies] 5)
#@48 compiler-macro for inlining `ebrowse-bs-name'.
(defalias 'ebrowse-bs-name--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-bs-name (or (and (memq (aref cl-x 0) cl-struct-ebrowse-bs-tags)) (signal 'wrong-type-argument (list 'ebrowse-bs cl-x))) (aref cl-x 1)) nil] 7 (#$ . 26997)])
(put 'ebrowse-bs-name 'compiler-macro 'ebrowse-bs-name--cmacro)
#@73 Access slot "name" of `(ebrowse-bs (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-bs-name #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-bs-tags 0 signal wrong-type-argument ebrowse-bs 1] 4 (#$ . 27414)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-bs-name side-effect-free t] 4)
#@49 compiler-macro for inlining `ebrowse-bs-scope'.
(defalias 'ebrowse-bs-scope--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-bs-scope (or (and (memq (aref cl-x 0) cl-struct-ebrowse-bs-tags)) (signal 'wrong-type-argument (list 'ebrowse-bs cl-x))) (aref cl-x 2)) nil] 7 (#$ . 27759)])
(put 'ebrowse-bs-scope 'compiler-macro 'ebrowse-bs-scope--cmacro)
#@74 Access slot "scope" of `(ebrowse-bs (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-bs-scope #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-bs-tags 0 signal wrong-type-argument ebrowse-bs 2] 4 (#$ . 28181)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-bs-scope side-effect-free t] 4)
#@49 compiler-macro for inlining `ebrowse-bs-flags'.
(defalias 'ebrowse-bs-flags--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-bs-flags (or (and (memq (aref cl-x 0) cl-struct-ebrowse-bs-tags)) (signal 'wrong-type-argument (list 'ebrowse-bs cl-x))) (aref cl-x 3)) nil] 7 (#$ . 28529)])
(put 'ebrowse-bs-flags 'compiler-macro 'ebrowse-bs-flags--cmacro)
#@74 Access slot "flags" of `(ebrowse-bs (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-bs-flags #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-bs-tags 0 signal wrong-type-argument ebrowse-bs 3] 4 (#$ . 28951)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-bs-flags side-effect-free t] 4)
#@48 compiler-macro for inlining `ebrowse-bs-file'.
(defalias 'ebrowse-bs-file--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-bs-file (or (and (memq (aref cl-x 0) cl-struct-ebrowse-bs-tags)) (signal 'wrong-type-argument (list 'ebrowse-bs cl-x))) (aref cl-x 4)) nil] 7 (#$ . 29299)])
(put 'ebrowse-bs-file 'compiler-macro 'ebrowse-bs-file--cmacro)
#@73 Access slot "file" of `(ebrowse-bs (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-bs-file #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-bs-tags 0 signal wrong-type-argument ebrowse-bs 4] 4 (#$ . 29716)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-bs-file side-effect-free t] 4)
#@51 compiler-macro for inlining `ebrowse-bs-pattern'.
(defalias 'ebrowse-bs-pattern--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-bs-pattern (or (and (memq (aref cl-x 0) cl-struct-ebrowse-bs-tags)) (signal 'wrong-type-argument (list 'ebrowse-bs cl-x))) (aref cl-x 5)) nil] 7 (#$ . 30061)])
(put 'ebrowse-bs-pattern 'compiler-macro 'ebrowse-bs-pattern--cmacro)
#@76 Access slot "pattern" of `(ebrowse-bs (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-bs-pattern #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-bs-tags 0 signal wrong-type-argument ebrowse-bs 5] 4 (#$ . 30493)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-bs-pattern side-effect-free t] 4)
#@49 compiler-macro for inlining `ebrowse-bs-point'.
(defalias 'ebrowse-bs-point--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-bs-point (or (and (memq (aref cl-x 0) cl-struct-ebrowse-bs-tags)) (signal 'wrong-type-argument (list 'ebrowse-bs cl-x))) (aref cl-x 6)) nil] 7 (#$ . 30847)])
(put 'ebrowse-bs-point 'compiler-macro 'ebrowse-bs-point--cmacro)
#@74 Access slot "point" of `(ebrowse-bs (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-bs-point #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-bs-tags 0 signal wrong-type-argument ebrowse-bs 6] 4 (#$ . 31269)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ebrowse-bs-point side-effect-free t defalias copy-ebrowse-bs copy-sequence] 4)
#@114 compiler-macro for inlining `make-ebrowse-bs'.

(fn CL-WHOLE &cl-quote &key NAME SCOPE FLAGS FILE PATTERN POINT)
(defalias 'make-ebrowse-bs--cmacro #[(cl-whole &rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\306\311\"A@\306\312\"A@\306\313\"A@\306\314\"A@\203^@\315>\203EAA\211\2020\316>A@\203T\317\211\2020\320\321@\"\210\202.)\322\323\324\317\317	\n\f
&.\207" [#1# name scope flags file pattern plist-member :name :scope :flags :file :pattern :point (:name :scope :flags :file :pattern :point :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :scope :flags :file :pattern :point)" cl--defsubst-expand (name scope flags file pattern point) (cl-block make-ebrowse-bs (vector 'ebrowse-bs name scope flags file pattern point)) point #2=#:--cl-keys-- cl-whole] 13 (#$ . 31667)])
(put 'make-ebrowse-bs 'compiler-macro 'make-ebrowse-bs--cmacro)
#@94 Constructor for objects of type `ebrowse-bs'.

(fn &key NAME SCOPE FLAGS FILE PATTERN POINT)
(defalias 'make-ebrowse-bs #[(&rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\306\311\"A@\306\312\"A@\306\313\"A@\306\314\"A@\203^@\315>\203EAA\211\2020\316>A@\203T\317\211\2020\320\321@\"\210\202.)\322\323	\n\f
&.\207" [#1# name scope flags file pattern plist-member :name :scope :flags :file :pattern :point (:name :scope :flags :file :pattern :point :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :scope :flags :file :pattern :point)" vector ebrowse-bs point #2=#:--cl-keys--] 9 (#$ . 32593)])
(byte-code "\300\301\302\303#\304\305\306\307\310\303\311\312\305\307&	\207" [function-put make-ebrowse-bs side-effect-free t cl-struct-define ebrowse-bs "Common sub-structure.\nA common structure defining an occurrence of some name in the\nsource files." nil vector ((cl-tag-slot) (name) (scope) (flags) (file) (pattern) (point)) cl-struct-ebrowse-bs-tags] 11)
#@45 compiler-macro for inlining `ebrowse-cs-p'.
(defalias 'ebrowse-cs-p--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-cs-p (and (vectorp cl-x) (>= (length cl-x) 8) (memq (aref cl-x 0) cl-struct-ebrowse-cs-tags) t)) nil] 7 (#$ . 33632)])
(put 'ebrowse-cs-p 'compiler-macro 'ebrowse-cs-p--cmacro)
(defalias 'ebrowse-cs-p #[(cl-x) "\302!\205G\303Y\205\304H	>\205\305\207" [cl-x cl-struct-ebrowse-cs-tags vectorp 8 0 t] 2])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ebrowse-cs-p side-effect-free error-free put ebrowse-cs cl-deftype-satisfies] 5)
#@48 compiler-macro for inlining `ebrowse-cs-name'.
(defalias 'ebrowse-cs-name--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-cs-name (or (and (memq (aref cl-x 0) cl-struct-ebrowse-cs-tags)) (signal 'wrong-type-argument (list 'ebrowse-cs cl-x))) (aref cl-x 1)) nil] 7 (#$ . 34280)])
(put 'ebrowse-cs-name 'compiler-macro 'ebrowse-cs-name--cmacro)
#@95 Access slot "name" of `(ebrowse-cs (:include ebrowse-bs) (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-cs-name #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-cs 1] 4 (#$ . 34697)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-cs-name side-effect-free t] 4)
#@49 compiler-macro for inlining `ebrowse-cs-scope'.
(defalias 'ebrowse-cs-scope--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-cs-scope (or (and (memq (aref cl-x 0) cl-struct-ebrowse-cs-tags)) (signal 'wrong-type-argument (list 'ebrowse-cs cl-x))) (aref cl-x 2)) nil] 7 (#$ . 35064)])
(put 'ebrowse-cs-scope 'compiler-macro 'ebrowse-cs-scope--cmacro)
#@96 Access slot "scope" of `(ebrowse-cs (:include ebrowse-bs) (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-cs-scope #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-cs 2] 4 (#$ . 35486)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-cs-scope side-effect-free t] 4)
#@49 compiler-macro for inlining `ebrowse-cs-flags'.
(defalias 'ebrowse-cs-flags--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-cs-flags (or (and (memq (aref cl-x 0) cl-struct-ebrowse-cs-tags)) (signal 'wrong-type-argument (list 'ebrowse-cs cl-x))) (aref cl-x 3)) nil] 7 (#$ . 35856)])
(put 'ebrowse-cs-flags 'compiler-macro 'ebrowse-cs-flags--cmacro)
#@96 Access slot "flags" of `(ebrowse-cs (:include ebrowse-bs) (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-cs-flags #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-cs 3] 4 (#$ . 36278)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-cs-flags side-effect-free t] 4)
#@48 compiler-macro for inlining `ebrowse-cs-file'.
(defalias 'ebrowse-cs-file--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-cs-file (or (and (memq (aref cl-x 0) cl-struct-ebrowse-cs-tags)) (signal 'wrong-type-argument (list 'ebrowse-cs cl-x))) (aref cl-x 4)) nil] 7 (#$ . 36648)])
(put 'ebrowse-cs-file 'compiler-macro 'ebrowse-cs-file--cmacro)
#@95 Access slot "file" of `(ebrowse-cs (:include ebrowse-bs) (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-cs-file #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-cs 4] 4 (#$ . 37065)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-cs-file side-effect-free t] 4)
#@51 compiler-macro for inlining `ebrowse-cs-pattern'.
(defalias 'ebrowse-cs-pattern--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-cs-pattern (or (and (memq (aref cl-x 0) cl-struct-ebrowse-cs-tags)) (signal 'wrong-type-argument (list 'ebrowse-cs cl-x))) (aref cl-x 5)) nil] 7 (#$ . 37432)])
(put 'ebrowse-cs-pattern 'compiler-macro 'ebrowse-cs-pattern--cmacro)
#@98 Access slot "pattern" of `(ebrowse-cs (:include ebrowse-bs) (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-cs-pattern #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-cs 5] 4 (#$ . 37864)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-cs-pattern side-effect-free t] 4)
#@49 compiler-macro for inlining `ebrowse-cs-point'.
(defalias 'ebrowse-cs-point--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-cs-point (or (and (memq (aref cl-x 0) cl-struct-ebrowse-cs-tags)) (signal 'wrong-type-argument (list 'ebrowse-cs cl-x))) (aref cl-x 6)) nil] 7 (#$ . 38240)])
(put 'ebrowse-cs-point 'compiler-macro 'ebrowse-cs-point--cmacro)
#@96 Access slot "point" of `(ebrowse-cs (:include ebrowse-bs) (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-cs-point #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-cs 6] 4 (#$ . 38662)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-cs-point side-effect-free t] 4)
#@55 compiler-macro for inlining `ebrowse-cs-source-file'.
(defalias 'ebrowse-cs-source-file--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-cs-source-file (or (and (memq (aref cl-x 0) cl-struct-ebrowse-cs-tags)) (signal 'wrong-type-argument (list 'ebrowse-cs cl-x))) (aref cl-x 7)) nil] 7 (#$ . 39032)])
(put 'ebrowse-cs-source-file 'compiler-macro 'ebrowse-cs-source-file--cmacro)
#@102 Access slot "source-file" of `(ebrowse-cs (:include ebrowse-bs) (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-cs-source-file #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-cs 7] 4 (#$ . 39485)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ebrowse-cs-source-file side-effect-free t defalias copy-ebrowse-cs copy-sequence] 4)
#@126 compiler-macro for inlining `make-ebrowse-cs'.

(fn CL-WHOLE &cl-quote &key NAME SCOPE FLAGS FILE PATTERN POINT SOURCE-FILE)
(defalias 'make-ebrowse-cs--cmacro #[(cl-whole &rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\306\311\"A@\306\312\"A@\306\313\"A@\306\314\"A@\306\315\"A@\203f@\316>\203MAA\211\2028\317>A@\203\\\320\211\2028\321\322@\"\210\2026)\323\324\325\320\320	\n\f
&\f.\207" [#1# name scope flags file pattern plist-member :name :scope :flags :file :pattern :point :source-file (:name :scope :flags :file :pattern :point :source-file :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :scope :flags :file :pattern :point :source-file)" cl--defsubst-expand (name scope flags file pattern point source-file) (cl-block make-ebrowse-cs (vector 'ebrowse-cs name scope flags file pattern point source-file)) point source-file #2=#:--cl-keys-- cl-whole] 14 (#$ . 39923)])
(put 'make-ebrowse-cs 'compiler-macro 'make-ebrowse-cs--cmacro)
#@106 Constructor for objects of type `ebrowse-cs'.

(fn &key NAME SCOPE FLAGS FILE PATTERN POINT SOURCE-FILE)
(defalias 'make-ebrowse-cs #[(&rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\306\311\"A@\306\312\"A@\306\313\"A@\306\314\"A@\306\315\"A@\203f@\316>\203MAA\211\2028\317>A@\203\\\320\211\2028\321\322@\"\210\2026)\323\324	\n\f
&.\207" [#1# name scope flags file pattern plist-member :name :scope :flags :file :pattern :point :source-file (:name :scope :flags :file :pattern :point :source-file :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :scope :flags :file :pattern :point :source-file)" vector ebrowse-cs point source-file #2=#:--cl-keys--] 10 (#$ . 40956)])
(byte-code "\300\301\302\303#\304\305\306\307\310\303\311\312\305\313&	\207" [function-put make-ebrowse-cs side-effect-free t cl-struct-define ebrowse-cs "Class structure.\nThis is the structure stored in the CLASS slot of a `ebrowse-ts'\nstructure.  It describes the location of the class declaration." ebrowse-bs vector ((cl-tag-slot nil) (name nil) (scope nil) (flags nil) (file nil) (pattern nil) (point nil) (source-file)) cl-struct-ebrowse-cs-tags nil] 11)
#@45 compiler-macro for inlining `ebrowse-ms-p'.
(defalias 'ebrowse-ms-p--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-p (and (vectorp cl-x) (>= (length cl-x) 11) (memq (aref cl-x 0) cl-struct-ebrowse-ms-tags) t)) nil] 7 (#$ . 42178)])
(put 'ebrowse-ms-p 'compiler-macro 'ebrowse-ms-p--cmacro)
(defalias 'ebrowse-ms-p #[(cl-x) "\302!\205G\303Y\205\304H	>\205\305\207" [cl-x cl-struct-ebrowse-ms-tags vectorp 11 0 t] 2])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ebrowse-ms-p side-effect-free error-free put ebrowse-ms cl-deftype-satisfies] 5)
#@48 compiler-macro for inlining `ebrowse-ms-name'.
(defalias 'ebrowse-ms-name--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-name (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ms-tags)) (signal 'wrong-type-argument (list 'ebrowse-ms cl-x))) (aref cl-x 1)) nil] 7 (#$ . 42828)])
(put 'ebrowse-ms-name 'compiler-macro 'ebrowse-ms-name--cmacro)
#@95 Access slot "name" of `(ebrowse-ms (:include ebrowse-bs) (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ms-name #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 1] 4 (#$ . 43245)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-name side-effect-free t] 4)
#@49 compiler-macro for inlining `ebrowse-ms-scope'.
(defalias 'ebrowse-ms-scope--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-scope (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ms-tags)) (signal 'wrong-type-argument (list 'ebrowse-ms cl-x))) (aref cl-x 2)) nil] 7 (#$ . 43612)])
(put 'ebrowse-ms-scope 'compiler-macro 'ebrowse-ms-scope--cmacro)
#@96 Access slot "scope" of `(ebrowse-ms (:include ebrowse-bs) (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ms-scope #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 2] 4 (#$ . 44034)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-scope side-effect-free t] 4)
#@49 compiler-macro for inlining `ebrowse-ms-flags'.
(defalias 'ebrowse-ms-flags--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-flags (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ms-tags)) (signal 'wrong-type-argument (list 'ebrowse-ms cl-x))) (aref cl-x 3)) nil] 7 (#$ . 44404)])
(put 'ebrowse-ms-flags 'compiler-macro 'ebrowse-ms-flags--cmacro)
#@96 Access slot "flags" of `(ebrowse-ms (:include ebrowse-bs) (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ms-flags #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 3] 4 (#$ . 44826)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-flags side-effect-free t] 4)
#@48 compiler-macro for inlining `ebrowse-ms-file'.
(defalias 'ebrowse-ms-file--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-file (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ms-tags)) (signal 'wrong-type-argument (list 'ebrowse-ms cl-x))) (aref cl-x 4)) nil] 7 (#$ . 45196)])
(put 'ebrowse-ms-file 'compiler-macro 'ebrowse-ms-file--cmacro)
#@95 Access slot "file" of `(ebrowse-ms (:include ebrowse-bs) (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ms-file #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 4] 4 (#$ . 45613)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-file side-effect-free t] 4)
#@51 compiler-macro for inlining `ebrowse-ms-pattern'.
(defalias 'ebrowse-ms-pattern--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-pattern (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ms-tags)) (signal 'wrong-type-argument (list 'ebrowse-ms cl-x))) (aref cl-x 5)) nil] 7 (#$ . 45980)])
(put 'ebrowse-ms-pattern 'compiler-macro 'ebrowse-ms-pattern--cmacro)
#@98 Access slot "pattern" of `(ebrowse-ms (:include ebrowse-bs) (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ms-pattern #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 5] 4 (#$ . 46412)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-pattern side-effect-free t] 4)
#@49 compiler-macro for inlining `ebrowse-ms-point'.
(defalias 'ebrowse-ms-point--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-point (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ms-tags)) (signal 'wrong-type-argument (list 'ebrowse-ms cl-x))) (aref cl-x 6)) nil] 7 (#$ . 46788)])
(put 'ebrowse-ms-point 'compiler-macro 'ebrowse-ms-point--cmacro)
#@96 Access slot "point" of `(ebrowse-ms (:include ebrowse-bs) (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ms-point #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 6] 4 (#$ . 47210)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-point side-effect-free t] 4)
#@54 compiler-macro for inlining `ebrowse-ms-visibility'.
(defalias 'ebrowse-ms-visibility--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-visibility (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ms-tags)) (signal 'wrong-type-argument (list 'ebrowse-ms cl-x))) (aref cl-x 7)) nil] 7 (#$ . 47580)])
(put 'ebrowse-ms-visibility 'compiler-macro 'ebrowse-ms-visibility--cmacro)
#@101 Access slot "visibility" of `(ebrowse-ms (:include ebrowse-bs) (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ms-visibility #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 7] 4 (#$ . 48028)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-visibility side-effect-free t] 4)
#@59 compiler-macro for inlining `ebrowse-ms-definition-file'.
(defalias 'ebrowse-ms-definition-file--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-definition-file (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ms-tags)) (signal 'wrong-type-argument (list 'ebrowse-ms cl-x))) (aref cl-x 8)) nil] 7 (#$ . 48413)])
(put 'ebrowse-ms-definition-file 'compiler-macro 'ebrowse-ms-definition-file--cmacro)
#@106 Access slot "definition-file" of `(ebrowse-ms (:include ebrowse-bs) (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ms-definition-file #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 8] 4 (#$ . 48886)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-definition-file side-effect-free t] 4)
#@62 compiler-macro for inlining `ebrowse-ms-definition-pattern'.
(defalias 'ebrowse-ms-definition-pattern--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-definition-pattern (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ms-tags)) (signal 'wrong-type-argument (list 'ebrowse-ms cl-x))) (aref cl-x 9)) nil] 7 (#$ . 49286)])
(put 'ebrowse-ms-definition-pattern 'compiler-macro 'ebrowse-ms-definition-pattern--cmacro)
#@109 Access slot "definition-pattern" of `(ebrowse-ms (:include ebrowse-bs) (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ms-definition-pattern #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 9] 4 (#$ . 49774)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-definition-pattern side-effect-free t] 4)
#@60 compiler-macro for inlining `ebrowse-ms-definition-point'.
(defalias 'ebrowse-ms-definition-point--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-definition-point (or (and (memq (aref cl-x 0) cl-struct-ebrowse-ms-tags)) (signal 'wrong-type-argument (list 'ebrowse-ms cl-x))) (aref cl-x 10)) nil] 7 (#$ . 50183)])
(put 'ebrowse-ms-definition-point 'compiler-macro 'ebrowse-ms-definition-point--cmacro)
#@107 Access slot "definition-point" of `(ebrowse-ms (:include ebrowse-bs) (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-ms-definition-point #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 10] 4 (#$ . 50662)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ebrowse-ms-definition-point side-effect-free t defalias copy-ebrowse-ms copy-sequence] 4)
#@177 compiler-macro for inlining `make-ebrowse-ms'.

(fn CL-WHOLE &cl-quote &key NAME SCOPE FLAGS FILE PATTERN POINT VISIBILITY DEFINITION-FILE DEFINITION-PATTERN DEFINITION-POINT)
(defalias 'make-ebrowse-ms--cmacro #[(cl-whole &rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\306\311\"A@\306\312\"A@\306\313\"A@\306\314\"A@\306\315\"A@\306\316\"A@\306\317\"A@\306\320\"A@\203~@\321>\203eAA\211\202P\322>A@\203t\323\211\202P\324\325@\"\210\202N)\326\327\330\323\323	\n\f
&.\n\207" [#1# name scope flags file pattern plist-member :name :scope :flags :file :pattern :point :visibility :definition-file :definition-pattern :definition-point (:name :scope :flags :file :pattern :point :visibility :definition-file :definition-pattern :definition-point :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :scope :flags :file :pattern :point :visibility :definition-file :definition-pattern :definition-point)" cl--defsubst-expand (name scope flags file pattern point visibility definition-file definition-pattern definition-point) (cl-block make-ebrowse-ms (vector 'ebrowse-ms name scope flags file pattern point visibility definition-file definition-pattern definition-point)) point visibility definition-file definition-pattern definition-point #2=#:--cl-keys-- cl-whole] 17 (#$ . 51116)])
(put 'make-ebrowse-ms 'compiler-macro 'make-ebrowse-ms--cmacro)
#@157 Constructor for objects of type `ebrowse-ms'.

(fn &key NAME SCOPE FLAGS FILE PATTERN POINT VISIBILITY DEFINITION-FILE DEFINITION-PATTERN DEFINITION-POINT)
(defalias 'make-ebrowse-ms #[(&rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\306\311\"A@\306\312\"A@\306\313\"A@\306\314\"A@\306\315\"A@\306\316\"A@\306\317\"A@\306\320\"A@\203~@\321>\203eAA\211\202P\322>A@\203t\323\211\202P\324\325@\"\210\202N)\326\327	\n\f
&.\n\207" [#1# name scope flags file pattern plist-member :name :scope :flags :file :pattern :point :visibility :definition-file :definition-pattern :definition-point (:name :scope :flags :file :pattern :point :visibility :definition-file :definition-pattern :definition-point :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :scope :flags :file :pattern :point :visibility :definition-file :definition-pattern :definition-point)" vector ebrowse-ms point visibility definition-file definition-pattern definition-point #2=#:--cl-keys--] 13 (#$ . 52565)])
(byte-code "\300\301\302\303#\304\305\306\307\310\303\311\312\305\313&	\207" [function-put make-ebrowse-ms side-effect-free t cl-struct-define ebrowse-ms "Member structure.\nThis is the structure describing a single member.  The `ebrowse-ts'\nstructure contains various lists for the different types of\nmembers." ebrowse-bs vector ((cl-tag-slot nil) (name nil) (scope nil) (flags nil) (file nil) (pattern nil) (point nil) (visibility) (definition-file) (definition-pattern) (definition-point)) cl-struct-ebrowse-ms-tags nil] 11)
#@46 Value is non-nil if MEMBER's bit BIT is set.
(defalias 'ebrowse-member-bit-set-p #[(member bit) "\303\304H	>\204\305\306\307D\"\210\310H\n\"\304U?\207" [member cl-struct-ebrowse-bs-tags bit logand 0 signal wrong-type-argument ebrowse-bs 3] 5 (#$ . 54169)])
(put 'ebrowse-member-bit-set-p 'byte-optimizer 'byte-compile-inline-expand)
#@40 Value is non-nil if MEMBER is virtual.
(defalias 'ebrowse-virtual-p #[(member) "\303\304\305H\n>\204\306\307\310D\"\210\311H	\"\305U*?\207" [member bit cl-struct-ebrowse-bs-tags 1 logand 0 signal wrong-type-argument ebrowse-bs 3] 5 (#$ . 54513)])
(put 'ebrowse-virtual-p 'byte-optimizer 'byte-compile-inline-expand)
#@39 Value is non-nil if MEMBER is inline.
(defalias 'ebrowse-inline-p #[(member) "\303\304\305H\n>\204\306\307\310D\"\210\311H	\"\305U*?\207" [member bit cl-struct-ebrowse-bs-tags 2 logand 0 signal wrong-type-argument ebrowse-bs 3] 5 (#$ . 54843)])
(put 'ebrowse-inline-p 'byte-optimizer 'byte-compile-inline-expand)
#@38 Value is non-nil if MEMBER is const.
(defalias 'ebrowse-const-p #[(member) "\303\304\305H\n>\204\306\307\310D\"\210\311H	\"\305U*?\207" [member bit cl-struct-ebrowse-bs-tags 4 logand 0 signal wrong-type-argument ebrowse-bs 3] 5 (#$ . 55170)])
(put 'ebrowse-const-p 'byte-optimizer 'byte-compile-inline-expand)
#@56 Value is non-nil if MEMBER is a pure virtual function.
(defalias 'ebrowse-pure-virtual-p #[(member) "\303\304\305H\n>\204\306\307\310D\"\210\311H	\"\305U*?\207" [member bit cl-struct-ebrowse-bs-tags 8 logand 0 signal wrong-type-argument ebrowse-bs 3] 5 (#$ . 55494)])
(put 'ebrowse-pure-virtual-p 'byte-optimizer 'byte-compile-inline-expand)
#@40 Value is non-nil if MEMBER is mutable.
(defalias 'ebrowse-mutable-p #[(member) "\303\304\305H\n>\204\306\307\310D\"\210\311H	\"\305U*?\207" [member bit cl-struct-ebrowse-bs-tags 16 logand 0 signal wrong-type-argument ebrowse-bs 3] 5 (#$ . 55850)])
(put 'ebrowse-mutable-p 'byte-optimizer 'byte-compile-inline-expand)
#@43 Value is non-nil if MEMBER is a template.
(defalias 'ebrowse-template-p #[(member) "\303\304\305H\n>\204\306\307\310D\"\210\311H	\"\305U*?\207" [member bit cl-struct-ebrowse-bs-tags 32 logand 0 signal wrong-type-argument ebrowse-bs 3] 5 (#$ . 56181)])
(put 'ebrowse-template-p 'byte-optimizer 'byte-compile-inline-expand)
#@41 Value is non-nil if MEMBER is explicit.
(defalias 'ebrowse-explicit-p #[(member) "\303\304\305H\n>\204\306\307\310D\"\210\311H	\"\305U*?\207" [member bit cl-struct-ebrowse-bs-tags 64 logand 0 signal wrong-type-argument ebrowse-bs 3] 5 (#$ . 56517)])
(put 'ebrowse-explicit-p 'byte-optimizer 'byte-compile-inline-expand)
#@55 Value is non-nil if MEMBER has a throw specification.
(defalias 'ebrowse-throw-list-p #[(member) "\303\304\305H\n>\204\306\307\310D\"\210\311H	\"\305U*?\207" [member bit cl-struct-ebrowse-bs-tags 128 logand 0 signal wrong-type-argument ebrowse-bs 3] 5 (#$ . 56851)])
(put 'ebrowse-throw-list-p 'byte-optimizer 'byte-compile-inline-expand)
#@45 Value is non-nil if MEMBER is `extern "C"'.
(defalias 'ebrowse-extern-c-p #[(member) "\303\304\305H\n>\204\306\307\310D\"\210\311H	\"\305U*?\207" [member bit cl-struct-ebrowse-bs-tags 256 logand 0 signal wrong-type-argument ebrowse-bs 3] 5 (#$ . 57204)])
(put 'ebrowse-extern-c-p 'byte-optimizer 'byte-compile-inline-expand)
#@41 Value is non-nil if MEMBER is a define.
(defalias 'ebrowse-define-p #[(member) "\303\304\305H\n>\204\306\307\310D\"\210\311H	\"\305U*?\207" [member bit cl-struct-ebrowse-bs-tags 512 logand 0 signal wrong-type-argument ebrowse-bs 3] 5 (#$ . 57543)])
(put 'ebrowse-define-p 'byte-optimizer 'byte-compile-inline-expand)
#@42 Version string expected in BROWSE files.
(defconst ebrowse-version-string "ebrowse 5.0" (#$ . 57874))
#@110 The name used for the surrogate class.containing global entities.
This must be the same that `ebrowse' uses.
(defconst ebrowse-globals-name "*Globals*" (#$ . 57983))
#@128 Last regular expression searched for in tree and member buffers.
Each tree and member buffer maintains its own search history.
(defvar ebrowse--last-regexp nil (#$ . 58156))
(make-variable-buffer-local 'ebrowse--last-regexp)
#@180 List of accessors for member lists.
Each element is the symbol of an accessor function.
The nth element must be the accessor for the nth member list
in an `ebrowse-ts' structure.
(defconst ebrowse-member-list-accessors '(ebrowse-ts-member-variables ebrowse-ts-member-functions ebrowse-ts-static-variables ebrowse-ts-static-functions ebrowse-ts-friends ebrowse-ts-types) (#$ . 58388))
#@95 Obarray holding all `ebrowse-ts' structures of a class tree.
Buffer-local in Ebrowse buffers.
(defvar ebrowse--tree-obarray nil (#$ . 58778))
#@74 File from which BROWSE file was loaded.
Buffer-local in Ebrowse buffers.
(defvar ebrowse--tags-file-name nil (#$ . 58926))
#@89 Header structure of type `ebrowse-hs' of a class tree.
Buffer-local in Ebrowse buffers.
(defvar ebrowse--header nil (#$ . 59055))
#@83 Non-nil means an Ebrowse buffer won't be reused.
Buffer-local in Ebrowse buffers.
(defvar ebrowse--frozen-flag nil (#$ . 59191))
#@87 Non-nil means show file names in a tree buffer.
Buffer-local in Ebrowse tree buffers.
(defvar ebrowse--show-file-names-flag nil (#$ . 59326))
#@90 Non-nil means show members in long display form.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--long-display-flag nil (#$ . 59474))
#@101 Number of columns to display for short member display form.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--n-columns nil (#$ . 59623))
#@102 Width of a columns to display for short member display form.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--column-width nil (#$ . 59775))
#@99 Non-nil means display virtual members in a member buffer.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--virtual-display-flag nil (#$ . 59930))
#@98 Non-nil means display inline members in a member buffer.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--inline-display-flag nil (#$ . 60090))
#@97 Non-nil means display const members in a member buffer.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--const-display-flag nil (#$ . 60248))
#@104 Non-nil means display pure virtual members in a member buffer.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--pure-display-flag nil (#$ . 60405))
#@202 Filter for display of public, protected, and private members.
This is a vector of three elements.  An element nil means the
corresponding members are not shown.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--filters nil (#$ . 60568))
#@101 Non-nil means display inherited members in a member buffer.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--show-inherited-flag nil (#$ . 60819))
#@101 Non-nil means display member attributes in a member buffer.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--attributes-flag nil (#$ . 60981))
#@98 Non-nil means display member regexps in a member buffer.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--source-regexp-flag nil (#$ . 61138))
#@103 Class displayed in a member buffer, a `ebrowse-ts' structure.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--displayed-class nil (#$ . 61296))
#@189 Member list displayed in a member buffer.
This is a symbol whose function definition is an accessor for the
member list in `ebrowse-cs' structures.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--accessor nil (#$ . 61456))
#@107 The list of `ebrowse-ms' structures displayed in a member buffer.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--member-list nil (#$ . 61695))
#@103 Column in which declarations are displayed in member buffers.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--decl-column nil (#$ . 61855))
#@106 Frame configuration saved when viewing a class/member in another frame.
Buffer-local in Ebrowse buffers.
(defvar ebrowse--frame-configuration nil (#$ . 62011))
#@111 Action to perform after viewing a class/member.
Either `kill-buffer' or nil.
Buffer-local in Ebrowse buffers.
(defvar ebrowse--view-exit-action nil (#$ . 62178))
#@46 Class tree.
Buffer-local in Ebrowse buffers.
(defvar ebrowse--tree nil (#$ . 62346))
(defvar ebrowse-temp-position-to-view nil)
(defvar ebrowse-temp-info-to-view nil)
#@39 The keymap used in tree mode buffers.
(defvar ebrowse-tree-mode-map nil (#$ . 62519))
#@55 Strings displayed in the mode line of member buffers.
(defvar ebrowse--member-mode-strings nil (#$ . 62611))
#@40 The keymap used in the member buffers.
(defvar ebrowse-member-mode-map nil (#$ . 62726))
(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\301\316\317#\210\300\304\316\320#\210\300\306\316\307#\210\300\310\316\311#\210\300\312\316\321#\210\300\314\316\315#\207" [put ebrowse-ts-member-variables ebrowse-title "Member Variables" ebrowse-ts-member-functions "Member Functions" ebrowse-ts-static-variables "Static Variables" ebrowse-ts-static-functions "Static Functions" ebrowse-ts-friends "Friends" ebrowse-ts-types "Types" ebrowse-global-title "Global Variables" "Global Functions" "Defines"] 4)
#@201 Return an obarray containing all files mentioned in the current tree.
The tree is expected in the buffer-local variable `ebrowse--tree-obarray'.
MARKED-ONLY non-nil means include marked classes only.
(defalias 'ebrowse-files-table #[(&optional marked-only) "\304\305\306\"\307\310\311\312\"\210)	*\207" [i files tree ebrowse--tree-obarray make-hash-table :test equal -1 nil mapatoms #[(#1=#:var) "\306N\307	!\205
\n\203#	\310H>\204\311\312\313	D\"\210	\314H\205
	\310H>\2042\311\312\313	D\"\210	\315H
T\211\316\246\310U\203H\317\320
\310U\"\210\f\310H>\204X\311\312\321\fD\"\210\f\322H\f\310H>\204k\311\312\321\fD\"\210\f\323H\211\203~\324\211#\210\203\213\324\211#\210\325\211\205
@\211	!\325\211 \325!:\203
@\211 \310H\">\204\305\311\312\326 D\"\210 \323H \310H\">\204\335\311\312\326 D\"\210 \327H!\203\360\324\211#\210!\203\375\324!\211#\210A\211\202\253,A\211\204\226\325-\207" [#1# tree marked-only cl-struct-ebrowse-ts-tags class i ebrowse-root vectorp 0 signal wrong-type-argument ebrowse-ts 10 1 20 ebrowse-show-progress "Preparing file list" ebrowse-cs 7 4 puthash nil ebrowse-ms 8 cl-struct-ebrowse-cs-tags file source-file files ebrowse-member-list-accessors accessor --dolist-tail-- #2=#:--cl-var-- m def-file cl-struct-ebrowse-ms-tags] 6]] 3 (#$ . 63422)])
#@112 Return a list containing all files mentioned in a tree.
MARKED-ONLY non-nil means include marked classes only.
(defalias 'ebrowse-files-list #[(&optional marked-only) "\302\303\304\305	!\"\210)\207" [list marked-only nil maphash #[(file _dummy) "	B\211\207" [file list] 2] ebrowse-files-table] 4 (#$ . 64796)])
#@68 Value is non-nil if any class in the current class tree is marked.
(defalias 'ebrowse-marked-classes-p #[nil "\3022\303\304\305	\"\210)\3030\207" [tree ebrowse--tree-obarray --cl-block-ebrowse-marked-classes-p-- nil mapatoms #[(#1=#:var) "\303N\304	!\205#	\305H\n>\204\306\307\310	D\"\210	\311H\205#\312\313	\"\207" [#1# tree cl-struct-ebrowse-ts-tags ebrowse-root vectorp 0 signal wrong-type-argument ebrowse-ts 10 throw --cl-block-ebrowse-marked-classes-p--] 4]] 3 (#$ . 65117)])
#@50 Return t if TREE is the one for global entities.
(defalias 'ebrowse-globals-tree-p #[(tree) "\304H	>\204\305\306\307D\"\210\310H\304H\n>\2041\305\306\311\304H	>\204+\305\306\307D\"\210\310HD\"\210\304H	>\204@\305\306\307D\"\210\310H\310H\230\207" [tree cl-struct-ebrowse-ts-tags cl-struct-ebrowse-bs-tags ebrowse-globals-name 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-bs] 7 (#$ . 65614)])
(put 'ebrowse-globals-tree-p 'byte-optimizer 'byte-compile-inline-expand)
#@56 Return the name of CLASS with scope prepended, if any.
(defalias 'ebrowse-qualified-class-name #[(class) "\302H	>\204\303\304\305D\"\210\306H\203<\302H	>\204$\303\304\305D\"\210\306H\307\302H	>\2047\303\304\305D\"\210\310HQ\207\302H	>\204K\303\304\305D\"\210\310H\207" [class cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-cs 2 "::" 1] 6 (#$ . 66106)])
(put 'ebrowse-qualified-class-name 'byte-optimizer 'byte-compile-inline-expand)
#@356 Return an alist describing all classes in a tree.
Each elements in the list has the form (CLASS-NAME . TREE).
CLASS-NAME is the name of the class.  TREE is the
class tree whose root is QUALIFIED-CLASS-NAME.
QUALIFIED-NAMES-P non-nil means return qualified names as CLASS-NAME.
The class tree is found in the buffer-local variable `ebrowse--tree-obarray'.
(defalias 'ebrowse-tree-obarray-as-alist #[(&optional qualified-names-p) "\304	\203\304\305\306\"\210)\202\304\305\307\"\210))\207" [alist qualified-names-p tree ebrowse--tree-obarray nil mapatoms #[(#1=#:var) "\306N\307	!\205y	\310H\n>\204\311\312\313	D\"\210	\314H\211\310H\f>\204,\311\312\315D\"\210\316H\203[\310H\f>\204A\311\312\315D\"\210\316H\317\310H\f>\204T\311\312\315D\"\210\314HQ\202m\310H\f>\204j\311\312\315D\"\210\314H)	
B
B\266\203\211\207" [#1# tree cl-struct-ebrowse-ts-tags class cl-struct-ebrowse-cs-tags alist ebrowse-root vectorp 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs 2 "::"] 7] #[(#2=#:var) "\305N\306	!\205Z	\307H\n>\204\310\311\312	D\"\210	\313H\307H>\204;\310\311\314	\307H\n>\2045\310\311\312	D\"\210	\313HD\"\210	\307H\n>\204J\310\311\312	D\"\210	\313H\313H	\fB
B\266\203\211\207" [#2# tree cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags alist ebrowse-root vectorp 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs] 7]] 3 (#$ . 66580)])
#@66 Sort a LIST of `ebrowse-ts' structures by qualified class names.
(defalias 'ebrowse-sort-tree-list #[(list) "\301\302\"\207" [list sort #[(a b) "\305H	>\204\306\307\310D\"\210\311H\211\305H>\204\"\306\307\312\nD\"\210\n\313H\203Q\n\305H>\2047\306\307\312\nD\"\210\n\313H\314\n\305H>\204J\306\307\312\nD\"\210\n\311HQ\202c\n\305H>\204`\306\307\312\nD\"\210\n\311H)\f\305H	>\204s\306\307\310\fD\"\210\f\311H\211\305H>\204\206\306\307\312\nD\"\210\n\313H\203\265\n\305H>\204\233\306\307\312\nD\"\210\n\313H\314\n\305H>\204\256\306\307\312\nD\"\210\n\311HQ\202\307\n\305H>\204\304\306\307\312\nD\"\210\n\311H)\231\207" [a cl-struct-ebrowse-ts-tags class cl-struct-ebrowse-cs-tags b 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs 2 "::"] 8]] 3 (#$ . 67977)])
#@218 Search for a class with name CLASS in TREE.
If CLASS is found, return the tail of TREE starting at CLASS.  This function
is used during the load phase where classes appended to a file replace older
class information.
(defalias 'ebrowse-class-in-tree #[(class tree) "\306H	>\204\307\310\311D\"\210\312H\313\f\203\356\n\204\356\f\211@\306H	>\2040\307\310\311
@D\"\210
@\312H\211\306H>\204E\307\310\314D\"\210\315H\203v\306H>\204[\307\310\314D\"\210\315H\316\306H>\204o\307\310\314D\"\210\312HQ\202\211\306H>\204\206\307\310\314D\"\210\312H)\211\306H>\204\234\307\310\314D\"\210\315H\203\315\306H>\204\262\307\310\314D\"\210\315H\316\306H>\204\306\307\310\314D\"\210\312HQ\202\340\306H>\204\335\307\310\314D\"\210\312H)\230\203\347
\fA)\202\n*\207" [class cl-struct-ebrowse-ts-tags found tclass tree root-ptr 0 signal wrong-type-argument ebrowse-ts 1 nil ebrowse-cs 2 "::" cl-struct-ebrowse-cs-tags] 8 (#$ . 68773)])
#@219 Return list of base-classes of TREE by searching subclass lists.
This function must be used instead of the struct slot
`base-classes' to access the base-class list directly because it
computes this information lazily.
(defalias 'ebrowse-base-classes #[(tree) "\306H	>\204\307\310\311D\"\210\312H\206J\306H	>\204$\307\310\311D\"\210\211\312C\313\211\211A\242\211\203F\313\314\315\"\210)\202/\f+I)\207" [tree cl-struct-ebrowse-ts-tags #1=#:v to-search result search 0 signal wrong-type-argument ebrowse-ts 9 nil mapatoms #[(#2=#:var) "\306N\307	!\2051\n	\310H>\204\311\312\313	D\"\210	\314H>\2051	\f>\204,\f	C\244	
B\211\207" [#2# ti search cl-struct-ebrowse-ts-tags result to-search ebrowse-root vectorp 0 signal wrong-type-argument ebrowse-ts 2] 5] ti ebrowse--tree-obarray] 6 (#$ . 69763)])
#@50 Return the list of direct super classes of TREE.
(defalias 'ebrowse-direct-base-classes #[(tree) "\305\306	!\305\211\2031@	\n\307H\f>\204\310\311\312\nD\"\210\n\313H>\203*\nBA\211\204\f*)\207" [result tree s --dolist-tail-- cl-struct-ebrowse-ts-tags nil ebrowse-base-classes 0 signal wrong-type-argument ebrowse-ts 2] 6 (#$ . 70595)])
#@209 Return an alist containing all members of TREE in group ACCESSOR.
ACCESSOR is the accessor function for the member list.
Elements of the result have the form (NAME . ACCESSOR), where NAME
is the member name.
(defalias 'ebrowse-name/accessor-alist #[(tree accessor) "	!\306\211\n:\203.\n@\211\307H
>\204\310\311\312D\"\210\313HB\fB\nA\211\202	\f\237+\207" [accessor tree #1=#:--cl-var-- member #2=#:--cl-var-- cl-struct-ebrowse-ms-tags nil 0 signal wrong-type-argument ebrowse-ms 1] 5 (#$ . 70952)])
#@345 Return an alist describing all members visible in the current buffer.
Each element of the list has the form (MEMBER-NAME . ACCESSOR),
where MEMBER-NAME is the member's name, and ACCESSOR is the struct
accessor with which the member's list can be accessed in an `ebrowse-ts'
structure.  The list includes inherited members if these are visible.
(defalias 'ebrowse-name/accessor-alist-for-visible-members #[nil "\306	\"\2034\n\307!\310\211	\f:\203,\f@\306
	\"\237	\244	\fA\211\202	\237+\244\2025\n)\207" [ebrowse--displayed-class ebrowse--accessor list ebrowse--show-inherited-flag #1=#:--cl-var-- tree ebrowse-name/accessor-alist ebrowse-base-classes nil #2=#:--cl-var--] 5 (#$ . 71472)])
#@153 Like `ebrowse-name/accessor-alist-for-visible-members'.
This function includes members of base classes if base class members
are visible in the buffer.
(defalias 'ebrowse-name/accessor-alist-for-class-members #[nil "\306	\306\211\203>@\307\f\n\"\244
\2037\310\f!\306	\211\2036@	\307	\n\"\244A\211\204#*A\211\204\n\306+\207" [list ebrowse-member-list-accessors func --dolist-tail-- ebrowse--displayed-class ebrowse--show-inherited-flag nil ebrowse-name/accessor-alist ebrowse-base-classes class] 5 (#$ . 72184)])
(defvar ebrowse-n-boxes 0)
(defconst ebrowse-max-boxes 60)
#@142 Display a progress indicator.
TITLE is the title of the progress message.  START non-nil means
this is the first progress message displayed.
(defalias 'ebrowse-show-progress #[(title &optional start) "\305	\203\306\307\nT\"\310\311\f\312\313\n\314 \203\315\202\316\"\317\320##)\207" [message-log-max start ebrowse-n-boxes ebrowse-max-boxes title nil 0 mod message "%s: %s" propertize make-string display-color-p 32 43 face ebrowse-progress] 7 (#$ . 72787)])
#@205 Read `ebrowse-hs' and `ebrowse-ts' structures in the current buffer.
Return a list (HEADER TREE) where HEADER is the file header read
and TREE is a list of `ebrowse-ts' structures forming the class tree.
(defalias 'ebrowse-read #[nil "\3061\307p!0\202\210\310\311!\312\313	!\203'	G\314Y\203'	\315H\n>\204+\310\311!\210	\315H\n>\204:\316\317\320	D\"\210	\321H\230\204Y\310\322	\315H\n>\204S\316\317\320	D\"\210	\321H#\210\323\324\312w\210m\204\210\307p!\325
\"\326\327?\"\210\203\200
\240\210\202\204
B*\202[)\330 \210	*D\207" [tree header cl-struct-ebrowse-hs-tags ebrowse-version-string gc-cons-threshold root (error) read error "No Ebrowse file header found" nil vectorp 5 0 signal wrong-type-argument ebrowse-hs 1 "File has wrong version `%s' (`%s' expected)" 2000000 " 	\n
" ebrowse-class-in-tree ebrowse-show-progress "Reading data" garbage-collect old-root-ptr] 6 (#$ . 73262)])
#@150 Function installed as `revert-buffer-function' in tree buffers.
See that variable's documentation for the meaning of IGNORE-AUTO-SAVE and
NOCONFIRM.
(defalias 'ebrowse-revert-tree-buffer-from-file #[(_ignore-auto-save noconfirm) "\204\n\303\304!\205\305\306\307 \"\210\310 \210\311	\206\n!\210\312 \210p\207" [noconfirm buffer-file-name ebrowse--tags-file-name yes-or-no-p "Revert tree from disk? " mapc kill-buffer ebrowse-same-tree-member-buffer-list erase-buffer insert-file ebrowse-tree-mode] 3 (#$ . 74185)])
#@267 Create a new tree buffer for tree TREE.
The tree was loaded from file TAGS-FILE.
HEADER is the header structure of the file.
CLASSES is an obarray with a symbol for each class in the tree.
POP non-nil means popup the buffer up at the end.
Return the buffer created.
(defalias 'ebrowse-create-tree-buffer #[(tree tags-file header classes pop) "\306	!q\210\307 \210\n\f\310\311 \210\312\310!\210\313\267\2022\314	!\210\2022\315	!\210p)\207" [ebrowse-tree-buffer-name name tree ebrowse--tree tags-file ebrowse--tags-file-name get-buffer-create ebrowse-tree-mode nil ebrowse-redraw-tree set-buffer-modified-p #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (switch 39 pop 46)) switch-to-buffer pop-to-buffer classes ebrowse--tree-obarray header ebrowse--header ebrowse--frozen-flag pop] 2 (#$ . 74712)])
#@595 Return an obarray holding all members of all classes in the current tree.

For each member, a symbol is added to the obarray.  Members are
extracted from the buffer-local tree `ebrowse--tree-obarray'.

Each symbol has its property `ebrowse-info' set to a list (TREE MEMBER-LIST
MEMBER) where TREE is the tree in which the member is defined,
MEMBER-LIST is a symbol describing the member list in which the member
is found, and MEMBER is a MEMBER structure describing the member.

The slot `member-table' of the buffer-local header structure of
type `ebrowse-hs' is set to the resulting obarray.
(defalias 'ebrowse-fill-member-table #[nil "\306\307\310\"\311\n\312H>\204\313\314\315\nD\"\210\n\211\316\317I\210)\320 \210\317\321\322\"\210)\n\312H>\2049\313\314\315\nD\"\210\n\211\316	I+\207" [i members ebrowse--header cl-struct-ebrowse-hs-tags #1=#:v c make-hash-table :test equal -1 0 signal wrong-type-argument ebrowse-hs 4 nil garbage-collect mapatoms #[(#2=#:var) "\306N\307	!\205z\nT\211\310\246\311U\203\312\313\n\311U\"\210\314\211\205y
@\211	!\314\211\203p
@\211\311H>\204G\315\316\317D\"\210\320H\321\"	\fEB\322#\210*
A\211\2042*
A\211\204$\314*\207" [#2# c i ebrowse-member-list-accessors f --dolist-tail-- ebrowse-root vectorp 10 0 ebrowse-show-progress "Preparing member lookup" nil signal wrong-type-argument ebrowse-ms 1 gethash puthash m cl-struct-ebrowse-ms-tags member-name members value] 5] ebrowse--tree-obarray #3=#:v] 5 (#$ . 75574)])
#@123 Return the member obarray.  Build it if it hasn't been set up yet.
HEADER is the tree header structure of the class tree.
(defalias 'ebrowse-member-table #[(header) "\304H	>\204\305\306\307D\"\210\310H\204:\311 \312\n:\2032\n@\313\314\"=\2042\nA\211\202rq\210\315 \210+\304H	>\204I\305\306\307D\"\210\310H\207" [header cl-struct-ebrowse-hs-tags #1=#:--cl-var-- buffer 0 signal wrong-type-argument ebrowse-hs 4 ebrowse-browser-buffer-list nil buffer-local-value ebrowse--header ebrowse-fill-member-table] 5 (#$ . 77097)])
#@104 Make sure every class in TREE is represented by a unique object.
Build obarray of all classes in TREE.
(defalias 'ebrowse-build-tree-obarray #[(tree) "\306\307\310\"	\311\211\n:\203\243\n@\312\310H
>\204#\313\314\315D\"\210\316H\211\310H>\2049\313\314\317D\"\210\320H\203q\310H>\204R\313\314\317D\"\210\320H\321\310H>\204i\313\314\317D\"\210\316HQ\202\207\310H>\204\203\313\314\317D\"\210\316H)\"\211\322N\204\234\f\323\322#\210)\nA\211\202\f+\324	\"\210)\207" [classes tree #1=#:--cl-var-- root sym cl-struct-ebrowse-ts-tags make-vector 127 0 nil intern signal wrong-type-argument ebrowse-ts 1 ebrowse-cs 2 "::" ebrowse-root put ebrowse-insert-supers class cl-struct-ebrowse-cs-tags #2=#:v] 8 (#$ . 77646)])
#@529 Build base class lists in class tree TREE.
CLASSES is an obarray used to collect classes.

Helper function for `ebrowse-build-tree-obarray'.  Base classes should
be ordered so that immediate base classes come first, then the base
class of the immediate base class and so on.  This means that we must
construct the base-class list top down with adding each level at the
beginning of the base-class list.

We have to be cautious here not to end up in an infinite recursion
if for some reason a circle is in the inheritance graph.
(defalias 'ebrowse-insert-supers #[(tree classes) "\306\211	:\203\331	@\211\307H\f>\204\310\311\312\nD\"\210\n\313H\211\306\211
:\203\313\314
@\307H\f>\204@\310\311\312
@D\"\210
@\315H\211\307H>\204U\310\311\316\nD\"\210\n\313H\203\206\n\307H>\204k\310\311\316\nD\"\210\n\313H\317\n\307H>\204\310\311\316\nD\"\210\n\315HQ\202\231\n\307H>\204\226\310\311\316\nD\"\210\n\315H)\"\306\320N\203\267
\211\320N\240\210)\202\304\321\320
@#\210)
A\211\202*+\322\"\210	A\211\202+\306\207" [tree #1=#:--cl-var-- class subclasses cl-struct-ebrowse-ts-tags subclass nil 0 signal wrong-type-argument ebrowse-ts 2 intern 1 ebrowse-cs "::" ebrowse-root put ebrowse-insert-supers sym next cl-struct-ebrowse-cs-tags classes #2=#:v #3=#:v] 8 (#$ . 78422)])
(byte-code "\204\342\303 \211\304	!\210\305 \203$\306	\307\310#\210\306	\311\312#\210\306	\313\314#\210\315 \304\n\316\"\210\306	\317\n#\210\306\n\320\321#\210\306\n\322\323#\210\306\n\324\325#\210\306\n\326\327#\210\306\n\330\331#\210\306\n\332\333#\210)\315 \304\n\316\"\210\306	\334\n#\210\306\n\335\336#\210\306\n\326\337#\210)\315 \304\n\316\"\210\306	\340\n#\210\306\n\322\341#\210\306\n\342\343#\210\306\n\344\345#\210\306	\346\347#\210)\306	\350\351#\210\306	\352\353#\210\306	\354\355#\210\306	\356\357#\210\306	\360\361#\210\306	\362\363#\210\306	\364\365#\210\306	\366\367#\210\306	\370\371#\210\306	\372\373#\210\306	\374\375#\210\306	\376\377#\210)\303\207" [ebrowse-tree-mode-map map map1 make-keymap suppress-keymap display-mouse-p define-key [down-mouse-3] ebrowse-mouse-3-in-tree-buffer [mouse-2] ebrowse-mouse-2-in-tree-buffer [down-mouse-1] ebrowse-mouse-1-in-tree-buffer make-sparse-keymap t "L" "d" ebrowse-tree-command:show-friends "f" ebrowse-tree-command:show-member-functions "F" ebrowse-tree-command:show-static-member-functions "t" ebrowse-tree-command:show-types "v" ebrowse-tree-command:show-member-variables "V" ebrowse-tree-command:show-static-member-variables "M" "a" ebrowse-mark-all-classes ebrowse-toggle-mark-at-point "T" ebrowse-toggle-file-name-display "s" ebrowse-show-file-name-at-point "w" ebrowse-set-tree-indentation "x" ebrowse-statistics "n" ebrowse-repeat-member-search "q" bury-buffer "*" ebrowse-expand-all "+" ebrowse-expand-branch "-" ebrowse-collapse-branch "/" ebrowse-read-class-name-and-go " " ebrowse-view-class-declaration "?" describe-mode "	" ebrowse-pop/switch-to-member-buffer-for-same-tree "" ebrowse-remove-class-at-point "\f" ebrowse-redraw-tree "
" ebrowse-find-class-declaration] 5)
(defvar ebrowse-tree-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [ebrowse-tree-mode-hook variable-documentation put "Hook run after entering Ebrowse-Tree mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp ebrowse-tree-mode-map definition-name ebrowse-tree-mode] 4)
(defvar ebrowse-tree-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [ebrowse-tree-mode-abbrev-table ebrowse-tree-mode-map variable-documentation put purecopy "Keymap for `ebrowse-tree-mode'." boundp ebrowse-tree-mode-syntax-table definition-name ebrowse-tree-mode (lambda (#1=#:def-tmp-var) (defvar ebrowse-tree-mode-syntax-table #1#)) make-syntax-table "Syntax table for `ebrowse-tree-mode'." (lambda (#1#) (defvar ebrowse-tree-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `ebrowse-tree-mode'." derived-mode-parent special-mode] 5)
#@514 Major mode for Ebrowse class tree buffers.
Each line corresponds to a class in a class tree.
Letters do not insert themselves, they are commands.
File operations in the tree buffer work on class tree data structures.
E.g.\[save-buffer] writes the tree to the file it was loaded from.

Tree mode key bindings:
\{ebrowse-tree-mode-map}

In addition to any hooks its parent mode `special-mode' might have run,
this mode runs the hook `ebrowse-tree-mode-hook', as the final or penultimate step
during initialization.
(defalias 'ebrowse-tree-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324:\325\"\204V:;=\204V\326:\325;C#\210\327!\210\330\f!\210:;\331\332!<\307=\333\211>?\334 \210\335 \336U\204\235eb\210\337 \211@@>@A@?)\340\341!\210\342?!?\343 \210\340\333!\210\306\344!\210\333$\306\345!\210\346\347\336\"%\306\350!\210\333(<A\307\211BC\307D\306\351!\210\352)\306\353!\210>+\306\354!\210?,\306\355!\210E-\306\345!\210?\205\356\356?!%\306\350!\210\333(\357\360\361\333\307$\210\362\363\364\365z!\"\210?\203
\366 \210\367\333!\210-\370\371!\207" [delay-mode-hooks major-mode mode-name ebrowse-tree-mode-map ebrowse-tree-mode-syntax-table parent make-local-variable t special-mode ebrowse-tree-mode "Ebrowse-Tree" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table propertized-buffer-identification "C++ Tree" nil buffer-disable-undo buffer-size 0 ebrowse-read message "Sorting. Please be patient..." ebrowse-sort-tree-list erase-buffer ebrowse--show-file-names-flag ebrowse--tree-obarray make-vector 127 ebrowse--frozen-flag revert-buffer-function ebrowse-revert-tree-buffer-from-file ebrowse--header ebrowse--tree ebrowse--tags-file-name ebrowse-build-tree-obarray add-hook local-write-file-hooks ebrowse-write-file-hook-fn modify-syntax-entry 95 char-to-string 97 ebrowse-redraw-tree set-buffer-modified-p run-mode-hooks ebrowse-tree-mode-hook ebrowse-tree-mode-abbrev-table local-abbrev-table ident inhibit-read-only header tree #1=#:--cl-var-- mode-line-buffer-identification buffer-read-only selective-display selective-display-ellipses buffer-file-name] 6 (#$ . 82743) nil])
#@35 Update the tree buffer mode line.
(defalias 'ebrowse-update-tree-buffer-mode-line #[nil "\303\203\304	!\202\f\n!\210\305 \207" [ebrowse--frozen-flag ebrowse--tags-file-name ebrowse-tree-buffer-name ebrowse-rename-buffer ebrowse-frozen-tree-buffer-name force-mode-line-update] 3 (#$ . 85157)])
#@98 Remove from TREE class CLASS.
Kill all member buffers still containing a reference to the class.
(defalias 'ebrowse-remove-class-and-kill-member-buffers #[(tree class) "\306\307H	>\204\310\311\312D\"\210\313H\307H\n>\2042\310\311\314\307H	>\204,\310\311\312D\"\210\313HD\"\210\307H	>\204A\310\311\312D\"\210\313H\313H\"\315
\"\f\316\317\320#\210)
\320\211\203\326@\211\307H	>\204x\310\311\312D\"\210\211\321\315\307H	>\204\221\310\311\312D\"\210\321H\"I\210)\307H	>\204\252\310\311\312D\"\210\211\322\320I\210)\323\307H	>\204\306\310\311\312D\"\210\321H\"\210A\211\204c*\324!\210
)\207" [class cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags ebrowse--tree-obarray sym tree intern-soft 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs delq put ebrowse-root nil 2 9 ebrowse-remove-class-and-kill-member-buffers ebrowse-kill-member-buffers-displaying #1=#:v root --dolist-tail-- #2=#:v #3=#:v] 9 (#$ . 85460)])
#@101 Remove the class point is on from the class tree.
Do not ask for confirmation if FORCED is non-nil.
(defalias 'ebrowse-remove-class-at-point #[(forced) "\306 \211\307H	>\204\310\311\312D\"\210\313H\307H\n>\2044\310\311\314\307H	>\204.\310\311\312D\"\210\313HD\"\210\307H	>\204C\310\311\312D\"\210\313H\313H\307H	>\204X\310\311\312D\"\210\315H
\204i\316\317\320Q!\203\207\321\"\322\323!\210\324\325\f\203\326\202\200\327#\210\330 \202\212\324\331!+\207" [class cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags class-name subclasses forced ebrowse-tree-at-point 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs 2 y-or-n-p "Delete class " "? " ebrowse-remove-class-and-kill-member-buffers set-buffer-modified-p t message "%s %sdeleted." "and derived classes " "" ebrowse-redraw-tree "Aborted" ebrowse--tree] 8 (#$ . 86452) "P"])
#@98 Toggle mark for class cursor is on.
If given a numeric N-TIMES argument, mark that many classes.
(defalias 'ebrowse-toggle-mark-at-point #[(&optional n-times) "\306\3071R	\206\310\306\nS\211\311Y\205M\312 \211\311H\f>\204)\313\314\315D\"\210\211\316\311H\f>\204<\313\314\315D\"\210\316H?I\210)\310y\210B\202*0\202V\210\202W\210\212\306\317 \320\216\306\211:\203	
@\321\322\311H\f>\204\204\313\314\315D\"\210\310H\311H >\204\247\313\314\323\311H\f>\204\241\313\314\315D\"\210\310HD\"\210\311H\f>\204\266\313\314\315D\"\210\310H\310H!\324Qeb\210\325\306\326#\203
\311\224b\210\327\310!\210\330\311H\f>\204\344\313\314\315D\"\210\316H\203\356\331\202\357\332\310\"\210\333`S`#\210\311\225b\210\202\303A\211\202k.\306\207" [to-change n-times #1=#:--cl-var-- tree cl-struct-ebrowse-ts-tags #2=#:v nil (error) 1 0 ebrowse-tree-at-point signal wrong-type-argument ebrowse-ts 10 buffer-modified-p #[nil "\301!\207" [#3=#:--ebrowse-output-- set-buffer-modified-p] 2] "^.*\\b" regexp-quote ebrowse-cs "\\b" re-search-forward t delete-char insert-char 62 32 ebrowse-set-mark-props #3# buffer-read-only #4=#:--cl-var-- regexp cl-struct-ebrowse-cs-tags] 10 (#$ . 87324) "p"])
#@52 Unmark, with PREFIX mark, all classes in the tree.
(defalias 'ebrowse-mark-all-classes #[(prefix) "\302\303\304	\"\210)\305ed\"\207" [tree ebrowse--tree-obarray nil mapatoms #[(#1=#:var) "\305N\306	!\205 	\307H\n>\204\310\311\312	D\"\210	\211\313\fI)\207" [#1# tree cl-struct-ebrowse-ts-tags #2=#:v prefix ebrowse-root vectorp 0 signal wrong-type-argument ebrowse-ts 10] 5] ebrowse-redraw-marks] 3 (#$ . 88566) "P"])
#@63 Display class marker signs in the tree between START and END.
(defalias 'ebrowse-redraw-marks #[(start end) "\212\306\307 \310\216\3112+eb\210\n\306\211\205)\f@\312
	#\210\fA\211\204\306*0\210+\313 )\207" [#1=#:--ebrowse-output-- buffer-read-only ebrowse--tree root --dolist-tail-- start nil buffer-modified-p #[nil "\301!\207" [#1# set-buffer-modified-p] 2] end ebrowse-draw-marks-fn ebrowse-update-tree-buffer-mode-line] 5 (#$ . 88996) nil])
#@59 Display class marker signs in TREE between START and END.
(defalias 'ebrowse-draw-marks-fn #[(tree start end) "`Y\203-\306\307!\210	\310H\n>\204\311\312\313	D\"\210	\314H\203#\315\202$\316c\210\317`S`	#\210\307y\210`V\203;\320\303\321\"\210	\310H\n>\204J\311\312\313	D\"\210	\322H\321\211\205e
@\323\f#\210
A\211\204T\321*\207" [start tree cl-struct-ebrowse-ts-tags end sub --dolist-tail-- delete-char 1 0 signal wrong-type-argument ebrowse-ts 10 62 32 ebrowse-set-mark-props throw nil 2 ebrowse-draw-marks-fn] 5 (#$ . 89459)])
#@81 Show filename in the line point is in.
With PREFIX, insert that many filenames.
(defalias 'ebrowse-show-file-name-at-point #[(prefix) "?\205\277\306\307 \310\216\311\f
W\205\276\312 \306\211\313 \210\314\306w\210`\315\316!\317 |\210\204\231j\210\316\311H >\204Q\320\321\322D\"\210\323H\311H!>\204y\320\321\324\311H >\204r\320\321\322D\"\210\323HD\"\210\311H >\204\213\320\321\322D\"\210\323H\325H\206\225\326\327\261\210`\330\"\331\332\"\"\333#+\210\313 \210\323y\210+\fT\211\202-\207" [ebrowse--show-file-names-flag #1=#:--ebrowse-output-- buffer-read-only prefix i --dotimes-limit-- nil buffer-modified-p #[nil "\301!\207" [#1# set-buffer-modified-p] 2] 0 ebrowse-tree-at-point beginning-of-line " 	*a-zA-Z0-9_" looking-at "(" line-end-position signal wrong-type-argument ebrowse-ts 1 ebrowse-cs 4 "unknown" ")" ebrowse-file-name overlay-put make-overlay face file-name-existing start tree ebrowse-source-file-column cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags end] 9 (#$ . 90010) "p"])
#@45 Toggle display of filenames in tree buffer.
(defalias 'ebrowse-toggle-file-name-display #[nil "?\302e`\"\303 \210eb\210	Sy)\207" [ebrowse--show-file-names-flag old-line count-lines ebrowse-redraw-tree] 3 (#$ . 91082) nil])
#@48 Value is non-nil if BUFFER is a member buffer.
(defalias 'ebrowse-member-buffer-p #[(buffer) "\301\302\303!\"A\304=\207" [buffer assoc major-mode buffer-local-variables ebrowse-member-mode] 4 (#$ . 91314)])
#@52 Value is non-nil if BUFFER is a class tree buffer.
(defalias 'ebrowse-tree-buffer-p #[(buffer) "\301\302\303!\"A\304=\207" [buffer assoc major-mode buffer-local-variables ebrowse-tree-mode] 4 (#$ . 91528)])
#@56 Value is non-nil if BUFFER is a tree or member buffer.
(defalias 'ebrowse-buffer-p #[(buffer) "\301\302\303!\"A\304>\207" [buffer assoc major-mode buffer-local-variables (ebrowse-tree-mode ebrowse-member-mode)] 4 (#$ . 91742)])
#@46 Return a list of all tree or member buffers.
(defalias 'ebrowse-browser-buffer-list #[nil "\300\301\302 \"\207" [cl-delete-if-not ebrowse-buffer-p buffer-list] 3 (#$ . 91977)])
#@38 Return a list of all member buffers.
(defalias 'ebrowse-member-buffer-list #[nil "\300\301\302 \"\207" [cl-delete-if-not ebrowse-member-buffer-p buffer-list] 3 (#$ . 92160)])
#@36 Return a list of all tree buffers.
(defalias 'ebrowse-tree-buffer-list #[nil "\300\301\302 \"\207" [cl-delete-if-not ebrowse-tree-buffer-p buffer-list] 3 (#$ . 92341)])
#@155 Return a list of buffers containing class trees.
The list will contain, for each class tree loaded,
one buffer.  Prefer tree buffers over member buffers.
(defalias 'ebrowse-known-class-trees-buffer-list #[nil "\306 \307 \244\310 \311\211\311\211\2034\f@\312\313\"\314
	\"\204&B\315
\316	#\210)\fA\211\204*+\207" [result set buffers buffer --dolist-tail-- tree ebrowse-tree-buffer-list ebrowse-member-buffer-list make-hash-table nil buffer-local-value ebrowse--tree gethash puthash t] 5 (#$ . 92517)])
#@68 Return a list of members buffers with same tree as current buffer.
(defalias 'ebrowse-same-tree-member-buffer-list #[nil "\300\301\302 \"\207" [cl-delete-if-not #[(buffer) "\302\301\"	=\207" [buffer ebrowse--tree buffer-local-value] 3] ebrowse-member-buffer-list] 3 (#$ . 93041)])
#@109 Pop to the buffer displaying members.
Switch to buffer if prefix ARG.
If no member buffer exists, make one.
(defalias 'ebrowse-pop/switch-to-member-buffer-for-same-tree #[(arg) "\303 @\206\304!\206\305 \211\203\"\n\203\306	!\210\202\"\307	!\210	)\207" [ebrowse-member-buffer-name buf arg ebrowse-same-tree-member-buffer-list get-buffer ebrowse-tree-command:show-member-functions switch-to-buffer pop-to-buffer] 3 (#$ . 93330) "P"])
#@31 Switch to next member buffer.
(defalias 'ebrowse-switch-to-next-member-buffer #[nil "\303 p>A\211\203	@\202@\211p=\203 \304\305!\202&\306 \210\307\n!+\207" [list next-list next-buffer ebrowse-member-buffer-list error "No next buffer" bury-buffer switch-to-buffer] 3 (#$ . 93778) nil])
#@42 Kill all member buffers displaying TREE.
(defalias 'ebrowse-kill-member-buffers-displaying #[(tree) "\304 \305\211:\203%@\306\307	\"\211=\203\310	!\210A\211\202+\305\207" [#1=#:--cl-var-- buffer class tree ebrowse-member-buffer-list nil buffer-local-value ebrowse--displayed-class kill-buffer] 4 (#$ . 94080)])
#@65 Return the buffer name of a tree which is associated TAGS-FILE.
(defalias 'ebrowse-frozen-tree-buffer-name #[(tags-file) "\302	\303R\207" [ebrowse-tree-buffer-name tags-file " (" ")"] 4 (#$ . 94412)])
#@113 Pop to a browser buffer from any other buffer.
Pop to member buffer if no prefix ARG, to tree buffer otherwise.
(defalias 'ebrowse-pop-to-browser-buffer #[(arg) "\304\203		\202\n\n!\211\204\304\203\n\202	!\204$\305\306!\210\307!)\207" [arg ebrowse-tree-buffer-name ebrowse-member-buffer-name buffer get-buffer error "No browser buffer found" pop-to-buffer] 3 (#$ . 94621) "P"])
#@48 Set the indentation width of the tree display.
(defalias 'ebrowse-set-tree-indentation #[nil "\302\303\304\305!\306Q\307\211$!\211\211\310V\262
\205\311\300!\210	\312 )\207" [ebrowse--indentation width string-to-number read-string "Indentation (default " int-to-string "): " nil 0 make-local-variable ebrowse-redraw-tree] 7 (#$ . 95020) nil])
#@82 Position cursor on CLASS.
Read a class name from the minibuffer if CLASS is nil.
(defalias 'ebrowse-read-class-name-and-go #[(&optional class) "\304	\204\305\306\307 \310\304$\neb\210~\210\310\311	\311Q\312\310\304#\203-\313\224b\210\314 \2020\315\316!*\207" [completion-ignore-case class selective-display ebrowse--last-regexp t completing-read "Goto class: " ebrowse-tree-obarray-as-alist nil "\\b" re-search-forward 0 ebrowse-unhide-base-classes error "Not found"] 5 (#$ . 95375) nil])
#@68 Display member variables; with prefix ARG in frozen member buffer.
(defalias 'ebrowse-tree-command:show-member-variables #[(arg) "\301\302\"\207" [arg ebrowse-display-member-buffer ebrowse-ts-member-variables] 3 (#$ . 95880) "P"])
#@68 Display member functions; with prefix ARG in frozen member buffer.
(defalias 'ebrowse-tree-command:show-member-functions #[(&optional arg) "\301\302\"\207" [arg ebrowse-display-member-buffer ebrowse-ts-member-functions] 3 (#$ . 96118) "P"])
#@75 Display static member variables; with prefix ARG in frozen member buffer.
(defalias 'ebrowse-tree-command:show-static-member-variables #[(arg) "\301\302\"\207" [arg ebrowse-display-member-buffer ebrowse-ts-static-variables] 3 (#$ . 96366) "P"])
#@75 Display static member functions; with prefix ARG in frozen member buffer.
(defalias 'ebrowse-tree-command:show-static-member-functions #[(arg) "\301\302\"\207" [arg ebrowse-display-member-buffer ebrowse-ts-static-functions] 3 (#$ . 96618) "P"])
#@68 Display friend functions; with prefix ARG in frozen member buffer.
(defalias 'ebrowse-tree-command:show-friends #[(arg) "\301\302\"\207" [arg ebrowse-display-member-buffer ebrowse-ts-friends] 3 (#$ . 96870) "P"])
#@76 Display types defined in a class; with prefix ARG in frozen member buffer.
(defalias 'ebrowse-tree-command:show-types #[(arg) "\301\302\"\207" [arg ebrowse-display-member-buffer ebrowse-ts-types] 3 (#$ . 97090) "P"])
#@55 Return the class structure for the class point is on.
(defalias 'ebrowse-tree-at-point #[nil "\300`\301\"\206\n\302\303!\207" [get-text-property ebrowse-tree error "Not on a class"] 3 (#$ . 97314)])
#@141 View or find the declarator of the class point is on.
VIEW non-nil means view it.  WHERE is additional position info.

(fn &key VIEW WHERE)
(defalias 'ebrowse-view/find-class-declaration #[(&rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\203:@\311>\203#AA\211\202\312>A@\2031\313\211\202\314\315@\"\210\202)\316 \211\317H
>\204M\320\321\322\fD\"\210\f\323H)\211\317H>\204d\320\321\324D\"\210\325H\326\327\317H>\204~\320\321\324D\"\210\323H\313\317H>\204\225\320\321\324D\"\210\330H\317H>\204\253\320\321\324D\"\210\325H\317H>\204\301\320\321\324D\"\210\331H\317H>\204\327\320\321\324D\"\210\332H&\333 \313E!	\n&-\207" [#1# view where #2=#:--cl-keys-- cl-x cl-struct-ebrowse-ts-tags plist-member :view :where (:view :where :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:view :where)" ebrowse-tree-at-point 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs 4 vector ebrowse-bs 3 5 6 ebrowse-view/find-file-and-search-pattern class cl-struct-ebrowse-cs-tags file browse-struct ebrowse--header ebrowse--tags-file-name] 12 (#$ . 97521)])
#@136 Find a class declaration and position cursor on it.
PREFIX 4 means find it in another window.
PREFIX 5 means find it in another frame.
(defalias 'ebrowse-find-class-declaration #[(prefix) "\301\302\303\304\305U\203\306\202\307U\203\310\202\311$\207" [prefix ebrowse-view/find-class-declaration :view nil :where 4 other-window 5 other-frame this-window] 6 (#$ . 98692) "p"])
#@134 View class declaration and position cursor on it.
PREFIX 4 means view it in another window.
PREFIX 5 means view it in another frame.
(defalias 'ebrowse-view-class-declaration #[(prefix) "\301\302\303\304\305U\203\306\202\307U\203\310\202\311$\207" [prefix ebrowse-view/find-class-declaration :view view :where 4 other-window 5 other-frame this-window] 6 (#$ . 99083) "p"])
#@214 Find source file FILE.
Source files are searched for (a) relative to TAGS-FILE
which is the path of the BROWSE file from which the class tree was loaded,
and (b) in the directories named in `ebrowse-search-path'.
(defalias 'ebrowse-find-source-file #[(file tags-file) "\306\307\310	!\"\311\n!\203\n\2024\f
\2033\2043\307
@\"\311\n!\203,\n
A)\202)\204=\312\313\"\210*\207" [file tags-file try-file file-name ebrowse-search-path search-in nil expand-file-name file-name-directory file-readable-p error "File `%s' not found"] 5 (#$ . 99473)])
#@148 Function called when exiting View mode in BUFFER.
Restore frame configuration active before viewing the file,
and possibly kill the viewed buffer.
(defalias 'ebrowse-view-exit-fn #[(buffer) "\306\211r\nq\210\f)\307\310\311 \306\211\n
:\2035
@\211\n\236\204.\nB
A\211\202\237+\"\210	\205B	\n!*\207" [original-frame-configuration exit-action buffer ebrowse--frame-configuration ebrowse--view-exit-action #1=#:--cl-var-- nil mapc delete-frame frame-list frame #2=#:--cl-var--] 5 (#$ . 100042)])
#@107 View a file FILE in another frame.
The new frame is deleted when you quit viewing the file in that frame.
(defalias 'ebrowse-view-file-other-frame #[(file) "\306 \307!\310!\311	!\210\312\304!\210\312\305!\210\n?\205&\313	!?\205&\314\315\316 \316 \317BB\320\"+\207" [file buf-to-view had-a-buf old-frame-configuration ebrowse--frame-configuration ebrowse--view-exit-action current-frame-configuration get-file-buffer find-file-noselect switch-to-buffer-other-frame make-local-variable buffer-modified-p kill-buffer view-mode-enter selected-window t ebrowse-view-exit-fn] 4 (#$ . 100565) nil])
#@841 Find or view a member or class.
STRUC is an `ebrowse-bs' structure (or a structure including that)
describing what to search.
INFO is a list (HEADER MEMBER-OR-CLASS ACCESSOR).  HEADER is the
header structure of a class tree.  MEMBER-OR-CLASS is either an
`ebrowse-ms' or `ebrowse-cs' structure depending on what is searched.
ACCESSOR is an accessor function for the member list of a member
if MEMBER-OR-CLASS is an `ebrowse-ms'.
FILE is the file to search the member in.
FILE is not taken out of STRUC here because the filename in STRUC
may be nil in which case the filename of the class description is used.
TAGS-FILE is the name of the BROWSE file from which the
tree was loaded.
If VIEW is non-nil, view file else find the file.
WHERE is either `other-window', `other-frame' or `this-window' and
specifies where to find/view the result.
(defalias 'ebrowse-view/find-file-and-search-pattern #[(struc info file tags-file &optional view where) "\204\306\307	\310H\n>\204\311\312\313	D\"\210	\314H\"\210\315\"\316 \203&\317
\203R	\320\321!\204:\322\323B\f\324\267\202N\325!\207\326!\207\327!\207\f\330\267\202f\331!\210\202j\332!\210\202j\333!\210\323	\"\207" [file struc cl-struct-ebrowse-bs-tags tags-file where view error "Sorry, no file information available for %s" 0 signal wrong-type-argument ebrowse-bs 1 ebrowse-find-source-file window-dedicated-p other-window boundp view-mode-hook nil ebrowse-find-pattern #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (other-window 70 other-frame 74)) view-file-other-window ebrowse-view-file-other-frame view-file #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (other-window 88 other-frame 95)) find-file-other-window find-file-other-frame find-file ebrowse-temp-position-to-view info ebrowse-temp-info-to-view] 6 (#$ . 101174)])
#@318 Generate a suitable regular expression for a member or class NAME.
This is `regexp-quote' for most symbols, except for operator names
which may contain whitespace.  For these symbols, replace white
space in the symbol name (generated by BROWSE) with a regular
expression matching any number of whitespace characters.
(defalias 'ebrowse-symbol-regexp #[(name) "\303!\304\305\306	\n#\203#	\304\211\224O\307	\304\225\310OQ\304\224\311\\\202	*\207" [name regexp start regexp-quote 0 string-match "[ 	]+" "[ 	]*" nil 5] 5 (#$ . 103069)])
#@53 Construct a regexp for a declaration of class NAME.
(defalias 'ebrowse-class-declaration-regexp #[(name) "\301\302\303!\304R\207" [name "^[ 	]*\\(template[ 	\n]*<.*>\\)?" "[ 	\n]*\\(class\\|struct\\|union\\).*\\S_" ebrowse-symbol-regexp "\\S_"] 4 (#$ . 103616)])
#@50 Construct a regexp for matching a variable NAME.
(defalias 'ebrowse-variable-declaration-regexp #[(name) "\301\302!\301Q\207" [name "\\S_" ebrowse-symbol-regexp] 3 (#$ . 103886)])
#@50 Construct a regexp for matching a function NAME.
(defalias 'ebrowse-function-declaration/definition-regexp #[(name) "\301\302!\303Q\207" [name "^[a-zA-Z0-9_:*&<>, 	]*\\S_" ebrowse-symbol-regexp "[ 	\n]*("] 3 (#$ . 104073)])
#@47 Construct a regexp matching a define of NAME.
(defalias 'ebrowse-pp-define-regexp #[(name) "\301\302!P\207" [name "^[ 	]*#[ 	]*define[ 	]+" regexp-quote] 3 (#$ . 104304)])
#@346 Find a pattern.

This is a kluge: Ebrowse allows you to find or view a file containing
a pattern.  To be able to do a search in a viewed buffer,
`view-mode-hook' is temporarily set to this function;
`ebrowse-temp-position-to-view' holds what to search for.

INFO is a list (TREE-HEADER TREE-OR-MEMBER MEMBER-LIST).

(fn &optional POSITION INFO)
(defalias 'ebrowse-find-pattern #[(&optional position info &rest #1=#:--cl-rest--) "\306	\203\307\310\311\312	G\\D\"\210\n\204 \210A\313\f
.~\210\n\314H/>\2042\307\315\316\nD\"\210\n\317H0\n\314H/>\204G\307\315\316\nD\"\210\n\320H1\3212\3063.@4.A\2115@65A\2117@87A9864:;<0;\203\210\322\3230!P00\204Q
\324;!\203!
;G\325Y\203!
;\314H=>\203!
<\326>\203\305\327\n\314H/>\204\276\307\315\316\nD\"\210\n\330H!\202
;\211>\331?>\332>\314H/>\204\342\307\315\316>D\"\210>\333H?\"\314U+\204
\334\n\314H/>\204
\307\315\316\nD\"\210\n\330H!\202
\335\n\314H/>\204
\307\315\316\nD\"\210\n\330H!0\202Q
\324;!\203Q
;G\336Y\203Q
;\314H@>\203Q
\337\n\314H/>\204K
\307\315\316\nD\"\210\n\330H!0\340\341!\203i
\341J\203i
\342\343\3441\"!\210\3420!\210\313A\306Be12Z]b\210\345012\\\313#\203\217
\313B\306\211A\202\220
\313\203\244
o?\211A\203\244
2\211\\2\202o
A\203\255
\313\202\257
B*\2113\203\277
\346 \210\347\350!\202	\n\314H/>\204\317
\307\315\316\nD\"\210\n\317H\247\203\357
1b\210)\203\345
\347\351!\202	\352\353!\210\354\312!\202	)\203\372
\347\351!\202	\204\355\353!\210\352\353!\210\354\312!.\207" [viewing #1# position view-mode-hook ebrowse-temp-position-to-view ebrowse-temp-info-to-view nil signal wrong-number-of-arguments ebrowse-find-pattern 2 t 0 wrong-type-argument ebrowse-bs 5 6 100 "^.*" regexp-quote vectorp 11 (ebrowse-ts-types ebrowse-ts-static-variables ebrowse-ts-member-variables) ebrowse-variable-declaration-regexp 1 512 logand 3 ebrowse-pp-define-regexp ebrowse-function-declaration/definition-regexp 8 ebrowse-class-declaration-regexp boundp ebrowse-debug y-or-n-p format "start = %d? " re-search-forward beginning-of-line run-hooks ebrowse-view/find-hook ebrowse-not-found-hook message "Not found" sit-for error info cl-struct-ebrowse-bs-tags pattern start offset found #2=#:x0 #3=#:x1 #4=#:x2 #5=#:x3 #6=#:x4 #7=#:x5 header class-or-member member-list cl-struct-ebrowse-ms-tags member bit cl-struct-ebrowse-cs-tags #8=#:--cl-var-- #9=#:--cl-var--] 6 (#$ . 104484)])
#@85 Redisplay the complete tree.
QUIETLY non-nil means don't display progress messages.
(defalias 'ebrowse-redraw-tree #[(&optional quietly) "\204\303\304!\210\212\305\306 \307\216\310 \210\311 \210,\312 \210\206!\303\305!\207" [quietly #1=#:--ebrowse-output-- buffer-read-only message "Displaying..." nil buffer-modified-p #[nil "\301!\207" [#1# set-buffer-modified-p] 2] erase-buffer ebrowse-draw-tree-fn ebrowse-update-tree-buffer-mode-line] 2 (#$ . 106914) nil])
#@97 Set text properties for class marker signs between START and END.
TREE denotes the class shown.
(defalias 'ebrowse-set-mark-props #[(start end tree) "\304	\305\306\307\310\311\n\312BBBBBB#\210	\313\314\315	\"\303#+\207" [start end tree face add-text-properties mouse-face highlight ebrowse-what mark ebrowse-tree (help-echo "double-mouse-1: mark/unmark") ebrowse-tree-mark overlay-put make-overlay] 10 (#$ . 107391)])
#@121 Display a single class and recursively its subclasses.
This function may look weird, but this is faster than recursion.
(defalias 'ebrowse-draw-tree-fn #[nil "\306\211\306\307G\310\"\311!\306\211\306,	\203\316
\211A\242	\211A\242\211\310H->\2047\312\313\314
D\"\210
\315H,`\306\211./0
\310H->\204U\312\313\314
D\"\210
\316H\203_\317\202`\320c\210\f1_2\\j\210`,\211,\310H3>\204\202\312\313\321,D\"\210,\322H\203\272,\310H3>\204\233\312\313\321,D\"\210,\322H\323,\310H3>\204\262\312\313\321,D\"\210,\315HQ\202\320,\310H3>\204\314\312\313\321,D\"\210,\315H)c\210,\2114\32454\3254\310H6>\204\360\312\313\3264D\"\2104\327H5\"\310U+\204
\330c\210\n`\f\310U\203\f
\331\202

\3327\333\334\n7\"\335#+\210\n/`.8\203b
9j\210`\336,\310H3>\204B
\312\313\321,D\"\210,\337H\206J
\340\341\261\210\n`\3427\333\334\n7\"\335#+\210\3430\211T
#\210\344/.\345\346\347\350\351
\352BBBBBB#\210\353c\210+
\310H->\204\222
\312\313\314
D\"\210
\322H\203\311
\310H->\204\251
\312\313\314
D\"\210
\322H!	\244\307
\310H->\204\301
\312\313\314
D\"\210
\322HG\fT\"\244\202.\306\207" [stack1 stack2 start ebrowse--tree level tree nil make-list 0 copy-sequence signal wrong-type-argument ebrowse-ts 1 10 ">" " " ebrowse-cs 2 "::" 32 logand ebrowse-bs 3 "<>" ebrowse-root-class ebrowse-default overlay-put make-overlay face "(" 4 "unknown" ")" ebrowse-file-name ebrowse-set-mark-props add-text-properties mouse-face highlight ebrowse-what class-name ebrowse-tree (help-echo "double-mouse-1: (un)expand tree; mouse-2: member functions, mouse-3: menu") "\n" class cl-struct-ebrowse-ts-tags end-of-class-name start-of-class-name start-of-line ebrowse--indentation ebrowse-tree-left-margin cl-struct-ebrowse-cs-tags member bit cl-struct-ebrowse-bs-tags end ebrowse--show-file-names-flag ebrowse-source-file-column] 11 (#$ . 107823)])
#@94 Expand a sub-tree that has been previously collapsed.
With prefix ARG, expand all sub-trees.
(defalias 'ebrowse-expand-branch #[(arg) "\203\301!\207\302\303!\207" [arg ebrowse-expand-all ebrowse-collapse-fn nil] 2 (#$ . 109724) "P"])
#@140 Fold (do no longer display) the subclasses of the current class.
(The class cursor is on.)  With prefix ARG, fold all trees in the buffer.
(defalias 'ebrowse-collapse-branch #[(arg) "\203	\301?!\207\302\303!\207" [arg ebrowse-expand-all ebrowse-collapse-fn t] 2 (#$ . 109969) "P"])
#@75 Expand or fold all trees in the buffer.
COLLAPSE non-nil means fold them.
(defalias 'ebrowse-expand-all #[(collapse) "\203\305\202	\306\203\307\202\310\311\312 \313\216\212eb\210\n\311w\210m?\205D\2032\314\315!\2039\316\317!\210	c\210\203\315\311w\210\202.\207" [collapse insertion line-end #1=#:--ebrowse-output-- buffer-read-only "^\n" "^
" "
" "\n" nil buffer-modified-p #[nil "\301!\207" [#1# set-buffer-modified-p] 2] looking-at "\n " delete-char 1] 2 (#$ . 110260) "P"])
#@56 Unhide the line the cursor is on and all base classes.
(defalias 'ebrowse-unhide-base-classes #[nil "\304\305 \306\216\212\304\211\307\304x\210\310\311!?\205R\312\304w\210\n\203%\313V\205R\314\315\304\316#\205R\317\225\317\224Z\n\203=\nW\203L\310\320!\203L\321\313!\210\322c\210\323u\210\202.\207" [#1=#:--ebrowse-output-- buffer-read-only last-indent indent nil buffer-modified-p #[nil "\301!\207" [#1# set-buffer-modified-p] 2] "^
\n" looking-at "[
\n][^ 	]" "
\n 	" 1 re-search-backward "[
\n][ 	]*" t 0 "
" delete-char 10 -1] 4 (#$ . 110767)])
#@67 Hide/show a single line in the tree.
COLLAPSE non-nil means hide.
(defalias 'ebrowse-hide-line #[(collapse) "\212\303\304 \305\216\306\303w\210\307\310!\210\n\203\311\202\312c,\207" [#1=#:--ebrowse-output-- buffer-read-only collapse nil buffer-modified-p #[nil "\301!\207" [#1# set-buffer-modified-p] 2] "^
\n" delete-char 1 13 10] 2 (#$ . 111341)])
#@86 Collapse or expand a branch of the tree.
COLLAPSE non-nil means collapse the branch.
(defalias 'ebrowse-collapse-fn #[(collapse) "\304\305 \306\216\212\307 \210\310\304w\210im?\2059\212\311\304w\210`Tb\210\310\304w\210i\nV)\2059\312!\210\311\304w\210`Tb\210\202-\207" [#1=#:--ebrowse-output-- buffer-read-only indentation collapse nil buffer-modified-p #[nil "\301!\207" [#1# set-buffer-modified-p] 2] beginning-of-line "> 	" "^
\n" ebrowse-hide-line] 2 (#$ . 111704)])
#@53 Keymap used in electric Ebrowse buffer list window.
(defvar ebrowse-electric-list-mode-map nil (#$ . 112189))
(byte-code "\204\231\303 \303 \211\304\nA@\305\"\210\304	A@\305\"\210\306\n\307	#\210\306\n\310\311#\210\306\n\312\313#\210\306\n\314\315#\210\306\n\316\317#\210\306\n\320\321#\210\306\n\322\321#\210\306\n\323\324#\210\306\n\325\326#\210\306\n\327\330#\210\306\n\331\332#\210\306\n\333\334#\210\306\n\335\332#\210\306\n\336\334#\210\306\n\337\340#\210\306\n\341\342#\210\306\n\343\344#\210\306\n\345\346#\210\306\n\347\350#\210\306\n\351\352#\210\306\n\347\350#\210*\353\354\355\356#\210\353\305\357\360#\207" [ebrowse-electric-list-mode-map submap map make-keymap fillarray ebrowse-electric-list-undefined define-key "" "" suspend-frame "" Helper-help "?" Helper-describe-bindings "" nil "" ebrowse-electric-list-quit "q" " " ebrowse-electric-list-select "\f" recenter "" universal-argument "" previous-line "" next-line "p" "n" "v" ebrowse-electric-view-buffer "" scroll-up-command "v" scroll-down-command "" scroll-other-window ">" end-of-buffer "<" beginning-of-buffer put ebrowse-electric-list-mode mode-class special suppress-keymap t] 5)
(defvar ebrowse-electric-list-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [ebrowse-electric-list-mode-hook variable-documentation put "Hook run after entering Electric Position Menu mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp ebrowse-electric-list-mode-map definition-name ebrowse-electric-list-mode] 4)
(defvar ebrowse-electric-list-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\317#\207" [ebrowse-electric-list-mode-abbrev-table ebrowse-electric-list-mode-map variable-documentation put purecopy "Keymap for `ebrowse-electric-list-mode'." boundp ebrowse-electric-list-mode-syntax-table definition-name ebrowse-electric-list-mode (lambda (#1=#:def-tmp-var) (defvar ebrowse-electric-list-mode-syntax-table #1#)) make-syntax-table "Syntax table for `ebrowse-electric-list-mode'." (lambda (#1#) (defvar ebrowse-electric-list-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `ebrowse-electric-list-mode'." derived-mode-parent] 5)
#@186 Mode for electric tree list mode.

This mode runs the hook `ebrowse-electric-list-mode-hook', as the final or penultimate step
during initialization.

\{ebrowse-electric-list-mode-map}
(defalias 'ebrowse-electric-list-mode #[nil "\306\300!\210\307\310 \210\311\312\313!\210\314\f!\210
\315\302>\203/\316!\302>\317\240\210\306\320!\210\321\307\211)\322\323!\207" [delay-mode-hooks major-mode mode-name ebrowse-electric-list-mode-map ebrowse-electric-list-mode-syntax-table ebrowse-electric-list-mode-abbrev-table make-local-variable t kill-all-local-variables ebrowse-electric-list-mode "Electric Position Menu" use-local-map set-syntax-table "Electric Tree Menu" copy-sequence "Tree Buffers" Helper-return-blurb "return to buffer editing" run-mode-hooks ebrowse-electric-list-mode-hook local-abbrev-table mode-line-buffer-identification mode-line-format truncate-lines buffer-read-only] 3 (#$ . 114725) nil])
#@37 Display a list of all tree buffers.
(defalias 'ebrowse-list-tree-buffers #[nil "\303\304!q\210\305\306 \210\307\310\261\210\311 \305\211\203)\n@\312	!\313\261\210\nA\211\204*\314\211\207" [buffer-read-only buffer --dolist-tail-- get-buffer-create "*Tree Buffers*" nil erase-buffer "Tree\n" "----\n" ebrowse-known-class-trees-buffer-list buffer-name "\n" t] 3 (#$ . 115663)])
#@72 Return a buffer containing a tree or nil if no tree found or canceled.
(defalias 'ebrowse-electric-choose-tree #[nil "\306 @\204\n\307\310!\210\311\211\211\312 \313\216\312 \314\216\315 \210*\316\317!\320!\321!\210\322\216	q\210\323 \210\3242^\325\326!\210eb\210\327y\210`db\210\330y\210`\331\211 b\210\332\324\311\333\334 B%+0+\n\203k	q\210\335\n!\336	!\210\n+\207" [window buffer select #1=#:wconfig #2=#:wconfig goal-column ebrowse-known-class-trees-buffer-list error "No tree buffers" nil current-window-configuration #[nil "\301!\207" [#1# set-window-configuration] 2] #[nil "\301!\207" [#2# set-window-configuration] 2] ebrowse-list-tree-buffers Electric-pop-up-window "*Tree Buffers*" window-buffer shrink-window-if-larger-than-buffer #[nil "q\210\301!\210\302\303!\207" [buffer bury-buffer message nil] 2] ebrowse-electric-list-mode ebrowse-electric-list-select message "<<< Press Space to bury the list >>>" 2 -1 0 Electric-command-loop t ebrowse-electric-list-looper ebrowse-electric-get-buffer kill-buffer last first] 8 (#$ . 116055) nil])
#@161 Prevent cursor from moving beyond the buffer end.
Don't let it move into the title lines.
See `Electric-command-loop' for a description of STATE and CONDITION.
(defalias 'ebrowse-electric-list-looper #[(state condition) "\203@\302>\204\303@A\"\207`	@W\203eb\210\304y\207`	AV\2055db\210\305y\210\306d!\2055\307\305!\207" [condition state (buffer-read-only end-of-buffer beginning-of-buffer) signal 2 -1 pos-visible-in-window-p recenter] 3 (#$ . 117138)])
#@46 Function called for keys that are undefined.
(defalias 'ebrowse-electric-list-undefined #[nil "\300\301!\210\302\303!\207" [message "Type C-h for help, ? for commands, q to quit, Space to select." sit-for 4] 2 (#$ . 117610) nil])
#@26 Discard the buffer list.
(defalias 'ebrowse-electric-list-quit #[nil "\300\301\302\"\207" [throw ebrowse-electric-list-select nil] 3 (#$ . 117846) nil])
#@39 Select a buffer from the buffer list.
(defalias 'ebrowse-electric-list-select #[nil "\300\301`\"\207" [throw ebrowse-electric-list-select] 3 (#$ . 118005) nil])
#@53 Get a buffer corresponding to the line POINT is in.
(defalias 'ebrowse-electric-get-buffer #[(point) "\302e\"\303Z\211\304 8)\207" [point index count-lines 2 ebrowse-known-class-trees-buffer-list] 4 (#$ . 118172)])
#@26 View buffer point is on.
(defalias 'ebrowse-electric-view-buffer #[nil "\301`!\211\203\302!\202\303\304!)\207" [buffer ebrowse-electric-get-buffer view-buffer error "Buffer no longer exists"] 3 (#$ . 118395) nil])
#@72 Read a browser buffer name from the minibuffer and return that buffer.
(defalias 'ebrowse-choose-from-browser-buffers #[nil "\303 \211\203A@\204@\2020\304 \2060\305\306!\2020\307\310\311\312\211\307$\212\313\n!\210)\314\n!*)\207" [buffers insert-default-directory file ebrowse-known-class-trees-buffer-list ebrowse-electric-choose-tree error "No tree buffer" t read-file-name "Find tree: " nil find-file find-buffer-visiting] 6 (#$ . 118621)])
(byte-code "\204\215
\304 \211\305	!\210\306 \203\307	\310\311#\210\307	\312\313#\210\314 \305\n\315\"\210\307	\316\n#\210\307\n\317\320#\210\307\n\321\322#\210\307\n\323\324#\210\307\n\325\326#\210\307\n\327\330#\210)\314 \305\n\315\"\210\307	\331\n#\210\307\n\332\333#\210\307\n\317\334#\210\307\n\335\336#\210\307\n\337\340#\210\307\n\341\342#\210\307\n\343\344#\210)\314 \305\n\315\"\210\307	\345\n#\210\314 \305\315\"\210\307\n\332#\210\307\346\347#\210\307\350\351#\210\307\352\353#\210)\307\n\321\354#\210\307\n\346\355#\210\307\n\327\356#\210\307\n\341\357#\210\307\n\360\361#\210)\314 \305\n\315\"\210\307	\362\n#\210\307\n\323\363#\210\307\n\335\364#\210\307\n\345\365#\210\307\n\325\366#\210\307\n\327\367#\210\307\n\370\371#\210\307\n\360\372#\210\307\n\373\374#\210)\314 \305\n\315\"\210\307	\375\n#\210\307\n\376\377#\210\307\n\325\201@#\210\307\n\360\201A#\210)\307	\335\201B#\210\307	\376\201C#\210\307	\201D\201E#\210\307	\370\201F#\210\307	\360\201G#\210\307	\201H\201I#\210\307	\201J\201K#\210\307	\201L\201M#\210\307	\201N\201O#\210\307	\201P\201Q#\210)\304\207" [ebrowse-member-mode-map map map1 map2 make-keymap suppress-keymap display-mouse-p define-key [down-mouse-3] ebrowse-member-mouse-3 [mouse-2] ebrowse-member-mouse-2 make-sparse-keymap t "C" "b" ebrowse-switch-member-buffer-to-base-class "c" ebrowse-switch-member-buffer-to-any-class "d" ebrowse-switch-member-buffer-to-derived-class "n" ebrowse-switch-member-buffer-to-next-sibling-class "p" ebrowse-switch-member-buffer-to-previous-sibling-class "D" "a" ebrowse-toggle-member-attributes-display ebrowse-toggle-base-class-display "f" ebrowse-freeze-member-buffer "l" ebrowse-toggle-long-short-display "r" ebrowse-toggle-regexp-display "w" ebrowse-set-member-buffer-column-width "F" "i" ebrowse-toggle-private-member-filter "o" ebrowse-toggle-protected-member-filter "u" ebrowse-toggle-public-member-filter ebrowse-toggle-const-member-filter ebrowse-toggle-inline-member-filter ebrowse-toggle-pure-member-filter ebrowse-remove-all-member-filters "v" ebrowse-toggle-virtual-member-filter "L" ebrowse-display-friends-member-list ebrowse-display-function-member-list ebrowse-display-static-functions-member-list ebrowse-display-next-member-list ebrowse-display-previous-member-list "t" ebrowse-display-types-member-list ebrowse-display-variables-member-list "V" ebrowse-display-static-variables-member-list "G" "m" ebrowse-goto-visible-member/all-member-lists ebrowse-repeat-member-search ebrowse-goto-visible-member ebrowse-find-member-declaration ebrowse-switch-to-next-member-buffer "q" bury-buffer ebrowse-show-displayed-class-in-tree ebrowse-view-member-declaration " " ebrowse-view-member-definition "?" describe-mode "	" ebrowse-pop-from-member-to-tree-buffer "\f" ebrowse-redisplay-member-buffer "
" ebrowse-find-member-definition] 5)
(defvar ebrowse-member-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [ebrowse-member-mode-hook variable-documentation put "Hook run after entering Ebrowse-Members mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp ebrowse-member-mode-map definition-name ebrowse-member-mode] 4)
(defvar ebrowse-member-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [ebrowse-member-mode-abbrev-table ebrowse-member-mode-map variable-documentation put purecopy "Keymap for `ebrowse-member-mode'." boundp ebrowse-member-mode-syntax-table definition-name ebrowse-member-mode (lambda (#1=#:def-tmp-var) (defvar ebrowse-member-mode-syntax-table #1#)) make-syntax-table "Syntax table for `ebrowse-member-mode'." (lambda (#1#) (defvar ebrowse-member-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `ebrowse-member-mode'." derived-mode-parent special-mode] 5)
#@249 Major mode for Ebrowse member buffers.

In addition to any hooks its parent mode `special-mode' might have run,
this mode runs the hook `ebrowse-member-mode-hook', as the final or penultimate step
during initialization.

\{ebrowse-member-mode-map}
(defalias 'ebrowse-member-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324%\325\"\204V%&=\204V\326%\325&C#\210\327!\210\330\f!\210%&\331\306\332\"\210\333\334!'\307(\335)\307\211*+\335,\336-./01\335\21123\335\21145\337\340\341\342z!\"\210)\343\344!\207" [delay-mode-hooks major-mode mode-name ebrowse-member-mode-map ebrowse-member-mode-syntax-table parent make-local-variable t special-mode ebrowse-member-mode "Ebrowse-Members" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table mapc (ebrowse--decl-column ebrowse--n-columns ebrowse--column-width ebrowse--show-inherited-flag ebrowse--filters ebrowse--accessor ebrowse--displayed-class ebrowse--long-display-flag ebrowse--source-regexp-flag ebrowse--attributes-flag ebrowse--member-list ebrowse--tree ebrowse--member-mode-strings ebrowse--tags-file-name ebrowse--header ebrowse--tree-obarray ebrowse--virtual-display-flag ebrowse--inline-display-flag ebrowse--const-display-flag ebrowse--pure-display-flag ebrowse--frozen-flag) propertized-buffer-identification "C++ Members" nil [0 1 2] modify-syntax-entry 95 char-to-string 97 run-mode-hooks ebrowse-member-mode-hook ebrowse-member-mode-abbrev-table local-abbrev-table mode-line-buffer-identification buffer-read-only ebrowse--long-display-flag ebrowse--attributes-flag ebrowse--show-inherited-flag ebrowse--source-regexp-flag ebrowse--filters ebrowse-default-declaration-column ebrowse--decl-column ebrowse-default-column-width ebrowse--column-width ebrowse--virtual-display-flag ebrowse--inline-display-flag ebrowse--const-display-flag ebrowse--pure-display-flag] 6 (#$ . 123202) nil])
#@62 Return the name of the class displayed in the member buffer.
(defalias 'ebrowse-class-name-displayed-in-member-buffer #[nil "\303H	>\204\304\305\306D\"\210\307H\303H\n>\2041\304\305\310\303H	>\204+\304\305\306D\"\210\307HD\"\210\303H	>\204@\304\305\306D\"\210\307H\307H\207" [ebrowse--displayed-class cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs] 7 (#$ . 125359)])
(put 'ebrowse-class-name-displayed-in-member-buffer 'byte-optimizer 'byte-compile-inline-expand)
#@68 Return a string describing what is displayed in the member buffer.
(defalias 'ebrowse-member-list-name #[nil "	\211\306H>\204\307\310\311\nD\"\210\n\312H\306H\f>\2044\307\310\313\n\306H>\204.\307\310\311\nD\"\210\n\312HD\"\210\n\306H>\204C\307\310\311\nD\"\210\n\312H\312H
\230)\203R\314\202S\315N\207" [ebrowse--accessor ebrowse--displayed-class tree cl-struct-ebrowse-ts-tags cl-struct-ebrowse-bs-tags ebrowse-globals-name 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-bs ebrowse-global-title ebrowse-title] 9 (#$ . 125901)])
(put 'ebrowse-member-list-name 'byte-optimizer 'byte-compile-inline-expand)
#@41 Update the mode line of member buffers.
(defalias 'ebrowse-update-member-buffer-mode-line #[nil "\205K	\306H\n>\204\307\310\311	D\"\210	\312H\306H>\2045\307\310\313	\306H\n>\204/\307\310\311	D\"\210	\312HD\"\210	\306H\n>\204D\307\310\311	D\"\210	\312H\312H\314P\211
	\211\306H\n>\204a\307\310\311D\"\210\312H\306H>\204\210\307\310\315\306H\n>\204\201\307\310\311D\"\210\312HD\"\210\306H\n>\204\231\307\310\311D\"\210\312H\312H\230)\203\252\316\202\253\317NP\320!\321\f\203\277\202\301!\210\322 *\207" [ebrowse--frozen-flag ebrowse--displayed-class cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags name ebrowse--accessor 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs " " ebrowse-bs ebrowse-global-title ebrowse-title propertized-buffer-identification ebrowse-rename-buffer force-mode-line-update tree cl-struct-ebrowse-bs-tags ebrowse-globals-name ident mode-line-buffer-identification ebrowse-member-buffer-name] 10 (#$ . 126527)])
#@41 Toggle frozen status of current buffer.
(defalias 'ebrowse-freeze-member-buffer #[nil "?\301 \207" [ebrowse--frozen-flag ebrowse-redisplay-member-buffer] 1 (#$ . 127524) nil])
#@115 Show the currently displayed class in the tree window.
With prefix ARG, switch to the tree buffer else pop to it.
(defalias 'ebrowse-show-displayed-class-in-tree #[(arg) "\305H	>\204\306\307\310D\"\210\311H\305H\n>\2041\306\307\312\305H	>\204+\306\307\310D\"\210\311HD\"\210\305H	>\204@\306\307\310D\"\210\311H\311H\313\f!\205O\314!)\207" [ebrowse--displayed-class cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags class-name arg 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs ebrowse-pop-from-member-to-tree-buffer ebrowse-read-class-name-and-go] 7 (#$ . 127709) "P"])
#@88 Set the column width of the member display.
The new width is read from the minibuffer.
(defalias 'ebrowse-set-member-buffer-column-width #[nil "\304\305\306\307\203\f	\202
\n!\310Q!!\211\211\311V\262
\205)\203%\202'\312 )\207" [ebrowse--long-display-flag ebrowse--decl-column ebrowse--column-width width string-to-number read-from-minibuffer "Column width (" int-to-string "): " 0 ebrowse-redisplay-member-buffer] 6 (#$ . 128310) nil])
#@128 Pop from a member buffer to the matching tree buffer.
Switch to the buffer if prefix ARG.  If no tree buffer exists,
make one.
(defalias 'ebrowse-pop-from-member-to-tree-buffer #[(arg) "\306\307!!\206\306	!\206\310\n\f\311%\211\203'\f\203#\312\202$\313
!\210
)\207" [ebrowse--tags-file-name ebrowse-tree-buffer-name ebrowse--tree ebrowse--header ebrowse--tree-obarray buf get-buffer ebrowse-frozen-tree-buffer-name ebrowse-create-tree-buffer pop switch-to-buffer pop-to-buffer arg] 7 (#$ . 128765) "P"])
#@67 Switch the member buffer to display the member list for ACCESSOR.
(defalias 'ebrowse-display-member-list-for-accessor #[(accessor) "\n!\304 \207" [accessor ebrowse--accessor ebrowse--displayed-class ebrowse--member-list ebrowse-redisplay-member-buffer] 2 (#$ . 129287)])
#@57 Switch buffer to INCR'th next/previous list of members.
(defalias 'ebrowse-cyclic-display-next/previous-member-list #[(incr) "\304	\"\211\305V\262
\203\nT	8\2066	@\2026\211\305W\262
\2056\nS\211\305Y\2032\n	8\2066\306	!@\307!)\207" [ebrowse--accessor ebrowse-member-list-accessors index incr ebrowse-position 0 last ebrowse-display-member-list-for-accessor] 3 (#$ . 129568)])
#@36 Switch buffer to next member list.
(defalias 'ebrowse-display-next-member-list #[nil "\300\301!\207" [ebrowse-cyclic-display-next/previous-member-list 1] 2 (#$ . 129964) nil])
#@40 Switch buffer to previous member list.
(defalias 'ebrowse-display-previous-member-list #[nil "\300\301!\207" [ebrowse-cyclic-display-next/previous-member-list -1] 2 (#$ . 130146) nil])
#@39 Display the list of member functions.
(defalias 'ebrowse-display-function-member-list #[nil "\300\301!\207" [ebrowse-display-member-list-for-accessor ebrowse-ts-member-functions] 2 (#$ . 130337) nil])
#@39 Display the list of member variables.
(defalias 'ebrowse-display-variables-member-list #[nil "\300\301!\207" [ebrowse-display-member-list-for-accessor ebrowse-ts-member-variables] 2 (#$ . 130544) nil])
#@46 Display the list of static member variables.
(defalias 'ebrowse-display-static-variables-member-list #[nil "\300\301!\207" [ebrowse-display-member-list-for-accessor ebrowse-ts-static-variables] 2 (#$ . 130752) nil])
#@46 Display the list of static member functions.
(defalias 'ebrowse-display-static-functions-member-list #[nil "\300\301!\207" [ebrowse-display-member-list-for-accessor ebrowse-ts-static-functions] 2 (#$ . 130974) nil])
#@30 Display the list of friends.
(defalias 'ebrowse-display-friends-member-list #[nil "\300\301!\207" [ebrowse-display-member-list-for-accessor ebrowse-ts-friends] 2 (#$ . 131196) nil])
#@28 Display the list of types.
(defalias 'ebrowse-display-types-member-list #[nil "\300\301!\207" [ebrowse-display-member-list-for-accessor ebrowse-ts-types] 2 (#$ . 131384) nil])
#@53 Toggle display of `virtual', `inline', `const' etc.
(defalias 'ebrowse-toggle-member-attributes-display #[nil "?\301 \207" [ebrowse--attributes-flag ebrowse-redisplay-member-buffer] 1 (#$ . 131566) nil])
#@60 Toggle the display of members inherited from base classes.
(defalias 'ebrowse-toggle-base-class-display #[nil "?\301 \207" [ebrowse--show-inherited-flag ebrowse-redisplay-member-buffer] 1 (#$ . 131778) nil])
#@41 Toggle display of pure virtual members.
(defalias 'ebrowse-toggle-pure-member-filter #[nil "?\301 \207" [ebrowse--pure-display-flag ebrowse-redisplay-member-buffer] 1 (#$ . 131994) nil])
#@34 Toggle display of const members.
(defalias 'ebrowse-toggle-const-member-filter #[nil "?\301 \207" [ebrowse--const-display-flag ebrowse-redisplay-member-buffer] 1 (#$ . 132189) nil])
#@35 Toggle display of inline members.
(defalias 'ebrowse-toggle-inline-member-filter #[nil "?\301 \207" [ebrowse--inline-display-flag ebrowse-redisplay-member-buffer] 1 (#$ . 132379) nil])
#@36 Toggle display of virtual members.
(defalias 'ebrowse-toggle-virtual-member-filter #[nil "?\301 \207" [ebrowse--virtual-display-flag ebrowse-redisplay-member-buffer] 1 (#$ . 132572) nil])
#@21 Remove all filters.
(defalias 'ebrowse-remove-all-member-filters #[nil "\306\307	W\203\n\211I\210T\211\202*\310\211\310\211\n\311 \207" [i --dotimes-limit-- ebrowse--filters ebrowse--pure-display-flag ebrowse--const-display-flag ebrowse--virtual-display-flag 3 0 nil ebrowse-redisplay-member-buffer ebrowse--inline-display-flag] 4 (#$ . 132768) nil])
#@38 Toggle visibility of public members.
(defalias 'ebrowse-toggle-public-member-filter #[nil "\300\301!\210\302 \207" [ebrowse-set-member-access-visibility 0 ebrowse-redisplay-member-buffer] 2 (#$ . 133139) nil])
#@41 Toggle visibility of protected members.
(defalias 'ebrowse-toggle-protected-member-filter #[nil "\300\301!\210\302 \207" [ebrowse-set-member-access-visibility 1 ebrowse-redisplay-member-buffer] 2 (#$ . 133355) nil])
#@39 Toggle visibility of private members.
(defalias 'ebrowse-toggle-private-member-filter #[nil "\300\301!\210\302 \207" [ebrowse-set-member-access-visibility 2 ebrowse-redisplay-member-buffer] 2 (#$ . 133577) nil])
(defalias 'ebrowse-set-member-access-visibility #[(vis) "\n	\nH?\205\nI*\207" [ebrowse--filters #1=#:v vis #2=#:v] 4])
#@63 Toggle between long and short display form of member buffers.
(defalias 'ebrowse-toggle-long-short-display #[nil "?\301 \207" [ebrowse--long-display-flag ebrowse-redisplay-member-buffer] 1 (#$ . 133921) nil])
#@113 Toggle declaration/definition regular expression display.
Used in member buffers showing the long display form.
(defalias 'ebrowse-toggle-regexp-display #[nil "?\301 \207" [ebrowse--source-regexp-flag ebrowse-redisplay-member-buffer] 1 (#$ . 134139) nil])
#@133 Find the file containing a member definition.
With PREFIX 4. find file in another window, with prefix 5
find file in another frame.
(defalias 'ebrowse-find-member-definition #[(&optional prefix) "\301\302\303#\207" [prefix ebrowse-view/find-member-declaration/definition nil t] 4 (#$ . 134404) "p"])
#@133 View the file containing a member definition.
With PREFIX 4. find file in another window, with prefix 5
find file in another frame.
(defalias 'ebrowse-view-member-definition #[(prefix) "\301\302\211#\207" [prefix ebrowse-view/find-member-declaration/definition t] 4 (#$ . 134712) "p"])
#@136 Find the file containing a member's declaration.
With PREFIX 4. find file in another window, with prefix 5
find file in another frame.
(defalias 'ebrowse-find-member-declaration #[(prefix) "\301\302\"\207" [prefix ebrowse-view/find-member-declaration/definition nil] 3 (#$ . 135006) "p"])
#@136 View the file containing a member's declaration.
With PREFIX 4. find file in another window, with prefix 5
find file in another frame.
(defalias 'ebrowse-view-member-declaration #[(prefix) "\301\302\"\207" [prefix ebrowse-view/find-member-declaration/definition t] 3 (#$ . 135303) "p"])
#@332 Find or view a member declaration or definition.
With PREFIX 4. find file in another window, with prefix 5
find file in another frame.
DEFINITION non-nil means find the definition, otherwise find the
declaration.
INFO is a list (TREE ACCESSOR MEMBER) describing the member to
search.
TAGS-FILE is the file name of the BROWSE file.
(defalias 'ebrowse-view/find-member-declaration/definition #[(prefix view &optional definition info header tags-file) "\3062@\204\n	\n\204\307\211\211\211\211\f\310U\203\311\202*\f\312U\203)\313\202*\314,-./01\203O1@01A@.1AA@/\202h\315 \2112@02A@/\31628,)3.,\203\371\317\306\3200\321H4>\204\202\322\323\3240D\"\2100\325H	0\321H4>\204\231\322\323\3240D\"\2100\325H\307E0\321H4>\204\261\322\323\3240D\"\2100\325H\321H5>\204\331\322\323\3260\321H4>\204\322\322\323\3240D\"\2100\325HD\"\2100\321H4>\204\353\322\323\3240D\"\2100\325H\310H\n6
&\"\2107\203
.\327=\203
\30777\203\206
\330\331/\321H8>\204!
\322\323\331/D\"\210/\325H\307/\321H8>\2048
\322\323\331/D\"\210/\332H/\321H8>\204N
\322\323\331/D\"\210/\333H/\321H8>\204d
\322\323\331/D\"\210/\334H/\321H8>\204z
\322\323\331/D\"\210/\335H\307\211\211\211&//\321H8>\204\230
\322\323\331/D\"\210/\310H\206K7\203\371
0\321H4>\204\266
\322\323\3240D\"\2100\325H\321H5>\204\336
\322\323\3260\321H4>\204\327
\322\323\3240D\"\2100\325HD\"\2100\321H4>\204\360
\322\323\3240D\"\2100\325H\336H\202K0\321H4>\204\322\323\3240D\"\2100\325H\321H5>\2043\322\323\3260\321H4>\204,\322\323\3240D\"\2100\325HD\"\2100\321H4>\204E\322\323\3240D\"\2100\325H\310H\211-\203l/\321H8>\204c\322\323\331/D\"\210/\337H\321U\203\273\340\3417\203w\342\202x\343\3447\203\202\343\202\203\342\345/\321H8>\204\226\322\323\331/D\"\210/\325H\346\260!\203\265\347\307!\210\350\f67?1\n&\202=\351\352!\202=\320\330\353/\321H8>\204\320\322\323\331/D\"\210/\325H\307/\321H8>\204\347\322\323\331/D\"\210/\332H/\321H8>\204\375\322\323\331/D\"\210/\310H/\321H8>\204\322\323\331/D\"\210/\312H/\321H8>\204)\322\323\331/D\"\210/\337H&/.E-\n6
&.0\207" [header ebrowse--header tags-file ebrowse--tags-file-name prefix where --cl-block-ebrowse-view/find-member-declaration/definition-- nil 4 other-window 5 other-frame this-window ebrowse-member-info-from-point 2 throw ebrowse-view/find-file-and-search-pattern 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs ebrowse-ts-member-variables vector ebrowse-ms 3 8 9 10 7 6 y-or-n-p "No information about " "definition" "declaration" ".  Search for " " of `" "'? " message ebrowse-view/find-member-declaration/definition error "Search canceled" ebrowse-bs on-class file accessor member tree info #1=#:--cl-var-- ebrowse--accessor cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags view definition cl-struct-ebrowse-ms-tags] 13 (#$ . 135598)])
#@25 Force buffer redisplay.
(defalias 'ebrowse-redisplay-member-buffer #[nil "\203\306\202	\307\310\311 \312\216\313 \210\314 \210	\f
\"\210\203Y\315
!\310\211\203X@db\210n\203=\316\202>\317c\210\314!\210	!\"\210A\211\204-*\320 ,\207" [ebrowse--long-display-flag display-fn #1=#:--ebrowse-output-- buffer-read-only ebrowse--member-list ebrowse--displayed-class ebrowse-draw-member-long-fn ebrowse-draw-member-short-fn nil buffer-modified-p #[nil "\301!\207" [#1# set-buffer-modified-p] 2] erase-buffer ebrowse-draw-member-buffer-class-line ebrowse-base-classes "\n\n" "\n" ebrowse-update-member-buffer-mode-line ebrowse--show-inherited-flag super --dolist-tail-- ebrowse--accessor] 4 (#$ . 138523) nil])
#@152 Display the title line for a class section in the member buffer.
CLASS non-nil means display that class' title.  Otherwise use
the class cursor is on.
(defalias 'ebrowse-draw-member-buffer-class-line #[(&optional class) "`\206	\306\211\307c\210`\f\310H>\204!\311\312\313\fD\"\210\f\314H\211\310H>\2045\311\312\315D\"\210\316H\203f\310H>\204K\311\312\315D\"\210\316H\317\310H>\204_\311\312\315D\"\210\314HQ\202y\310H>\204v\311\312\315D\"\210\314H)c\210\f\310H>\204\214\311\312\313\fD\"\210\f\314H\211 \320! \321 \310H\">\204\252\311\312\322 D\"\210 \323H!\"\310U+\204\272\324c\210`\325c\210
`\326#\327\330
#\"\331#+\210\332\n\333#\210\334
\n\335\f$,\207" [class ebrowse--displayed-class class-name-end class-name-start tree start nil "class " 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs 2 "::" 32 logand ebrowse-bs 3 "<>" ":\n\n" ebrowse-member-class overlay-put make-overlay face add-text-properties (ebrowse-what class-name mouse-face highlight help-echo "mouse-3: menu") put-text-property ebrowse-tree cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags member bit cl-struct-ebrowse-bs-tags end] 7 (#$ . 139265)])
#@158 Start point for member buffer creation.
LIST is the member list to display.  STAND-ALONE non-nil
means the member buffer is standalone.  CLASS is its class.
(defalias 'ebrowse-display-member-buffer #[(list &optional stand-alone class) "\n\f\306\307!\204\310 \311 r\312\216\2030\313!\210\202:\313\314!!\210\315 \210!	
\316\317 \210p.	\207" [ebrowse--tree-obarray classes ebrowse--tree tree ebrowse--tags-file-name tags-file nil get-buffer ebrowse-tree-at-point internal--before-save-selected-window #[nil "\301!\207" [save-selected-window--state internal--after-save-selected-window] 2] pop-to-buffer get-buffer-create ebrowse-member-mode t ebrowse-redisplay-member-buffer ebrowse--header header temp-buffer-setup-hook ebrowse-member-buffer-name temp-buffer class save-selected-window--state list ebrowse--member-list ebrowse--displayed-class ebrowse--accessor stand-alone ebrowse--frozen-flag buffer-read-only] 3 (#$ . 140456)])
#@73 Return t if MEMBER must be displayed under the current filter settings.
(defalias 'ebrowse-member-display-p #[(member) "	\306H\n>\204\307\310\311	D\"\210	\312HH\205\246\203=	\211\313\314	\306H
>\2041\307\310\315	D\"\210	\316H\f\"\306U+?\205\246\203d	\211\317\314	\306H
>\204X\307\310\315	D\"\210	\316H\f\"\306U+?\205\246\203~\320	!\205\246	G\312Y\205\246	\306H
>\205\246\203\245	\211\321\314	\306H
>\204\231\307\310\315	D\"\210	\316H\f\"\306U+?\205\246	\207" [ebrowse--filters member cl-struct-ebrowse-ms-tags ebrowse--const-display-flag bit cl-struct-ebrowse-bs-tags 0 signal wrong-type-argument ebrowse-ms 7 4 logand ebrowse-bs 3 2 vectorp 1 ebrowse--inline-display-flag ebrowse--pure-display-flag ebrowse--virtual-display-flag] 6 (#$ . 141450)])
#@47 Insert a string for the attributes of MEMBER.
(defalias 'ebrowse-draw-member-attributes #[(member) "\211\303\304\305H\n>\204\306\307\310D\"\210\311H	\"\305U+\204%\312\202&\313\211\314\304\305H\n>\204<\306\307\310D\"\210\311H	\"\305U+\204K\315\202L\313\211\316\304\305H\n>\204b\306\307\310D\"\210\311H	\"\305U+\204q\317\202r\313\211\320\304\305H\n>\204\210\306\307\310D\"\210\311H	\"\305U+\204\227\321\202\230\313\211\322\304\305H\n>\204\256\306\307\310D\"\210\311H	\"\305U+\204\275\323\202\276\313\211\324\304\305H\n>\204\324\306\307\310D\"\210\311H	\"\305U+\204\343\325\202\344\313\211\326\304\305H\n>\204\372\306\307\310D\"\210\311H	\"\305U+\204	
\327\202\n
\313\211\330\304\305H\n>\204 
\306\307\310D\"\210\311H	\"\305U+\204/
\331\2020
\313\211\332\304\305H\n>\204F
\306\307\310D\"\210\311H	\"\305U+\204U
\333\202V
\313\261	\207" [member bit cl-struct-ebrowse-bs-tags 32 logand 0 signal wrong-type-argument ebrowse-bs 3 "T" "-" 256 "C" 1 "v" 2 "i" 4 "c" 8 "0" 16 "m" 64 "e" 128 "t"] 14 (#$ . 142238)])
#@67 Insert a string for the regular expression matching MEMBER-STRUC.
(defalias 'ebrowse-draw-member-regexp #[(member-struc) "\203	\305H\n>\204\306\307\310	D\"\210	\311H\202+	\305H\n>\204(\306\307\310	D\"\210	\312H\211;\203\\\313!\314\261\210\315\305!\210\316\317\f\\!\210\320\321\322\323#\203V\305\224\305\225|\210\324c\210\202B\315\325!\202^\326c)\207" [ebrowse--source-regexp-flag member-struc cl-struct-ebrowse-ms-tags pattern ebrowse--decl-column 0 signal wrong-type-argument ebrowse-ms 9 5 ebrowse-trim-string "...\n" beginning-of-line move-to-column 4 re-search-forward "[ 	]+" nil t " " 2 "[not recorded or unknown]\n"] 5 (#$ . 143332)])
#@92 Display member buffer for MEMBER-LIST in long form.
TREE is the class tree of MEMBER-LIST.
(defalias 'ebrowse-draw-member-long-fn #[(member-list tree) "\306\307\"\310\211\203\213\n@\211\203\204	\311H>\204!\312\313\314	D\"\210	\315H`\211\311
G!S^Oc\210\316\f`\317\320\321\322\323	\324\"\325BBBBBBBB#\210`!j\210\326\f`\317\310$\210#\203|`\327c\210\330	!\210\331c\210\f`\332$\333\334\f$\"\335#+\210)\336c\210\337	!\210*\nA\211\204*\340c\210eb\207" [member-list member-struc --dolist-tail-- cl-struct-ebrowse-ms-tags start name mapcar ebrowse-member-display-p nil 0 signal wrong-type-argument ebrowse-ms 1 add-text-properties mouse-face highlight ebrowse-what member-name ebrowse-member ebrowse-tree (help-echo "mouse-2: view definition; mouse-3: menu") put-text-property "<" ebrowse-draw-member-attributes ">" ebrowse-member-attribute overlay-put make-overlay face " " ebrowse-draw-member-regexp "\n" ebrowse--decl-column tree ebrowse--attributes-flag end] 13 (#$ . 143994)])
#@91 Display MEMBER-LIST in short form.
TREE is the class tree in which the members are found.
(defalias 'ebrowse-draw-member-short-fn #[(member-list tree) "\306	\203\n\307\202\306\\\310\311 \n\245]\312\313
\"\314!\211\"\203\302\"@\211!\203\271!\306H#>\204=\315\316\317!D\"\210!\310H\314`\314$%&'\n_j\210\320%`\321\314$\210`&	\203\202\322c\210\323!!\210\324c\210&`\325()\326\327)(\"\330#+\210`$'\306'GS^Oc\210\331$`\332\333\334!\321\335\336*\337BBBBBBBB#\210T\211\fY\203\270\306\340c\210,\"A\211\"\204\"*\211\306V\262
\203\317\340c\210eb*\207" [ebrowse--column-width ebrowse--attributes-flag column-width i ebrowse--n-columns member-list 0 12 1 ebrowse-width-of-drawable-area mapcar ebrowse-member-display-p nil signal wrong-type-argument ebrowse-ms put-text-property mouse-face "<" ebrowse-draw-member-attributes "> " ebrowse-member-attribute overlay-put make-overlay face add-text-properties ebrowse-what member-name ebrowse-member highlight ebrowse-tree (help-echo "mouse-2: view definition; mouse-3: menu") "\n" member --dolist-tail-- cl-struct-ebrowse-ms-tags start-of-name start-of-column start-of-entry name end start tree] 13 (#$ . 145000)])
#@180 Ger information about the member at point.
The result has the form (TREE MEMBER NULL-P).  TREE is the tree
we're in, MEMBER is the member we're on.  NULL-P is t if MEMBER
is nil.
(defalias 'ebrowse-member-info-from-point #[nil "\302`\303\"\206\n\304\305!\302`\306\"\211\211?E*\207" [member tree get-text-property ebrowse-tree error "No information at point" ebrowse-member] 5 (#$ . 146204)])
#@156 Position cursor on a member read from the minibuffer.
With PREFIX, search all members in the tree.  Otherwise consider
only members visible in the buffer.
(defalias 'ebrowse-goto-visible-member/all-member-lists #[(_prefix) "\306\307 \310\311	\312\306$\313\n	\"A\211\204\314\315\n\"\210\f=\204+
!\316 \210\317\n!,\207" [completion-ignore-case completion-list member accessor ebrowse--accessor ebrowse--displayed-class t ebrowse-name/accessor-alist-for-class-members completing-read "Goto member: " nil assoc error "`%s' not found" ebrowse-redisplay-member-buffer ebrowse-move-point-to-member ebrowse--member-list] 6 (#$ . 146607) "p"])
#@187 Position point on a member.
Read the member's name from the minibuffer.  Consider only members
visible in the member buffer.
REPEAT non-nil means repeat the search that number of times.
(defalias 'ebrowse-goto-visible-member #[(repeat) "\304\305 \306\307	\310\304$\311\n\"+\207" [completion-ignore-case completion-list member repeat t ebrowse-name/accessor-alist-for-visible-members completing-read "Goto member: " nil ebrowse-move-point-to-member] 5 (#$ . 147262) "p"])
#@103 Repeat the last regular expression search.
REPEAT, if specified, says repeat the search REPEAT times.
(defalias 'ebrowse-repeat-member-search #[(repeat) "\204\302\303!\210\304\305w\210\306\305\307	$\203\310\224b\210\311\305w\207eb\210\306\305\307#\2030\310\224b\210\311\305w\207\302\312!\207" [ebrowse--last-regexp repeat error "No regular expression remembered" "^ 	\n" nil re-search-forward t 0 " 	\n" "Not found"] 5 (#$ . 147744) "p"])
#@147 Set point on member NAME in the member buffer
COUNT, if specified, says search the COUNT'th member with the same name.

(fn NAME &optional COUNT)
(defalias 'ebrowse-move-point-to-member #[(name &optional count &rest #1=#:--cl-rest--) "\306	\203\307\310\311\312	G\\D\"\210eb\210~\210\n\313\nGS^O\314\315!\316Q\317\f\306\320
$\2035\313\224Tb\2028\321\322!)\207" [member #1# name ebrowse--column-width ebrowse--last-regexp count nil signal wrong-number-of-arguments ebrowse-move-point-to-member 2 0 "[ 	\n]" regexp-quote "[ \n	]" re-search-forward t error "Not found"] 5 (#$ . 148198)])
#@131 Switch member buffer to a class read from the minibuffer.
Use TITLE as minibuffer prompt.
COMPL-LIST is a completion list to use.
(defalias 'ebrowse-switch-member-buffer-to-other-class #[(title compl-list) "A@?\205\n@@\306\n	#\206\307\310!\211
\f!\n\311 *\207" [compl-list initial title class ebrowse--displayed-class ebrowse--accessor ebrowse-completing-read-value error "Not found" ebrowse-redisplay-member-buffer ebrowse--member-list] 5 (#$ . 148798)])
#@59 Switch member buffer to a class read from the minibuffer.
(defalias 'ebrowse-switch-member-buffer-to-any-class #[nil "\300\301\302 \"\207" [ebrowse-switch-member-buffer-to-other-class "Goto class: " ebrowse-tree-obarray-as-alist] 3 (#$ . 149270) nil])
#@37 Switch buffer to ARG'th base class.
(defalias 'ebrowse-switch-member-buffer-to-base-class #[(arg) "\306!\206	\307\310!\n\203\261	A@\203\261	\311\211:\203\243@\211\312H>\2042\313\314\315\fD\"\210\f\316H\211\312H>\204H\313\314\317D\"\210\320H\203\200\312H>\204a\313\314\317D\"\210\320H\321\312H>\204x\313\314\317D\"\210\316HQ\202\226\312H>\204\222\313\314\317D\"\210\316H)\fB
BA\211\202
\237+\322\323\")\202\274	@!\324 )\207" [ebrowse--displayed-class supers arg #1=#:--cl-var-- s #2=#:--cl-var-- ebrowse-direct-base-classes error "No base classes" nil 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs 2 "::" ebrowse-switch-member-buffer-to-other-class "Goto base class: " ebrowse-redisplay-member-buffer cl-struct-ebrowse-ts-tags class cl-struct-ebrowse-cs-tags alist ebrowse--accessor ebrowse--member-list] 7 (#$ . 149528) "P"])
#@30 Move to ARG'th next sibling.
(defalias 'ebrowse-switch-member-buffer-to-next-sibling-class #[(arg) "\301!\207" [arg ebrowse-switch-member-buffer-to-sibling-class] 2 (#$ . 150436) "p"])
#@34 Move to ARG'th previous sibling.
(defalias 'ebrowse-switch-member-buffer-to-previous-sibling-class #[(arg) "\301[!\207" [arg ebrowse-switch-member-buffer-to-sibling-class] 2 (#$ . 150628) "p"])
#@81 Switch member display to nth sibling class.
Prefix arg INC specifies which one.
(defalias 'ebrowse-switch-member-buffer-to-sibling-class #[(inc) "\306\211\307	!\310\n\203F\nA@\203\"\311\312\n!\306#\202$\n@\211\204.\313\314!\210\315H>\204@\316\317\320D\"\210\321H))\322	
\"\\\211\211\315W\262
\203_\323\324!\210\202i\f
8\204i\323\325!\210\315\f
GS^]\211
8\211!\326 ,\207" [ebrowse--tree ebrowse--displayed-class supers cls index containing-list nil ebrowse-direct-base-classes #[(trees) "\306\211	:\203_	@\211\307H\f>\204\310\311\312\nD\"\210\n\313H\307H
>\204?\310\311\314\n\307H\f>\2049\310\311\312\nD\"\210\n\313HD\"\210\n\307H\f>\204N\310\311\312\nD\"\210\n\313H\313H\nBB	A\211\202\237+\207" [trees #1=#:--cl-var-- tr #2=#:--cl-var-- cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags nil 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs] 8] ebrowse-completing-read-value "Relative to base class: " error "Not found" 0 signal wrong-type-argument ebrowse-ts 2 ebrowse-position message "No previous class" "No next class" ebrowse-redisplay-member-buffer #3=#:--cl-trees-alist-- tree cl-struct-ebrowse-ts-tags inc ebrowse--accessor ebrowse--member-list] 6 (#$ . 150829) "p"])
#@135 Switch member display to nth derived class.
Prefix arg ARG says which class should be displayed.  Default is
the first derived class.
(defalias 'ebrowse-switch-member-buffer-to-derived-class #[(arg) "\306	\307H\n>\204\310\311\312	D\"\210	\313H\206\314\315!\f\203-A@\203-\316\317 \"\2027@
	!\320 *\207" [#1=#:--cl-ebrowse-tree-obarray-as-alist-- ebrowse--displayed-class cl-struct-ebrowse-ts-tags subs arg ebrowse--accessor #[nil "\306H	>\204\307\310\311D\"\210\312H\313\211\n:\203p\n@\211\306H	>\204.\307\310\311D\"\210\314H\306H
>\204P\307\310\315\306H	>\204J\307\310\311D\"\210\314HD\"\210\306H	>\204_\307\310\311D\"\210\314H\314HB\fB\nA\211\202\f\237+\207" [ebrowse--displayed-class cl-struct-ebrowse-ts-tags #2=#:--cl-var-- s #3=#:--cl-var-- cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-ts 2 nil 1 ebrowse-cs] 8] 0 signal wrong-type-argument ebrowse-ts 2 error "No derived classes" ebrowse-switch-member-buffer-to-other-class "Goto derived class: " ebrowse-redisplay-member-buffer ebrowse--member-list] 4 (#$ . 152073) "P"])
(defalias 'ebrowse-displaying-functions #[nil "\301=\207" [ebrowse--accessor ebrowse-ts-member-functions] 2])
(defalias 'ebrowse-displaying-variables #[nil "\301=\207" [ebrowse--accessor ebrowse-ts-member-variables] 2])
(defalias 'ebrowse-displaying-static-functions #[nil "\300\207" [nil] 1])
(defalias 'ebrowse-displaying-static-variables #[nil "\300\207" [nil] 1])
(defalias 'ebrowse-displaying-types #[nil "\301=\207" [ebrowse--accessor ebrowse-ts-types] 2])
(defalias 'ebrowse-displaying-friends #[nil "\301=\207" [ebrowse--accessor ebrowse-ts-friends] 2])
#@43 Object menu for the member buffer itself.
(defvar ebrowse-member-buffer-object-menu nil (#$ . 153734))
(easy-menu-do-define 'ebrowse-member-buffer-object-menu ebrowse-member-mode-map "Object menu for the member buffer itself." '("Members" ("Members List" ["Functions" ebrowse-display-function-member-list :help "Show the list of member functions" :style radio :selected (eq ebrowse--accessor 'ebrowse-ts-member-functions) :active t] ["Variables" ebrowse-display-variables-member-list :help "Show the list of member variables" :style radio :selected (eq ebrowse--accessor 'ebrowse-ts-member-variables) :active t] ["Static Functions" ebrowse-display-static-functions-member-list :help "Show the list of static member functions" :style radio :selected (eq ebrowse--accessor 'ebrowse-ts-static-functions) :active t] ["Static Variables" ebrowse-display-static-variables-member-list :help "Show the list of static member variables" :style radio :selected (eq ebrowse--accessor 'ebrowse-ts-static-variables) :active t] ["Types" ebrowse-display-types-member-list :help "Show the list of nested types" :style radio :selected (eq ebrowse--accessor 'ebrowse-ts-types) :active t] ["Friends/Defines" ebrowse-display-friends-member-list :help "Show the list of friends or defines" :style radio :selected (eq ebrowse--accessor 'ebrowse-ts-friends) :active t]) ("Class" ["Up" ebrowse-switch-member-buffer-to-base-class :help "Show the base class of this class" :active t] ["Down" ebrowse-switch-member-buffer-to-derived-class :help "Show a derived class of this class" :active t] ["Next Sibling" ebrowse-switch-member-buffer-to-next-sibling-class :help "Show the next sibling class" :active t] ["Previous Sibling" ebrowse-switch-member-buffer-to-previous-sibling-class :help "Show the previous sibling class" :active t]) ("Member" ["Show in Tree" ebrowse-show-displayed-class-in-tree :help "Show this class in the class tree" :active t] ["Find in this Class" ebrowse-goto-visible-member :help "Search for a member of this class" :active t] ["Find in Tree" ebrowse-goto-visible-member/all-member-lists :help "Search for a member in any class" :active t]) ("Display" ["Inherited" ebrowse-toggle-base-class-display :help "Toggle display of inherited members" :style toggle :selected ebrowse--show-inherited-flag :active t] ["Attributes" ebrowse-toggle-member-attributes-display :help "Show member attributes" :style toggle :selected ebrowse--attributes-flag :active t] ["Long Display" ebrowse-toggle-long-short-display :help "Toggle the member display format" :style toggle :selected ebrowse--long-display-flag :active t] ["Column Width" ebrowse-set-member-buffer-column-width :help "Set the display's column width" :active t]) ("Filter" ["Public" ebrowse-toggle-public-member-filter :help "Toggle the visibility of public members" :style toggle :selected (not (aref ebrowse--filters 0)) :active t] ["Protected" ebrowse-toggle-protected-member-filter :help "Toggle the visibility of protected members" :style toggle :selected (not (aref ebrowse--filters 1)) :active t] ["Private" ebrowse-toggle-private-member-filter :help "Toggle the visibility of private members" :style toggle :selected (not (aref ebrowse--filters 2)) :active t] ["Virtual" ebrowse-toggle-virtual-member-filter :help "Toggle the visibility of virtual members" :style toggle :selected ebrowse--virtual-display-flag :active t] ["Inline" ebrowse-toggle-inline-member-filter :help "Toggle the visibility of inline members" :style toggle :selected ebrowse--inline-display-flag :active t] ["Const" ebrowse-toggle-const-member-filter :help "Toggle the visibility of const members" :style toggle :selected ebrowse--const-display-flag :active t] ["Pure" ebrowse-toggle-pure-member-filter :help "Toggle the visibility of pure virtual members" :style toggle :selected ebrowse--pure-display-flag :active t] "-----------------" ["Show all" ebrowse-remove-all-member-filters :help "Remove any display filters" :active t]) ("Buffer" ["Tree" ebrowse-pop-from-member-to-tree-buffer :help "Pop to the class tree buffer" :active t] ["Next Member Buffer" ebrowse-switch-to-next-member-buffer :help "Switch to the next member buffer of this class tree" :active t] ["Freeze" ebrowse-freeze-member-buffer :help "Freeze (do not reuse) this member buffer" :active t])))
#@47 Value is non-nil if point is on a class name.
(defalias 'ebrowse-on-class-name #[nil "\300`\301\"\302=\207" [get-text-property ebrowse-what class-name] 3 (#$ . 158036)])
#@48 Value is non-nil if point is on a member name.
(defalias 'ebrowse-on-member-name #[nil "\300`\301\"\302=\207" [get-text-property ebrowse-what member-name] 3 (#$ . 158212)])
#@47 Object menu for class names in member buffer.
(defvar ebrowse-member-class-name-object-menu nil (#$ . 158391))
(easy-menu-do-define 'ebrowse-member-class-name-object-menu ebrowse-member-mode-map "Object menu for class names in member buffer." '("Class" ["Find" ebrowse-find-member-definition :help "Find this class in the source files" :active (eq (get-text-property (point) 'ebrowse-what) 'class-name)] ["View" ebrowse-view-member-definition :help "View this class in the source files" :active (eq (get-text-property (point) 'ebrowse-what) 'class-name)]))
#@30 Object menu for member names
(defvar ebrowse-member-name-object-menu nil (#$ . 158954))
(easy-menu-do-define 'ebrowse-member-name-object-menu ebrowse-member-mode-map "Object menu for member names" '("Ebrowse" ["Find Definition" ebrowse-find-member-definition :help "Find this member's definition in the source files" :active (ebrowse-on-member-name)] ["Find Declaration" ebrowse-find-member-declaration :help "Find this member's declaration in the source files" :active (ebrowse-on-member-name)] ["View Definition" ebrowse-view-member-definition :help "View this member's definition in the source files" :active (ebrowse-on-member-name)] ["View Declaration" ebrowse-view-member-declaration :help "View this member's declaration in the source files" :active (ebrowse-on-member-name)]))
#@70 Handle `mouse-3' events in member buffers.
EVENT is the mouse event.
(defalias 'ebrowse-member-mouse-3 #[(event) "\306!\210\211:\203\307
8\250\203\307
8\262
\202\310\262
\211\311\267\202M\312 \202N\313\314\315!!\316\"\211\317\267\202E\320\"\202I\320\f\"\202I\320
\")\202N\321)\207" [event #1=#:val #2=#:val ebrowse-member-name-object-menu ebrowse-member-class-name-object-menu ebrowse-member-buffer-object-menu mouse-set-point 2 1 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (2 35 1 40)) ebrowse-find-member-definition get-text-property posn-point event-start ebrowse-what #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (member-name 55 class-name 62)) ebrowse-popup-menu nil] 5 (#$ . 159745) "e"])
#@70 Handle `mouse-2' events in member buffers.
EVENT is the mouse event.
(defalias 'ebrowse-member-mouse-2 #[(event) "\303!\210\211:\203\304
8\250\203\304
8\262
\202\305\262
\211\306\267\202>\307 \202?\310\311\312!!\313\"\211\314=\205:\315\316!)\202?\317)\207" [event #1=#:val #2=#:val mouse-set-point 2 1 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (2 35 1 40)) ebrowse-find-member-definition get-text-property posn-point event-start ebrowse-what member-name ebrowse-view-member-definition 0 nil] 5 (#$ . 160549) "e"])
#@440 Return information about a member in a class tree.
TREE-HEADER is the header structure of the class tree.
NAME is the name of the member.
Value is an alist of elements (CLASS-NAME . (CLASS LIST NAME)),
where each element describes one occurrence of member NAME in the tree.
CLASS-NAME is the qualified name of the class in which the
member was found.  The CDR of the acons is described in function
`ebrowse-class/index/member-for-member'.
(defalias 'ebrowse-class-alist-for-member #[(tree-header name) "\306!\307\211\f\205\267\310\f\"\307\211\203\263@\211@\n>\204\252
@\311H>\2045\312\313\314
@D\"\210
@\315H\211\311H>\204L\312\313\316D\"\210\317H\203\204\311H>\204e\312\313\316D\"\210\317H\320\311H>\204|\312\313\316D\"\210\315HQ\202\232\311H>\204\226\312\313\316D\"\210\315H)
	B
B\266\203
@\nBA\211\204\307	*+\207" [tree-header alist known-classes table name info ebrowse-member-table nil gethash 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs 2 "::" --dolist-tail-- cl-struct-ebrowse-ts-tags class cl-struct-ebrowse-cs-tags] 7 (#$ . 161128)])
#@280 Choose a class tree to use.
If there's more than one class tree loaded, let the user choose
the one he wants.  Value is (TREE HEADER BUFFER), with TREE being
the class tree, HEADER the header structure of the tree, and BUFFER
being the tree or member buffer containing the tree.
(defalias 'ebrowse-choose-tree #[nil "\301 \211\205\302\303\"\302\304\"E)\207" [buffer ebrowse-choose-from-browser-buffers buffer-local-value ebrowse--tree ebrowse--header] 5 (#$ . 162253)])
#@236 Read a C++ identifier from the minibuffer.
HEADER is the `ebrowse-hs' structure of the class tree.
Prompt with PROMPT.  Insert into the minibuffer a C++ identifier read
from point as default.  Value is a list (CLASS-NAME MEMBER-NAME).
(defalias 'ebrowse-tags-read-name #[(header prompt) "\212\306!\307 \211@\nA@\211\204\310\311!\210	\203^\312\313	\314\211\f%)\315	\"\316	\"\204V\317\320!\203R\321	\322!#@\206M\310\323!\202V\310\324!\210*D\202e\325\f\"D-\207" [header members #1=#:--cl-var-- class-name member-name completion-ignore-case ebrowse-member-table ebrowse-tags-read-member+class-name error "No member name at point" t completing-read nil try-completion gethash y-or-n-p "No exact match found.  Try substrings? " ebrowse-list-of-matching-members regexp-quote "Sorry, nothing found" "Canceled" read-from-minibuffer prompt name completion-result] 7 (#$ . 162736)])
#@205 Read a C++ identifier from point.
Value is (CLASS-NAME MEMBER-NAME).
CLASS-NAME is the name of the class if the identifier was qualified.
It is nil otherwise.
MEMBER-NAME is the name of the member found.
(defalias 'ebrowse-tags-read-member+class-name #[nil "\212\303\304x\210`\303\304w\210`{\304\211	,D\207" [start name class "a-zA-Z0-9_" nil] 3 (#$ . 163651)])
#@283 Read a class name for a member from the minibuffer.
TREE is the class tree we operate on.
HEADER is its header structure.
NAME is the name of the member.
INITIAL-CLASS-NAME is an initial class name to insert in the minibuffer.
Value is a list (TREE ACCESSOR MEMBER) for the member.
(defalias 'ebrowse-tags-choose-class #[(_tree header name initial-class-name) "\306	\"\206\307\310	\"\311\nA@\204\n@A\202)\312\fB\313\314\315\n\316\311
%\n\"A*\207" [header name alist completion-ignore-case unread-command-events initial-class-name ebrowse-class-alist-for-member error "No classes with member `%s' found" t 63 assoc completing-read "In class: " nil] 7 (#$ . 164024)])
#@503 If VIEW is t, view, else find an occurrence of MEMBER-NAME.

If DEFINITION is t, find or view the member definition else its
declaration.  This function reads the member's name from the
current buffer like FIND-TAG.  It then prepares a completion list
of all classes containing a member with the given name and lets
the user choose the class to use.  As a last step, a tags search
is performed that positions point on the member declaration or
definition.

(fn PREFIX &key VIEW DEFINITION MEMBER-NAME)
(defalias 'ebrowse-tags-view/find-member-decl/defn #[(prefix &rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\306\311\"A@\f\203A\f@\312>\203*\fAA\211\202\313>A@\2038\314\211\202\315\316\f@\"\210\202)\317 \211@ 
A@!\320
8\" \204\\\315\321!\210\322 #\314$%\314&%\204\224\323!	\203y\324\202z\325\326\n\203\203\327\202\204\330\331R\"\211'@$'A@%)\332 !%$$&\333#&\"\210\334(	\n&!\335\336\"\"&\210\333\322 &\337#.\207" [#1# view definition member-name #2=#:--cl-keys-- #3=#:--cl-var-- plist-member :view :definition :member-name (:view :definition :member-name :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:view :definition :member-name)" ebrowse-choose-tree 2 "No class tree" point-marker ebrowse-tags-read-name "View" "Find" " member " "definition" "declaration" ": " ebrowse-tags-choose-class ebrowse-push-position ebrowse-view/find-member-declaration/definition buffer-local-value ebrowse--tags-file-name t tree header tree-buffer marker class-name name info #4=#:--cl-var-- prefix] 10 (#$ . 164706)])
#@38 View declaration of member at point.
(defalias 'ebrowse-tags-view-declaration #[nil "\300\301\302\303\304\305%\207" [ebrowse-tags-view/find-member-decl/defn 0 :view t :definition nil] 6 (#$ . 166305) nil])
#@38 Find declaration of member at point.
(defalias 'ebrowse-tags-find-declaration #[nil "\300\301\302\303\304\303%\207" [ebrowse-tags-view/find-member-decl/defn 0 :view nil :definition] 6 (#$ . 166517) nil])
#@37 View definition of member at point.
(defalias 'ebrowse-tags-view-definition #[nil "\300\301\302\303\304\303%\207" [ebrowse-tags-view/find-member-decl/defn 0 :view t :definition] 6 (#$ . 166727) nil])
#@37 Find definition of member at point.
(defalias 'ebrowse-tags-find-definition #[nil "\300\301\302\303\304\305%\207" [ebrowse-tags-view/find-member-decl/defn 0 :view nil :definition t] 6 (#$ . 166933) nil])
#@54 View declaration of member at point in other window.
(defalias 'ebrowse-tags-view-declaration-other-window #[nil "\300\301\302\303\304\305%\207" [ebrowse-tags-view/find-member-decl/defn 4 :view t :definition nil] 6 (#$ . 167143) nil])
#@54 Find declaration of member at point in other window.
(defalias 'ebrowse-tags-find-declaration-other-window #[nil "\300\301\302\303\304\303%\207" [ebrowse-tags-view/find-member-decl/defn 4 :view nil :definition] 6 (#$ . 167384) nil])
#@53 View definition of member at point in other window.
(defalias 'ebrowse-tags-view-definition-other-window #[nil "\300\301\302\303\304\303%\207" [ebrowse-tags-view/find-member-decl/defn 4 :view t :definition] 6 (#$ . 167623) nil])
#@53 Find definition of member at point in other window.
(defalias 'ebrowse-tags-find-definition-other-window #[nil "\300\301\302\303\304\305%\207" [ebrowse-tags-view/find-member-decl/defn 4 :view nil :definition t] 6 (#$ . 167858) nil])
#@52 View definition of member at point in other frame.
(defalias 'ebrowse-tags-view-declaration-other-frame #[nil "\300\301\302\303\304\305%\207" [ebrowse-tags-view/find-member-decl/defn 5 :view t :definition nil] 6 (#$ . 168097) nil])
#@52 Find definition of member at point in other frame.
(defalias 'ebrowse-tags-find-declaration-other-frame #[nil "\300\301\302\303\304\303%\207" [ebrowse-tags-view/find-member-decl/defn 5 :view nil :definition] 6 (#$ . 168335) nil])
#@52 View definition of member at point in other frame.
(defalias 'ebrowse-tags-view-definition-other-frame #[nil "\300\301\302\303\304\303%\207" [ebrowse-tags-view/find-member-decl/defn 5 :view t :definition] 6 (#$ . 168571) nil])
#@52 Find definition of member at point in other frame.
(defalias 'ebrowse-tags-find-definition-other-frame #[nil "\300\301\302\303\304\305%\207" [ebrowse-tags-view/find-member-decl/defn 5 :view nil :definition t] 6 (#$ . 168804) nil])
#@137 Select or create member buffer.
TREE-BUFFER specifies the tree to use.  INFO describes the member.
It is a list (TREE ACCESSOR MEMBER).
(defalias 'ebrowse-tags-select/create-member-buffer #[(tree-buffer info) "\306!\211\204\nq\210\307\310A@\311@#!\210\202,\307	!\210@A@\211\f!\312 \210\313AA@\314H>\204C\315\316\317AA@D\"\210AA@\320H!)\207" [ebrowse-member-buffer-name buffer tree-buffer info ebrowse--displayed-class ebrowse--accessor get-buffer switch-to-buffer ebrowse-display-member-buffer nil ebrowse-redisplay-member-buffer ebrowse-move-point-to-member 0 signal wrong-type-argument ebrowse-ms 1 ebrowse--member-list cl-struct-ebrowse-ms-tags] 6 (#$ . 169042)])
#@139 Display a member buffer for a member.
FIX-NAME non-nil means display the buffer for that member.
Otherwise read a member name from point.
(defalias 'ebrowse-tags-display-member-buffer #[(&optional fix-name) "\306 \211@A@\3078	\204\310\311!\210\312 \313\313\2047\314\n\315\"\211@A@)\316	\n
$\317\f\"\210\320\".\207" [#1=#:--cl-var-- tree header tree-buffer marker class-name ebrowse-choose-tree 2 error "No class tree" point-marker nil ebrowse-tags-read-name "Find member list of: " ebrowse-tags-choose-class ebrowse-push-position ebrowse-tags-select/create-member-buffer fix-name name info #2=#:--cl-var--] 6 (#$ . 169735) nil])
#@157 Return a list of members in table MEMBERS matching REGEXP or NAME.
Both NAME and REGEXP may be nil in which case exact or regexp matches
are not performed.
(defalias 'ebrowse-list-of-matching-members #[(members regexp &optional name) "\304	\204\n\n\203\305\306\"\210)\207" [list name regexp members nil maphash #[(member-name _info) "\203\n	\230\204\n\205\304\n	\"\205	B\211\207" [name member-name regexp list string-match] 3]] 3 (#$ . 170407)])
#@71 Display a list of members matching a regexp read from the minibuffer.
(defalias 'ebrowse-tags-apropos #[nil "\306 \206\307\310!\311\312\"\313	!\314\315\316!
r\317\320!q\210p\321 \210\314\211\322\211\322 \323 \210\324\303!\210+\211!\211\"q\210\323 \210\325\326\f\"c\210\327\n\f\"#\314$#:\203\221#@$\330$\n\"%\314&%:\203\207%@&\331&!\210%A\211%\202p*#A\211#\202[*\314\332!!\210.\207" [buffer header members temp-buffer-setup-hook regexp default-directory ebrowse-choose-from-browser-buffers error "No tree buffer" buffer-local-value ebrowse--header ebrowse-member-table nil read-from-minibuffer "List members matching regexp: " get-buffer-create "*Apropos Members*" kill-all-local-variables t erase-buffer run-hooks format-message "Members matching `%s'\n\n" ebrowse-list-of-matching-members gethash ebrowse-draw-file-member-info internal-temp-output-buffer-show #1=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output #3=#:--cl-var-- s #4=#:--cl-var-- info] 4 (#$ . 170876) nil])
#@87 Display a list of members found in a file.
The file name is read from the minibuffer.
(defalias 'ebrowse-tags-list-members-in-file #[nil "\306 \206\307\310!rq\210\311 )\312\313	\314\315$\316\317\"\314\320!r\321\322\n\323Q!q\210p\324 \210\314\211\315\211\315 \325 \210\326\304!\210+\211!\211\"q\210\327\330
\"\331!!\210.	\207" [buffer files file header temp-buffer-setup-hook members ebrowse-choose-from-browser-buffers error "No tree buffer" ebrowse-files-table completing-read "List members in file: " nil t buffer-local-value ebrowse--header ebrowse-member-table get-buffer-create "*Members in file " "*" kill-all-local-variables erase-buffer run-hooks maphash #[(_member-name list) "\306\211\306	:\203\314	@\211AA@\n@\307H
>\204&\310\311\312\n@D\"\210\n@\313H\307H>\204;\310\311\314D\"\210\315H\204Z\f\307H>\204Q\310\311\316\fD\"\210\f\315H\230\204s\307H>\204l\310\311\314D\"\210\315H\230\203x\317\n\320\"\210\307H>\204\210\310\311\314D\"\210\321H\204\247\f\307H>\204\236\310\311\316\fD\"\210\f\322H\230\204\300\307H>\204\271\310\311\314D\"\210\321H\230\203\305\317\n\323\"\210	A\211\202	,\306\207" [list #1=#:--cl-var-- info member class cl-struct-ebrowse-ts-tags nil 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-ms 4 ebrowse-cs ebrowse-draw-file-member-info "decl." 8 7 "defn." cl-struct-ebrowse-ms-tags cl-struct-ebrowse-cs-tags file] 6] internal-temp-output-buffer-show default-directory #2=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #3=#:buf standard-output] 6 (#$ . 171985) nil])
#@323 Display a line in the members info buffer.
INFO describes the member.  It has the form (TREE ACCESSOR MEMBER).
TREE is the class of the member to display.
ACCESSOR is the accessor symbol of its member list.
MEMBER is the member structure.
KIND is an additional string printed in the buffer.

(fn INFO &optional (KIND ""))
(defalias 'ebrowse-draw-file-member-info #[(info &rest #1=#:--cl-rest--) "\203\f\211A\242\202
\306\203\307\310\311\312G\\D\"\210\n@\211\211\313H\f>\2040\307\314\315D\"\210\316H\313H
>\204R\307\314\317\313H\f>\204L\307\314\315D\"\210\316HD\"\210\313H\f>\204a\307\314\315D\"\210\316H\316H\230)\211 \204\270\313H\f>\204\307\314\315D\"\210\316H\313H!>\204\242\307\314\320\313H\f>\204\234\307\314\315D\"\210\316HD\"\210\313H\f>\204\261\307\314\315D\"\210\316H\316Hc\210\321\nAA@\313H\">\204\317\307\314\322\nAA@D\"\210\nAA@\316H\261\210\323j\210	c\210\324j\210\nA@\211#\325\267\202

\326\202
\327\202
\330\202
\331\202
 \203
\332\202
\333\202
\334\202
\335)\336\261+\207" [#1# kind info tree cl-struct-ebrowse-ts-tags cl-struct-ebrowse-bs-tags "" signal wrong-number-of-arguments ebrowse-draw-file-member-info 2 0 wrong-type-argument ebrowse-ts 1 ebrowse-bs ebrowse-cs "::" ebrowse-ms 40 50 #s(hash-table size 6 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (ebrowse-ts-member-functions 236 ebrowse-ts-member-variables 240 ebrowse-ts-static-functions 244 ebrowse-ts-static-variables 248 ebrowse-ts-friends 252 ebrowse-ts-types 265)) "member function" "member variable" "static function" "static variable" "define" "friend" "type" "unknown" "\n" ebrowse-globals-name globals-p cl-struct-ebrowse-cs-tags cl-struct-ebrowse-ms-tags #2=#:val] 8 (#$ . 173636)])
#@49 Text inserted by the last completion operation.
(defvar ebrowse-last-completion nil (#$ . 175390))
#@63 String which was the basis for the last completion operation.
(defvar ebrowse-last-completion-start nil (#$ . 175495))
#@71 Buffer position at which the last completion operation was initiated.
(defvar ebrowse-last-completion-location nil (#$ . 175620))
#@43 Member used in last completion operation.
(defvar ebrowse-last-completion-obarray nil (#$ . 175756))
(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\207" [make-variable-buffer-local ebrowse-last-completion-obarray ebrowse-last-completion-location ebrowse-last-completion ebrowse-last-completion-start] 2)
#@136 Return a hash table containing all members of a tree.
If there's only one tree loaded, use that.  Otherwise let the
use choose a tree.
(defalias 'ebrowse-some-member-table #[nil "\303 \211@\203A@\204@\202\304 \206\305\306!\307\310	\"\311\n!+\207" [buffers buffer header ebrowse-known-class-trees-buffer-list ebrowse-electric-choose-tree error "No tree buffer" buffer-local-value ebrowse--header ebrowse-member-table] 4 (#$ . 176081)])
#@113 Return the item following STRING in LIST.
If STRING is the last element, return the first element as successor.
(defalias 'ebrowse-cyclic-successor-in-string-list #[(string list) "\302	\303#T	8\206
	@\207" [string list ebrowse-position string=] 4 (#$ . 176536)])
#@223 Perform completion on the C++ symbol preceding point.
A second call of this function without changing point inserts the next match.
A call with prefix PREFIX reads the symbol to insert from the minibuffer with
completion.
(defalias 'ebrowse-tags-complete-symbol #[(prefix) "`\212\306\307x\210`)\211{\307\211
\2034\310 \311\312\307\313\n%\211\2050\307	|\210\fc*\202\242`=\203o\314\"\315\"\211\204R\316\317!\202\242\f\n\230\203^\316\320!\202\242	|\210\fc\210\f`\211\202\242\310 \314\n\307#@\211\313=\206\241\f\204\214\316\321\n\"\202\241	|\210\fc\210`\n\f\211*-\207" [end begin pattern list completion prefix "a-zA-Z_0-9" nil ebrowse-some-member-table completing-read "Insert member: " t all-completions ebrowse-cyclic-successor-in-string-list error "No completion" "No further completion" "Can't find completion for `%s'" members ebrowse-last-completion-location ebrowse-last-completion-start ebrowse-last-completion-obarray ebrowse-last-completion] 7 (#$ . 176808) "P"])
#@120 Form for `ebrowse-loop-continue'.
Evaluated for each file in the tree.  If it returns nil, proceed
with the next file.
(defvar ebrowse-tags-loop-form nil (#$ . 177844))
#@34 A list of files to be processed.
(defvar ebrowse-tags-next-file-list nil (#$ . 178019))
#@55 The path relative to which files have to be searched.
(defvar ebrowse-tags-next-file-path nil (#$ . 178113))
#@48 The last file visited via `ebrowse-tags-loop'.
(defvar ebrowse-tags-loop-last-file nil (#$ . 178228))
#@229 Select next file among files in current tag table.
Non-nil argument INITIALIZE (prefix arg, if interactive) initializes
to the beginning of the list of files in the tag table.
TREE-BUFFER specifies the class tree we operate on.
(defalias 'ebrowse-tags-next-file #[(&optional initialize tree-buffer) "\203	\206\n\306 r\nq\210\307\310 !\311\312
!*\204$\313\314!\210\f\203;\315\f!\211\203:\316\n!\204:\317\n!\210)\320@\"\315!?\205M\210A\321!)\207" [initialize tree-buffer buffer ebrowse-tags-next-file-list ebrowse-tags-loop-last-file ebrowse--tags-file-name ebrowse-choose-from-browser-buffers ebrowse-files-list ebrowse-marked-classes-p nil file-name-directory error "All files processed" get-file-buffer buffer-modified-p kill-buffer expand-file-name find-file ebrowse-tags-next-file-path file] 4 (#$ . 178337) "P"])
#@174 Repeat last operation on files in tree.
FIRST-TIME non-nil means this is not a repetition, but the first time.
TREE-BUFFER if indirectly specifies which files to loop over.
(defalias 'ebrowse-tags-loop-continue #[(&optional first-time tree-buffer) "\203\f\304	\"\210eb\210\305\n!?\205!\304 \210\306\307\"\210eb\210\202\f\207" [first-time tree-buffer ebrowse-tags-loop-form buffer-file-name ebrowse-tags-next-file eval message "Scanning file `%s'..."] 3 (#$ . 179192) nil])
#@148 Search for REGEXP in all files in a tree.
If marked classes exist, process marked classes, only.
If regular expression is nil, repeat last search.
(defalias 'ebrowse-tags-search #[(regexp) "\302\230\203	@\303=\203\304 \207\303\305\306F\304\307!\207" [regexp ebrowse-tags-loop-form "" re-search-forward ebrowse-tags-loop-continue nil t first-time] 4 (#$ . 179678) "sTree search (regexp): "])
#@113 Query replace FROM with TO in all files of a class tree.
With prefix arg, process files of marked classes only.
(defalias 'ebrowse-tags-query-replace #[(from to) "\303\304\305\306\307FD\310\311	\307\211\306\257DE\312\313!\207" [from to ebrowse-tags-loop-form and save-excursion re-search-forward nil t not perform-replace ebrowse-tags-loop-continue first-time] 9 (#$ . 180083) "sTree query replace (regexp): \nsTree query replace %s by: "])
#@250 Search for call sites of a member.
If FIX-NAME is specified, search uses of that member.
Otherwise, read a member name from the minibuffer.
Searches in all files mentioned in a class tree for something that
looks like a function call to the member.
(defalias 'ebrowse-tags-search-member-use #[(&optional fix-name) "\306 \211@A@\3078	\204\310\311!\210\f\312\211\211\2043\313\n\314\"\211@A@)\315\316Q\317
\312\320F\321\322\".\207" [#1=#:--cl-var-- tree header tree-buffer fix-name regexp ebrowse-choose-tree 2 error "No class tree" nil ebrowse-tags-read-name "Find calls of: " "\\<" "[ 	]*(" re-search-forward t ebrowse-tags-loop-continue first-time class-name name #2=#:--cl-var-- ebrowse-tags-loop-form] 5 (#$ . 180535) nil])
#@51 compiler-macro for inlining `ebrowse-position-p'.
(defalias 'ebrowse-position-p--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-position-p (and (vectorp cl-x) (>= (length cl-x) 5) (memq (aref cl-x 0) cl-struct-ebrowse-position-tags) t)) nil] 7 (#$ . 181296)])
(put 'ebrowse-position-p 'compiler-macro 'ebrowse-position-p--cmacro)
(defalias 'ebrowse-position-p #[(cl-x) "\302!\205G\303Y\205\304H	>\205\305\207" [cl-x cl-struct-ebrowse-position-tags vectorp 5 0 t] 2])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ebrowse-position-p side-effect-free error-free put ebrowse-position cl-deftype-satisfies] 5)
#@59 compiler-macro for inlining `ebrowse-position-file-name'.
(defalias 'ebrowse-position-file-name--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-position-file-name (or (and (memq (aref cl-x 0) cl-struct-ebrowse-position-tags)) (signal 'wrong-type-argument (list 'ebrowse-position cl-x))) (aref cl-x 1)) nil] 7 (#$ . 182005)])
(put 'ebrowse-position-file-name 'compiler-macro 'ebrowse-position-file-name--cmacro)
#@84 Access slot "file-name" of `(ebrowse-position (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-position-file-name #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-position-tags 0 signal wrong-type-argument ebrowse-position 1] 4 (#$ . 182490)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-position-file-name side-effect-free t] 4)
#@55 compiler-macro for inlining `ebrowse-position-point'.
(defalias 'ebrowse-position-point--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-position-point (or (and (memq (aref cl-x 0) cl-struct-ebrowse-position-tags)) (signal 'wrong-type-argument (list 'ebrowse-position cl-x))) (aref cl-x 2)) nil] 7 (#$ . 182881)])
(put 'ebrowse-position-point 'compiler-macro 'ebrowse-position-point--cmacro)
#@80 Access slot "point" of `(ebrowse-position (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-position-point #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-position-tags 0 signal wrong-type-argument ebrowse-position 2] 4 (#$ . 183346)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-position-point side-effect-free t] 4)
#@56 compiler-macro for inlining `ebrowse-position-target'.
(defalias 'ebrowse-position-target--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-position-target (or (and (memq (aref cl-x 0) cl-struct-ebrowse-position-tags)) (signal 'wrong-type-argument (list 'ebrowse-position cl-x))) (aref cl-x 3)) nil] 7 (#$ . 183725)])
(put 'ebrowse-position-target 'compiler-macro 'ebrowse-position-target--cmacro)
#@81 Access slot "target" of `(ebrowse-position (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-position-target #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-position-tags 0 signal wrong-type-argument ebrowse-position 3] 4 (#$ . 184195)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-position-target side-effect-free t] 4)
#@54 compiler-macro for inlining `ebrowse-position-info'.
(defalias 'ebrowse-position-info--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ebrowse-position-info (or (and (memq (aref cl-x 0) cl-struct-ebrowse-position-tags)) (signal 'wrong-type-argument (list 'ebrowse-position cl-x))) (aref cl-x 4)) nil] 7 (#$ . 184577)])
(put 'ebrowse-position-info 'compiler-macro 'ebrowse-position-info--cmacro)
#@79 Access slot "info" of `(ebrowse-position (:type vector) :named)' struct CL-X.
(defalias 'ebrowse-position-info #[(cl-x) "\302H	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-ebrowse-position-tags 0 signal wrong-type-argument ebrowse-position 4] 4 (#$ . 185037)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ebrowse-position-info side-effect-free t defalias copy-ebrowse-position copy-sequence] 4)
#@112 compiler-macro for inlining `make-ebrowse-position'.

(fn CL-WHOLE &cl-quote &key FILE-NAME POINT TARGET INFO)
(defalias 'make-ebrowse-position--cmacro #[(cl-whole &rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\306\311\"A@\306\312\"A@
\203H
@\313>\2031
AA\211\202\314>A@\203?\315\211\202\316\317
@\"\210\202)\320\321\322\315\315	\n\f&	,\207" [#1# file-name point target info #2=#:--cl-keys-- plist-member :file-name :point :target :info (:file-name :point :target :info :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:file-name :point :target :info)" cl--defsubst-expand (file-name point target info) (cl-block make-ebrowse-position (vector 'ebrowse-position file-name point target info)) cl-whole] 11 (#$ . 185469)])
(put 'make-ebrowse-position 'compiler-macro 'make-ebrowse-position--cmacro)
#@92 Constructor for objects of type `ebrowse-position'.

(fn &key FILE-NAME POINT TARGET INFO)
(defalias 'make-ebrowse-position #[(&rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\306\311\"A@\306\312\"A@
\203H
@\313>\2031
AA\211\202\314>A@\203?\315\211\202\316\317
@\"\210\202)\320\321	\n\f%,\207" [#1# file-name point target info #2=#:--cl-keys-- plist-member :file-name :point :target :info (:file-name :point :target :info :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:file-name :point :target :info)" vector ebrowse-position] 7 (#$ . 186330)])
(byte-code "\300\301\302\303#\304\305\306\211\307\303\310\311\305\306&	\207" [function-put make-ebrowse-position side-effect-free t cl-struct-define ebrowse-position nil vector ((cl-tag-slot) (file-name) (point) (target) (info)) cl-struct-ebrowse-position-tags] 11)
#@41 Stack of `ebrowse-position' structured.
(defvar ebrowse-position-stack nil (#$ . 187205))
#@37 Current position in position stack.
(defvar ebrowse-position-index 0 (#$ . 187301))
#@104 Return an identifying string for POSITION.
The string is printed in the electric position list buffer.
(defalias 'ebrowse-position-name #[(position) "\306H	>\204\307\310\311D\"\210\312H\306H	>\204\"\307\310\311D\"\210\313H\203,\314\202-\315\n@\306H>\204>\307\310\316\n@D\"\210\n@\317H\306H\f>\204d\307\310\320\n@\306H>\204]\307\310\316\n@D\"\210\n@\317HD\"\210\n@\306H>\204u\307\310\316\n@D\"\210\n@\317H\317H\321\nAA@\306H
>\204\221\307\310\322\nAA@D\"\210\nAA@\317HR)\207" [position cl-struct-ebrowse-position-tags info cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-position 4 3 "at " "to " ebrowse-ts 1 ebrowse-cs "::" ebrowse-ms] 8 (#$ . 187392)])
#@87 Position point on POSITION.
If VIEW is non-nil, view the position, otherwise find it.
(defalias 'ebrowse-view/find-position #[(position &optional view) "\204-\304	\305H\n>\204\306\307\310	D\"\210	\311H!\210	\305H\n>\204(\306\307\310	D\"\210	\312Hb\207\313\216\314B\315	\305H\n>\204C\306\307\310	D\"\210	\311H!)\207" [view position cl-struct-ebrowse-position-tags view-mode-hook find-file 0 signal wrong-type-argument ebrowse-position 1 2 #[nil "\211A\242\207" [view-mode-hook] 2] #[nil "\302H	>\204\303\304\305D\"\210\306Hb\207" [position cl-struct-ebrowse-position-tags 0 signal wrong-type-argument ebrowse-position 2] 4] view-file] 5 (#$ . 188139)])
#@255 Push current position on position stack.
MARKER is the marker to remember as position.
INFO is a list (CLASS FUNC MEMBER) specifying what we jumped to.
TARGET non-nil means we performed a jump.
Positions in buffers that have no file names are not saved.
(defalias 'ebrowse-push-position #[(marker info &optional target) "\306\307!!\2051	G\nZ\211\211\310V\262
\203\311	\"\312\313\306\307!!\314\315!\316\f\317
&	B\211)\207" [marker ebrowse-position-stack ebrowse-max-positions too-much target info buffer-file-name marker-buffer 0 butlast make-ebrowse-position :file-name :point marker-position :target :info] 10 (#$ . 188813)])
#@42 Move by INCREMENT in the position stack.
(defalias 'ebrowse-move-in-position-stack #[(increment) "G\211\304U\203
\305\306!\210\307\n\\	\"\310\311	#\210\3128!)\207" [ebrowse-position-stack length increment ebrowse-position-index 0 error "No positions remembered" mod message "Position %d of %d " ebrowse-view/find-position] 5 (#$ . 189457)])
#@68 Move backward in the position stack.
Prefix arg ARG says how much.
(defalias 'ebrowse-back-in-position-stack #[(arg) "\301\302]!\207" [arg ebrowse-move-in-position-stack 1] 3 (#$ . 189812) "p"])
#@67 Move forward in the position stack.
Prefix arg ARG says how much.
(defalias 'ebrowse-forward-in-position-stack #[(arg) "\301\302[^!\207" [arg ebrowse-move-in-position-stack -1] 3 (#$ . 190014) "p"])
#@48 Keymap used in electric position stack window.
(defvar ebrowse-electric-position-mode-map nil (#$ . 190220))
#@70 If non-nil, its value is called by `ebrowse-electric-position-mode'.
(defvar ebrowse-electric-position-mode-hook nil (#$ . 190335))
(byte-code "\204\231\303 \303 \211\304\nA@\305\"\210\304	A@\305\"\210\306\n\307	#\210\306\n\310\311#\210\306\n\312\313#\210\306\n\314\315#\210\306\n\316\317#\210\306\n\320\321#\210\306\n\322\321#\210\306\n\323\324#\210\306\n\325\326#\210\306\n\327\330#\210\306\n\331\332#\210\306\n\333\334#\210\306\n\335\332#\210\306\n\336\334#\210\306\n\337\340#\210\306\n\341\342#\210\306\n\343\344#\210\306\n\345\346#\210\306\n\347\350#\210\306\n\351\352#\210\306\n\347\350#\210*\353\354\355\356#\210\353\305\357\360#\207" [ebrowse-electric-position-mode-map submap map make-keymap fillarray ebrowse-electric-position-undefined define-key "" "" suspend-frame "" Helper-help "?" Helper-describe-bindings "" nil "" ebrowse-electric-position-quit "q" " " ebrowse-electric-select-position "\f" recenter "" universal-argument "" previous-line "" next-line "p" "n" "v" ebrowse-electric-view-position "" scroll-up-command "v" scroll-down-command "" scroll-other-window ">" end-of-buffer "<" beginning-of-buffer put ebrowse-electric-position-mode mode-class special suppress-keymap t] 5)
(defvar ebrowse-electric-position-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [ebrowse-electric-position-mode-hook variable-documentation put "Hook run after entering Electric Position Menu mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp ebrowse-electric-position-mode-map definition-name ebrowse-electric-position-mode] 4)
(defvar ebrowse-electric-position-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\317#\207" [ebrowse-electric-position-mode-abbrev-table ebrowse-electric-position-mode-map variable-documentation put purecopy "Keymap for `ebrowse-electric-position-mode'." boundp ebrowse-electric-position-mode-syntax-table definition-name ebrowse-electric-position-mode (lambda (#1=#:def-tmp-var) (defvar ebrowse-electric-position-mode-syntax-table #1#)) make-syntax-table "Syntax table for `ebrowse-electric-position-mode'." (lambda (#1#) (defvar ebrowse-electric-position-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `ebrowse-electric-position-mode'." derived-mode-parent] 5)
#@129 Mode for electric position buffers.
Runs the hook `ebrowse-electric-position-mode-hook'.

\{ebrowse-electric-position-mode-map}
(defalias 'ebrowse-electric-position-mode #[nil "\306\300!\210\307\310 \210\311\312\313!\210\314\f!\210
\312\302>\203/\315!\302>\316\240\210\306\317!\210\320\307\211)\321\322!\207" [delay-mode-hooks major-mode mode-name ebrowse-electric-position-mode-map ebrowse-electric-position-mode-syntax-table ebrowse-electric-position-mode-abbrev-table make-local-variable t kill-all-local-variables ebrowse-electric-position-mode "Electric Position Menu" use-local-map set-syntax-table copy-sequence "Positions" Helper-return-blurb "return to buffer editing" run-mode-hooks ebrowse-electric-position-mode-hook local-abbrev-table mode-line-buffer-identification mode-line-format truncate-lines buffer-read-only] 3 (#$ . 192971) nil])
#@42 Display positions in buffer *Positions*.
(defalias 'ebrowse-draw-position-buffer #[nil "\305\306!q\210\307\310 \210\311\312\261\210	\307\211\203Z@\313\n\314H\f>\204*\315\316\317\nD\"\210\n\320H!c\210\321j\210\322\n\314H\f>\204C\315\316\317\nD\"\210\n\323H!c\210\324j\210\325\n!\326\261\210A\211\204*\327\211\207" [buffer-read-only ebrowse-position-stack position --dolist-tail-- cl-struct-ebrowse-position-tags get-buffer-create "*Positions*" nil erase-buffer "File           Point  Description\n" "----           -----  -----------\n" file-name-nondirectory 0 signal wrong-type-argument ebrowse-position 1 15 int-to-string 2 22 ebrowse-position-name "\n" t] 6 (#$ . 193852)])
#@61 List positions in the position stack in an electric buffer.
(defalias 'ebrowse-electric-position-menu #[nil "\204\306\307!\210\310\211\211\311 \312\216\311 \313\216\314 \210*\315\316!\317	!\320	!\210\321\216\nq\210\322 \210\3232]\324\325!\210eb\210\326y\210`db\210\327y\210`\330\211 b\210\331\323\310\332\333 B%+0+\203j\nq\210\334!\210\335\n!+\207" [ebrowse-position-stack window buffer select #1=#:wconfig #2=#:wconfig error "No positions remembered" nil current-window-configuration #[nil "\301!\207" [#1# set-window-configuration] 2] #[nil "\301!\207" [#2# set-window-configuration] 2] ebrowse-draw-position-buffer Electric-pop-up-window "*Positions*" window-buffer shrink-window-if-larger-than-buffer #[nil "q\210\301!\210\302\303!\207" [buffer bury-buffer message nil] 2] ebrowse-electric-position-mode ebrowse-electric-select-position message "<<< Press Space to bury the list >>>" 2 -1 0 Electric-command-loop t ebrowse-electric-position-looper ebrowse-electric-find-position kill-buffer goal-column last first] 8 (#$ . 194550) nil])
#@128 Prevent moving point on invalid lines.
Called from `Electric-command-loop'.  See there for the meaning
of STATE and CONDITION.
(defalias 'ebrowse-electric-position-looper #[(state condition) "\203@\302>\204\303@A\"\207`	@W\203eb\210\304y\207`	AV\2055db\210\305y\210\306d!\2055\307\305!\207" [condition state (buffer-read-only end-of-buffer beginning-of-buffer) signal 2 -1 pos-visible-in-window-p recenter] 3 (#$ . 195625)])
#@37 Function called for undefined keys.
(defalias 'ebrowse-electric-position-undefined #[nil "\300\301!\210\302\303!\207" [message "Type C-h for help, ? for commands, q to quit, Space to execute" sit-for 4] 2 (#$ . 196068) nil])
#@35 Leave the electric position list.
(defalias 'ebrowse-electric-position-quit #[nil "\300\301\302\"\207" [throw ebrowse-electric-select-position nil] 3 (#$ . 196299) nil])
#@34 Select a position from the list.
(defalias 'ebrowse-electric-select-position #[nil "\300\301`\"\207" [throw ebrowse-electric-select-position] 3 (#$ . 196475) nil])
#@100 View/find what is described by the line at POINT.
If VIEW is non-nil, view else find source files.
(defalias 'ebrowse-electric-find-position #[(point &optional view) "\304e\"\305Z\306	\n8\")\207" [point index ebrowse-position-stack view count-lines 2 ebrowse-view/find-position] 3 (#$ . 196646)])
#@54 View the position described by the line point is in.
(defalias 'ebrowse-electric-view-position #[nil "\300`\301\"\207" [ebrowse-electric-find-position t] 3 (#$ . 196952) nil])
#@78 Write current buffer as a class tree.
Installed on `local-write-file-hooks'.
(defalias 'ebrowse-write-file-hook-fn #[nil "\300 \210\301\207" [ebrowse-save-tree t] 1 (#$ . 197134)])
#@52 Save current tree in same file it was loaded from.
(defalias 'ebrowse-save-tree #[nil "\302\206	!\207" [buffer-file-name ebrowse--tags-file-name ebrowse-save-tree-as] 2 (#$ . 197321) nil])
#@166 Write the current tree data structure to a file.
Read the file name from the minibuffer if interactive.
Otherwise, FILE-NAME specifies the file to save the tree in.
(defalias 'ebrowse-save-tree-as #[(&optional file-name) "\306\307!\310	!\n\311\216r\211q\210\312 \210\f\313H>\204)\314\315\316\fD\"\210\f\211\317\320I\210)\321\f!\322\261\210\323\324\"\210\325!\210\326\327\".\207" [standard-output ebrowse--header ebrowse--tree tree header old-standard-output get-buffer-create "*Tree Output" copy-ebrowse-hs #[nil "\303!\210\304\305!\210\306 \210	\211\207" [temp-buffer old-standard-output standard-output kill-buffer set-buffer-modified-p nil ebrowse-update-tree-buffer-mode-line] 2] erase-buffer 0 signal wrong-type-argument ebrowse-hs 4 nil prin1-to-string " " mapc ebrowse-save-class write-file message "Tree written to file `%s'" temp-buffer cl-struct-ebrowse-hs-tags #1=#:v file-name] 5 (#$ . 197520) "FSave tree as: "])
#@45 Write single class CLASS to current buffer.
(defalias 'ebrowse-save-class #[(class) "\306\307\310H	>\204\311\312\313D\"\210\314H\310H\n>\2043\311\312\315\310H	>\204-\311\312\313D\"\210\314HD\"\210\310H	>\204B\311\312\313D\"\210\314H\314H\"\210\316c\210\317\310H	>\204\\\311\312\313D\"\210\314H!\210\320c\210\321\322\310H	>\204u\311\312\313D\"\210\323H\"\210\324c\210\325\211\203\230
@\317\f!!\210\326c\210
A\211\204\205*\327c\210\317\310H	>\204\254\311\312\313D\"\210\330H!\210\331c\207" [class cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags ebrowse-member-list-accessors func --dolist-tail-- message "%s..." 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs "[ebrowse-ts " prin1 "(" mapc ebrowse-save-class 2 ")" nil "\n" "()" 10 "]\n"] 10 (#$ . 198475)])
#@38 Display statistics for a class tree.
(defalias 'ebrowse-statistics #[nil "\305 \306\nr\307\310!q\210p\311 \210\306\211\312\211\312\313 \210\314\300!\210+\211\315 \211 @! A@\"\316 8#\317 8$\320 8%q\210\313 \210\321	\206Z\322\323\261\210\324\325!\"\210\324\326\"\"\210\324\327#\"\210\324\330$\"\210\324\331%\".\332!\210-\207" [temp-buffer-setup-hook tree-file default-directory #1=#:old-dir buffer-read-only buffer-file-name nil get-buffer-create "*Tree Statistics*" kill-all-local-variables t erase-buffer run-hooks ebrowse-gather-statistics 2 3 4 "STATISTICS FOR TREE " "unknown" ":\n\n" ebrowse-print-statistics-line "Number of classes:" "Number of member functions:" "Number of member variables:" "Number of static functions:" "Number of static variables:" internal-temp-output-buffer-show buffer-undo-list inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output #3=#:--cl-var-- classes member-functions member-variables static-functions static-variables] 4 (#$ . 199280) nil])
#@116 Print a line in the statistics buffer.
TITLE is the title of the line, VALUE is a number to be printed
after that.
(defalias 'ebrowse-print-statistics-line #[(title value) "c\210\302j\210\303\304	\"c\207" [title value 40 format "%d\n"] 3 (#$ . 200320)])
#@188 Return statistics for a class tree.
The result is a list (NUMBER-OF-CLASSES NUMBER-OF-MEMBER-FUNCTIONS
NUMBER-OF-INSTANCE-VARIABLES NUMBER-OF-STATIC-FUNCTIONS
NUMBER-OF-STATIC-VARIABLES:
(defalias 'ebrowse-gather-statistics #[nil "\306\211\211\211\211\307\310\311\n\"\210)\f\n	\257-\207" [static-variables static-functions member-variables member-functions classes tree 0 nil mapatoms #[(#1=#:var) "\306N\307	!\205j\nT	\310H\f>\204\311\312\313	D\"\210	\314HG\\
	\310H\f>\2043\311\312\313	D\"\210	\315HG\\	\310H\f>\204J\311\312\313	D\"\210	\316HG\\	\310H\f>\204b\311\312\313	D\"\210	\317HG\\\211\207" [#1# tree classes member-functions cl-struct-ebrowse-ts-tags member-variables ebrowse-root vectorp 0 signal wrong-type-argument ebrowse-ts 4 3 6 5 static-functions static-variables] 5] ebrowse--tree-obarray] 5 (#$ . 200582)])
#@30 Keymap for Ebrowse commands.
(defvar ebrowse-global-map nil (#$ . 201444))
#@34 Prefix key for Ebrowse commands.
(defvar ebrowse-global-prefix-key "
" (#$ . 201525))
#@58 Keymap used for `ebrowse-global-prefix' followed by `4'.
(defvar ebrowse-global-submap-4 nil (#$ . 201618))
#@58 Keymap used for `ebrowse-global-prefix' followed by `5'.
(defvar ebrowse-global-submap-5 nil (#$ . 201732))
(byte-code "\204\315\305 \305 \305 \306\307\310#\210\306\311\312#\210\306\313\314#\210\306\315\316#\210\306\317\320#\210\306\321\322#\210\306\323\324#\210\306\325\326#\210\306\327\330#\210\306\331\332#\210\306\333\334#\210\306\335\336#\210\306\337\340#\210\306\341\342#\210\306\343\342#\210\306\344\345#\210\306\346\347#\210\306\350\351#\210\306\352\353#\210\306\354	#\210\306	\341\355#\210\306	\343\355#\210\306	\333\356#\210\306	\344\357#\210\306	\335\360#\210\306\361\n#\210\306\n\341\362#\210\306\n\343\362#\210\306\n\333\363#\210\306\n\344\364#\210\306\n\335\365#\210\306\f#\210\305\207" [ebrowse-global-map ebrowse-global-submap-4 ebrowse-global-submap-5 global-map ebrowse-global-prefix-key make-sparse-keymap define-key "a" ebrowse-tags-apropos "b" ebrowse-pop-to-browser-buffer "-" ebrowse-back-in-position-stack "+" ebrowse-forward-in-position-stack "l" ebrowse-tags-list-members-in-file "m" ebrowse-tags-display-member-buffer "n" ebrowse-tags-next-file "p" ebrowse-electric-position-menu "s" ebrowse-tags-search "u" ebrowse-tags-search-member-use "v" ebrowse-tags-view-definition "V" ebrowse-tags-view-declaration "%" ebrowse-tags-query-replace "." ebrowse-tags-find-definition "f" "F" ebrowse-tags-find-declaration "," ebrowse-tags-loop-continue " " ebrowse-electric-buffer-list "	" ebrowse-tags-complete-symbol "4" ebrowse-tags-find-definition-other-window ebrowse-tags-find-declaration-other-window ebrowse-tags-view-definition-other-window ebrowse-tags-view-declaration-other-window "5" ebrowse-tags-find-definition-other-frame ebrowse-tags-find-declaration-other-frame ebrowse-tags-view-definition-other-frame ebrowse-tags-view-declaration-other-frame] 4)
(defvar electric-buffer-menu-mode-hook nil)
#@59 Hack the electric buffer menu to display browser buffers.
(defalias 'ebrowse-hack-electric-buffer-menu #[nil "\303\304\216\212\303\305b\210\306y\210m?\205<\307\303!\310\n!\204$\311\n!\312\230\203,\305y\210\313\2028`\212\303\210d`T^)|\210)\202
+\207" [non-empty buffer-read-only b nil #[nil "\204\303\304!\210\305\306!	\244\307\310 !\210\311\211\207" [non-empty unread-command-events buffer-read-only error "No tree buffers" listify-key-sequence "p" shrink-window-if-larger-than-buffer selected-window t] 2] 1 2 Buffer-menu-buffer ebrowse-buffer-p buffer-name "*Apropos Members*" t] 3 (#$ . 203590)])
#@52 Select the nth entry in the list by the keys 1..9.
(defalias 'ebrowse-select-1st-to-9nth #[nil "\302ed\"\211\303\304\305 !\\^eb\210	Sy\210\306\307`\"*\207" [maxlin n count-lines 2 string-to-number this-command-keys throw electric-buffer-menu-select] 5 (#$ . 204211) nil])
#@63 Define keys 1..9 to select the 1st to 9nth entry in the list.
(defalias 'ebrowse-install-1-to-9-keys #[nil "\302\303	W\205\304\305 \306\307\\!\310#\210T\211\202*\207" [i --dotimes-limit-- 9 0 define-key current-local-map char-to-string 49 ebrowse-select-1st-to-9nth] 6 (#$ . 204491)])
#@46 Display an electric list of Ebrowse buffers.
(defalias 'ebrowse-electric-buffer-list #[nil "\300\216\301\302\303\"\210\301\302\304\"\210\305\306!)\207" [#[nil "\300\301\302\"\207" [remove-hook electric-buffer-menu-mode-hook ebrowse-hack-electric-buffer-menu] 3] add-hook electric-buffer-menu-mode-hook ebrowse-hack-electric-buffer-menu ebrowse-install-1-to-9-keys call-interactively electric-buffer-list] 3 (#$ . 204792) nil])
#@77 Find the member clicked on in another frame.
EVENT is a mouse button event.
(defalias 'ebrowse-mouse-find-member #[(event) "\303!\210\304\211\212\305\304x\210`\305\304w\210\n`{)\306\307\310\304\311\312\313	&*\207" [event name start mouse-set-point nil "a-zA-Z0-9_" ebrowse-tags-view/find-member-decl/defn 5 :view :definition t :member-name] 8 (#$ . 205225) "e"])
#@88 Pop up MENU and perform an action if something was selected.
EVENT is the mouse event.
(defalias 'ebrowse-popup-menu #[(menu event) "\305 r\306\216\307\310	!\211@\262
!\210\311	\n\"\312\211\203.\313\206!\n\314\f@!\"\fA\211\204\2055\315!-\207" [save-selected-window--state event menu binding selection internal--before-save-selected-window #[nil "\301!\207" [save-selected-window--state internal--after-save-selected-window] 2] select-window event-start x-popup-menu nil lookup-key vector call-interactively] 5 (#$ . 205600)])
#@44 Object menu for classes in the tree buffer
(defvar ebrowse-tree-buffer-class-object-menu nil (#$ . 206146))
(easy-menu-do-define 'ebrowse-tree-buffer-class-object-menu ebrowse-tree-mode-map "Object menu for classes in the tree buffer" '("Class" ["Functions" ebrowse-tree-command:show-member-functions :help "Display a list of member functions" :active t] ["Variables" ebrowse-tree-command:show-member-variables :help "Display a list of member variables" :active t] ["Static Functions" ebrowse-tree-command:show-static-member-functions :help "Display a list of static member functions" :active t] ["Static Variables" ebrowse-tree-command:show-static-member-variables :help "Display a list of static member variables" :active t] ["Friends/ Defines" ebrowse-tree-command:show-friends :help "Display a list of friends of a class" :active t] ["Types" ebrowse-tree-command:show-types :help "Display a list of types defined in a class" :active t] "-----------------" ["View" ebrowse-view-class-declaration :help "View class declaration" :active (eq (get-text-property (point) 'ebrowse-what) 'class-name)] ["Find" ebrowse-find-class-declaration :help "Find class declaration in file" :active (eq (get-text-property (point) 'ebrowse-what) 'class-name)] "-----------------" ["Mark" ebrowse-toggle-mark-at-point :help "Mark class point is on" :active (eq (get-text-property (point) 'ebrowse-what) 'class-name)] "-----------------" ["Collapse" ebrowse-collapse-branch :help "Collapse subtree under class point is on" :active (eq (get-text-property (point) 'ebrowse-what) 'class-name)] ["Expand" ebrowse-expand-branch :help "Expand subtree under class point is on" :active (eq (get-text-property (point) 'ebrowse-what) 'class-name)]))
#@30 Object menu for tree buffers
(defvar ebrowse-tree-buffer-object-menu nil (#$ . 207874))
(easy-menu-do-define 'ebrowse-tree-buffer-object-menu ebrowse-tree-mode-map "Object menu for tree buffers" '("Ebrowse" ["Filename Display" ebrowse-toggle-file-name-display :help "Toggle display of source files names" :style toggle :selected ebrowse--show-file-names-flag :active t] ["Tree Indentation" ebrowse-set-tree-indentation :help "Set the tree's indentation" :active t] ["Unmark All Classes" ebrowse-mark-all-classes :help "Unmark all classes in the class tree" :active t] ["Expand All" ebrowse-expand-all :help "Expand all subtrees in the class tree" :active t] ["Statistics" ebrowse-statistics :help "Show a buffer with class hierarchy statistics" :active t] ["Find Class" ebrowse-read-class-name-and-go :help "Find a class in the tree" :active t] ["Member Buffer" ebrowse-pop/switch-to-member-buffer-for-same-tree :help "Show a member buffer for this class tree" :active t]))
#@66 Perform mouse actions in tree buffers.
EVENT is the mouse event.
(defalias 'ebrowse-mouse-3-in-tree-buffer #[(event) "\306!\210\307\310!!\311	\312\"\211:\203$\313
8\250\203$\313
8\262
\202'\314\262
\211\314=\205?\n\315=\203;\316\f\"\202?\316
\"+\207" [event where property #1=#:val ebrowse-tree-buffer-class-object-menu ebrowse-tree-buffer-object-menu mouse-set-point posn-point event-start get-text-property ebrowse-what 2 1 class-name ebrowse-popup-menu] 4 (#$ . 208854) "e"])
#@66 Perform mouse actions in tree buffers.
EVENT is the mouse event.
(defalias 'ebrowse-mouse-2-in-tree-buffer #[(event) "\304!\210\305\306!!\307	\310\"\211:\203$\311
8\250\203$\311
8\262
\202'\312\262
\211\312=\2056\n\313=\2056\314 +\207" [event where property #1=#:val mouse-set-point posn-point event-start get-text-property ebrowse-what 2 1 class-name ebrowse-tree-command:show-member-functions] 4 (#$ . 209353) "e"])
#@66 Perform mouse actions in tree buffers.
EVENT is the mouse event.
(defalias 'ebrowse-mouse-1-in-tree-buffer #[(event) "\305!\210\306\307!!\310	\311\"\211:\203$\312
8\250\203$\312
8\262
\202'\313\262
\211\312=\205M\n\314\267\202L\212\315\316w\210\317\320!)\321\f?!)\202M\322\313!\202M\316+\207" [event where property #1=#:val collapsed mouse-set-point posn-point event-start get-text-property ebrowse-what 2 1 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (class-name 52 mark 70)) "^
\n" nil looking-at "
" ebrowse-collapse-fn ebrowse-toggle-mark-at-point] 4 (#$ . 209788) "e"])
(provide 'ebrowse)