WWWWWW

Current Directory: /usr/share/emacs/24.3/lisp/cedet/semantic
Viewing File: /usr/share/emacs/24.3/lisp/cedet/semantic/find.elc
;ELC
;;; Compiled by mockbuild@buildfarm01-new.corp.cloudlinux.com on Tue Nov 11 12:56:57 2025
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/cedet/semantic/find.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

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

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

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


(byte-code "\300\301!\210\300\302!\207" [require semantic semantic/tag] 2)
#@386 Find all tags covering POSITIONORMARKER by using overlays.
If POSITIONORMARKER is nil, use the current point.
Optional BUFFER is used if POSITIONORMARKER is a number, otherwise the current
buffer is used.  This finds all tags covering the specified position
by checking for all overlays covering the current spot.  They are then sorted
from largest to smallest via the start location.
(defalias 'semantic-find-tag-by-overlay #[(&optional positionormarker buffer) "\212\203\306!\203\307!q\210\202\310	!\203	q\210\311\206\"`!\312\211\203J\313@\314\"\211\203B\f\312\315\316\217)\203B\f\nB)A\211\204*\317\n\320\"+\207" [positionormarker buffer ret ol tmp tag markerp marker-buffer bufferp semantic-overlays-at nil semantic-overlay-get semantic (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) sort #[(a b) "\211\304	8)\305\n!\203\306\n!\202\n\307H*\211\304	8)\305\n!\203.\306\n!\2021\n\307H*W\207" [a tag o b 4 semantic-overlay-p semantic-overlay-start 0] 4]] 4 (#$ . 638)])
#@161 Find all tags which exist in whole or in part between START and END.
Uses overlays to determine position.
Optional BUFFER argument specifies the buffer to use.
(defalias 'semantic-find-tag-by-overlay-in-region #[(start end &optional buffer) "\212\203q\210\306	\n\"\307\211\2034\310\f@\311\"\211\203,
\307\312\313\217)\203,
B)\fA\211\204\314\315\"+\207" [buffer start end ret ol tmp semantic-overlays-in nil semantic-overlay-get semantic (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) sort #[(a b) "\211\304	8)\305\n!\203\306\n!\202\n\307H*\211\304	8)\305\n!\203.\306\n!\2021\n\307H*W\207" [a tag o b 4 semantic-overlay-p semantic-overlay-start 0] 4] tag] 4 (#$ . 1703)])
#@122 Find the next tag after START in BUFFER.
If START is in an overlay, find the tag which starts next,
not the current tag.
(defalias 'semantic-find-tag-by-overlay-next #[(&optional start buffer) "\212\203q\210	\204`	\305\203cdW\203c\n\204c\306!\211\203\307!\n\203\n<\203\310\n@\311\"\203W\310\n@\311\"\305\312\313\217)\203W\314\n@!U\203W\n@\n<\203,\nA\211\202-\n\205x\310\n\311\"\305\315\316\217)\205x\310\n\311\"+\207" [buffer start ol os tag nil semantic-overlay-next-change semantic-overlays-at semantic-overlay-get semantic (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) semantic-overlay-start (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error))] 4 (#$ . 2463)])
#@123 Find the next tag before START in BUFFER.
If START is in an overlay, find the tag which starts next,
not the current tag.
(defalias 'semantic-find-tag-by-overlay-prev #[(&optional start buffer) "\212\203q\210	\204`	\305\203deV\203d\n\204d\306!\211\203\307S!\n\203\n<\203\310\n@\311\"\203X\310\n@\311\"\305\312\313\217)\203X\314\n@!U\203X\n@\n<\203-\nA\211\202.\n\205y\310\n\311\"\305\315\316\217)\205y\310\n\311\"+\207" [buffer start ol os tag nil semantic-overlay-previous-change semantic-overlays-at semantic-overlay-get semantic (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) semantic-overlay-end (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error))] 4 (#$ . 3266)])
#@109 Find the parent of TAG by overlays.
Overlays are a fast way of finding this information for active buffers.
(defalias 'semantic-find-tag-parent-by-overlay #[(tag) "\302\211\3038)\304	!\203\305	!\202	\306H*!\237\211A@)\207" [tag o semantic-find-tag-by-overlay 4 semantic-overlay-p semantic-overlay-start 0] 4 (#$ . 4073)])
#@158 Return the current tag in the current buffer.
If there are more than one in the same location, return the
smallest tag.  Return nil if there is no tag here.
(defalias 'semantic-current-tag #[nil "\300 \237@\207" [semantic-find-tag-by-overlay] 1 (#$ . 4412)])
#@173 Return the current tags parent in the current buffer.
A tag's parent would be a containing structure, such as a type
containing a field.  Return nil if there is no parent.
(defalias 'semantic-current-tag-parent #[nil "\300 \237A@\207" [semantic-find-tag-by-overlay] 1 (#$ . 4678)])
#@195 Return the current (smallest) tags of CLASS in the current buffer.
If the smallest tag is not of type CLASS, keep going upwards until one
is found.
Uses `semantic-tag-class' for classification.
(defalias 'semantic-current-tag-of-class #[(class) "\303 \237\211\203@\211A@)\n=\204A\211\204@)\207" [tags tag class semantic-find-tag-by-overlay] 3 (#$ . 4967)])
#@179 Find tags for which PREDICATE is non-nil in TABLE.
PREDICATE is a lambda expression which accepts on TAG.
TABLE is a semantic tags table.  See `semantic-something-to-tag-table'.
(defalias 'semantic--find-tags-by-function #[(predicate &optional table) "\304!\305\211\203\n@!\203\n@	B\nA\211\204\n	\237*\207" [table result tags predicate semantic-something-to-tag-table nil] 3 (#$ . 5343)])
(put 'semantic--find-tags-by-function 'byte-optimizer 'byte-compile-inline-expand)
#@119 Find tags for which FORM is non-nil in TABLE.
TABLE is a semantic tags table.  See `semantic-something-to-tag-table'.
(defalias 'semantic--find-tags-by-macro '(macro . #[(form &optional table) "\302\303\304DD\305B\306\303\307	\310BB\311BBB\312BBB\207" [table form let tags semantic-something-to-tag-table ((result nil)) while and ((setq result (cons (car tags) result))) ((setq tags (cdr tags))) ((nreverse result))] 7 (#$ . 5833)]))
#@198 Find the first tag with NAME in TABLE.
NAME is a string.
TABLE is a semantic tags table.  See `semantic-something-to-tag-table'.
This routine uses `assoc' to quickly find the first matching entry.
(defalias 'semantic-find-first-tag-by-name #[(name &optional table) "\203\303\202	\304	\305\n!\"\207" [semantic-case-fold name table assoc-ignore-case assoc semantic-something-to-tag-table] 4 (#$ . 6275)])
#@115 Find all tags with NAME in TABLE.
NAME is a string.
TABLE is a tag table.  See `semantic-something-to-tag-table'.
(defalias 'semantic-find-tags-by-name '(macro . #[(name &optional table) "\302\303\304\305\306BB	EE\207" [name table let ((case-fold-search semantic-case-fold)) semantic--find-tags-by-macro string= ((semantic-tag-name (car tags)))] 6 (#$ . 6689)]))
#@305 Find all tags whose name begins with PREFIX in TABLE.
PREFIX is a string.
TABLE is a tag table.  See `semantic-something-to-tag-table'.
While it would be nice to use `try-completion' or `all-completions',
those functions do not return the tags, only a string.
Uses `compare-strings' for fast comparison.
(defalias 'semantic-find-tags-for-completion '(macro . #[(prefix &optional table) "\302\303\304DDC\305\306\307\310BB\311BB	EE\207" [prefix table let l length semantic--find-tags-by-macro eq compare-strings (0 nil (semantic-tag-name (car tags)) 0 l semantic-case-fold) (t)] 7 (#$ . 7060)]))
#@257 Find all tags with name matching REGEXP in TABLE.
REGEXP is a string containing a regular expression,
TABLE is a tag table.  See `semantic-something-to-tag-table'.
Consider using `semantic-find-tags-for-completion' if you are
attempting to do completions.
(defalias 'semantic-find-tags-by-name-regexp '(macro . #[(regexp &optional table) "\302\303\304\305\306BB	EE\207" [regexp table let ((case-fold-search semantic-case-fold)) semantic--find-tags-by-macro string-match ((semantic-tag-name (car tags)))] 6 (#$ . 7663)]))
#@191 Find all tags of class CLASS in TABLE.
CLASS is a symbol representing the class of the token, such as
'variable, of 'function..
TABLE is a tag table.  See `semantic-something-to-tag-table'.
(defalias 'semantic-find-tags-by-class '(macro . #[(class &optional table) "\302\303\304BB	E\207" [class table semantic--find-tags-by-macro eq ((semantic-tag-class (car tags)))] 4 (#$ . 8192)]))
#@283 Find all tags of with a type TYPE in TABLE.
TYPE is a string or tag representing a data type as defined in the
language the tags were parsed from, such as "int", or perhaps
a tag whose name is that of a struct or class.
TABLE is a tag table.  See `semantic-something-to-tag-table'.
(defalias 'semantic-find-tags-by-type '(macro . #[(type &optional table) "\302\303\304E	E\207" [type table semantic--find-tags-by-macro semantic-tag-of-type-p (car tags)] 4 (#$ . 8585)]))
#@180 Find all tags which are a compound type in TABLE.
Compound types are structures, or other data type which
is not of a primitive nature, such as int or double.
Used in completion.
(defalias 'semantic-find-tags-of-compound-type '(macro . #[(&optional table) "\301\302E\207" [table semantic--find-tags-by-macro (semantic-tag-type-compound-p (car tags))] 3 (#$ . 9063)]))
#@458 Find all tags accessible by SCOPEPROTECTION.
SCOPEPROTECTION is a symbol which can be returned by the method
`semantic-tag-protection'.  A hard-coded order is used to determine a match.
PARENT is a tag representing the PARENT slot needed for
`semantic-tag-protection'.
TABLE is a list of tags (a subset of PARENT members) to scan.  If TABLE is nil,
the type members of PARENT are used.
See `semantic-tag-protected-p' for details on which tags are returned.
(defalias 'semantic-find-tags-by-scope-protection #[(scopeprotection parent &optional table) "\211A@)\306=\204\307\310\311\"\207\312\211\313\314\211\f\315
!\313\f\204?\211\204?\205=\316\"\f\203l\204l\f\317N\203[\316\f\317N\"\211\204?\f\211\320N\206f\f\321N)\211\204C,\211\205\200\203~
N\205\200
J+\206\n\211\322N)\205\n\211\322N)\313\314\211\f\315
!\313\f\204\277\211\204\277\205\275\316\"\f\203\354\204\354\f\317N\203\333\316\f\317N\"\211\204\277\f\211\320N\206\346\f\321N)\211\204\303,\211\205\203\376
N\205
J+)\211\203#\202\323#)\207" [parent tag overload property mode symbol type signal wrong-type-argument (semantic-find-tags-by-scope-protection parent semantic-tag-class type) semantic-find-tags-by-scope-protection nil override-flag symbol-name intern-soft mode-local-symbol-table mode-local-parent derived-mode-parent overload-obsolete semantic-find-tags-by-scope-protection-default bind name mode-local-active-mode major-mode #1=#:override scopeprotection table] 5 (#$ . 9439)])
(put 'semantic-find-tags-by-scope-protection 'mode-local-overload t)
#@458 Find all tags accessible by SCOPEPROTECTION.
SCOPEPROTECTION is a symbol which can be returned by the method
`semantic-tag-protection'.  A hard-coded order is used to determine a match.
PARENT is a tag representing the PARENT slot needed for
`semantic-tag-protection'.
TABLE is a list of tags (a subset of PARENT members) to scan.  If TABLE is nil,
the type members of PARENT are used.
See `semantic-tag-protected-p' for details on which tags are returned.
(defalias 'semantic-find-tags-by-scope-protection-default #[(scopeprotection parent &optional table) "\204	\211\306\307\n\310\n8)\"+\f\204\207\311\312!\210\313!\314\211\203L\315@\f	#\203=\316@	\"\204C@
BA\211\204*
\237*\207" [table parent tag attribute scopeprotection result :members plist-get 2 require semantic/tag-ls semantic-something-to-tag-table nil semantic-tag-protected-p semantic-tag-package-protected-p tags] 5 (#$ . 11088)])
#@118 Find all tags in TABLE that are of the 'include class.
TABLE is a tag table.  See `semantic-something-to-tag-table'.
(defalias 'semantic-find-tags-included #[(&optional table) "\306\211\307\310\211\n\311!\307\n\204+\211\204+\205*\312
\"\n\203U\f\204U\n\313N\203D\312
\n\313N\"\211\204+\n\211\314N\206O\n\315N)\211\204/\f,\211\205h	\203f	N\205hJ+\206\341\211\316N)\205\341\211\316N)\307\310\211\n\311!\307\n\204\243\211\204\243\205\242\312
\"\n\203\315\f\204\315\n\313N\203\274\312
\n\313N\"\211\204\243\n\211\314N\206\307\n\315N)\211\204\247\f,\211\205\340	\203\336	N\205\340J+)\211\203\360!\202\364\317!)\207" [overload property mode symbol bind name semantic-find-tags-included nil override-flag symbol-name intern-soft mode-local-symbol-table mode-local-parent derived-mode-parent overload-obsolete semantic-find-tags-included-default mode-local-active-mode major-mode #1=#:override table] 5 (#$ . 12021)])
(put 'semantic-find-tags-included 'mode-local-overload t)
#@171 Find all tags in TABLE that are of the 'include class.
TABLE is a tag table.  See `semantic-something-to-tag-table'.
By default, just call `semantic-find-tags-by-class'.
(defalias 'semantic-find-tags-included-default #[(&optional table) "\304!\305\211\203\"\n@\211A@)\306=\203\n@	B\nA\211\204\n	\237*\207" [table result tags tag semantic-something-to-tag-table nil include] 3 (#$ . 13087)])
#@208 Find all tags with NAME in TABLE.
Search in top level tags, and their components, in TABLE.
NAME is a string.
TABLE is a tag table.  See `semantic-flatten-tags-table'.
See also `semantic-find-tags-by-name'.
(defalias 'semantic-deep-find-tags-by-name '(macro . #[(name &optional table) "\302\303	DE\207" [name table semantic-find-tags-by-name semantic-flatten-tags-table] 4 (#$ . 13495)]))
#@217 Find all tags whose name begins with PREFIX in TABLE.
Search in top level tags, and their components, in TABLE.
TABLE is a tag table.  See `semantic-flatten-tags-table'.
See also `semantic-find-tags-for-completion'.
(defalias 'semantic-deep-find-tags-for-completion '(macro . #[(prefix &optional table) "\302\303	DE\207" [prefix table semantic-find-tags-for-completion semantic-flatten-tags-table] 4 (#$ . 13892)]))
#@362 Find all tags with name matching REGEXP in TABLE.
Search in top level tags, and their components, in TABLE.
REGEXP is a string containing a regular expression,
TABLE is a tag table.  See `semantic-flatten-tags-table'.
See also `semantic-find-tags-by-name-regexp'.
Consider using `semantic-deep-find-tags-for-completion' if you are
attempting to do completions.
(defalias 'semantic-deep-find-tags-by-name-regexp '(macro . #[(regexp &optional table) "\302\303	DE\207" [regexp table semantic-find-tags-by-name-regexp semantic-flatten-tags-table] 4 (#$ . 14316)]))
#@186 Find all tags in whose parent is TYPE in TABLE.
These tags are defined outside the scope of the original TYPE declaration.
TABLE is a tag table.  See `semantic-something-to-tag-table'.
(defalias 'semantic-find-tags-external-children-of-type #[(type &optional table) "\304!\305\211\203\306\n@!\232\203\n@	B\nA\211\204\n	\237*\207" [table result tags type semantic-something-to-tag-table nil semantic-tag-external-member-parent] 3 (#$ . 14885)])
#@200 Find all tags of class type in whose parent is TYPE in TABLE.
These tags are defined outside the scope of the original TYPE declaration.
TABLE is a tag table.  See `semantic-something-to-tag-table'.
(defalias 'semantic-find-tags-subclasses-of-type #[(type &optional table) "\306!\307\211\203A\n@\211A@)\304=\203:\f\310\n@!\235\2045\f\n@\211\311\312\3138)
\"+\235\203:\n@	B\nA\211\204\n	\237*\207" [table result tags tag type attribute semantic-something-to-tag-table nil semantic-tag-type-superclasses :interfaces plist-get 2] 5 (#$ . 15347)])
#@201 Find a tag NAME within STREAMORBUFFER.  NAME is a string.
If SEARCH-PARTS is non-nil, search children of tags.
If SEARCH-INCLUDE was never implemented.

Use `semantic-find-first-tag-by-name' instead.
(defalias 'semantic-brute-find-first-tag-by-name #[(name streamorbuffer &optional search-parts search-include) "\306!\n\203\f\307\202
\310\211\f	\"\211\203
\202P	\311\f

\204L
\203L\203D\312
@!\211\f\203D\313\f\f$
A
\202!
\210
*+\207" [streamorbuffer stream semantic-case-fold assoc-fun name m semantic-something-to-tag-table assoc-ignore-case assoc nil semantic-tag-components-with-overlays semantic-brute-find-first-tag-by-name children toklst search-parts search-include] 6 (#$ . 15915)])
#@292 Find all tags with a class CLASS within STREAMORBUFFER.
CLASS is a symbol representing the class of the tags to find.
See `semantic-tag-class'.
Optional argument SEARCH-PARTS and SEARCH-INCLUDES are passed to
`semantic-brute-find-tag-by-function'.

Use `semantic-find-tag-by-class' instead.
(defalias 'semantic-brute-find-tag-by-class '(macro . #[(class streamorbuffer &optional search-parts search-includes) "\304\305\306\307\310BBE	\n\257\207" [class streamorbuffer search-parts search-includes semantic-brute-find-tag-by-function lambda (tag) eq ((semantic-tag-class tag))] 6 (#$ . 16643)]))
#@196 Find all tags in STREAMORBUFFER which define simple class types.
See `semantic-tag-class'.
Optional argument SEARCH-PARTS and SEARCH-INCLUDES are passed to
`semantic-brute-find-tag-by-function'.
(defalias 'semantic-brute-find-tag-standard '(macro . #[(streamorbuffer &optional search-parts search-includes) "\303\304	\n\257\207" [streamorbuffer search-parts search-includes semantic-brute-find-tag-by-function (lambda (tag) (member (semantic-tag-class tag) '(function variable type)))] 5 (#$ . 17248)]))
#@251 Find all tags with type TYPE within STREAMORBUFFER.
TYPE is a string which is the name of the type of the tags returned.
See `semantic-tag-type'.
Optional argument SEARCH-PARTS and SEARCH-INCLUDES are passed to
`semantic-brute-find-tag-by-function'.
(defalias 'semantic-brute-find-tag-by-type #[(type streamorbuffer &optional search-parts search-includes) "\303\304	\n$\207" [streamorbuffer search-parts search-includes semantic-brute-find-tag-by-function #[(tag) "\211\304\305\3068)	\"+\211<\203.\nG\307U\204(\n\211A@)\303=\203.\n\211@)\n\232)\207" [tag attribute ts type :type plist-get 2 1] 4]] 5 (#$ . 17761)])
#@284 Find all tags with type matching REGEXP within STREAMORBUFFER.
REGEXP is a regular expression  which matches the  name of the type of the
tags returned.  See `semantic-tag-type'.
Optional argument SEARCH-PARTS and SEARCH-INCLUDES are passed to
`semantic-brute-find-tag-by-function'.
(defalias 'semantic-brute-find-tag-by-type-regexp #[(regexp streamorbuffer &optional search-parts search-includes) "\303\304	\n$\207" [streamorbuffer search-parts search-includes semantic-brute-find-tag-by-function #[(tag) "\211\304\305\3068)	\"+\211<\203,\n\211A@)\307=\203)\n\211@)\202+\n@\n\2054\310\n\")\207" [tag attribute ts regexp :type plist-get 2 type string-match] 4]] 5 (#$ . 18399)])
#@161 Find all tags whose name match REGEX in STREAMORBUFFER.
Optional argument SEARCH-PARTS and SEARCH-INCLUDES are passed to
`semantic-brute-find-tag-by-function'.
(defalias 'semantic-brute-find-tag-by-name-regexp #[(regex streamorbuffer &optional search-parts search-includes) "\303\304	\n$\207" [streamorbuffer search-parts search-includes semantic-brute-find-tag-by-function #[(tag) "\302	\211@)\"\207" [regex tag string-match] 4]] 5 (#$ . 19102)])
#@167 Find all tags with PROPERTY equal to VALUE in STREAMORBUFFER.
Optional argument SEARCH-PARTS and SEARCH-INCLUDES are passed to
`semantic-brute-find-tag-by-function'.
(defalias 'semantic-brute-find-tag-by-property #[(property value streamorbuffer &optional search-parts search-includes) "\303\304	\n$\207" [streamorbuffer search-parts search-includes semantic-brute-find-tag-by-function #[(tag) "	\303\3048)	\"*\n\232\207" [tag property value plist-get 3] 3]] 5 (#$ . 19560)])
#@203 Find all tags with a given ATTR in STREAMORBUFFER.
ATTR is a symbol key into the attributes list.
Optional argument SEARCH-PARTS and SEARCH-INCLUDES are passed to
`semantic-brute-find-tag-by-function'.
(defalias 'semantic-brute-find-tag-by-attribute #[(attr streamorbuffer &optional search-parts search-includes) "\303\304	\n$\207" [streamorbuffer search-parts search-includes semantic-brute-find-tag-by-function #[(tag) "	\303\3048)\n\"*\207" [tag attr attribute plist-get 2] 3]] 5 (#$ . 20050)])
#@261 Find all tags with a given ATTR equal to VALUE in STREAMORBUFFER.
ATTR is a symbol key into the attributes list.
VALUE is the value that ATTR should match.
Optional argument SEARCH-PARTS and SEARCH-INCLUDES are passed to
`semantic-brute-find-tag-by-function'.
(defalias 'semantic-brute-find-tag-by-attribute-value #[(attr value streamorbuffer &optional search-parts search-includes) "\303\304	\n$\207" [streamorbuffer search-parts search-includes semantic-brute-find-tag-by-function #[(tag) "	\304\3058)\n\"*\232\207" [tag attr attribute value plist-get 2] 3]] 5 (#$ . 20562)])
#@557 Find all tags for which FUNCTION's value is non-nil within STREAMORBUFFER.
FUNCTION must return non-nil if an element of STREAM will be included
in the new list.

If optional argument SEARCH-PARTS is non-nil, all sub-parts of tags
are searched.  The overloadable function `semantic-tag-components' is
used for the searching child lists.  If SEARCH-PARTS is the symbol
'positiononly, then only children that have positional information are
searched.

If SEARCH-INCLUDES has not been implemented.
This parameter hasn't be active for a while and is obsolete.
(defalias 'semantic-brute-find-tag-by-function #[(function streamorbuffer &optional search-parts search-includes) "\306!\307\211	\211\307\211\203`@\211\307\310\311\217)\203W!\2031B\203W\312=\203D\313!\202H\314!\211\203W\315\f#\244A\211\204*\237\211,\207" [streamorbuffer semantic-case-fold case-fold-search nl sl stream semantic-something-to-tag-table nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) positiononly semantic-tag-components-with-overlays semantic-tag-components semantic-brute-find-tag-by-function tag --dolist-tail-- function search-parts] 6 (#$ . 21155)])
#@433 Find the first tag which FUNCTION match within STREAMORBUFFER.
FUNCTION must return non-nil if an element of STREAM will be included
in the new list.

The following parameters were never implemented.

If optional argument SEARCH-PARTS, all sub-parts of tags are searched.
The overloadable function `semantic-tag-components' is used for
searching.
If SEARCH-INCLUDES is non-nil, then all include files are also
searched for matches.
(defalias 'semantic-brute-find-first-tag-by-function #[(function streamorbuffer &optional search-parts search-includes) "\306!\307	\204 \f\203 
\f@!\203\f@\fA\202+\207" [streamorbuffer semantic-case-fold case-fold-search found stream function semantic-something-to-tag-table nil] 3 (#$ . 22395)])
#@160 Find a tag covering POSITION within STREAMORBUFFER.
POSITION is a number, or marker.  If NOMEDIAN is non-nil, don't do
the median calculation, and return nil.
(defalias 'semantic-brute-find-tag-by-position #[(position streamorbuffer &optional nomedian) "\212\306!\203\f\307!q\210\310	!\203r	q\210\311 )\202	\312\211\n\203\f\204\n@\211\313
8)\314!\203D\315!\202H\316H*Y\203v\n@\211\313
8)\314!\203g\317!\202k\320H*X\203v\n@\202\203\204\211\313
8)\314!\203\230\317!\202\234\320H*Y\203\n@\211\313
8)\314!\203\273\315!\202\277\316H*X\203\211\313
8)\314!\203\334\317!\202\340\320H*\n@\211\313
8)\314!\203\372\315!\202\376\316H*\\\321\245V\203\n@\202)\n@\nA\211\204&\f,\207" [position streamorbuffer stream prev found tag markerp marker-buffer bufferp semantic-fetch-tags nil 4 semantic-overlay-p semantic-overlay-start 0 semantic-overlay-end 1 2 o nomedian median] 4 (#$ . 23145)])
#@272 Find a list of tags covering POSITION within STREAMORBUFFER.
POSITION is a number, or marker.  If NOMEDIAN is non-nil, don't do
the median calculation, and return nil.
This function will find the topmost item, and recurse until no more
details are available of findable.
(defalias 'semantic-brute-find-innermost-tag-by-position #[(position streamorbuffer &optional nomedian) "\306\307	\n#\211\205)\f\211A@)\310=\205)\f\211\311
\312
\313
8)
\"+\211\203a\fB\307	#\211\205[\f\211A@)\314=\205[\f\211\311
\312
\313
8)
\"+\211\204/\fB\237+\207" [returnme position streamorbuffer nomedian current tag nil semantic-brute-find-tag-by-position type :members plist-get 2 token attribute nextstream] 5 (#$ . 24151)])
(provide 'semantic/find)
F1l3 Manager
