Current File : //kunden/usr/share/emacs/27.2/lisp/progmodes/ebrowse.elc

;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

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


(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\210\305\306\307\310\311\312%\210\313\314\315\316\317DD\320\311\306\321\322&\210\313\323\315\316\324DD\325\311\306\321\326&\210\313\327\315\316\330DD\331\311\306\321\326&\210\313\332\315\316\333DD\334\311\306\321\326&\210\313\335\315\316\336DD\337\311\306\321\340&\210\305\341\307\342\311\306%\210\313\343\315\316\344DD\345\311\341\321\326&\210\313\346\315\316\347DD\350\311\341\321\351&\210\313\352\315\316\353DD\354\311\341\321\340&\210\313\355\315\316\356DD\357\311\341\321\340&\210\313\360\315\316\361DD\362\311\341\321\340&\210\305\363\307\364\311\306%\210\313\365\315\316\366DD\367\311\363\321\340&\210\313\370\315\316\371DD\372\311\363\321\340&\210\313\373\315\316\374DD\375\311\363\321\351&\210\313\376\315\316\377DD\201@\311\363\321\326&\210\305\201A\307\201B\311\306%\210\201C\201D\201E\201F\311\201A%\210\201C\201G\201H\201I\311\201A%\210\201C\201J\201K\201L\311\201A%\210\201C\201M\201N\201O\311\201A%\210\201C\201P\201Q\201R\311\201A%\210\201C\201S\201T\201U\311\201A%\210\201C\201V\201W\201X\311\201A%\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 funcall function #[0 "\300\207" [nil] 1] "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 #[0 "\300\207" [nil] 1] "Hooks run after finding or viewing a member or class." hook ebrowse-not-found-hook #[0 "\300\207" [nil] 1] "Hooks run when finding or viewing a member or class was not successful." ebrowse-electric-list-mode-hook #[0 "\300\207" [nil] 1] "Hook called by `ebrowse-electric-position-mode'." ebrowse-max-positions #[0 "\300\207" [50] 1] "Number of markers saved on electric position stack." integer ebrowse-tree "Settings for class tree buffers." ebrowse-tree-mode-hook #[0 "\300\207" [nil] 1] "Hook run in each new tree buffer." ebrowse-tree-buffer-name #[0 "\300\207" [#1="*Tree*"] 1 #1#] "The default name of class tree buffers." string ebrowse--indentation #[0 "\300\207" [4] 1] "The amount by which subclasses are indented in the tree." ebrowse-source-file-column #[0 "\300\207" [40] 1] "The column in which source file names are displayed in the tree." ebrowse-tree-left-margin #[0 "\300\207" [2] 1] "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 #[0 "\300\207" [25] 1] "The column in which member declarations are displayed in member buffers." ebrowse-default-column-width #[0 "\300\207" [25] 1] "The width of the columns in member buffers (short display form)." ebrowse-member-buffer-name #[0 "\300\207" [#2="*Members*"] 1 #2#] "The name of the buffer for member display." ebrowse-member-mode-hook #[0 "\300\207" [nil] 1] "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)
#@131 Return true if PREDICATE is true of some element of VECTOR.
If so, return the value returned by PREDICATE.

(fn PREDICATE VECTOR)
(defalias 'ebrowse-some #[514 "\211G\300\301
W\203\211\204H!\262

T\262\202\207" [0 nil] 8 (#$ . 4436)])
#@85 Return true if PREDICATE is true of every element of VECTOR.

(fn PREDICATE VECTOR)
(defalias 'ebrowse-every #[514 "\211G\300\301
W\203\211\203H!\262

T\262\202\207" [0 t] 8 (#$ . 4688)])
#@135 Return the position of ITEM in LIST or nil if not found.
Compare items with `eq' or TEST if specified.

(fn ITEM LIST &optional TEST)
(defalias 'ebrowse-position #[770 "\300\301\203#\203?@\"\203
\262
\301\262A\262
T\262\202\203?@=\2034
\262
\301\262A\262
T\262\202#\207" [0 nil] 8 (#$ . 4894)])
#@70 Eval BODY with `completion-ignore-case' bound to t.

(fn &rest BODY)
(defalias 'ebrowse-ignoring-completion-case '(macro . #[128 "\300\301BB\207" [let ((completion-ignore-case t))] 4 (#$ . 5220)]))
(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 For all trees in SPEC, eval BODY.

(fn SPEC &rest BODY)
(defalias 'ebrowse-for-all-trees '(macro . #[385 "\300\301!@A@\302\303\304\305\306\307\310\n\311\312\313BB\314\315\316DBB\257\207" [make-symbol "var" cl-loop for being the symbols of as = get ('ebrowse-root) do when vectorp] 21 (#$ . 5574)]))
(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)
#@62 Set face of a region START END to FACE.

(fn START END FACE)
(defalias 'ebrowse-set-face #[771 "\300\301\"\302#\207" [overlay-put make-overlay face] 7 (#$ . 6047)])
(put 'ebrowse-set-face 'byte-optimizer 'byte-compile-inline-expand)
#@502 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.

(fn PROMPT TABLE INITIAL-INPUT)
(defalias 'ebrowse-completing-read-value #[771 "\301\302\303\301%)\207" [completion-ignore-case t completing-read nil] 9 (#$ . 6290)])
#@115 Rename current buffer to NEW-NAME.
If a buffer with name NEW-NAME already exists, delete it first.

(fn NEW-NAME)
(defalias 'ebrowse-rename-buffer #[257 "\300
!\211p=?\205\211\203\212\301
!\210)\302!\207" [get-buffer kill-buffer rename-buffer] 4 (#$ . 6937)])
#@123 Return a copy of STRING with leading white space removed.
Replace sequences of newlines with a single space.

(fn STRING)
(defalias 'ebrowse-trim-string #[257 "\300\301\"\203\302
\303\225\"\262
\300\304\"\203 \305\306\307\310$\262
\202\207" [string-match "^[ 	\n]+" substring 0 "[\n]+" replace-match " " nil t] 6 (#$ . 7209)])
#@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 #[0 "\300p!\211\203
\301
!\202\302 \207" [get-buffer-window window-width frame-width] 3 (#$ . 7551)])
#@69 compiler-macro for inlining `ebrowse-hs-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-hs-p--cmacro #[514 "\300\301\302\303\211\211&\207" [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] 9 (#$ . 7867)])
(put 'ebrowse-hs-p 'compiler-macro 'ebrowse-hs-p--cmacro)
#@13 

(fn CL-X)
(defalias 'ebrowse-hs-p #[257 "\301
!\205\211G\302Y\205\211\303H>\205\304\207" [cl-struct-ebrowse-hs-tags vectorp 5 0 t] 3 (#$ . 8236)])
(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)
#@75 compiler-macro for inlining `ebrowse-hs-version'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-hs-version--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-hs-version (progn (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] 9 (#$ . 8545)])
(put 'ebrowse-hs-version 'compiler-macro 'ebrowse-hs-version--cmacro)
#@63 Access slot "version" of `ebrowse-hs' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-hs-version #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-hs-tags 0 signal wrong-type-argument ebrowse-hs 1] 5 (#$ . 8987)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-hs-version side-effect-free t] 4)
#@88 compiler-macro for inlining `ebrowse-hs-command-line-options'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-hs-command-line-options--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-hs-command-line-options (progn (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] 9 (#$ . 9325)])
(put 'ebrowse-hs-command-line-options 'compiler-macro 'ebrowse-hs-command-line-options--cmacro)
#@76 Access slot "command-line-options" of `ebrowse-hs' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-hs-command-line-options #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-hs-tags 0 signal wrong-type-argument ebrowse-hs 2] 5 (#$ . 9832)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-hs-command-line-options side-effect-free t] 4)
#@74 compiler-macro for inlining `ebrowse-hs-unused'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-hs-unused--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-hs-unused (progn (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] 9 (#$ . 10209)])
(put 'ebrowse-hs-unused 'compiler-macro 'ebrowse-hs-unused--cmacro)
#@62 Access slot "unused" of `ebrowse-hs' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-hs-unused #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-hs-tags 0 signal wrong-type-argument ebrowse-hs 3] 5 (#$ . 10647)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-hs-unused side-effect-free t] 4)
#@80 compiler-macro for inlining `ebrowse-hs-member-table'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-hs-member-table--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-hs-member-table (progn (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] 9 (#$ . 10983)])
(put 'ebrowse-hs-member-table 'compiler-macro 'ebrowse-hs-member-table--cmacro)
#@68 Access slot "member-table" of `ebrowse-hs' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-hs-member-table #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-hs-tags 0 signal wrong-type-argument ebrowse-hs 4] 5 (#$ . 11451)])
(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 #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\211\203D\211@\305>\203,\211AA\262
\202\306>A@\203;\307\262
\202\310\311@\"\210\202\210\312\313\314\307	\307				&	\207" [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))] 16 (#$ . 11855)])
(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 #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\211\203D\211@\305>\203,\211AA\262
\202\306>A@\203;\307\262
\202\310\311@\"\210\202\210\312\313%\207" [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] 11 (#$ . 12727)])
(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)
#@69 compiler-macro for inlining `ebrowse-ts-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ts-p--cmacro #[514 "\300\301\302\303\211\211&\207" [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] 9 (#$ . 13660)])
(put 'ebrowse-ts-p 'compiler-macro 'ebrowse-ts-p--cmacro)
#@13 

(fn CL-X)
(defalias 'ebrowse-ts-p #[257 "\301
!\205\211G\302Y\205\211\303H>\205\304\207" [cl-struct-ebrowse-ts-tags vectorp 11 0 t] 3 (#$ . 14031)])
(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)
#@73 compiler-macro for inlining `ebrowse-ts-class'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ts-class--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-class (progn (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] 9 (#$ . 14342)])
(put 'ebrowse-ts-class 'compiler-macro 'ebrowse-ts-class--cmacro)
#@61 Access slot "class" of `ebrowse-ts' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ts-class #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 1] 5 (#$ . 14775)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-class side-effect-free t] 4)
#@78 compiler-macro for inlining `ebrowse-ts-subclasses'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ts-subclasses--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-subclasses (progn (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] 9 (#$ . 15108)])
(put 'ebrowse-ts-subclasses 'compiler-macro 'ebrowse-ts-subclasses--cmacro)
#@66 Access slot "subclasses" of `ebrowse-ts' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ts-subclasses #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 2] 5 (#$ . 15566)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-subclasses side-effect-free t] 4)
#@84 compiler-macro for inlining `ebrowse-ts-member-variables'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ts-member-variables--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-member-variables (progn (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] 9 (#$ . 15914)])
(put 'ebrowse-ts-member-variables 'compiler-macro 'ebrowse-ts-member-variables--cmacro)
#@72 Access slot "member-variables" of `ebrowse-ts' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ts-member-variables #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 3] 5 (#$ . 16402)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-member-variables side-effect-free t] 4)
#@84 compiler-macro for inlining `ebrowse-ts-member-functions'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ts-member-functions--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-member-functions (progn (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] 9 (#$ . 16768)])
(put 'ebrowse-ts-member-functions 'compiler-macro 'ebrowse-ts-member-functions--cmacro)
#@72 Access slot "member-functions" of `ebrowse-ts' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ts-member-functions #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 4] 5 (#$ . 17256)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-member-functions side-effect-free t] 4)
#@84 compiler-macro for inlining `ebrowse-ts-static-variables'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ts-static-variables--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-static-variables (progn (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] 9 (#$ . 17622)])
(put 'ebrowse-ts-static-variables 'compiler-macro 'ebrowse-ts-static-variables--cmacro)
#@72 Access slot "static-variables" of `ebrowse-ts' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ts-static-variables #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 5] 5 (#$ . 18110)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-static-variables side-effect-free t] 4)
#@84 compiler-macro for inlining `ebrowse-ts-static-functions'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ts-static-functions--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-static-functions (progn (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] 9 (#$ . 18476)])
(put 'ebrowse-ts-static-functions 'compiler-macro 'ebrowse-ts-static-functions--cmacro)
#@72 Access slot "static-functions" of `ebrowse-ts' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ts-static-functions #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 6] 5 (#$ . 18964)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-static-functions side-effect-free t] 4)
#@75 compiler-macro for inlining `ebrowse-ts-friends'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ts-friends--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-friends (progn (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] 9 (#$ . 19330)])
(put 'ebrowse-ts-friends 'compiler-macro 'ebrowse-ts-friends--cmacro)
#@63 Access slot "friends" of `ebrowse-ts' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ts-friends #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 7] 5 (#$ . 19773)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-friends side-effect-free t] 4)
#@73 compiler-macro for inlining `ebrowse-ts-types'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ts-types--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-types (progn (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] 9 (#$ . 20112)])
(put 'ebrowse-ts-types 'compiler-macro 'ebrowse-ts-types--cmacro)
#@61 Access slot "types" of `ebrowse-ts' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ts-types #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 8] 5 (#$ . 20545)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-types side-effect-free t] 4)
#@80 compiler-macro for inlining `ebrowse-ts-base-classes'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ts-base-classes--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-base-classes (progn (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] 9 (#$ . 20878)])
(put 'ebrowse-ts-base-classes 'compiler-macro 'ebrowse-ts-base-classes--cmacro)
#@68 Access slot "base-classes" of `ebrowse-ts' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ts-base-classes #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 9] 5 (#$ . 21346)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ts-base-classes side-effect-free t] 4)
#@72 compiler-macro for inlining `ebrowse-ts-mark'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ts-mark--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ts-mark (progn (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] 9 (#$ . 21700)])
(put 'ebrowse-ts-mark 'compiler-macro 'ebrowse-ts-mark--cmacro)
#@60 Access slot "mark" of `ebrowse-ts' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ts-mark #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ts-tags 0 signal wrong-type-argument ebrowse-ts 10] 5 (#$ . 22129)])
(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 #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\n\211\203n\211@\313>\203V\211AA\262
\202C\314\f>A@\203e\315\262
\202C\316\317@\"\210\202C\210\320\321\322\315\315&\207" [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))] 28 (#$ . 22510)])
(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 #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\n\211\203n\211@\313>\203V\211AA\262
\202C\314\f>A@\203e\315\262
\202C\316\317@\"\210\202C\210\320\321&\207" [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] 23 (#$ . 23907)])
(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)
#@69 compiler-macro for inlining `ebrowse-bs-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-bs-p--cmacro #[514 "\300\301\302\303\211\211&\207" [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] 9 (#$ . 25456)])
(put 'ebrowse-bs-p 'compiler-macro 'ebrowse-bs-p--cmacro)
#@13 

(fn CL-X)
(defalias 'ebrowse-bs-p #[257 "\301
!\205\211G\302Y\205\211\303H>\205\304\207" [cl-struct-ebrowse-bs-tags vectorp 7 0 t] 3 (#$ . 25826)])
(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)
#@72 compiler-macro for inlining `ebrowse-bs-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-bs-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-bs-name (progn (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] 9 (#$ . 26136)])
(put 'ebrowse-bs-name 'compiler-macro 'ebrowse-bs-name--cmacro)
#@60 Access slot "name" of `ebrowse-bs' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-bs-name #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-bs-tags 0 signal wrong-type-argument ebrowse-bs 1] 5 (#$ . 26564)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-bs-name side-effect-free t] 4)
#@73 compiler-macro for inlining `ebrowse-bs-scope'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-bs-scope--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-bs-scope (progn (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] 9 (#$ . 26894)])
(put 'ebrowse-bs-scope 'compiler-macro 'ebrowse-bs-scope--cmacro)
#@61 Access slot "scope" of `ebrowse-bs' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-bs-scope #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-bs-tags 0 signal wrong-type-argument ebrowse-bs 2] 5 (#$ . 27327)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-bs-scope side-effect-free t] 4)
#@73 compiler-macro for inlining `ebrowse-bs-flags'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-bs-flags--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-bs-flags (progn (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] 9 (#$ . 27660)])
(put 'ebrowse-bs-flags 'compiler-macro 'ebrowse-bs-flags--cmacro)
#@61 Access slot "flags" of `ebrowse-bs' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-bs-flags #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-bs-tags 0 signal wrong-type-argument ebrowse-bs 3] 5 (#$ . 28093)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-bs-flags side-effect-free t] 4)
#@72 compiler-macro for inlining `ebrowse-bs-file'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-bs-file--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-bs-file (progn (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] 9 (#$ . 28426)])
(put 'ebrowse-bs-file 'compiler-macro 'ebrowse-bs-file--cmacro)
#@60 Access slot "file" of `ebrowse-bs' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-bs-file #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-bs-tags 0 signal wrong-type-argument ebrowse-bs 4] 5 (#$ . 28854)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-bs-file side-effect-free t] 4)
#@75 compiler-macro for inlining `ebrowse-bs-pattern'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-bs-pattern--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-bs-pattern (progn (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] 9 (#$ . 29184)])
(put 'ebrowse-bs-pattern 'compiler-macro 'ebrowse-bs-pattern--cmacro)
#@63 Access slot "pattern" of `ebrowse-bs' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-bs-pattern #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-bs-tags 0 signal wrong-type-argument ebrowse-bs 5] 5 (#$ . 29627)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-bs-pattern side-effect-free t] 4)
#@73 compiler-macro for inlining `ebrowse-bs-point'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-bs-point--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-bs-point (progn (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] 9 (#$ . 29966)])
(put 'ebrowse-bs-point 'compiler-macro 'ebrowse-bs-point--cmacro)
#@61 Access slot "point" of `ebrowse-bs' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-bs-point #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-bs-tags 0 signal wrong-type-argument ebrowse-bs 6] 5 (#$ . 30399)])
(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 #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R\211@\307>\203:\211AA\262
\202'\310>A@\203I\311\262
\202'\312\313@\"\210\202'\210\314\315\316\311\311&\207" [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))] 20 (#$ . 30782)])
(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 #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R\211@\307>\203:\211AA\262
\202'\310>A@\203I\311\262
\202'\312\313@\"\210\202'\210\314\315&\207" [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] 15 (#$ . 31613)])
(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)
#@69 compiler-macro for inlining `ebrowse-cs-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-cs-p--cmacro #[514 "\300\301\302\303\211\211&\207" [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] 9 (#$ . 32576)])
(put 'ebrowse-cs-p 'compiler-macro 'ebrowse-cs-p--cmacro)
#@13 

(fn CL-X)
(defalias 'ebrowse-cs-p #[257 "\301
!\205\211G\302Y\205\211\303H>\205\304\207" [cl-struct-ebrowse-cs-tags vectorp 8 0 t] 3 (#$ . 32946)])
(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)
#@72 compiler-macro for inlining `ebrowse-cs-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-cs-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-cs-name (progn (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] 9 (#$ . 33256)])
(put 'ebrowse-cs-name 'compiler-macro 'ebrowse-cs-name--cmacro)
#@60 Access slot "name" of `ebrowse-cs' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-cs-name #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-cs 1] 5 (#$ . 33684)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-cs-name side-effect-free t] 4)
#@73 compiler-macro for inlining `ebrowse-cs-scope'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-cs-scope--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-cs-scope (progn (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] 9 (#$ . 34014)])
(put 'ebrowse-cs-scope 'compiler-macro 'ebrowse-cs-scope--cmacro)
#@61 Access slot "scope" of `ebrowse-cs' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-cs-scope #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-cs 2] 5 (#$ . 34447)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-cs-scope side-effect-free t] 4)
#@73 compiler-macro for inlining `ebrowse-cs-flags'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-cs-flags--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-cs-flags (progn (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] 9 (#$ . 34780)])
(put 'ebrowse-cs-flags 'compiler-macro 'ebrowse-cs-flags--cmacro)
#@61 Access slot "flags" of `ebrowse-cs' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-cs-flags #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-cs 3] 5 (#$ . 35213)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-cs-flags side-effect-free t] 4)
#@72 compiler-macro for inlining `ebrowse-cs-file'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-cs-file--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-cs-file (progn (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] 9 (#$ . 35546)])
(put 'ebrowse-cs-file 'compiler-macro 'ebrowse-cs-file--cmacro)
#@60 Access slot "file" of `ebrowse-cs' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-cs-file #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-cs 4] 5 (#$ . 35974)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-cs-file side-effect-free t] 4)
#@75 compiler-macro for inlining `ebrowse-cs-pattern'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-cs-pattern--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-cs-pattern (progn (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] 9 (#$ . 36304)])
(put 'ebrowse-cs-pattern 'compiler-macro 'ebrowse-cs-pattern--cmacro)
#@63 Access slot "pattern" of `ebrowse-cs' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-cs-pattern #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-cs 5] 5 (#$ . 36747)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-cs-pattern side-effect-free t] 4)
#@73 compiler-macro for inlining `ebrowse-cs-point'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-cs-point--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-cs-point (progn (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] 9 (#$ . 37086)])
(put 'ebrowse-cs-point 'compiler-macro 'ebrowse-cs-point--cmacro)
#@61 Access slot "point" of `ebrowse-cs' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-cs-point #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-cs 6] 5 (#$ . 37519)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-cs-point side-effect-free t] 4)
#@79 compiler-macro for inlining `ebrowse-cs-source-file'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-cs-source-file--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-cs-source-file (progn (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] 9 (#$ . 37852)])
(put 'ebrowse-cs-source-file 'compiler-macro 'ebrowse-cs-source-file--cmacro)
#@67 Access slot "source-file" of `ebrowse-cs' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-cs-source-file #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-cs 7] 5 (#$ . 38315)])
(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 #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\211\203Y\211@\310>\203A\211AA\262
\202.\311	>A@\203P\312\262
\202.\313\314@\"\210\202.\210\315\316\317\312\f\312\f\f\f\f\f\f\f&\f\207" [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))] 22 (#$ . 38716)])
(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 #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\211\203Y\211@\310>\203A\211AA\262
\202.\311	>A@\203P\312\262
\202.\313\314@\"\210\202.\210\315\316&\207" [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] 17 (#$ . 39648)])
(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)
#@69 compiler-macro for inlining `ebrowse-ms-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ms-p--cmacro #[514 "\300\301\302\303\211\211&\207" [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] 9 (#$ . 40779)])
(put 'ebrowse-ms-p 'compiler-macro 'ebrowse-ms-p--cmacro)
#@13 

(fn CL-X)
(defalias 'ebrowse-ms-p #[257 "\301
!\205\211G\302Y\205\211\303H>\205\304\207" [cl-struct-ebrowse-ms-tags vectorp 11 0 t] 3 (#$ . 41150)])
(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)
#@72 compiler-macro for inlining `ebrowse-ms-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ms-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-name (progn (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] 9 (#$ . 41461)])
(put 'ebrowse-ms-name 'compiler-macro 'ebrowse-ms-name--cmacro)
#@60 Access slot "name" of `ebrowse-ms' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ms-name #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 1] 5 (#$ . 41889)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-name side-effect-free t] 4)
#@73 compiler-macro for inlining `ebrowse-ms-scope'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ms-scope--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-scope (progn (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] 9 (#$ . 42219)])
(put 'ebrowse-ms-scope 'compiler-macro 'ebrowse-ms-scope--cmacro)
#@61 Access slot "scope" of `ebrowse-ms' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ms-scope #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 2] 5 (#$ . 42652)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-scope side-effect-free t] 4)
#@73 compiler-macro for inlining `ebrowse-ms-flags'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ms-flags--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-flags (progn (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] 9 (#$ . 42985)])
(put 'ebrowse-ms-flags 'compiler-macro 'ebrowse-ms-flags--cmacro)
#@61 Access slot "flags" of `ebrowse-ms' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ms-flags #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 3] 5 (#$ . 43418)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-flags side-effect-free t] 4)
#@72 compiler-macro for inlining `ebrowse-ms-file'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ms-file--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-file (progn (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] 9 (#$ . 43751)])
(put 'ebrowse-ms-file 'compiler-macro 'ebrowse-ms-file--cmacro)
#@60 Access slot "file" of `ebrowse-ms' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ms-file #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 4] 5 (#$ . 44179)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-file side-effect-free t] 4)
#@75 compiler-macro for inlining `ebrowse-ms-pattern'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ms-pattern--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-pattern (progn (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] 9 (#$ . 44509)])
(put 'ebrowse-ms-pattern 'compiler-macro 'ebrowse-ms-pattern--cmacro)
#@63 Access slot "pattern" of `ebrowse-ms' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ms-pattern #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 5] 5 (#$ . 44952)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-pattern side-effect-free t] 4)
#@73 compiler-macro for inlining `ebrowse-ms-point'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ms-point--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-point (progn (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] 9 (#$ . 45291)])
(put 'ebrowse-ms-point 'compiler-macro 'ebrowse-ms-point--cmacro)
#@61 Access slot "point" of `ebrowse-ms' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ms-point #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 6] 5 (#$ . 45724)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-point side-effect-free t] 4)
#@78 compiler-macro for inlining `ebrowse-ms-visibility'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ms-visibility--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-visibility (progn (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] 9 (#$ . 46057)])
(put 'ebrowse-ms-visibility 'compiler-macro 'ebrowse-ms-visibility--cmacro)
#@66 Access slot "visibility" of `ebrowse-ms' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ms-visibility #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 7] 5 (#$ . 46515)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-visibility side-effect-free t] 4)
#@83 compiler-macro for inlining `ebrowse-ms-definition-file'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ms-definition-file--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-definition-file (progn (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] 9 (#$ . 46863)])
(put 'ebrowse-ms-definition-file 'compiler-macro 'ebrowse-ms-definition-file--cmacro)
#@71 Access slot "definition-file" of `ebrowse-ms' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ms-definition-file #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 8] 5 (#$ . 47346)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-definition-file side-effect-free t] 4)
#@86 compiler-macro for inlining `ebrowse-ms-definition-pattern'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ms-definition-pattern--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-definition-pattern (progn (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] 9 (#$ . 47709)])
(put 'ebrowse-ms-definition-pattern 'compiler-macro 'ebrowse-ms-definition-pattern--cmacro)
#@74 Access slot "definition-pattern" of `ebrowse-ms' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ms-definition-pattern #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 9] 5 (#$ . 48207)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-ms-definition-pattern side-effect-free t] 4)
#@84 compiler-macro for inlining `ebrowse-ms-definition-point'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-ms-definition-point--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-ms-definition-point (progn (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] 9 (#$ . 48579)])
(put 'ebrowse-ms-definition-point 'compiler-macro 'ebrowse-ms-definition-point--cmacro)
#@72 Access slot "definition-point" of `ebrowse-ms' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-ms-definition-point #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-ms-tags 0 signal wrong-type-argument ebrowse-ms 10] 5 (#$ . 49068)])
(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 #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\n\211\203n\211@\313>\203V\211AA\262
\202C\314\f>A@\203e\315\262
\202C\316\317@\"\210\202C\210\320\321\322\315\315&\207" [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))] 28 (#$ . 49485)])
(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 #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\n\211\203n\211@\313>\203V\211AA\262
\202C\314\f>A@\203e\315\262
\202C\316\317@\"\210\202C\210\320\321&\207" [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] 23 (#$ . 50774)])
(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)
#@63 Value is non-nil if MEMBER's bit BIT is set.

(fn MEMBER BIT)
(defalias 'ebrowse-member-bit-set-p #[514 "\301\302H>\204\303\304\305D\"\210\306H\"\302U?\207" [cl-struct-ebrowse-bs-tags logand 0 signal wrong-type-argument ebrowse-bs 3] 7 (#$ . 52236)])
(put 'ebrowse-member-bit-set-p 'byte-optimizer 'byte-compile-inline-expand)
#@53 Value is non-nil if MEMBER is virtual.

(fn MEMBER)
(defalias 'ebrowse-virtual-p #[257 "\211\301\302\303H>\204\304\305\306D\"\210\307H\"\303U?\207" [cl-struct-ebrowse-bs-tags 1 logand 0 signal wrong-type-argument ebrowse-bs 3] 8 (#$ . 52576)])
(put 'ebrowse-virtual-p 'byte-optimizer 'byte-compile-inline-expand)
#@52 Value is non-nil if MEMBER is inline.

(fn MEMBER)
(defalias 'ebrowse-inline-p #[257 "\211\301\302\303H>\204\304\305\306D\"\210\307H\"\303U?\207" [cl-struct-ebrowse-bs-tags 2 logand 0 signal wrong-type-argument ebrowse-bs 3] 8 (#$ . 52902)])
(put 'ebrowse-inline-p 'byte-optimizer 'byte-compile-inline-expand)
#@51 Value is non-nil if MEMBER is const.

(fn MEMBER)
(defalias 'ebrowse-const-p #[257 "\211\301\302\303H>\204\304\305\306D\"\210\307H\"\303U?\207" [cl-struct-ebrowse-bs-tags 4 logand 0 signal wrong-type-argument ebrowse-bs 3] 8 (#$ . 53225)])
(put 'ebrowse-const-p 'byte-optimizer 'byte-compile-inline-expand)
#@69 Value is non-nil if MEMBER is a pure virtual function.

(fn MEMBER)
(defalias 'ebrowse-pure-virtual-p #[257 "\211\301\302\303H>\204\304\305\306D\"\210\307H\"\303U?\207" [cl-struct-ebrowse-bs-tags 8 logand 0 signal wrong-type-argument ebrowse-bs 3] 8 (#$ . 53545)])
(put 'ebrowse-pure-virtual-p 'byte-optimizer 'byte-compile-inline-expand)
#@53 Value is non-nil if MEMBER is mutable.

(fn MEMBER)
(defalias 'ebrowse-mutable-p #[257 "\211\301\302\303H>\204\304\305\306D\"\210\307H\"\303U?\207" [cl-struct-ebrowse-bs-tags 16 logand 0 signal wrong-type-argument ebrowse-bs 3] 8 (#$ . 53897)])
(put 'ebrowse-mutable-p 'byte-optimizer 'byte-compile-inline-expand)
#@56 Value is non-nil if MEMBER is a template.

(fn MEMBER)
(defalias 'ebrowse-template-p #[257 "\211\301\302\303H>\204\304\305\306D\"\210\307H\"\303U?\207" [cl-struct-ebrowse-bs-tags 32 logand 0 signal wrong-type-argument ebrowse-bs 3] 8 (#$ . 54224)])
(put 'ebrowse-template-p 'byte-optimizer 'byte-compile-inline-expand)
#@54 Value is non-nil if MEMBER is explicit.

(fn MEMBER)
(defalias 'ebrowse-explicit-p #[257 "\211\301\302\303H>\204\304\305\306D\"\210\307H\"\303U?\207" [cl-struct-ebrowse-bs-tags 64 logand 0 signal wrong-type-argument ebrowse-bs 3] 8 (#$ . 54556)])
(put 'ebrowse-explicit-p 'byte-optimizer 'byte-compile-inline-expand)
#@68 Value is non-nil if MEMBER has a throw specification.

(fn MEMBER)
(defalias 'ebrowse-throw-list-p #[257 "\211\301\302\303H>\204\304\305\306D\"\210\307H\"\303U?\207" [cl-struct-ebrowse-bs-tags 128 logand 0 signal wrong-type-argument ebrowse-bs 3] 8 (#$ . 54886)])
(put 'ebrowse-throw-list-p 'byte-optimizer 'byte-compile-inline-expand)
#@58 Value is non-nil if MEMBER is `extern "C"'.

(fn MEMBER)
(defalias 'ebrowse-extern-c-p #[257 "\211\301\302\303H>\204\304\305\306D\"\210\307H\"\303U?\207" [cl-struct-ebrowse-bs-tags 256 logand 0 signal wrong-type-argument ebrowse-bs 3] 8 (#$ . 55235)])
(put 'ebrowse-extern-c-p 'byte-optimizer 'byte-compile-inline-expand)
#@54 Value is non-nil if MEMBER is a define.

(fn MEMBER)
(defalias 'ebrowse-define-p #[257 "\211\301\302\303H>\204\304\305\306D\"\210\307H\"\303U?\207" [cl-struct-ebrowse-bs-tags 512 logand 0 signal wrong-type-argument ebrowse-bs 3] 8 (#$ . 55570)])
(put 'ebrowse-define-p 'byte-optimizer 'byte-compile-inline-expand)
#@42 Version string expected in BROWSE files.
(defconst ebrowse-version-string "ebrowse 5.0" (#$ . 55897))
#@110 The name used for the surrogate class.containing global entities.
This must be the same that `ebrowse' uses.
(defconst ebrowse-globals-name "*Globals*" (#$ . 56006))
#@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 (#$ . 56179))
(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) (#$ . 56411))
#@95 Obarray holding all `ebrowse-ts' structures of a class tree.
Buffer-local in Ebrowse buffers.
(defvar ebrowse--tree-obarray nil (#$ . 56801))
#@74 File from which BROWSE file was loaded.
Buffer-local in Ebrowse buffers.
(defvar ebrowse--tags-file-name nil (#$ . 56949))
#@89 Header structure of type `ebrowse-hs' of a class tree.
Buffer-local in Ebrowse buffers.
(defvar ebrowse--header nil (#$ . 57078))
#@83 Non-nil means an Ebrowse buffer won't be reused.
Buffer-local in Ebrowse buffers.
(defvar ebrowse--frozen-flag nil (#$ . 57214))
#@87 Non-nil means show file names in a tree buffer.
Buffer-local in Ebrowse tree buffers.
(defvar ebrowse--show-file-names-flag nil (#$ . 57349))
#@90 Non-nil means show members in long display form.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--long-display-flag nil (#$ . 57497))
#@101 Number of columns to display for short member display form.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--n-columns nil (#$ . 57646))
#@102 Width of a columns to display for short member display form.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--column-width nil (#$ . 57798))
#@99 Non-nil means display virtual members in a member buffer.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--virtual-display-flag nil (#$ . 57953))
#@98 Non-nil means display inline members in a member buffer.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--inline-display-flag nil (#$ . 58113))
#@97 Non-nil means display const members in a member buffer.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--const-display-flag nil (#$ . 58271))
#@104 Non-nil means display pure virtual members in a member buffer.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--pure-display-flag nil (#$ . 58428))
#@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 (#$ . 58591))
#@101 Non-nil means display inherited members in a member buffer.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--show-inherited-flag nil (#$ . 58842))
#@101 Non-nil means display member attributes in a member buffer.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--attributes-flag nil (#$ . 59004))
#@98 Non-nil means display member regexps in a member buffer.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--source-regexp-flag nil (#$ . 59161))
#@103 Class displayed in a member buffer, a `ebrowse-ts' structure.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--displayed-class nil (#$ . 59319))
#@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 (#$ . 59479))
#@107 The list of `ebrowse-ms' structures displayed in a member buffer.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--member-list nil (#$ . 59718))
#@103 Column in which declarations are displayed in member buffers.
Buffer-local in Ebrowse member buffers.
(defvar ebrowse--decl-column nil (#$ . 59878))
#@106 Frame configuration saved when viewing a class/member in another frame.
Buffer-local in Ebrowse buffers.
(defvar ebrowse--frame-configuration nil (#$ . 60034))
#@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 (#$ . 60201))
#@46 Class tree.
Buffer-local in Ebrowse buffers.
(defvar ebrowse--tree nil (#$ . 60369))
(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 (#$ . 60542))
#@55 Strings displayed in the mode line of member buffers.
(defvar ebrowse--member-mode-strings nil (#$ . 60634))
#@40 The keymap used in the member buffers.
(defvar ebrowse-member-mode-map nil (#$ . 60749))
(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)
#@229 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.

(fn &optional MARKED-ONLY)
(defalias 'ebrowse-files-table #[256 "\301\302\303\"\304C\305C\306\307\310\311\312\313				$\314\"\315\316%\"\266
\207" [ebrowse--tree-obarray make-hash-table :test equal -1 nil mapatoms make-byte-code 257 "\303
\306N\240\210\307\303\242!\205\366\300\203)\303\242\310H\f>\204\"\311\312\313\303\242D\"\210\303\242\314H\205\366\303\242\310H\f>\204:\311\312\313\303\242D\"\210\303\242\315H\302\211\242T\240\316\246\310U\203R\317\320\302\242\310U\"\210\211\310H
>\204a\311\312\321D\"\210\211\322H
\310H
>\204s\311\312\321D\"\210
\323H
\203\200\324\211\301#\210\211\203\212\324
\211\301#\210\211\205\360\211@\211\303\242!\325\211\211:\203\347@\262\310H>\204\262\311\312\326D\"\210\323H\262\310H>\204\307\311\312\326D\"\210\327H\262

\203\326\324\211\301#\210\211\203\340\324
\211\301#\210A\262\202\231\266
A\266\202\202\214\262
\266\202\262
\207" vconcat vector [cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags 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 ebrowse-member-list-accessors cl-struct-ebrowse-ms-tags] 14 "\n\n(fn VAR)"] 14 (#$ . 61445)])
#@140 Return a list containing all files mentioned in a tree.
MARKED-ONLY non-nil means include marked classes only.

(fn &optional MARKED-ONLY)
(defalias 'ebrowse-files-list #[256 "\300C\301\302\303\304\305\306!\307\"\310\311%\312!\"\210\211\242\207" [nil maphash make-byte-code 514 "\300\300\242B\240\207" vconcat vector [] 5 "\n\n(fn FILE DUMMY)" ebrowse-files-table] 9 (#$ . 62883)])
#@68 Value is non-nil if any class in the current class tree is marked.
(defalias 'ebrowse-marked-classes-p #[0 "\3012\302C\303\304\305\306\307\310!\311\"\312\313%\"\210\302\262
0\207" [ebrowse--tree-obarray --cl-block-ebrowse-marked-classes-p-- nil mapatoms make-byte-code 257 "\300
\302N\240\210\303\300\242!\205*\300\242\304H	>\204\305\306\307\300\242D\"\210\300\242\310H\205*\311\312\300\242\"\207" vconcat vector [cl-struct-ebrowse-ts-tags ebrowse-root vectorp 0 signal wrong-type-argument ebrowse-ts 10 throw --cl-block-ebrowse-marked-classes-p--] 5 "\n\n(fn VAR)"] 8 (#$ . 63275)])
#@61 Return t if TREE is the one for global entities.

(fn TREE)
(defalias 'ebrowse-globals-tree-p #[257 "\211\303H>\204\304\305\306D\"\210\211\307H\303H	>\2042\304\305\310\303H>\204,\304\305\306D\"\210\307HD\"\210\211\303H>\204A\304\305\306D\"\210\211\307H\307H\n\230\207" [cl-struct-ebrowse-ts-tags cl-struct-ebrowse-bs-tags ebrowse-globals-name 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-bs] 8 (#$ . 63874)])
(put 'ebrowse-globals-tree-p 'byte-optimizer 'byte-compile-inline-expand)
#@68 Return the name of CLASS with scope prepended, if any.

(fn CLASS)
(defalias 'ebrowse-qualified-class-name #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\203<\211\301H>\204$\302\303\304D\"\210\211\305H\306\301H>\2047\302\303\304D\"\210\307HQ\207\211\301H>\204K\302\303\304D\"\210\211\307H\207" [cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-cs 2 "::" 1] 7 (#$ . 64382)])
(put 'ebrowse-qualified-class-name 'byte-optimizer 'byte-compile-inline-expand)
#@390 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'.

(fn &optional QUALIFIED-NAMES-P)
(defalias 'ebrowse-tree-obarray-as-alist #[256 "\301C
\203\301C\302\303\304\305\306\307\"\310\"\311\312%\"\266\2025\301C\302\303\304\313\306\307\"\314\"\311\312%\"\266\211\242\207" [ebrowse--tree-obarray nil mapatoms make-byte-code 257 "\301
\304N\240\210\305\301\242!\205\203\300\301\242\306H\n>\204\307\310\311\301\242D\"\210\301\242\312H\211\306H>\2042\307\310\313D\"\210\211\314H\203c\211\306H>\204G\307\310\313D\"\210\211\314H\315\306H>\204Z\307\310\313D\"\210\312HQ\262
\202w\211\306H>\204r\307\310\313D\"\210\211\312H\262
\301\242\300\242B
B\266\203\240\207" vconcat vector [cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags ebrowse-root vectorp 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs 2 "::"] 9 "\n\n(fn VAR)" "\301
\304N\240\210\305\301\242!\205h\300\301\242\306H\n>\204\307\310\311\301\242D\"\210\301\242\312H\306H>\204E\307\310\313\301\242\306H\n>\204>\307\310\311\301\242D\"\210\301\242\312HD\"\210\301\242\306H\n>\204V\307\310\311\301\242D\"\210\301\242\312H\312H\301\242\300\242B
B\266\203\240\207" [cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags ebrowse-root vectorp 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs]] 11 (#$ . 64876)])
#@77 Sort a LIST of `ebrowse-ts' structures by qualified class names.

(fn LIST)
(defalias 'ebrowse-sort-tree-list #[257 "\300
\301\"\207" [sort #[514 "
\302H>\204\303\304\305D\"\210
\306H\211\302H	>\204!\303\304\307D\"\210\211\310H\203R\211\302H	>\2046\303\304\307D\"\210\211\310H\311\302H	>\204I\303\304\307D\"\210\306HQ\262
\202f\211\302H	>\204a\303\304\307D\"\210\211\306H\262

\302H>\204u\303\304\305D\"\210
\306H\211\302H	>\204\207\303\304\307D\"\210\211\310H\203\270\211\302H	>\204\234\303\304\307D\"\210\211\310H\311\302H	>\204\257\303\304\307D\"\210\306HQ\262
\202\314\211\302H	>\204\307\303\304\307D\"\210\211\306H\262
\231\207" [cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs 2 "::"] 10 "\n\n(fn A B)"]] 4 (#$ . 66491)])
#@235 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.

(fn CLASS TREE)
(defalias 'ebrowse-class-in-tree #[514 "
\302H>\204\303\304\305D\"\210
\306H\307\203\351\211\204\351\211@\302H>\204-\303\304\305@D\"\210\211@\306H\211\302H	>\204@\303\304\310D\"\210\211\311H\203q\211\302H	>\204U\303\304\310D\"\210\211\311H\312\302H	>\204h\303\304\310D\"\210\306HQ\262
\202\205\211\302H	>\204\200\303\304\310D\"\210\211\306H\262
\211\302H	>\204\225\303\304\310D\"\210\211\311H\203\306\211\302H	>\204\252\303\304\310D\"\210\211\311H\312\302H	>\204\275\303\304\310D\"\210\306HQ\262
\202\332\211\302H	>\204\325\303\304\310D\"\210\211\306H\262
\230\203\341\211\262A\262\210\202\207" [cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-ts 1 nil ebrowse-cs 2 "::"] 13 (#$ . 67314)])
#@230 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.

(fn TREE)
(defalias 'ebrowse-base-classes #[257 "\211\302H>\204\303\304\305D\"\210\211\306H\206c\211\302H>\204$\303\304\305D\"\210\211\211\306CC\307C\307C\211\242\211\242A\240\210\242\240\210\211\242\203\\\307C\310\311\312\313\314\315				$\316\"\317\320%	\"\266\202.
\242\266\203I\262
\207" [cl-struct-ebrowse-ts-tags ebrowse--tree-obarray 0 signal wrong-type-argument ebrowse-ts 9 nil mapatoms make-byte-code 257 "\303
\305N\240\210\306\303\242!\205@\302\242\303\242\307H\f>\204 \310\311\312\303\242D\"\210\303\242\313H>\205@\303\242\301\242>\2049\301\211\242\303\242C\244\240\210\300\303\242\300\242B\240\207" vconcat vector [cl-struct-ebrowse-ts-tags ebrowse-root vectorp 0 signal wrong-type-argument ebrowse-ts 2] 6 "\n\n(fn VAR)"] 18 (#$ . 68328)])
#@61 Return the list of direct super classes of TREE.

(fn TREE)
(defalias 'ebrowse-direct-base-classes #[257 "\301\302!\211\203-\211@
\303H>\204\304\305\306D\"\210
\307H>\203&\211B\262
A\266\202\202\210\211\207" [cl-struct-ebrowse-ts-tags nil ebrowse-base-classes 0 signal wrong-type-argument ebrowse-ts 2] 9 (#$ . 69329)])
#@229 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.

(fn TREE ACCESSOR)
(defalias 'ebrowse-name/accessor-alist #[514 "\211!\301\211:\203-@\262
\302H>\204\303\304\305D\"\210
\306HB
B\262
A\262\202\211\237\207" [cl-struct-ebrowse-ms-tags nil 0 signal wrong-type-argument ebrowse-ms 1] 9 (#$ . 69668)])
#@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 #[0 "\303	\"\n\203/\211\304!\305\211:\203'@\262\303	\"\237
\244\262
A\262\202\211\237\266\203\244\2020\211\207" [ebrowse--displayed-class ebrowse--accessor ebrowse--show-inherited-flag ebrowse-name/accessor-alist ebrowse-base-classes nil] 8 (#$ . 70145)])
#@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 #[0 "\303\211\2034\211@\304	\"\244\262\n\203-\305	!\211\203,\211@\304\"\244\262
A\266\202\202\210
A\266\202\202
\262
\207" [ebrowse-member-list-accessors ebrowse--displayed-class ebrowse--show-inherited-flag nil ebrowse-name/accessor-alist ebrowse-base-classes] 9 (#$ . 70824)])
(defvar ebrowse-n-boxes 0)
(defconst ebrowse-max-boxes 60)
#@170 Display a progress indicator.
TITLE is the title of the progress message.  START non-nil means
this is the first progress message displayed.

(fn TITLE &optional START)
(defalias 'ebrowse-show-progress #[513 "\303\211\203\304\305	T\n\"\306\307\310\311	\312 \203\313\202\314\"\315\316##)\207" [message-log-max ebrowse-n-boxes ebrowse-max-boxes nil 0 mod message "%s: %s" propertize make-string display-color-p 32 43 face ebrowse-progress] 9 (#$ . 71393)])
#@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 #[0 "\3031\304p!0\202\210\305\306!\307\310!\203%
G\311Y\203%
\312H>\204)\305\306!\210
\312H>\2048\313\314\315D\"\210
\316H	\230\204X\305\317\312H>\204R\313\314\315D\"\210\316H	#\210\320\321\307w\210m\204\204\304p!\322
\"\323\324?\"\210\211\203z\211\240\210\202
B\262\266\202Z)\325 \210

D\207" [cl-struct-ebrowse-hs-tags ebrowse-version-string gc-cons-threshold (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] 8 (#$ . 71865)])
#@183 Function installed as `revert-buffer-function' in tree buffers.
See that variable's documentation for the meaning of IGNORE-AUTO-SAVE and
NOCONFIRM.

(fn IGNORE-AUTO-SAVE NOCONFIRM)
(defalias 'ebrowse-revert-tree-buffer-from-file #[514 "\211\204\n\302\303!\205\304\305\306 \"\210\307 \210\310\206	!\210\311 \210p\207" [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] 5 (#$ . 72753)])
#@307 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.

(fn TREE TAGS-FILE HEADER CLASSES POP)
(defalias 'ebrowse-create-tree-buffer #[1285 "\306
!q\210\307 \210\310\311 \210\312\310!\210
\313\267\202+\314
!\210\202+\315
!\210p\207" [ebrowse-tree-buffer-name ebrowse--tree ebrowse--tags-file-name ebrowse--tree-obarray ebrowse--header ebrowse--frozen-flag 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 32 pop 39)) switch-to-buffer pop-to-buffer] 8 (#$ . 73279)])
#@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 #[0 "\303\304\305\"\306C\307H	>\204\310\311\312D\"\210\211\313\314I\266\315 \210\314C\316\317\320\321\322\323#\324\"\325\326%\n\"\266\307H	>\204F\310\311\312D\"\210\211\313I\262
\207" [ebrowse--header cl-struct-ebrowse-hs-tags ebrowse--tree-obarray make-hash-table :test equal -1 0 signal wrong-type-argument ebrowse-hs 4 nil garbage-collect mapatoms make-byte-code 257 "\302
\305N\240\210\306\302\242!\205i\301\211\242T\240\307\246\310U\203!\311\312\301\242\310U\"\210\211\205g\211@\211\302\242!\211\203_\211@\211\310H\f>\204A\313\314\315D\"\210\211\316H\317
\300\"\302\242E
B\262
\320\300#\266
A\266\202\202,\210
A\266\202\202\"\262
\207" vconcat vector [ebrowse-member-list-accessors cl-struct-ebrowse-ms-tags ebrowse-root vectorp 10 0 ebrowse-show-progress "Preparing member lookup" signal wrong-type-argument ebrowse-ms 1 gethash puthash] 11 "\n\n(fn VAR)"] 12 (#$ . 74101)])
#@136 Return the member obarray.  Build it if it hasn't been set up yet.
HEADER is the tree header structure of the class tree.

(fn HEADER)
(defalias 'ebrowse-member-table #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\204;\306 \307
:\2031
@\262
\310\311\"=\2041
A\262\202r\211q\210\312 \210)\266\211\301H>\204J\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-hs-tags 0 signal wrong-type-argument ebrowse-hs 4 ebrowse-browser-buffer-list nil buffer-local-value ebrowse--header ebrowse-fill-member-table] 7 (#$ . 75652)])
#@115 Make sure every class in TREE is represented by a unique object.
Build obarray of all classes in TREE.

(fn TREE)
(defalias 'ebrowse-build-tree-obarray #[257 "\302\303\304\"
\305\211:\203\220@\262\306\304H>\204 \307\310\311D\"\210\312H\211\304H	>\2042\307\310\313D\"\210\211\314H\203c\211\304H	>\204G\307\310\313D\"\210\211\314H\315\304H	>\204Z\307\310\313D\"\210\312HQ\262
\202w\211\304H	>\204r\307\310\313D\"\210\211\312H\262
\"\262
\211\316N\204\211\211\317
\316#\266A\262\202\266\320\"\210\211\207" [cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags make-vector 127 0 nil intern signal wrong-type-argument ebrowse-ts 1 ebrowse-cs 2 "::" ebrowse-root put ebrowse-insert-supers] 13 (#$ . 76198)])
#@548 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.

(fn TREE CLASSES)
(defalias 'ebrowse-insert-supers #[514 "
\302\211:\203\305@\262
\303H>\204\304\305\306D\"\210
\307H\262
\211\302
:\203\267\310@\303H>\2049\304\305\306@D\"\210@\311H\211\303H	>\204L\304\305\312D\"\210\211\307H\203}\211\303H	>\204a\304\305\312D\"\210\211\307H\313\303H	>\204t\304\305\312D\"\210\311HQ\262
\202\221\211\303H	>\204\214\304\305\312D\"\210\211\311H\262
\"\262
\211\314N\203\247
\211\314N\240\266\202\260\211\315
\314@#\266
A\262\202\"\266\316
\"\210A\262\202\302\207" [cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags nil 0 signal wrong-type-argument ebrowse-ts 2 intern 1 ebrowse-cs "::" ebrowse-root put ebrowse-insert-supers] 15 (#$ . 76938)])
(byte-code "\204\336\301 \211\302
!\210\303 \203#\304
\305\306#\210\304
\307\310#\210\304
\311\312#\210\313 \302
\314\"\210\304\315#\210\304
\316\317#\210\304
\320\321#\210\304
\322\323#\210\304
\324\325#\210\304
\326\327#\210\304
\330\331#\266\313 \302
\314\"\210\304\332#\210\304
\333\334#\210\304
\324\335#\266\313 \302
\314\"\210\304\336#\210\304
\320\337#\210\304
\340\341#\210\304
\342\343#\210\304\344\345#\266\304
\346\347#\210\304
\350\351#\210\304
\352\353#\210\304
\354\355#\210\304
\356\357#\210\304
\360\361#\210\304
\362\363#\210\304
\364\365#\210\304
\366\367#\210\304
\370\371#\210\304
\372\373#\210\304
\374\375#\266\301\207" [ebrowse-tree-mode-map 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] 6)
(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 #[0 "\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\2035\211\321 =\203;\322\f\323 \"\210\210\324
\325\"\204R
==\204R\326
\325=C#\210\327!\210\330\f!\210
=\331\332!\307>\333\211\334 \210\335 \336U\204\217eb\210\337\340 !\211@\262\211A@\266\202\341\342!\210\343
!\262
\344 \210\341\333!\210\306\345!\210\333%\306\346!\210\347\350\336\"&\306\351!\210\333)?\307@\352\353!\210\306\354!\210\355,\306\356!\210
.\306\357!\210\211/\306\360!\210A0\306\346!\210\211\205\331\361
!&\306\351!\210\333)\362\363\364\333\307$\210\365\366\367\370z!\"\210\211\203\374\371 \210\372\333!\210)\266)\373\374!\207" [delay-mode-hooks major-mode mode-name ebrowse-tree-mode-map ebrowse-tree-mode-syntax-table ebrowse-tree-mode-abbrev-table 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 cl-values-list 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 add-to-invisibility-spec (ebrowse . t) revert-buffer-function ebrowse-revert-tree-buffer-from-file ebrowse--header ebrowse--tree ebrowse--tags-file-name ebrowse-build-tree-obarray add-hook write-file-functions 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 local-abbrev-table inhibit-read-only mode-line-buffer-identification buffer-read-only buffer-file-name] 8 (#$ . 81152) nil])
#@35 Update the tree buffer mode line.
(defalias 'ebrowse-update-tree-buffer-mode-line #[0 "\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 (#$ . 83553)])
#@115 Remove from TREE class CLASS.
Kill all member buffers still containing a reference to the class.

(fn TREE CLASS)
(defalias 'ebrowse-remove-class-and-kill-member-buffers #[514 "\303
\304H>\204\305\306\307D\"\210
\310H\304H	>\2043\305\306\311\304H>\204-\305\306\307D\"\210\310HD\"\210
\304H>\204B\305\306\307D\"\210
\310H\310H\n\"\312\"\262\211\313
\314\315#\266\211\203\275\211@\211\304H>\204m\305\306\307D\"\210\211\211\316\312\304H>\204\203\305\306\307D\"\210\316H\"I\266\211\304H>\204\231\305\306\307D\"\210\211\211\317\315I\266\320
\304H>\204\260\305\306\307D\"\210
\316H\"\210
A\266\202\202X\210\321!\210\207" [cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags ebrowse--tree-obarray 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] 14 (#$ . 83855)])
#@114 Remove the class point is on from the class tree.
Do not ask for confirmation if FORCED is non-nil.

(fn FORCED)
(defalias 'ebrowse-remove-class-at-point #[257 "\303 \211\304H>\204\305\306\307D\"\210\211\310H\304H	>\2044\305\306\311\304H>\204.\305\306\307D\"\210\310HD\"\210\211\304H>\204C\305\306\307D\"\210\211\310H\310H
\304H>\204W\305\306\307D\"\210
\312H\204g\313\314\315Q!\203\203\316\n\"\317\320!\210\321\322\203{\323\202|\324#\210\325 \202\206\321\326!\207" [cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags ebrowse--tree 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"] 9 (#$ . 84793) "P"])
#@122 Toggle mark for class cursor is on.
If given a numeric N-TIMES argument, mark that many classes.

(fn &optional N-TIMES)
(defalias 'ebrowse-toggle-mark-at-point #[256 "\305\3061S
\206\n\307\305
S\211\262\310Y\205M\311 \262
\211\310H>\204(\312\313\314D\"\210\211\211\315\310H>\204;\312\313\314D\"\210\315H?I\266\307y\210\211B\262\202\266\2020\202W\210\202X\210\212\316 \317\211\317\320\310\321\322\323!\324\"\325$\216
\305\211:\203
@\262\326\327\310H>\204\213\312\313\314D\"\210\307H\310H\f>\204\260\312\313\330\310H>\204\251\312\313\314	D\"\210\307HD\"\210\310H>\204\300\312\313\314D\"\210\307H\307H!\331Q\262
eb\210\332
\305\317#\203	
\310\224b\210\333\307!\210\334\310H>\204\355\312\313\314D\"\210\315H\203\367\335\202\370\336\307\"\210\337`S`#\210\310\225b\210\202\315A\262\202p\305\266\203,\262
)\207" [cl-struct-ebrowse-ts-tags buffer-undo-list inhibit-read-only inhibit-modification-hooks cl-struct-ebrowse-cs-tags nil (error) 1 0 ebrowse-tree-at-point signal wrong-type-argument ebrowse-ts 10 buffer-modified-p t make-byte-code "\300?\205\301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 "^.*\\b" regexp-quote ebrowse-cs "\\b" re-search-forward delete-char insert-char 62 32 ebrowse-set-mark-props] 16 (#$ . 85639) "p"])
#@65 Unmark, with PREFIX mark, all classes in the tree.

(fn PREFIX)
(defalias 'ebrowse-mark-all-classes #[257 "\301C\302\303\304\305\306\307\"\310\"\311\312%\"\266\313ed\"\207" [ebrowse--tree-obarray nil mapatoms make-byte-code 257 "\301
\303N\240\210\304\301\242!\205&\301\242\305H\n>\204\306\307\310\301\242D\"\210\301\242\211\311\300I\262
\207" vconcat vector [cl-struct-ebrowse-ts-tags ebrowse-root vectorp 0 signal wrong-type-argument ebrowse-ts 10] 5 "\n\n(fn VAR)" ebrowse-redraw-marks] 10 (#$ . 86949) "P"])
#@79 Display class marker signs in the tree between START and END.

(fn START END)
(defalias 'ebrowse-redraw-marks #[514 "\212\304 \305\211\305\306\307\310\311\312!\313\"\314$\216\31525eb\210\211\2052\211@\316
#\210
A\266\202\202\262
0\210,\210\317 )\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks ebrowse--tree buffer-modified-p t make-byte-code 0 "\300?\205\301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 end ebrowse-draw-marks-fn ebrowse-update-tree-buffer-mode-line] 10 (#$ . 87476) nil])
#@80 Display class marker signs in TREE between START and END.

(fn TREE START END)
(defalias 'ebrowse-draw-marks-fn #[771 "`Y\203-\301\302!\210\303H>\204\304\305\306D\"\210\307H\203#\310\202$\311c\210\312`S`#\210\302y\210`
V\203;\313\314\315\"\210\303H>\204J\304\305\306D\"\210\316H\211\205`\211@\317
#\210
A\266\202\202M\207" [cl-struct-ebrowse-ts-tags delete-char 1 0 signal wrong-type-argument ebrowse-ts 10 62 32 ebrowse-set-mark-props throw end nil 2 ebrowse-draw-marks-fn] 9 (#$ . 88022)])
#@94 Show filename in the line point is in.
With PREFIX, insert that many filenames.

(fn PREFIX)
(defalias 'ebrowse-show-file-name-at-point #[257 "?\205\265\306 \307\211\307\310\311\312\313\314!\315\"\316$\216
\311\211W\205\260\211\317 \320\211\321 \210\322\320w\210`\262\323\324!\262

\325 |\210\211\204\225\fj\210\324\311H
>\204R\326\327\330D\"\210\331H\311H\">\204x\326\327\332\311H
>\204q\326\327\330	D\"\210\331HD\"\210\311H
>\204\210\326\327\330D\"\210\331H\333H\206\221\334\335\261\210
`\336\337\340\"\341#\266\321 \210\331y\266\211T\262
\202\266\202,\262
\207" [ebrowse--show-file-names-flag buffer-undo-list inhibit-read-only inhibit-modification-hooks ebrowse-source-file-column cl-struct-ebrowse-ts-tags buffer-modified-p t make-byte-code 0 "\300?\205\301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 ebrowse-tree-at-point nil 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 cl-struct-ebrowse-cs-tags] 17 (#$ . 88541) "p"])
#@45 Toggle display of filenames in tree buffer.
(defalias 'ebrowse-toggle-file-name-display #[0 "?\301e`\"\302 \210eb\210\211Sy\207" [ebrowse--show-file-names-flag count-lines ebrowse-redraw-tree] 3 (#$ . 89665) nil])
#@61 Value is non-nil if BUFFER is a member buffer.

(fn BUFFER)
(defalias 'ebrowse-member-buffer-p #[257 "\300\301\302!\"A\303=\207" [assoc major-mode buffer-local-variables ebrowse-member-mode] 5 (#$ . 89887)])
#@65 Value is non-nil if BUFFER is a class tree buffer.

(fn BUFFER)
(defalias 'ebrowse-tree-buffer-p #[257 "\300\301\302!\"A\303=\207" [assoc major-mode buffer-local-variables ebrowse-tree-mode] 5 (#$ . 90102)])
#@69 Value is non-nil if BUFFER is a tree or member buffer.

(fn BUFFER)
(defalias 'ebrowse-buffer-p #[257 "\300\301\302!\"A\303>\207" [assoc major-mode buffer-local-variables (ebrowse-tree-mode ebrowse-member-mode)] 5 (#$ . 90317)])
#@46 Return a list of all tree or member buffers.
(defalias 'ebrowse-browser-buffer-list #[0 "\300\301\302 \"\207" [cl-delete-if-not ebrowse-buffer-p buffer-list] 3 (#$ . 90553)])
#@38 Return a list of all member buffers.
(defalias 'ebrowse-member-buffer-list #[0 "\300\301\302 \"\207" [cl-delete-if-not ebrowse-member-buffer-p buffer-list] 3 (#$ . 90734)])
#@36 Return a list of all tree buffers.
(defalias 'ebrowse-tree-buffer-list #[0 "\300\301\302 \"\207" [cl-delete-if-not ebrowse-tree-buffer-p buffer-list] 3 (#$ . 90913)])
#@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 #[0 "\300 \301 \244\302 \303\211\203/\211@\304\305\"\306
\"\204 
B\262\307
\310#\266
A\266\202\202	\210\207" [ebrowse-tree-buffer-list ebrowse-member-buffer-list make-hash-table nil buffer-local-value ebrowse--tree gethash puthash t] 10 (#$ . 91087)])
#@68 Return a list of members buffers with same tree as current buffer.
(defalias 'ebrowse-same-tree-member-buffer-list #[0 "\300\301\302 \"\207" [cl-delete-if-not #[257 "\301\300\"=\207" [ebrowse--tree buffer-local-value] 4 "\n\n(fn BUFFER)"] ebrowse-member-buffer-list] 3 (#$ . 91560)])
#@119 Pop to the buffer displaying members.
Switch to buffer if prefix ARG.
If no member buffer exists, make one.

(fn ARG)
(defalias 'ebrowse-pop/switch-to-member-buffer-for-same-tree #[257 "\301 @\206\302!\206\303 \211\203!
\203\304
!\210\202!\305
!\210\211\207" [ebrowse-member-buffer-name ebrowse-same-tree-member-buffer-list get-buffer ebrowse-tree-command:show-member-functions switch-to-buffer pop-to-buffer] 4 (#$ . 91853) "P"])
#@31 Switch to next member buffer.
(defalias 'ebrowse-switch-to-next-member-buffer #[0 "\300 p
>A\211\203\211@\202
@\211p=\203\301\302!\202#\303 \210\304
!\207" [ebrowse-member-buffer-list error "No next buffer" bury-buffer switch-to-buffer] 5 (#$ . 92299) nil])
#@53 Kill all member buffers displaying TREE.

(fn TREE)
(defalias 'ebrowse-kill-member-buffers-displaying #[257 "\300 \301\211:\203$@\262\302\303\"\262
\211=\203\304!\210A\262\202\301\207" [ebrowse-member-buffer-list nil buffer-local-value ebrowse--displayed-class kill-buffer] 7 (#$ . 92570)])
#@81 Return the buffer name of a tree which is associated TAGS-FILE.

(fn TAGS-FILE)
(defalias 'ebrowse-frozen-tree-buffer-name #[257 "\301\302R\207" [ebrowse-tree-buffer-name " (" ")"] 5 (#$ . 92880)])
#@123 Pop to a browser buffer from any other buffer.
Pop to member buffer if no prefix ARG, to tree buffer otherwise.

(fn ARG)
(defalias 'ebrowse-pop-to-browser-buffer #[257 "\302
\203	\202\n	!\211\204\302\203	\202!\262
\211\204$\303\304!\210\305
!\207" [ebrowse-tree-buffer-name ebrowse-member-buffer-name get-buffer error "No browser buffer found" pop-to-buffer] 4 (#$ . 93087) "P"])
#@22 

(fn &optional POS)
(defalias 'ebrowse--hidden-p #[256 "\300
\206`\301\"\302=\207" [get-char-property invisible ebrowse] 4 (#$ . 93486)])
#@18 

(fn START END)
(defalias 'ebrowse--hide #[514 "\300\301\302$\207" [put-text-property invisible ebrowse] 7 (#$ . 93633)])
#@18 

(fn START END)
(defalias 'ebrowse--unhide #[514 "\300\301#\207" [remove-text-properties (invisible nil)] 6 (#$ . 93764)])
#@48 Set the indentation width of the tree display.
(defalias 'ebrowse-set-tree-indentation #[0 "\301\302\303\304!\305Q\306\211$!\211\211\307V\262
\205\310\300!\210\211\311 \207" [ebrowse--indentation string-to-number read-string "Indentation (default " int-to-string "): " nil 0 make-local-variable ebrowse-redraw-tree] 6 (#$ . 93896) nil])
#@104 Position cursor on CLASS.
Read a class name from the minibuffer if CLASS is nil.

(fn &optional CLASS)
(defalias 'ebrowse-read-class-name-and-go #[256 "\302\211\204\303\304\305 \306\302$\262
eb\210~\210\307
\307Q\310	\306\302#\203*\311\224b\210\312 \202-\313\314!)\207" [completion-ignore-case 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"] 6 (#$ . 94245) nil])
#@78 Display member variables; with prefix ARG in frozen member buffer.

(fn ARG)
(defalias 'ebrowse-tree-command:show-member-variables #[257 "\300\301\"\207" [ebrowse-display-member-buffer ebrowse-ts-member-variables] 4 (#$ . 94733) "P"])
#@88 Display member functions; with prefix ARG in frozen member buffer.

(fn &optional ARG)
(defalias 'ebrowse-tree-command:show-member-functions #[256 "\300\301\"\207" [ebrowse-display-member-buffer ebrowse-ts-member-functions] 4 (#$ . 94975) "P"])
#@85 Display static member variables; with prefix ARG in frozen member buffer.

(fn ARG)
(defalias 'ebrowse-tree-command:show-static-member-variables #[257 "\300\301\"\207" [ebrowse-display-member-buffer ebrowse-ts-static-variables] 4 (#$ . 95227) "P"])
#@85 Display static member functions; with prefix ARG in frozen member buffer.

(fn ARG)
(defalias 'ebrowse-tree-command:show-static-member-functions #[257 "\300\301\"\207" [ebrowse-display-member-buffer ebrowse-ts-static-functions] 4 (#$ . 95483) "P"])
#@78 Display friend functions; with prefix ARG in frozen member buffer.

(fn ARG)
(defalias 'ebrowse-tree-command:show-friends #[257 "\300\301\"\207" [ebrowse-display-member-buffer ebrowse-ts-friends] 4 (#$ . 95739) "P"])
#@86 Display types defined in a class; with prefix ARG in frozen member buffer.

(fn ARG)
(defalias 'ebrowse-tree-command:show-types #[257 "\300\301\"\207" [ebrowse-display-member-buffer ebrowse-ts-types] 4 (#$ . 95963) "P"])
#@55 Return the class structure for the class point is on.
(defalias 'ebrowse-tree-at-point #[0 "\300`\301\"\206\n\302\303!\207" [get-text-property ebrowse-tree error "Not on a class"] 3 (#$ . 96191)])
#@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 #[128 "\304
\305\"A@\304\306\"A@\211\2037\211@\307>\203 \211AA\262
\202
\310>A@\203.\311\262
\202
\312\313@\"\210\202
\210\314 \211\315H>\204I\316\317\320D\"\210\211\321H\262
\211\315H	>\204]\316\317\322D\"\210\211\323H\324\325\315H	>\204r\316\317\322D\"\210\321H\311\315H	>\204\206\316\317\322D\"\210\326H\315H	>\204\232\316\317\322	D\"\210\323H\315H	>\204\257\316\317\322\nD\"\210\327H\315H	>\204\304\316\317\322D\"\210\330H&\331
\n\311E		&\266\203\207" [cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags ebrowse--header ebrowse--tags-file-name 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] 16 (#$ . 96396)])
#@149 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.

(fn PREFIX)
(defalias 'ebrowse-find-class-declaration #[257 "\300\301\302\303\304U\203\305\202\306U\203\307\202\310$\207" [ebrowse-view/find-class-declaration :view nil :where 4 other-window 5 other-frame this-window] 7 (#$ . 97487) "p"])
#@147 View class declaration and position cursor on it.
PREFIX 4 means view it in another window.
PREFIX 5 means view it in another frame.

(fn PREFIX)
(defalias 'ebrowse-view-class-declaration #[257 "\300\301\302\303\304U\203\305\202\306U\203\307\202\310$\207" [ebrowse-view/find-class-declaration :view view :where 4 other-window 5 other-frame this-window] 7 (#$ . 97879) "p"])
#@235 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'.

(fn FILE TAGS-FILE)
(defalias 'ebrowse-find-source-file #[514 "\301\302\303!\"\304
!\203\211\262\2022\211\2031\2041\302@\"\304
!\203*\211\262
A\266\202\202\210
\204;\305\306\"\210
\207" [ebrowse-search-path nil expand-file-name file-name-directory file-readable-p error "File `%s' not found"] 8 (#$ . 98270)])
#@161 Function called when exiting View mode in BUFFER.
Restore frame configuration active before viewing the file,
and possibly kill the viewed buffer.

(fn BUFFER)
(defalias 'ebrowse-view-exit-fn #[257 "\302\211rq\210\262
	\262)\303\304\305 \302\211:\203/@\262
\236\204(

B\262
A\262\202\211\237\266\203\"\210
\205<
!\207" [ebrowse--frame-configuration ebrowse--view-exit-action nil mapc delete-frame frame-list] 10 (#$ . 98819)])
#@118 View a file FILE in another frame.
The new frame is deleted when you quit viewing the file in that frame.

(fn FILE)
(defalias 'ebrowse-view-file-other-frame #[257 "\302 \303!\304!\305
!\210\306\300!\210\306\301!\210
?\205#\307
!?\205#\310\311\312 \312 \313BB\314\"\207" [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] 8 (#$ . 99269) nil])
#@894 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.

(fn STRUC INFO FILE TAGS-FILE &optional VIEW WHERE)
(defalias 'ebrowse-view/find-file-and-search-pattern #[1540 "\204\303\304\305H>\204\306\307\310\nD\"\210\311H\"\210\312\"\262\313 \203+\314\262

\203J\315\316\317\"\210\211\320\267\202F\321!\207\322!\207\323!\207\211\324\267\202^\325!\210\202b\326!\210\202b\327!\210\317\"\207" [cl-struct-ebrowse-bs-tags ebrowse-temp-position-to-view ebrowse-temp-info-to-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 add-hook view-mode-hook ebrowse-find-pattern #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (other-window 62 other-frame 66)) 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 80 other-frame 87)) find-file-other-window find-file-other-frame find-file] 12 (#$ . 99829)])
#@329 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.

(fn NAME)
(defalias 'ebrowse-symbol-regexp #[257 "\300
!\301\302\303#\203$\304\301\211\224#\305\304\301\225\"Q\262\301\224\306\\\262
\202
\207" [regexp-quote 0 string-match "[ 	]+" substring "[ 	]*" 5] 8 (#$ . 101695)])
#@64 Construct a regexp for a declaration of class NAME.

(fn NAME)
(defalias 'ebrowse-class-declaration-regexp #[257 "\300\301!\302Q\207" ["^[ 	]*\\(template[ 	\n]*<.*>\\)?[ 	\n]*\\(class\\|struct\\|union\\).*\\S_" ebrowse-symbol-regexp "\\S_"] 4 (#$ . 102247)])
#@61 Construct a regexp for matching a variable NAME.

(fn NAME)
(defalias 'ebrowse-variable-declaration-regexp #[257 "\300\301!\300Q\207" ["\\S_" ebrowse-symbol-regexp] 4 (#$ . 102513)])
#@61 Construct a regexp for matching a function NAME.

(fn NAME)
(defalias 'ebrowse-function-declaration/definition-regexp #[257 "\300\301!\302Q\207" ["^[a-zA-Z0-9_:*&<>, 	]*\\S_" ebrowse-symbol-regexp "[ 	\n]*("] 4 (#$ . 102703)])
#@58 Construct a regexp matching a define of NAME.

(fn NAME)
(defalias 'ebrowse-pp-define-regexp #[257 "\300\301!P\207" ["^[ 	]*#[ 	]*define[ 	]+" regexp-quote] 4 (#$ . 102937)])
#@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 #[640 "\306
\203\307\310\311\312G\\D\"\210\204!\313\314\311\"\210\315\262
\262	\262~\210\316H\n>\2043\307\317\320D\"\210\321H\316H\n>\204F\307\317\320D\"\210\322H\323\306@A\211@
A\211@
A
\f;\203k\324\325!P\262
\f\204)
\326!\203\373
G\327Y\203\373
\316H>\203\373\330>\203\245\331\316H\n>\204\235\307\317\320D\"\210\332H!\202\366
\211\333\334\316H\n>\204\270\307\317\320D\"\210\335H\"\316U?\266\203\203\337\336\316H\n>\204\327\307\317\320D\"\210\332H!\202\366\337\316H\n>\204\361\307\317\320D\"\210\332H!\262
\202)
\326!\203)

G\340Y\203)

\316H\f>\203)
\341\316H\n>\204\"
\307\317\320D\"\210\332H!\262
\342\343!\203A
\343J\203A
\344\345\346\"!\210\344
!\210\315\306eZ]b\210\347\\\315#\203c
\315\262
\306\211\262\202d
\315\203x
o?\211\262\203x
\f\211\\\262
\202C

\203\200
\315\202\201
\211\266\202\262\n	\203\223
\350 \210\351\352!\202\336
\316H\n>\204\244
\307\317\320D\"\210\321H\247\203\304
b\210
\203\272
\351\305!\202\336
\353\354!\210\355\312!\202\336

\203\316
\351\305!\202\336

\204\327
\356\354!\210\353\354!\210\355\312!\266\203\266\206\266\204\207" [ebrowse-temp-position-to-view ebrowse-temp-info-to-view cl-struct-ebrowse-bs-tags cl-struct-ebrowse-ms-tags cl-struct-ebrowse-cs-tags ebrowse-not-found-hook nil signal wrong-number-of-arguments ebrowse-find-pattern 2 remove-hook view-mode-hook 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 message "Not found" sit-for error] 25 (#$ . 103120)])
#@109 Redisplay the complete tree.
QUIETLY non-nil means don't display progress messages.

(fn &optional QUIETLY)
(defalias 'ebrowse-redraw-tree #[256 "\211\204\303\304!\210\212\305 \306\211\306\307\310\311\312\313!\314\"\315$\216\316 \210\317 \210,\210)\320 \210\211\2060\303\321!\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks message "Displaying..." buffer-modified-p t make-byte-code 0 "\300?\205\301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 erase-buffer ebrowse-draw-tree-fn ebrowse-update-tree-buffer-mode-line nil] 9 (#$ . 105389) nil])
#@118 Set text properties for class marker signs between START and END.
TREE denotes the class shown.

(fn START END TREE)
(defalias 'ebrowse-set-mark-props #[771 "\300\301\302\303\304\305\306BBBBBB#\210\307\310\311\"\312#\207" [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 face] 13 (#$ . 105982)])
#@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 #[0 "\306\211\211\307G\310\"\262\311!\262\306\211\211\203\237
\211A\262\242\262\211A\262\242\262
\310H	>\2045\312\313\314D\"\210
\315H\262
`\306\211\310H	>\204M\312\313\314D\"\210\316H\203W\317\202X\320c\210\n_\\j\210`\262\211\310H\f>\204t\312\313\321D\"\210\211\322H\203\245\211\310H\f>\204\211\312\313\321D\"\210\211\322H\323\310H\f>\204\234\312\313\321D\"\210\315HQ\262
\202\271\211\310H\f>\204\264\312\313\321D\"\210\211\315H\262
c\210\211\324\325\310H
>\204\316\312\313\326D\"\210\327H\"\310U?\266\203\203\336\330c\210`\310U\203\354\331\202\355\332\333\334\"\335#\266\262`\262
,\2034
-j\210`\262\336\310H\f>\204
\312\313\321D\"\210\337H\206\"
\340\341\261\210`\342\333\334\"\335#\266\343\211T#\210\344\345\346\347\350\351\f\352BBBBBB#\210\353c\266
\310H	>\204b
\312\313\314D\"\210
\322H\203\311\310H	>\204x
\312\313\314D\"\210\322H!\244\262\307\310H	>\204\220
\312\313\314D\"\210\322HGT\"\244\262\202\306\266\203\207" [ebrowse--tree cl-struct-ebrowse-ts-tags ebrowse--indentation ebrowse-tree-left-margin cl-struct-ebrowse-cs-tags cl-struct-ebrowse-bs-tags 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" ebrowse--show-file-names-flag ebrowse-source-file-column] 19 (#$ . 106403)])
#@104 Expand a sub-tree that has been previously collapsed.
With prefix ARG, expand all sub-trees.

(fn ARG)
(defalias 'ebrowse-expand-branch #[257 "\211\203\300
!\207\301\302!\207" [ebrowse-expand-all ebrowse-collapse-fn nil] 3 (#$ . 108220) "P"])
#@150 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.

(fn ARG)
(defalias 'ebrowse-collapse-branch #[257 "\211\203	\300
?!\207\301\302!\207" [ebrowse-expand-all ebrowse-collapse-fn t] 3 (#$ . 108472) "P"])
#@90 Expand or fold all trees in the buffer.
COLLAPSE non-nil means fold them.

(fn COLLAPSE)
(defalias 'ebrowse-expand-all #[257 "\303 \304\211\304\305\306\307\310\311!\312\"\313$\216
\204\314ed\"\202@\212eb\210\315\210m?\205?\316\317!\2038\320`\321\313!\"\210\317\315w\210\202#),\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-modified-p t make-byte-code 0 "\300?\205\301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 ebrowse--unhide nil looking-at "\n " ebrowse--hide line-end-position] 9 (#$ . 108770) "P"])
#@56 Unhide the line the cursor is on and all base classes.
(defalias 'ebrowse-unhide-base-classes #[0 "\303 \304\211\304\305\306\307\310\311!\312\"\313$\216\212\314\211\306y\210\315\316!?\205Z\317\314w\210\211\203/
\320V\205Z\321\322\314\304#\205Z\306\225\306\224Z\262\211\203H

W\203%
\262
\323 \203%\324`\325\313!\"\210\202%\266\202-\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-modified-p t make-byte-code 0 "\300?\205\301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 nil looking-at "\n[^ 	]" "\n 	" 1 re-search-backward "\n[ 	]*" ebrowse--hidden-p ebrowse--unhide line-end-position] 8 (#$ . 109337)])
#@82 Hide/show a single line in the tree.
COLLAPSE non-nil means hide.

(fn COLLAPSE)
(defalias 'ebrowse-hide-line #[257 "\303 \304\211\304\305\306\307\310\311!\312\"\313$\216
\203\314\202\315\316 \316\313!\",\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-modified-p t make-byte-code 0 "\300?\205\301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 ebrowse--hide ebrowse--unhide line-end-position] 9 (#$ . 110003)])
#@101 Collapse or expand a branch of the tree.
COLLAPSE non-nil means collapse the branch.

(fn COLLAPSE)
(defalias 'ebrowse-collapse-fn #[257 "\303 \304\211\304\305\306\307\310\311!\312\"\313$\216\212\314 \210\315\316w\210im?\205;\212\317y\210\315\316w\210i
V)\205;\320!\210\317y\210\202\262
-\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-modified-p t make-byte-code 0 "\300?\205\301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 beginning-of-line "> 	" nil 1 ebrowse-hide-line] 9 (#$ . 110471)])
#@53 Keymap used in electric Ebrowse buffer list window.
(defvar ebrowse-electric-list-mode-map nil (#$ . 111023))
(byte-code "\204\227\301 \301 
\302A@\303\"\210\302
A@\303\"\210\304\305#\210\304\306\307#\210\304\310\311#\210\304\312\313#\210\304\314\315#\210\304\316\317#\210\304\320\317#\210\304\321\322#\210\304\323\324#\210\304\325\326#\210\304\327\330#\210\304\331\332#\210\304\333\330#\210\304\334\332#\210\304\335\336#\210\304\337\340#\210\304\341\342#\210\304\343\344#\210\304\345\346#\210\304\347\350#\210\304\345\346#\266\351\352\353\354#\210\351\303\355\356#\207" [ebrowse-electric-list-mode-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] 6)
(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 #[0 "\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 (#$ . 113521) nil])
#@37 Display a list of all tree buffers.
(defalias 'ebrowse-list-tree-buffers #[0 "\301\302!q\210\303\304 \210\305\306\261\210\307 \211\203%\211@\310
!\311\261\210
A\266\202\202\210\312\211\207" [buffer-read-only get-buffer-create "*Tree Buffers*" nil erase-buffer "Tree\n" "----\n" ebrowse-known-class-trees-buffer-list buffer-name "\n" t] 4 (#$ . 114457)])
#@72 Return a buffer containing a tree or nil if no tree found or canceled.
(defalias 'ebrowse-electric-choose-tree #[0 "\301 @\204\n\302\303!\210\304\211C\304\305 \306\307\310\311\312!\313\"\314$\216\305 \306\307\310\311\312!\315\"\314$\216\316 \210)\210\317\320!\262\321!\240\210\322!\210\306\307\323\311\312!\324\"\314$\216\242q\210\325 \210\3262|\327\330!\210eb\210\314y\210`db\210\331y\210`\307
b\210\332\326\304\333\334B%)\266\2020\262*\210\203\215
\242q\210\335!\262\336\242!\210\207" [goal-column ebrowse-known-class-trees-buffer-list error "No tree buffers" nil current-window-configuration make-byte-code 0 "\301\300!\207" vconcat vector [set-window-configuration] 2 [set-window-configuration] ebrowse-list-tree-buffers Electric-pop-up-window "*Tree Buffers*" window-buffer shrink-window-if-larger-than-buffer "\300\242q\210\301\300\242!\210\302\303!\207" [bury-buffer message nil] ebrowse-electric-list-mode ebrowse-electric-list-select message "<<< Press Space to bury the list >>>" -1 Electric-command-loop t ebrowse-electric-list-looper ebrowse-electric-get-buffer kill-buffer] 13 (#$ . 114824) nil])
#@183 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.

(fn STATE CONDITION)
(defalias 'ebrowse-electric-list-looper #[514 "\211\203\211@\300>\204\301
@A\"\207`@W\203eb\210\302y\207`AV\2055db\210\303y\210\304d!\2055\305\303!\207" [(buffer-read-only end-of-buffer beginning-of-buffer) signal 2 -1 pos-visible-in-window-p recenter] 5 (#$ . 115964)])
#@46 Function called for keys that are undefined.
(defalias 'ebrowse-electric-list-undefined #[0 "\300\301!\210\302\303!\207" [message "Type C-h for help, ? for commands, q to quit, Space to select." sit-for 4] 2 (#$ . 116434) nil])
#@26 Discard the buffer list.
(defalias 'ebrowse-electric-list-quit #[0 "\300\301\302\"\207" [throw ebrowse-electric-list-select nil] 3 (#$ . 116668) nil])
#@39 Select a buffer from the buffer list.
(defalias 'ebrowse-electric-list-select #[0 "\300\301`\"\207" [throw ebrowse-electric-list-select] 3 (#$ . 116825) nil])
#@65 Get a buffer corresponding to the line POINT is in.

(fn POINT)
(defalias 'ebrowse-electric-get-buffer #[257 "\300e\"\301Z\211\302 8\207" [count-lines 2 ebrowse-known-class-trees-buffer-list] 4 (#$ . 116990)])
#@26 View buffer point is on.
(defalias 'ebrowse-electric-view-buffer #[0 "\300`!\211\203
\301
!\202\302\303!\207" [ebrowse-electric-get-buffer view-buffer error "Buffer no longer exists"] 3 (#$ . 117207) nil])
#@72 Read a browser buffer name from the minibuffer and return that buffer.
(defalias 'ebrowse-choose-from-browser-buffers #[0 "\301 \211\203\211A@\204\211@\2020\302 \2060\303\304!\2020\305\306\307\310\211\305$\212\311
!\210)\312
!)\262
\207" [insert-default-directory 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 (#$ . 117422)])
(byte-code "\204\200
\301 \211\302
!\210\303 \203\304
\305\306#\210\304
\307\310#\210\311 \302
\312\"\210\304\313#\210\304
\314\315#\210\304
\316\317#\210\304
\320\321#\210\304
\322\323#\210\304
\324\325#\266\311 \302
\312\"\210\304\326#\210\304
\327\330#\210\304
\314\331#\210\304
\332\333#\210\304
\334\335#\210\304
\336\337#\210\304
\340\341#\266\311 \302
\312\"\210\304\342#\210\311 \302
\312\"\210\304\327#\210\304
\343\344#\210\304
\345\346#\210\304
\347\350#\266\304
\316\351#\210\304
\343\352#\210\304
\324\353#\210\304
\336\354#\210\304
\355\356#\266\311 \302
\312\"\210\304\357#\210\304
\320\360#\210\304
\332\361#\210\304
\342\362#\210\304
\322\363#\210\304
\324\364#\210\304
\365\366#\210\304
\355\367#\210\304
\370\371#\266\311 \302
\312\"\210\304\372#\210\304
\373\374#\210\304
\322\375#\210\304
\355\376#\266\304
\332\377#\210\304
\373\201@#\210\304
\201A\201B#\210\304
\365\201C#\210\304
\355\201D#\210\304
\201E\201F#\210\304
\201G\201H#\210\304
\201I\201J#\210\304
\201K\201L#\210\304
\201M\201N#\266\301\207" [ebrowse-member-mode-map 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] 7)
(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 #[0 "\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\2035\211\321 =\203;\322\f\323 \"\210\210\324
\325\"\204R
%=\204R\326
\325%C#\210\327!\210\330\f!\210
%\331\306\332\"\210\333\334!&\307'\335(\307\211)*\335+\336,-./0\335\21112\335\21134\337\340\341\342z!\"\210)\343\344!\207" [delay-mode-hooks major-mode mode-name ebrowse-member-mode-map ebrowse-member-mode-syntax-table ebrowse-member-mode-abbrev-table 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 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 (#$ . 121929) nil])
#@62 Return the name of the class displayed in the member buffer.
(defalias 'ebrowse-class-name-displayed-in-member-buffer #[0 "\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 (#$ . 124078)])
(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 #[0 "	\211\305H\n>\204\306\307\310D\"\210\211\311H\305H>\2044\306\307\312\305H\n>\204.\306\307\310D\"\210\311HD\"\210\211\305H\n>\204C\306\307\310D\"\210\211\311H\311H\f\230\262
\203S\313\202T\314N\207" [ebrowse--accessor ebrowse--displayed-class 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 (#$ . 124618)])
(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 #[0 "\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\f	\211\306H\n>\204]\307\310\311D\"\210\211\312H\306H
>\204\200\307\310\315\306H\n>\204z\307\310\311D\"\210\312HD\"\210\211\306H\n>\204\217\307\310\311D\"\210\211\312H\312H\230\262
\203\240\316\202\241\317NP\320
!\321\203\261
\202\263!\210\322 \207" [ebrowse--frozen-flag ebrowse--displayed-class cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags ebrowse--accessor cl-struct-ebrowse-bs-tags 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 ebrowse-globals-name mode-line-buffer-identification ebrowse-member-buffer-name] 11 (#$ . 125245)])
#@41 Toggle frozen status of current buffer.
(defalias 'ebrowse-freeze-member-buffer #[0 "?\301 \207" [ebrowse--frozen-flag ebrowse-redisplay-member-buffer] 1 (#$ . 126218) nil])
#@125 Show the currently displayed class in the tree window.
With prefix ARG, switch to the tree buffer else pop to it.

(fn ARG)
(defalias 'ebrowse-show-displayed-class-in-tree #[257 "\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\311!\205N\312
!\207" [ebrowse--displayed-class cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs ebrowse-pop-from-member-to-tree-buffer ebrowse-read-class-name-and-go] 8 (#$ . 126401) "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 #[0 "\303\304\305\306\203\f	\202
\n!\307Q!!\211\211\310V\262
\205(\203$\211\202&\211\311 \207" [ebrowse--long-display-flag ebrowse--decl-column ebrowse--column-width string-to-number read-from-minibuffer "Column width (" int-to-string "): " 0 ebrowse-redisplay-member-buffer] 5 (#$ . 126992) nil])
#@138 Pop from a member buffer to the matching tree buffer.
Switch to the buffer if prefix ARG.  If no tree buffer exists,
make one.

(fn ARG)
(defalias 'ebrowse-pop-from-member-to-tree-buffer #[257 "\305\306!!\206\305	!\206\307\n\f\310%\211\203%
\203!\311\202\"\312
!\210\211\207" [ebrowse--tags-file-name ebrowse-tree-buffer-name ebrowse--tree ebrowse--header ebrowse--tree-obarray get-buffer ebrowse-frozen-tree-buffer-name ebrowse-create-tree-buffer pop switch-to-buffer pop-to-buffer] 7 (#$ . 127443) "P"])
#@82 Switch the member buffer to display the member list for ACCESSOR.

(fn ACCESSOR)
(defalias 'ebrowse-display-member-list-for-accessor #[257 "\211\211	!\303 \207" [ebrowse--accessor ebrowse--displayed-class ebrowse--member-list ebrowse-redisplay-member-buffer] 3 (#$ . 127965)])
#@68 Switch buffer to INCR'th next/previous list of members.

(fn INCR)
(defalias 'ebrowse-cyclic-display-next/previous-member-list #[257 "\302	\"
\211\303V\262
\203\211T	8\2066	@\2026
\211\303W\262
\2056\211S\211\262\303Y\2032\211	8\2066\304	!@\305!\207" [ebrowse--accessor ebrowse-member-list-accessors ebrowse-position 0 last ebrowse-display-member-list-for-accessor] 5 (#$ . 128250)])
#@36 Switch buffer to next member list.
(defalias 'ebrowse-display-next-member-list #[0 "\300\301!\207" [ebrowse-cyclic-display-next/previous-member-list 1] 2 (#$ . 128651) nil])
#@40 Switch buffer to previous member list.
(defalias 'ebrowse-display-previous-member-list #[0 "\300\301!\207" [ebrowse-cyclic-display-next/previous-member-list -1] 2 (#$ . 128831) nil])
#@39 Display the list of member functions.
(defalias 'ebrowse-display-function-member-list #[0 "\300\301!\207" [ebrowse-display-member-list-for-accessor ebrowse-ts-member-functions] 2 (#$ . 129020) nil])
#@39 Display the list of member variables.
(defalias 'ebrowse-display-variables-member-list #[0 "\300\301!\207" [ebrowse-display-member-list-for-accessor ebrowse-ts-member-variables] 2 (#$ . 129225) nil])
#@46 Display the list of static member variables.
(defalias 'ebrowse-display-static-variables-member-list #[0 "\300\301!\207" [ebrowse-display-member-list-for-accessor ebrowse-ts-static-variables] 2 (#$ . 129431) nil])
#@46 Display the list of static member functions.
(defalias 'ebrowse-display-static-functions-member-list #[0 "\300\301!\207" [ebrowse-display-member-list-for-accessor ebrowse-ts-static-functions] 2 (#$ . 129651) nil])
#@30 Display the list of friends.
(defalias 'ebrowse-display-friends-member-list #[0 "\300\301!\207" [ebrowse-display-member-list-for-accessor ebrowse-ts-friends] 2 (#$ . 129871) nil])
#@28 Display the list of types.
(defalias 'ebrowse-display-types-member-list #[0 "\300\301!\207" [ebrowse-display-member-list-for-accessor ebrowse-ts-types] 2 (#$ . 130057) nil])
#@53 Toggle display of `virtual', `inline', `const' etc.
(defalias 'ebrowse-toggle-member-attributes-display #[0 "?\301 \207" [ebrowse--attributes-flag ebrowse-redisplay-member-buffer] 1 (#$ . 130237) nil])
#@60 Toggle the display of members inherited from base classes.
(defalias 'ebrowse-toggle-base-class-display #[0 "?\301 \207" [ebrowse--show-inherited-flag ebrowse-redisplay-member-buffer] 1 (#$ . 130447) nil])
#@41 Toggle display of pure virtual members.
(defalias 'ebrowse-toggle-pure-member-filter #[0 "?\301 \207" [ebrowse--pure-display-flag ebrowse-redisplay-member-buffer] 1 (#$ . 130661) nil])
#@34 Toggle display of const members.
(defalias 'ebrowse-toggle-const-member-filter #[0 "?\301 \207" [ebrowse--const-display-flag ebrowse-redisplay-member-buffer] 1 (#$ . 130854) nil])
#@35 Toggle display of inline members.
(defalias 'ebrowse-toggle-inline-member-filter #[0 "?\301 \207" [ebrowse--inline-display-flag ebrowse-redisplay-member-buffer] 1 (#$ . 131042) nil])
#@36 Toggle display of virtual members.
(defalias 'ebrowse-toggle-virtual-member-filter #[0 "?\301 \207" [ebrowse--virtual-display-flag ebrowse-redisplay-member-buffer] 1 (#$ . 131233) nil])
#@21 Remove all filters.
(defalias 'ebrowse-remove-all-member-filters #[0 "\305\306\211W\203\211
\211I\266\211T\262
\202\266\307\211\307\211\310 \207" [ebrowse--filters ebrowse--pure-display-flag ebrowse--const-display-flag ebrowse--virtual-display-flag ebrowse--inline-display-flag 3 0 nil ebrowse-redisplay-member-buffer] 7 (#$ . 131427) nil])
#@38 Toggle visibility of public members.
(defalias 'ebrowse-toggle-public-member-filter #[0 "\300\301!\210\302 \207" [ebrowse-set-member-access-visibility 0 ebrowse-redisplay-member-buffer] 2 (#$ . 131786) nil])
#@41 Toggle visibility of protected members.
(defalias 'ebrowse-toggle-protected-member-filter #[0 "\300\301!\210\302 \207" [ebrowse-set-member-access-visibility 1 ebrowse-redisplay-member-buffer] 2 (#$ . 132000) nil])
#@39 Toggle visibility of private members.
(defalias 'ebrowse-toggle-private-member-filter #[0 "\300\301!\210\302 \207" [ebrowse-set-member-access-visibility 2 ebrowse-redisplay-member-buffer] 2 (#$ . 132220) nil])
#@12 

(fn VIS)
(defalias 'ebrowse-set-member-access-visibility #[257 "


H?\205\fI\207" [ebrowse--filters] 7 (#$ . 132436)])
#@63 Toggle between long and short display form of member buffers.
(defalias 'ebrowse-toggle-long-short-display #[0 "?\301 \207" [ebrowse--long-display-flag ebrowse-redisplay-member-buffer] 1 (#$ . 132568) nil])
#@113 Toggle declaration/definition regular expression display.
Used in member buffers showing the long display form.
(defalias 'ebrowse-toggle-regexp-display #[0 "?\301 \207" [ebrowse--source-regexp-flag ebrowse-redisplay-member-buffer] 1 (#$ . 132784) nil])
#@156 Find the file containing a member definition.
With PREFIX 4. find file in another window, with prefix 5
find file in another frame.

(fn &optional PREFIX)
(defalias 'ebrowse-find-member-definition #[256 "\300
\301\302#\207" [ebrowse-view/find-member-declaration/definition nil t] 5 (#$ . 133047) "p"])
#@146 View the file containing a member definition.
With PREFIX 4. find file in another window, with prefix 5
find file in another frame.

(fn PREFIX)
(defalias 'ebrowse-view-member-definition #[257 "\300
\301\211#\207" [ebrowse-view/find-member-declaration/definition t] 5 (#$ . 133356) "p"])
#@149 Find the file containing a member's declaration.
With PREFIX 4. find file in another window, with prefix 5
find file in another frame.

(fn PREFIX)
(defalias 'ebrowse-find-member-declaration #[257 "\300
\301\"\207" [ebrowse-view/find-member-declaration/definition nil] 4 (#$ . 133651) "p"])
#@149 View the file containing a member's declaration.
With PREFIX 4. find file in another window, with prefix 5
find file in another frame.

(fn PREFIX)
(defalias 'ebrowse-view-member-declaration #[257 "\300
\301\"\207" [ebrowse-view/find-member-declaration/definition t] 4 (#$ . 133949) "p"])
#@393 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.

(fn PREFIX VIEW &optional DEFINITION INFO HEADER TAGS-FILE)
(defalias 'ebrowse-view/find-member-declaration/definition #[1538 "\3062
\204\262\211\204	\262
\307\211\211\211\211\n\310U\203\"\311\202.\n\312U\203-\313\202.\314\203H@\262A@\262AA@\262\202^\315\316 !\211@\262\211A@\262\317
8\262\210\n\262
\203\352\320\306\321\322H>\204v\323\324\325D\"\210\326H\n\322H>\204\214\323\324\325
D\"\210\n\326H\307E\n\322H>\204\243\323\324\325
D\"\210\n\326H\322H\f>\204\311\323\324\327
\322H>\204\302\323\324\325D\"\210
\326HD\"\210\n\322H>\204\332\323\324\325
D\"\210\n\326H\310H\f&\"\210	\203\370\330=\203\370\307\262\n	\203q
\331\332\322H
>\204
\323\324\332	D\"\210\326H\307\322H
>\204&
\323\324\332D\"\210\333H	\322H
>\204;
\323\324\332\fD\"\210	\334H\n\322H
>\204P
\323\324\332
D\"\210\n\335H\322H
>\204e
\323\324\332D\"\210\336H\307\211\211\211&\262\322H
>\204\201
\323\324\332D\"\210\310H\206#	\203\331
\322H>\204\234
\323\324\325D\"\210\326H\322H\f>\204\301
\323\324\327\322H>\204\272
\323\324\325D\"\210\326HD\"\210\322H>\204\321
\323\324\325D\"\210\326H\337H\202#\322H>\204\351
\323\324\325D\"\210\326H\322H\f>\204\323\324\327\322H>\204\323\324\325D\"\210\326HD\"\210\322H>\204\323\324\325D\"\210\326H\310H\262\203A\322H
>\2049\323\324\332D\"\210\340H\322U\203\222\341\342\203L\343\202M\344\345
\203W\344\202X\343\346\n\322H
>\204j\323\324\332
D\"\210\n\326H\347\260!\203\214\350\307!\210\351\f\f\f?\f\f\f&\202\352\353!\202\321\331\354\322H
>\204\246\323\324\332\nD\"\210\326H\307	\322H
>\204\274\323\324\332\fD\"\210	\333H\n\322H
>\204\321\323\324\332
D\"\210\n\310H\322H
>\204\346\323\324\332D\"\210\312H\f\322H
>\204\373\323\324\332D\"\210\f\340H&	E\n&\266\2060\207" [ebrowse--header ebrowse--tags-file-name ebrowse--accessor cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags cl-struct-ebrowse-ms-tags --cl-block-ebrowse-view/find-member-declaration/definition-- nil 4 other-window 5 other-frame this-window cl-values-list 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] 24 (#$ . 134245)])
#@25 Force buffer redisplay.
(defalias 'ebrowse-redisplay-member-buffer #[0 "\203\306\202	\307\310 \311\211\311\312\313\314\315\316!\317\"\320$\216\321 \210\322 \210
\f
\"\210\203X\323
!\211\203W\211@db\210n\203A\324\202B\325c\210\322
!\210!\"\210
A\266\202\2020\210\326 ,\262
\207" [ebrowse--long-display-flag buffer-undo-list inhibit-read-only inhibit-modification-hooks ebrowse--member-list ebrowse--displayed-class ebrowse-draw-member-long-fn ebrowse-draw-member-short-fn buffer-modified-p t make-byte-code 0 "\300?\205\301\302!\207" vconcat vector [restore-buffer-modified-p nil] 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 ebrowse--accessor] 9 (#$ . 137124) nil])
#@174 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.

(fn &optional CLASS)
(defalias 'ebrowse-draw-member-buffer-class-line #[256 "`
\206\304\211\305c\210`\262\306H	>\204\307\310\311D\"\210\312H\211\306H\n>\204/\307\310\313D\"\210\211\314H\203`\211\306H\n>\204D\307\310\313D\"\210\211\314H\315\306H\n>\204W\307\310\313D\"\210\312HQ\262
\202t\211\306H\n>\204o\307\310\313D\"\210\211\312H\262
c\210\306H	>\204\205\307\310\311D\"\210\312H\211\316\317\306H>\204\232\307\310\320D\"\210\321H\"\306U?\266\203\203\252\322c\210`\262
\323c\210`\324\325\326\"\327#\266\330\331#\210\332\333$\207" [ebrowse--displayed-class cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags cl-struct-ebrowse-bs-tags 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] 13 (#$ . 137928)])
#@197 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.

(fn LIST &optional STAND-ALONE CLASS)
(defalias 'ebrowse-display-member-buffer #[769 "	\n\306\307
!\204\310 \262\311 r\312\313\314\315\316!\317\"\320$\216
\203+\321!\210\2024\321\322
!!\210\323 \210!\324\325 \210p*\262
)\207" [ebrowse--tree-obarray ebrowse--tree ebrowse--tags-file-name ebrowse--header temp-buffer-setup-hook ebrowse-member-buffer-name nil get-buffer ebrowse-tree-at-point internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 pop-to-buffer get-buffer-create ebrowse-member-mode t ebrowse-redisplay-member-buffer ebrowse--member-list ebrowse--displayed-class ebrowse--accessor ebrowse--frozen-flag buffer-read-only] 15 (#$ . 139069)])
#@127 Check if MEMBER must be displayed under the current filter settings.
If so, return MEMBER; otherwise return nil.

(fn MEMBER)
(defalias 'ebrowse-member-display-p #[257 "
\306H	>\204\307\310\311D\"\210
\312HH\205\236\n\203;\211\211\313\314\306H>\204.\307\310\315D\"\210\316H\"\306U?\266\203\205\236\f\203_\211\211\317\314\306H>\204R\307\310\315D\"\210\316H\"\306U?\266\203\205\236
\203x\320
!\205\236\211G\312Y\205\236\211\306H>\205\236\203\235\211\211\321\314\306H>\204\220\307\310\315D\"\210\316H\"\306U?\266\203\205\236\211\207" [ebrowse--filters cl-struct-ebrowse-ms-tags ebrowse--const-display-flag cl-struct-ebrowse-bs-tags ebrowse--inline-display-flag ebrowse--pure-display-flag 0 signal wrong-type-argument ebrowse-ms 7 4 logand ebrowse-bs 3 2 vectorp 1 ebrowse--virtual-display-flag] 9 (#$ . 139998)])
#@60 Insert a string for the attributes of MEMBER.

(fn MEMBER)
(defalias 'ebrowse-draw-member-attributes #[257 "\211\211\301\302\303H>\204\304\305\306D\"\210\307H\"\303U?\266\203\203$\310\202%\311
\211\312\302\303H>\2048\304\305\306D\"\210\307H\"\303U?\266\203\203I\313\202J\311\211\314\302\303H>\204]\304\305\306D\"\210\307H\"\303U?\266\203\203n\315\202o\311\211\316\302\303H>\204\202\304\305\306D\"\210\307H\"\303U?\266\203\203\223\317\202\224\311\211\320\302\303H>\204\247\304\305\306D\"\210\307H\"\303U?\266\203\203\270\321\202\271\311\211\322\302\303H>\204\314\304\305\306D\"\210\307H\"\303U?\266\203\203\335\323\202\336\311\211\324\302\303H>\204\362\304\305\306D\"\210\307H\"\303U?\266\203\203
\325\202
\311\211\326\302\303H>\204
\304\305\306D\"\210\307H\"\303U?\266\203\203)
\327\202*
\311\211\330\302\303H>\204>
\304\305\306D\"\210\307H\"\303U?\266\203\203O
\331\202P
\311\261	\207" [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"] 17 (#$ . 140850)])
#@86 Insert a string for the regular expression matching MEMBER-STRUC.

(fn MEMBER-STRUC)
(defalias 'ebrowse-draw-member-regexp #[257 "\203\211\303H	>\204\304\305\306D\"\210\211\307H\202+\211\303H	>\204(\304\305\306D\"\210\211\310H\211;\203[\311
!\312\261\210\313\303!\210\314\315\n\\!\210\316\317\320\321#\203U\303\224\303\225|\210\322c\210\202A\313\323!\202]\324c\207" [ebrowse--source-regexp-flag cl-struct-ebrowse-ms-tags 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"] 6 (#$ . 141982)])
#@115 Display member buffer for MEMBER-LIST in long form.
TREE is the class tree of MEMBER-LIST.

(fn MEMBER-LIST TREE)
(defalias 'ebrowse-draw-member-long-fn #[514 "\303\304\"\211\203|\211@\211\203u\211\305H>\204\306\307\310D\"\210\211\311H`\312\305G	S^#c\210\313
`\314\315\316\317\320\n\321\322BBBBBBBB#\210`\262
	j\210\323
`\314\324$\210\n\203m`\325c\210\326!\210\327c\210\211`\330\331\332\"\333#\266\334c\210\335!\266
A\266\202\202\210\336c\210eb\207" [cl-struct-ebrowse-ms-tags ebrowse--decl-column ebrowse--attributes-flag mapcar ebrowse-member-display-p 0 signal wrong-type-argument ebrowse-ms 1 substring 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 nil "<" ebrowse-draw-member-attributes ">" ebrowse-member-attribute overlay-put make-overlay face " " ebrowse-draw-member-regexp "\n"] 18 (#$ . 142639)])
#@114 Display MEMBER-LIST in short form.
TREE is the class tree in which the members are found.

(fn MEMBER-LIST TREE)
(defalias 'ebrowse-draw-member-short-fn #[514 "\304	\203\n\305\202\304\\\306\307 \245]\310\311\"\211\203\244\211@\211\203\235\211\304H>\2040\312\313\314D\"\210\211\306H\315`\315_j\210\316`\317\315$\210`\262	\203b\320c\210\321!\210\322c\210`\323\324\325\"\326#\266`\262
\327\304GS^#c\210\330
`\331\332\333\n\317\334\335\336BBBBBBBB#\210T\262\nY\203\233\304\262\337c\210\266
A\266\202\202\210
\211\304V\262
\203\261\337c\210eb\207" [ebrowse--column-width ebrowse--attributes-flag ebrowse--n-columns cl-struct-ebrowse-ms-tags 0 12 1 ebrowse-width-of-drawable-area mapcar ebrowse-member-display-p signal wrong-type-argument ebrowse-ms nil put-text-property mouse-face "<" ebrowse-draw-member-attributes "> " ebrowse-member-attribute overlay-put make-overlay face substring add-text-properties ebrowse-what member-name ebrowse-member highlight ebrowse-tree (help-echo "mouse-2: view definition; mouse-3: menu") "\n"] 22 (#$ . 143595)])
#@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 #[0 "\300`\301\"\206\n\302\303!\300`\304\"

\211?E\207" [get-text-property ebrowse-tree error "No information at point" ebrowse-member] 5 (#$ . 144689)])
#@169 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.

(fn PREFIX)
(defalias 'ebrowse-goto-visible-member/all-member-lists #[257 "\304\305 \306\307\310\304$\311
\"A\211\204\312\313\"\210\211	=\204'\211\211\n!\314 \210\315!\266\203)\207" [completion-ignore-case ebrowse--accessor ebrowse--displayed-class ebrowse--member-list 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] 7 (#$ . 145072) "p"])
#@200 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.

(fn REPEAT)
(defalias 'ebrowse-goto-visible-member #[257 "\301\302 \303\304\305\301$\306
\"\266\202)\207" [completion-ignore-case t ebrowse-name/accessor-alist-for-visible-members completing-read "Goto member: " nil ebrowse-move-point-to-member] 7 (#$ . 145712) "p"])
#@116 Repeat the last regular expression search.
REPEAT, if specified, says repeat the search REPEAT times.

(fn REPEAT)
(defalias 'ebrowse-repeat-member-search #[257 "\204\301\302!\210\303\304w\210\305\304\306$\203\307\224b\210\310\304w\207eb\210\305\304\306#\2030\307\224b\210\310\304w\207\301\311!\207" [ebrowse--last-regexp error "No regular expression remembered" "^ 	\n" nil re-search-forward t 0 " 	\n" "Not found"] 6 (#$ . 146177) "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 #[641 "\302
\203\303\304\305\306G\\D\"\210eb\210~\210\307\310GS^#\262
\311\312!\313Q\314	\302\315$\2038\310\224Tb\202;\316\317!\207" [ebrowse--column-width ebrowse--last-regexp nil signal wrong-number-of-arguments ebrowse-move-point-to-member 2 substring 0 "[ 	\n]" regexp-quote "[ \n	]" re-search-forward t error "Not found"] 9 (#$ . 146632)])
#@154 Switch member buffer to a class read from the minibuffer.
Use TITLE as minibuffer prompt.
COMPL-LIST is a completion list to use.

(fn TITLE COMPL-LIST)
(defalias 'ebrowse-switch-member-buffer-to-other-class #[514 "\211A@?\205\n\211@@\303#\206\304\305!\211	!\306 \207" [ebrowse--displayed-class ebrowse--accessor ebrowse--member-list ebrowse-completing-read-value error "Not found" ebrowse-redisplay-member-buffer] 7 (#$ . 147183)])
#@59 Switch member buffer to a class read from the minibuffer.
(defalias 'ebrowse-switch-member-buffer-to-any-class #[0 "\300\301\302 \"\207" [ebrowse-switch-member-buffer-to-other-class "Goto class: " ebrowse-tree-obarray-as-alist] 3 (#$ . 147631) nil])
#@47 Switch buffer to ARG'th base class.

(fn ARG)
(defalias 'ebrowse-switch-member-buffer-to-base-class #[257 "\305!\206	\306\307!
\203\237\211A@\203\237\211\310\211:\203\222@\262
\311H	>\204.\312\313\314D\"\210
\315H\211\311H\n>\204@\312\313\316D\"\210\211\317H\203q\211\311H\n>\204U\312\313\316D\"\210\211\317H\320\311H\n>\204h\312\313\316D\"\210\315HQ\262
\202\205\211\311H\n>\204\200\312\313\316D\"\210\211\315H\262
B
B\262
A\262\202\211\237\266\203\321\322\"\262
\202\250\211@!\323 \207" [ebrowse--displayed-class cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags ebrowse--accessor ebrowse--member-list 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] 12 (#$ . 147887) "P"])
#@40 Move to ARG'th next sibling.

(fn ARG)
(defalias 'ebrowse-switch-member-buffer-to-next-sibling-class #[257 "\300
!\207" [ebrowse-switch-member-buffer-to-sibling-class] 3 (#$ . 148768) "p"])
#@44 Move to ARG'th previous sibling.

(fn ARG)
(defalias 'ebrowse-switch-member-buffer-to-previous-sibling-class #[257 "\300
[!\207" [ebrowse-switch-member-buffer-to-sibling-class] 3 (#$ . 148964) "p"])
#@91 Switch member display to nth sibling class.
Prefix arg INC specifies which one.

(fn INC)
(defalias 'ebrowse-switch-member-buffer-to-sibling-class #[257 "\305\211\306	!\307
\203:
A@\203\310\311!\305#\202
@\211\204%\312\313!\210\211\314H\n>\2044\315\316\317D\"\210\211\320H\262\210\210\321	\"\\\262\211\314W\262
\203T\322\323!\210\202^8\204^\322\324!\210\314GS^]\2628\262
!\325 \207" [ebrowse--tree ebrowse--displayed-class cl-struct-ebrowse-ts-tags ebrowse--accessor ebrowse--member-list nil ebrowse-direct-base-classes #[257 "\211\302\211:\203_@\262
\303H>\204\304\305\306D\"\210
\307H\303H	>\204>\304\305\310\303H>\2048\304\305\306D\"\210\307HD\"\210
\303H>\204M\304\305\306D\"\210
\307H\307HB
B\262
A\262\202\211\237\207" [cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags nil 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs] 11 "\n\n(fn TREES)"] 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] 11 (#$ . 149169) "p"])
#@145 Switch member display to nth derived class.
Prefix arg ARG says which class should be displayed.  Default is
the first derived class.

(fn ARG)
(defalias 'ebrowse-switch-member-buffer-to-derived-class #[257 "\304\305H	>\204\306\307\310D\"\210\311H\206\312\313!\203+\211A@\203+\314\315 \"\2024\211@\n!\316 \262
\207" [ebrowse--displayed-class cl-struct-ebrowse-ts-tags ebrowse--accessor ebrowse--member-list #[0 "\303H	>\204\304\305\306D\"\210\307H\310\211:\203p@\262
\303H	>\204,\304\305\306D\"\210
\311H\303H\n>\204O\304\305\312\303H	>\204I\304\305\306D\"\210\311HD\"\210
\303H	>\204^\304\305\306D\"\210
\311H\311HB
B\262
A\262\202\211\237\207" [ebrowse--displayed-class cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags 0 signal wrong-type-argument ebrowse-ts 2 nil 1 ebrowse-cs] 10] 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] 6 (#$ . 150322) "P"])
(defalias 'ebrowse-displaying-functions #[0 "\301=\207" [ebrowse--accessor ebrowse-ts-member-functions] 2])
(defalias 'ebrowse-displaying-variables #[0 "\301=\207" [ebrowse--accessor ebrowse-ts-member-variables] 2])
(defalias 'ebrowse-displaying-static-functions #[0 "\300\207" [nil] 1])
(defalias 'ebrowse-displaying-static-variables #[0 "\300\207" [nil] 1])
(defalias 'ebrowse-displaying-types #[0 "\301=\207" [ebrowse--accessor ebrowse-ts-types] 2])
(defalias 'ebrowse-displaying-friends #[0 "\301=\207" [ebrowse--accessor ebrowse-ts-friends] 2])
#@43 Object menu for the member buffer itself.
(defvar ebrowse-member-buffer-object-menu nil (#$ . 151900))
(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 #[0 "\300`\301\"\302=\207" [get-text-property ebrowse-what class-name] 3 (#$ . 156202)])
#@48 Value is non-nil if point is on a member name.
(defalias 'ebrowse-on-member-name #[0 "\300`\301\"\302=\207" [get-text-property ebrowse-what member-name] 3 (#$ . 156376)])
#@47 Object menu for class names in member buffer.
(defvar ebrowse-member-class-name-object-menu nil (#$ . 156553))
(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 (#$ . 157116))
(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)]))
#@82 Handle `mouse-3' events in member buffers.
EVENT is the mouse event.

(fn EVENT)
(defalias 'ebrowse-member-mouse-3 #[257 "\303
!\210\211\211:\203\304
8\250\203\304
8\262
\202\305\262
\211\306\267\202L\307 \202M\310\311\312!!\313\"\211\314\267\202C\315\"\202G\315	\"\202G\315\n\"\262
\202M\316\207" [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 eql rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (2 34 1 39)) 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 53 class-name 60)) ebrowse-popup-menu nil] 6 (#$ . 157907) "e"])
#@82 Handle `mouse-2' events in member buffers.
EVENT is the mouse event.

(fn EVENT)
(defalias 'ebrowse-member-mouse-2 #[257 "\300
!\210\211\211:\203\301
8\250\203\301
8\262
\202\302\262
\211\303\267\202=\304 \202>\305\306\307!!\310\"\211\311=\2058\312\313!\262
\202>\314\207" [mouse-set-point 2 1 #s(hash-table size 2 test eql rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (2 34 1 39)) ebrowse-find-member-definition get-text-property posn-point event-start ebrowse-what member-name ebrowse-view-member-definition 0 nil] 6 (#$ . 158700) "e"])
#@463 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'.

(fn TREE-HEADER NAME)
(defalias 'ebrowse-class-alist-for-member #[514 "\302!\303\211\205\236\304\"\211\203\233\211@\211@>\204\224\211@\305H>\204+\306\307\310@D\"\210\211@\311H\211\305H	>\204>\306\307\312D\"\210\211\313H\203o\211\305H	>\204S\306\307\312D\"\210\211\313H\314\305H	>\204f\306\307\312D\"\210\311HQ\262
\202\203\211\305H	>\204~\306\307\312D\"\210\211\311H\262

B
B\266\203\262\211@B\262
A\266\202\202

\262
\207" [cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags ebrowse-member-table nil gethash 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs 2 "::"] 14 (#$ . 159268)])
#@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 #[0 "\300 \211\205\301\302\"\301\303\"E\207" [ebrowse-choose-from-browser-buffers buffer-local-value ebrowse--tree ebrowse--header] 5 (#$ . 160335)])
#@256 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).

(fn HEADER PROMPT)
(defalias 'ebrowse-tags-read-name #[514 "\212\301!\302\303 !\211@
A@\211\204\304\305!\210\203P\306\307\310\211%)\311
\"\204H\312\313!\203D\314\315!#@\206?\304\316!\262
\202H\304\317!\210
D\262
\202W
\320\"D\266\203\262
)\207" [completion-ignore-case ebrowse-member-table cl-values-list ebrowse-tags-read-member+class-name error "No member name at point" t completing-read nil 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] 12 (#$ . 160807)])
#@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 #[0 "\212\300\301x\210`\300\301w\210\211`{\301\211D\266\203)\207" ["a-zA-Z0-9_" nil] 5 (#$ . 161648)])
#@325 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.

(fn TREE HEADER NAME INITIAL-CLASS-NAME)
(defalias 'ebrowse-tags-choose-class #[1028 "\302\"\206\303\304\"\305\211A@\204\211@A\202)\306	B\307\310\311\312\305%\"A)\207" [completion-ignore-case unread-command-events ebrowse-class-alist-for-member error "No classes with member `%s' found" t 63 assoc completing-read "In class: " nil] 12 (#$ . 162010)])
#@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 #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\211\203=\211@\304>\203&\211AA\262
\202\305>A@\2034\306\262
\202\307\310@\"\210\202\210\311\312 !\211@
A@\3138\204R\307\314!\210\315 \306\306
\204\203\311\316
\203i\317\202j\320\321\203t\322\202u\323\324R\"!\211@\262\211A@\262\210\325$\262
\326\"\210\327
\f\f\n\330\331\f\"&\210\326\315 \332#\266\204\266\204\207" [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)" cl-values-list 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] 22 (#$ . 162665)])
#@38 View declaration of member at point.
(defalias 'ebrowse-tags-view-declaration #[0 "\300\301\302\303\304\305%\207" [ebrowse-tags-view/find-member-decl/defn 0 :view t :definition nil] 6 (#$ . 164127) nil])
#@38 Find declaration of member at point.
(defalias 'ebrowse-tags-find-declaration #[0 "\300\301\302\303\304\303%\207" [ebrowse-tags-view/find-member-decl/defn 0 :view nil :definition] 6 (#$ . 164337) nil])
#@37 View definition of member at point.
(defalias 'ebrowse-tags-view-definition #[0 "\300\301\302\303\304\303%\207" [ebrowse-tags-view/find-member-decl/defn 0 :view t :definition] 6 (#$ . 164545) nil])
#@37 Find definition of member at point.
(defalias 'ebrowse-tags-find-definition #[0 "\300\301\302\303\304\305%\207" [ebrowse-tags-view/find-member-decl/defn 0 :view nil :definition t] 6 (#$ . 164749) nil])
#@54 View declaration of member at point in other window.
(defalias 'ebrowse-tags-view-declaration-other-window #[0 "\300\301\302\303\304\305%\207" [ebrowse-tags-view/find-member-decl/defn 4 :view t :definition nil] 6 (#$ . 164957) nil])
#@54 Find declaration of member at point in other window.
(defalias 'ebrowse-tags-find-declaration-other-window #[0 "\300\301\302\303\304\303%\207" [ebrowse-tags-view/find-member-decl/defn 4 :view nil :definition] 6 (#$ . 165196) nil])
#@53 View definition of member at point in other window.
(defalias 'ebrowse-tags-view-definition-other-window #[0 "\300\301\302\303\304\303%\207" [ebrowse-tags-view/find-member-decl/defn 4 :view t :definition] 6 (#$ . 165433) nil])
#@53 Find definition of member at point in other window.
(defalias 'ebrowse-tags-find-definition-other-window #[0 "\300\301\302\303\304\305%\207" [ebrowse-tags-view/find-member-decl/defn 4 :view nil :definition t] 6 (#$ . 165666) nil])
#@52 View definition of member at point in other frame.
(defalias 'ebrowse-tags-view-declaration-other-frame #[0 "\300\301\302\303\304\305%\207" [ebrowse-tags-view/find-member-decl/defn 5 :view t :definition nil] 6 (#$ . 165903) nil])
#@52 Find definition of member at point in other frame.
(defalias 'ebrowse-tags-find-declaration-other-frame #[0 "\300\301\302\303\304\303%\207" [ebrowse-tags-view/find-member-decl/defn 5 :view nil :definition] 6 (#$ . 166139) nil])
#@52 View definition of member at point in other frame.
(defalias 'ebrowse-tags-view-definition-other-frame #[0 "\300\301\302\303\304\303%\207" [ebrowse-tags-view/find-member-decl/defn 5 :view t :definition] 6 (#$ . 166373) nil])
#@52 Find definition of member at point in other frame.
(defalias 'ebrowse-tags-find-definition-other-frame #[0 "\300\301\302\303\304\305%\207" [ebrowse-tags-view/find-member-decl/defn 5 :view nil :definition t] 6 (#$ . 166604) nil])
#@160 Select or create member buffer.
TREE-BUFFER specifies the tree to use.  INFO describes the member.
It is a list (TREE ACCESSOR MEMBER).

(fn TREE-BUFFER INFO)
(defalias 'ebrowse-tags-select/create-member-buffer #[514 "\305!\211\204q\210\306\307A@\310@#!\210\202*\306
!\210
@
A@\211	!\311 \210\312AA@\313H\f>\204@\314\315\316AA@D\"\210AA@\317H!\207" [ebrowse-member-buffer-name ebrowse--displayed-class ebrowse--accessor ebrowse--member-list cl-struct-ebrowse-ms-tags 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] 9 (#$ . 166840)])
#@164 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.

(fn &optional FIX-NAME)
(defalias 'ebrowse-tags-display-member-buffer #[256 "\300\301 !\211@
A@\3028\204\303\304!\210\305 \306\306
\204/\300\307\310\"!\211@\262\211A@\262\210\311$\262
\312\"\210\313\"\266\204\207" [cl-values-list 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] 14 (#$ . 167512) nil])
#@193 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.

(fn MEMBERS REGEXP &optional NAME)
(defalias 'ebrowse-list-of-matching-members #[770 "\300C
\204\n\203\301\302\303\304\305\306#\307\"\310\311%\"\210\211\242\207" [nil maphash make-byte-code 514 "\301\203\n\301\230\204\300\205\303\300\"\205\302\302\242B\240\207" vconcat vector [string-match] 5 "\n\n(fn MEMBER-NAME INFO)"] 13 (#$ . 168131)])
#@71 Display a list of members matching a regexp read from the minibuffer.
(defalias 'ebrowse-tags-apropos #[0 "\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\300!\210+\211\211q\210\323 \210\325\326\"c\210\327\"\314
:\203t
@\262
\330
\"\314
:\203k
@\262
\331
!\210
A\262\202W\266
A\262\202H\314\266\202\332!\210)\266\202)\207" [temp-buffer-setup-hook default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks 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 inhibit-read-only standard-output] 13 (#$ . 168657) 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 #[0 "\306 \206\307\310!r\211q\210\311 )\312\313\314\315$\316\317\"\314\320
!	r\321\322\323Q!q\210p\324 \210
\314\211\315\211\315!\325 \210\326\300!\210+\211\"\211q\210\327\330\331\332\333\334\n!\335\"\336\337%\"\340!\210)\266\202)\207" [temp-buffer-setup-hook default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks 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 make-byte-code 514 "\211\304\211\211:\203\301@\262AA@\262@\305H	>\204$\306\307\310@D\"\210@\311H\262

\305H\n>\2049\306\307\312D\"\210
\313H\204V\211\305H>\204N\306\307\314D\"\210\211\313H\300\230\204m\300\305H\n>\204f\306\307\312D\"\210\313H\230\203r\315\316\"\210
\305H\n>\204\201\306\307\312D\"\210
\317H\204\236\211\305H>\204\226\306\307\314D\"\210\211\320H\300\230\204\265\300\305H\n>\204\256\306\307\312D\"\210\317H\230\203\272\315\321\"\210A\262\202\304\207" vconcat vector [cl-struct-ebrowse-ts-tags cl-struct-ebrowse-ms-tags cl-struct-ebrowse-cs-tags nil 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-ms 4 ebrowse-cs ebrowse-draw-file-member-info "decl." 8 7 "defn."] 11 "\n\n(fn MEMBER-NAME LIST)" internal-temp-output-buffer-show inhibit-read-only standard-output] 15 (#$ . 169658) 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 #[385 "\211\203
\211
A\262\242\202\305
\203\306\307\310\311G\\D\"\210@\211\211\312H>\204.\306\313\314D\"\210\211\315H\312H	>\204Q\306\313\316\312H>\204K\306\313\314D\"\210\315HD\"\210\211\312H>\204`\306\313\314D\"\210\211\315H\315H\n\230\262
\211\204\265
\312H>\204|\306\313\314D\"\210
\315H\312H>\204\237\306\313\317\312H>\204\231\306\313\314D\"\210\315HD\"\210
\312H>\204\256\306\313\314D\"\210
\315H\315Hc\210\320AA@\312H\f>\204\314\306\313\321AA@D\"\210AA@\315H\261\210\322j\210c\210\323j\210A@\211\324\267\202
\325\202
\326\202
\327\202
\330\202

\203\377\331\202
\332\202
\333\202
\334\262
\335\261\266\202\207" [cl-struct-ebrowse-ts-tags cl-struct-ebrowse-bs-tags ebrowse-globals-name cl-struct-ebrowse-cs-tags cl-struct-ebrowse-ms-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 231 ebrowse-ts-member-variables 235 ebrowse-ts-static-functions 239 ebrowse-ts-static-variables 243 ebrowse-ts-friends 247 ebrowse-ts-types 259)) "member function" "member variable" "static function" "static variable" "define" "friend" "type" "unknown" "\n"] 12 (#$ . 171291)])
#@49 Text inserted by the last completion operation.
(defvar ebrowse-last-completion nil (#$ . 172997))
#@63 String which was the basis for the last completion operation.
(defvar ebrowse-last-completion-start nil (#$ . 173102))
#@71 Buffer position at which the last completion operation was initiated.
(defvar ebrowse-last-completion-location nil (#$ . 173227))
#@43 Member used in last completion operation.
(defvar ebrowse-last-completion-obarray nil (#$ . 173363))
(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 #[0 "\300 \211@\203\211A@\204\211@\202\301 \206\302\303!\304\305\"\306
!\207" [ebrowse-known-class-trees-buffer-list ebrowse-electric-choose-tree error "No tree buffer" buffer-local-value ebrowse--header ebrowse-member-table] 5 (#$ . 173688)])
#@131 Return the item following STRING in LIST.
If STRING is the last element, return the first element as successor.

(fn STRING LIST)
(defalias 'ebrowse-cyclic-successor-in-string-list #[514 "\300\301#T
8\206
\211@\207" [ebrowse-position string=] 6 (#$ . 174120)])
#@236 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.

(fn PREFIX)
(defalias 'ebrowse-tags-complete-symbol #[257 "`\212\304\305x\210`)\211{\305\211\203-\306 \307\310\305\311%\211\205(\305|\210\211c\266\202\202\221`=\203d\312	\n\"\262\313\"\262
\211\204I\314\315!\202\221\211\230\203U\314\316!\202\221|\210\211c\210\211`\211\202\221\306 \312\305#@\211\311=\206\217\211\204~\314\317\"\202\217|\210\211c\210`\211
\211\266\202\207" [ebrowse-last-completion-location ebrowse-last-completion-start ebrowse-last-completion-obarray ebrowse-last-completion "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'"] 13 (#$ . 174391) "P"])
#@125 Form for `ebrowse-tags-loop-continue'.
Evaluated for each file in the tree.  If it returns nil, proceed
with the next file.
(defvar ebrowse-tags-loop-form nil (#$ . 175394))
#@34 A list of files to be processed.
(defvar ebrowse-tags-next-file-list nil (#$ . 175574))
#@55 The path relative to which files have to be searched.
(defvar ebrowse-tags-next-file-path nil (#$ . 175668))
#@48 The last file visited via `ebrowse-tags-loop'.
(defvar ebrowse-tags-loop-last-file nil (#$ . 175783))
#@268 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.

(fn &optional INITIALIZE TREE-BUFFER)
(defalias 'ebrowse-tags-next-file #[512 "
\203\211\206\n\304 r\211q\210\305\306 !\307\310\n!)\210\204#\311\312!\210	\2039\313	!\211\2038\314
!\2048\315
!\210\210\316@\"\313
!?\205F\211\210A\317
!\207" [ebrowse-tags-next-file-list ebrowse-tags-loop-last-file ebrowse--tags-file-name ebrowse-tags-next-file-path 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] 5 (#$ . 175892) "P"])
#@213 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.

(fn &optional FIRST-TIME TREE-BUFFER)
(defalias 'ebrowse-tags-loop-continue #[512 "
\203\f\302\"\210eb\210\303!?\205!\302 \210\304\305	\"\210eb\210\202\f\207" [ebrowse-tags-loop-form buffer-file-name ebrowse-tags-next-file eval message "Scanning file `%s'..."] 5 (#$ . 176722) nil])
#@161 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.

(fn REGEXP)
(defalias 'ebrowse-tags-search #[257 "\211\301\230\203@\302=\203\303 \207\302
\304\305F\303\306!\207" [ebrowse-tags-loop-form "" re-search-forward ebrowse-tags-loop-continue nil t first-time] 5 (#$ . 177192) "sTree search (regexp): "])
#@127 Query replace FROM with TO in all files of a class tree.
With prefix arg, process files of marked classes only.

(fn FROM TO)
(defalias 'ebrowse-tags-query-replace #[514 "\301\302\303\304\305FD\306\307\305\211\304\257DE\310\311!\207" [ebrowse-tags-loop-form and save-excursion re-search-forward nil t not perform-replace ebrowse-tags-loop-continue first-time] 11 (#$ . 177601) "sTree query replace (regexp): \nsTree query replace %s by: "])
#@275 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.

(fn &optional FIX-NAME)
(defalias 'ebrowse-tags-search-member-use #[256 "\301\302 !\211@
A@\3038\204\304\305!\210\306\211\204,\301\307\310\"!\211@\262\211A@\262\210\311\312Q\262
\313
\306\314F\315\316\"\266\203\207" [ebrowse-tags-loop-form cl-values-list 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] 12 (#$ . 178054) nil])
#@75 compiler-macro for inlining `ebrowse-position-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-position-p--cmacro #[514 "\300\301\302\303\211\211&\207" [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] 9 (#$ . 178765)])
(put 'ebrowse-position-p 'compiler-macro 'ebrowse-position-p--cmacro)
#@13 

(fn CL-X)
(defalias 'ebrowse-position-p #[257 "\301
!\205\211G\302Y\205\211\303H>\205\304\207" [cl-struct-ebrowse-position-tags vectorp 5 0 t] 3 (#$ . 179172)])
(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)
#@83 compiler-macro for inlining `ebrowse-position-file-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-position-file-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-position-file-name (progn (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] 9 (#$ . 179507)])
(put 'ebrowse-position-file-name 'compiler-macro 'ebrowse-position-file-name--cmacro)
#@71 Access slot "file-name" of `ebrowse-position' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-position-file-name #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-position-tags 0 signal wrong-type-argument ebrowse-position 1] 5 (#$ . 180003)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-position-file-name side-effect-free t] 4)
#@79 compiler-macro for inlining `ebrowse-position-point'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-position-point--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-position-point (progn (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] 9 (#$ . 180379)])
(put 'ebrowse-position-point 'compiler-macro 'ebrowse-position-point--cmacro)
#@67 Access slot "point" of `ebrowse-position' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-position-point #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-position-tags 0 signal wrong-type-argument ebrowse-position 2] 5 (#$ . 180855)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-position-point side-effect-free t] 4)
#@80 compiler-macro for inlining `ebrowse-position-target'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-position-target--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-position-target (progn (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] 9 (#$ . 181219)])
(put 'ebrowse-position-target 'compiler-macro 'ebrowse-position-target--cmacro)
#@68 Access slot "target" of `ebrowse-position' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-position-target #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-position-tags 0 signal wrong-type-argument ebrowse-position 3] 5 (#$ . 181700)])
(byte-code "\300\301\302\303#\300\207" [function-put ebrowse-position-target side-effect-free t] 4)
#@78 compiler-macro for inlining `ebrowse-position-info'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ebrowse-position-info--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ebrowse-position-info (progn (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] 9 (#$ . 182067)])
(put 'ebrowse-position-info 'compiler-macro 'ebrowse-position-info--cmacro)
#@66 Access slot "info" of `ebrowse-position' struct CL-X.

(fn CL-X)
(defalias 'ebrowse-position-info #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ebrowse-position-tags 0 signal wrong-type-argument ebrowse-position 4] 5 (#$ . 182538)])
(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 #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\211\203D\211@\305>\203,\211AA\262
\202\306>A@\203;\307\262
\202\310\311@\"\210\202\210\312\313\314\307	\307				&	\207" [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))] 16 (#$ . 182955)])
(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 #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\211\203D\211@\305>\203,\211AA\262
\202\306>A@\203;\307\262
\202\310\311@\"\210\202\210\312\313%\207" [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] 11 (#$ . 183737)])
(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 (#$ . 184548))
#@37 Current position in position stack.
(defvar ebrowse-position-index 0 (#$ . 184644))
#@119 Return an identifying string for POSITION.
The string is printed in the electric position list buffer.

(fn POSITION)
(defalias 'ebrowse-position-name #[257 "\211\304H>\204\305\306\307D\"\210\211\310H
\304H>\204!\305\306\307D\"\210
\311H\203+\312\202,\313
@\304H	>\204=\305\306\314@D\"\210
@\315H\304H\n>\204d\305\306\316@\304H	>\204]\305\306\314@D\"\210@\315HD\"\210
@\304H	>\204u\305\306\314@D\"\210
@\315H\315H\317AA@\304H>\204\222\305\306\320AA@D\"\210AA@\315HR\207" [cl-struct-ebrowse-position-tags 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] 10 (#$ . 184735)])
#@117 Position point on POSITION.
If VIEW is non-nil, view the position, otherwise find it.

(fn POSITION &optional VIEW)
(defalias 'ebrowse-view/find-position #[513 "\211\204-\301\302H>\204\303\304\305D\"\210\306H!\210
\302H>\204(\303\304\305D\"\210
\307Hb\207\310\302\311\312\313!\314\"\315$\310\302\316\312\313!\317\"\320$\216\321\322\"\210\323\302H>\204[\303\304\305D\"\210\306H!)\207" [cl-struct-ebrowse-position-tags find-file 0 signal wrong-type-argument ebrowse-position 1 2 make-byte-code "\300\302H	>\204\303\304\305\300D\"\210\300\306Hb\207" vconcat vector [cl-struct-ebrowse-position-tags 0 signal wrong-type-argument ebrowse-position 2] 4 "\301\302\300\"\207" [remove-hook view-mode-hook] 3 add-hook view-mode-hook view-file] 9 (#$ . 185471)])
#@290 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.

(fn MARKER INFO &optional TARGET)
(defalias 'ebrowse-push-position #[770 "\302\303!!\2055G	Z\211\211\304V\262
\203\305\"\306\307\302\303!!\310\311!\312\313\n&B\211\262
\207" [ebrowse-position-stack ebrowse-max-positions buffer-file-name marker-buffer 0 butlast make-ebrowse-position :file-name :point marker-position :target :info] 13 (#$ . 186251)])
#@58 Move by INCREMENT in the position stack.

(fn INCREMENT)
(defalias 'ebrowse-move-in-position-stack #[257 "G\211\302U\203\f\303\304!\210\305	\\\"\306\307	#\210\310	8!\207" [ebrowse-position-stack ebrowse-position-index 0 error "No positions remembered" mod message "Position %d of %d " ebrowse-view/find-position] 6 (#$ . 186881)])
#@78 Move backward in the position stack.
Prefix arg ARG says how much.

(fn ARG)
(defalias 'ebrowse-back-in-position-stack #[257 "\300\301]!\207" [ebrowse-move-in-position-stack 1] 4 (#$ . 187225) "p"])
#@77 Move forward in the position stack.
Prefix arg ARG says how much.

(fn ARG)
(defalias 'ebrowse-forward-in-position-stack #[257 "\300\301[^!\207" [ebrowse-move-in-position-stack -1] 4 (#$ . 187431) "p"])
#@48 Keymap used in electric position stack window.
(defvar ebrowse-electric-position-mode-map nil (#$ . 187641))
#@70 If non-nil, its value is called by `ebrowse-electric-position-mode'.
(defvar ebrowse-electric-position-mode-hook nil (#$ . 187756))
(byte-code "\204\227\301 \301 
\302A@\303\"\210\302
A@\303\"\210\304\305#\210\304\306\307#\210\304\310\311#\210\304\312\313#\210\304\314\315#\210\304\316\317#\210\304\320\317#\210\304\321\322#\210\304\323\324#\210\304\325\326#\210\304\327\330#\210\304\331\332#\210\304\333\330#\210\304\334\332#\210\304\335\336#\210\304\337\340#\210\304\341\342#\210\304\343\344#\210\304\345\346#\210\304\347\350#\210\304\345\346#\266\351\352\353\354#\210\351\303\355\356#\207" [ebrowse-electric-position-mode-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] 6)
(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 #[0 "\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 (#$ . 190354) nil])
#@42 Display positions in buffer *Positions*.
(defalias 'ebrowse-draw-position-buffer #[0 "\303\304!q\210\305\306 \210\307\310\261\210	\211\203V\211@\311
\312H\n>\204&\313\314\315D\"\210
\316H!c\210\317j\210\320
\312H\n>\204?\313\314\315D\"\210
\321H!c\210\322j\210\323
!\324\261\210
A\266\202\202\210\325\211\207" [buffer-read-only ebrowse-position-stack 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] 7 (#$ . 191233)])
#@61 List positions in the position stack in an electric buffer.
(defalias 'ebrowse-electric-position-menu #[0 "\204\302\303!\210\304\211C\304\305 \306\307\310\311\312!\313\"\314$\216\305 \306\307\310\311\312!\315\"\314$\216\316 \210)\210\317\320!\262\321!\240\210\322!\210\306\307\323\311\312!\324\"\314$\216\242q\210\325 \210\3262z\327\330!\210eb\210\314y\210`db\210\331y\210`\307
b\210\332\326\304\333\334B%)\266\2020\262*\210\203\212
\242q\210\335!\210\336\242!\207" [ebrowse-position-stack goal-column error "No positions remembered" nil current-window-configuration make-byte-code 0 "\301\300!\207" vconcat vector [set-window-configuration] 2 [set-window-configuration] ebrowse-draw-position-buffer Electric-pop-up-window "*Positions*" window-buffer shrink-window-if-larger-than-buffer "\300\242q\210\301\300\242!\210\302\303!\207" [bury-buffer message nil] ebrowse-electric-position-mode ebrowse-electric-select-position message "<<< Press Space to bury the list >>>" -1 Electric-command-loop t ebrowse-electric-position-looper ebrowse-electric-find-position kill-buffer] 13 (#$ . 191899) nil])
#@150 Prevent moving point on invalid lines.
Called from `Electric-command-loop'.  See there for the meaning
of STATE and CONDITION.

(fn STATE CONDITION)
(defalias 'ebrowse-electric-position-looper #[514 "\211\203\211@\300>\204\301
@A\"\207`@W\203eb\210\302y\207`AV\2055db\210\303y\210\304d!\2055\305\303!\207" [(buffer-read-only end-of-buffer beginning-of-buffer) signal 2 -1 pos-visible-in-window-p recenter] 5 (#$ . 193026)])
#@37 Function called for undefined keys.
(defalias 'ebrowse-electric-position-undefined #[0 "\300\301!\210\302\303!\207" [message "Type C-h for help, ? for commands, q to quit, Space to execute" sit-for 4] 2 (#$ . 193467) nil])
#@35 Leave the electric position list.
(defalias 'ebrowse-electric-position-quit #[0 "\300\301\302\"\207" [throw ebrowse-electric-select-position nil] 3 (#$ . 193696) nil])
#@34 Select a position from the list.
(defalias 'ebrowse-electric-select-position #[0 "\300\301`\"\207" [throw ebrowse-electric-select-position] 3 (#$ . 193870) nil])
#@127 View/find what is described by the line at POINT.
If VIEW is non-nil, view else find source files.

(fn POINT &optional VIEW)
(defalias 'ebrowse-electric-find-position #[513 "\301e\"\302Z\303
8\"\207" [ebrowse-position-stack count-lines 2 ebrowse-view/find-position] 6 (#$ . 194039)])
#@54 View the position described by the line point is in.
(defalias 'ebrowse-electric-view-position #[0 "\300`\301\"\207" [ebrowse-electric-find-position t] 3 (#$ . 194333) nil])
#@72 Write current buffer as a class tree.
Added to `write-file-functions'.
(defalias 'ebrowse-write-file-hook-fn #[0 "\300 \210\301\207" [ebrowse-save-tree t] 1 (#$ . 194513)])
#@52 Save current tree in same file it was loaded from.
(defalias 'ebrowse-save-tree #[0 "\302\206	!\207" [buffer-file-name ebrowse--tags-file-name ebrowse-save-tree-as] 2 (#$ . 194692) nil])
#@192 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.

(fn &optional FILE-NAME)
(defalias 'ebrowse-save-tree-as #[256 "\304\305!\306	!\n\307\310\311\312\313\"\314\"\315$\216r\211q\210\316 \210
\310H>\204/\317\320\321D\"\210
\211\322\323I\266\324!\325\261\210\326\327\"\210\330!\210\331\332\"*\207" [standard-output ebrowse--header ebrowse--tree cl-struct-ebrowse-hs-tags get-buffer-create "*Tree Output" copy-ebrowse-hs make-byte-code 0 "\303\300!\210\304\305!\210\306 \210\301\211\207" vconcat vector [standard-output kill-buffer set-buffer-modified-p nil ebrowse-update-tree-buffer-mode-line] 2 erase-buffer signal wrong-type-argument ebrowse-hs 4 nil prin1-to-string " " mapc ebrowse-save-class write-file message "Tree written to file `%s'"] 12 (#$ . 194889) "FSave tree as: "])
#@57 Write single class CLASS to current buffer.

(fn CLASS)
(defalias 'ebrowse-save-class #[257 "\303\304\305H>\204\306\307\310D\"\210\311H\305H	>\2044\306\307\312\305H>\204.\306\307\310D\"\210\311HD\"\210\305H>\204C\306\307\310D\"\210\311H\311H\"\210\313c\210\314
\305H>\204]\306\307\310D\"\210
\311H!\210\315c\210\316\317\305H>\204v\306\307\310D\"\210\320H\"\210\321c\210\n\211\203\225\211@\314
!!\210\322c\210
A\266\202\202\210\323c\210\314
\305H>\204\251\306\307\310D\"\210
\324H!\210\325c\207" [cl-struct-ebrowse-ts-tags cl-struct-ebrowse-cs-tags ebrowse-member-list-accessors message "%s..." 0 signal wrong-type-argument ebrowse-ts 1 ebrowse-cs "[ebrowse-ts " prin1 "(" mapc ebrowse-save-class 2 ")" "\n" "()" 10 "]\n"] 10 (#$ . 195807)])
#@38 Display statistics for a class tree.
(defalias 'ebrowse-statistics #[0 "\303 \306	r\307\310!q\210p\311 \210
\306\211\312\211\312\313 \210\314\300!\210+\211\315\316 !\211@
A@\3178\3208\3218q\210\313 \210\322	\206G\323\324\261\210\325\326\"\210\325\327\"\210\325\330\"\210\325\331\"\210\325\332\"\266\206\333!\210)\266\202)\207" [temp-buffer-setup-hook default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks nil get-buffer-create "*Tree Statistics*" kill-all-local-variables t erase-buffer run-hooks cl-values-list 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 inhibit-read-only standard-output] 13 (#$ . 196587) nil])
#@134 Print a line in the statistics buffer.
TITLE is the title of the line, VALUE is a number to be printed
after that.

(fn TITLE VALUE)
(defalias 'ebrowse-print-statistics-line #[514 "
c\210\300j\210\301\302\"c\207" [40 format "%d\n"] 5 (#$ . 197508)])
#@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 #[0 "\301C\301C\301C\301C\301C\302C\303\304\305\306\307\310&\311\"\312\313%\"\266\242\242\242\242\242\257\207" [ebrowse--tree-obarray 0 nil mapatoms make-byte-code 257 "\305
\306N\240\210\307\305\242!\205\206\300\211\242T\240\210\301\211\242\305\242\310H>\204(\311\312\313\305\242D\"\210\305\242\314HG\\\240\210\302\211\242\305\242\310H>\204E\311\312\313\305\242D\"\210\305\242\315HG\\\240\210\303\211\242\305\242\310H>\204b\311\312\313\305\242D\"\210\305\242\316HG\\\240\210\304\211\242\305\242\310H>\204\311\312\313\305\242D\"\210\305\242\317HG\\\240\207" vconcat vector [ebrowse-root vectorp 0 signal wrong-type-argument ebrowse-ts 4 3 6 5 cl-struct-ebrowse-ts-tags] 7 "\n\n(fn VAR)"] 18 (#$ . 197766)])
#@30 Keymap for Ebrowse commands.
(defvar ebrowse-global-map nil (#$ . 198738))
#@34 Prefix key for Ebrowse commands.
(defvar ebrowse-global-prefix-key "
" (#$ . 198819))
#@58 Keymap used for `ebrowse-global-prefix' followed by `4'.
(defvar ebrowse-global-submap-4 nil (#$ . 198912))
#@58 Keymap used for `ebrowse-global-prefix' followed by `5'.
(defvar ebrowse-global-submap-5 nil (#$ . 199026))
(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 #[0 "\301C\302\303\304\305\306!\307\"\310$\216\212\301\311b\210\310y\210m?\205G\312\301!\313
!\204-\314
!\315\230\2037\311y\210
\316\240\210\202C`\212\301\210d`T^)|\210\210\202*\207" [buffer-read-only nil make-byte-code 0 "\300\242\204	\303\304!\210\305\306!	\244\307\310 !\210\311\211\207" vconcat vector [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 Buffer-menu-buffer ebrowse-buffer-p buffer-name "*Apropos Members*" t] 7 (#$ . 200884)])
#@52 Select the nth entry in the list by the keys 1..9.
(defalias 'ebrowse-select-1st-to-9nth #[0 "\300ed\"\211\301\302\303 !\\^eb\210\211Sy\210\304\305`\"\207" [count-lines 2 string-to-number this-command-keys throw electric-buffer-menu-select] 5 (#$ . 201548) nil])
#@63 Define keys 1..9 to select the 1st to 9nth entry in the list.
(defalias 'ebrowse-install-1-to-9-keys #[0 "\300\301\211W\205\211\302\303 \304\305\\!\306#\266\211T\262
\202\207" [9 0 define-key current-local-map char-to-string 49 ebrowse-select-1st-to-9nth] 8 (#$ . 201817)])
#@46 Display an electric list of Ebrowse buffers.
(defalias 'ebrowse-electric-buffer-list #[0 "\300\216\301\302\303\"\210\301\302\304\"\210\305\306!)\207" [#[0 "\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 (#$ . 202104) nil])
#@89 Find the member clicked on in another frame.
EVENT is a mouse button event.

(fn EVENT)
(defalias 'ebrowse-mouse-find-member #[257 "\300
!\210\301\211\212\302\301x\210`\262\302\301w\210
`{\262
)\303\304\305\301\306\307\310&\207" [mouse-set-point nil "a-zA-Z0-9_" ebrowse-tags-view/find-member-decl/defn 5 :view :definition t :member-name] 11 (#$ . 202533) "e"])
#@105 Pop up MENU and perform an action if something was selected.
EVENT is the mouse event.

(fn MENU EVENT)
(defalias 'ebrowse-popup-menu #[514 "\300 r\301\302\303\304\305!\306\"\307$\216\310\311!\211@\262
!\210\312\"\313
\2036\314
\206(\305@!\"\262

A\262\202\211\205=\315
!\266\202*\207" [internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 select-window event-start x-popup-menu nil lookup-key call-interactively] 9 (#$ . 202906)])
#@44 Object menu for classes in the tree buffer
(defvar ebrowse-tree-buffer-class-object-menu nil (#$ . 203430))
(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 (#$ . 205158))
(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]))
#@78 Perform mouse actions in tree buffers.
EVENT is the mouse event.

(fn EVENT)
(defalias 'ebrowse-mouse-3-in-tree-buffer #[257 "\302
!\210\303\304!!\305
\306\"\211:\203\"\307
8\250\203\"\307
8\262
\202%\310\262
\311
\310\"\205=
\312=\2039\313\"\202=\313	\"\262
\207" [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 eql class-name ebrowse-popup-menu] 7 (#$ . 206138) "e"])
#@78 Perform mouse actions in tree buffers.
EVENT is the mouse event.

(fn EVENT)
(defalias 'ebrowse-mouse-2-in-tree-buffer #[257 "\300
!\210\301\302!!\303
\304\"\211:\203\"\305
8\250\203\"\305
8\262
\202%\306\262
\307
\306\"\2054
\310=\2054\311 \262
\207" [mouse-set-point posn-point event-start get-text-property ebrowse-what 2 1 eql class-name ebrowse-tree-command:show-member-functions] 7 (#$ . 206622) "e"])
#@78 Perform mouse actions in tree buffers.
EVENT is the mouse event.

(fn EVENT)
(defalias 'ebrowse-mouse-1-in-tree-buffer #[257 "\300
!\210\301\302!!\303
\304\"\211:\203\"\305
8\250\203\"\305
8\262
\202%\306\262
\307
\305\"\205F
\310\267\202E\311\312 !\313
?!\262
\202F\314\306!\202F\315\262
\207" [mouse-set-point posn-point event-start get-text-property ebrowse-what 2 1 eql #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (class-name 50 mark 63)) ebrowse--hidden-p line-end-position ebrowse-collapse-fn ebrowse-toggle-mark-at-point nil] 7 (#$ . 207043) "e"])
(provide 'ebrowse)