Current File : //usr/local/share/emacs/27.2/lisp/cedet/semantic/find.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!\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\203s \313 @\314\"\211 \203k \f \3151a
:\205]
@;\205]
A@9\205]
A@\205] \316
8<\205] \317
8<0\202c \210\312)\203k \f\nB) A\211\204* \320\n\321\"+\207" [positionormarker buffer ret ol tmp tag markerp marker-buffer bufferp overlays-at nil overlay-get semantic (error) 2 3 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 overlayp overlay-start 0] 4]] 4 (#$ . 484)])
#@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 \203c \310\f@\311\"\211 \203[
\3121Q :\205M @;\205M A@9\205M A@\205M \3138<\205M \3148<0\202S \210\307)\203[
B)\fA\211\204 \315 \316\"+\207" [buffer start end ret ol tmp overlays-in nil overlay-get semantic (error) 2 3 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 overlayp overlay-start 0] 4] tag] 4 (#$ . 1489)])
#@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 \203\214 dW\203\214 \n\204\214 \306 !\211\203 \307 !\n\203 \n<\203 \310\n@\311\"\203\200 \310\n@\311\" \3121n \f:\205j \f@;\205j \fA@9\205j \fA@\205j \313\f8<\205j \314\f8<0\202p \210\305)\203\200 \315\n@! U\203\200 \n@\n<\203, \nA\211\202- \n\205\312 \310\n\311\" \3161\300 \f:\205\274 \f@;\205\274 \fA@9\205\274 \fA@\205\274 \313\f8<\205\274 \314\f8<0\202\302 \210\305)\205\312 \310\n\311\"+\207" [buffer start ol os tag nil next-overlay-change overlays-at overlay-get semantic (error) 2 3 overlay-start (error)] 4 (#$ . 2195)])
#@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 \203\215 eV\203\215 \n\204\215 \306 !\211\203 \307 S!\n\203 \n<\203 \310\n@\311\"\203\201 \310\n@\311\" \3121o \f:\205k \f@;\205k \fA@9\205k \fA@\205k \313\f8<\205k \314\f8<0\202q \210\305)\203\201 \315\n@! U\203\201 \n@\n<\203- \nA\211\202. \n\205\313 \310\n\311\" \3161\301 \f:\205\275 \f@;\205\275 \fA@9\205\275 \fA@\205\275 \313\f8<\205\275 \314\f8<0\202\303 \210\305)\205\313 \310\n\311\"+\207" [buffer start ol os tag nil previous-overlay-change overlays-at overlay-get semantic (error) 2 3 overlay-end (error)] 4 (#$ . 2969)])
#@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\3038)\304 !\203 \305 !\202 \306H*!\237\211A@)\207" [tag o semantic-find-tag-by-overlay 4 overlayp overlay-start 0] 4 (#$ . 3747)])
#@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 (#$ . 4067)])
#@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 (#$ . 4333)])
#@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 @\211A@)\n=\204 A\211\204 @)\207" [tags tag class semantic-find-tag-by-overlay] 3 (#$ . 4622)])
#@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 (#$ . 4998)])
(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\304DD\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 (#$ . 5488)]))
#@161 Find the first tag with NAME in TABLE.
NAME is a string.
TABLE is a semantic tags table. See `semantic-something-to-tag-table'.
Respects `semantic-case-fold'.
(defalias 'semantic-find-first-tag-by-name #[(name &optional table) "\303\304 !\n#\207" [name table semantic-case-fold assoc-string semantic-something-to-tag-table] 4 (#$ . 5930)])
#@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 (#$ . 6279)]))
#@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\304DDC\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 (#$ . 6650)]))
#@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 (#$ . 7253)]))
#@191 Find all tags of class CLASS in TABLE.
CLASS is a symbol representing the class of the token, such as
`variable' or `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 (#$ . 7782)]))
#@216 Find all tags of class not in the list CLASS in TABLE.
CLASS is a list of symbols representing the class of the token,
such as `variable' or `function'.
TABLE is a tag table. See `semantic-something-to-tag-table'.
(defalias 'semantic-filter-tags-by-class '(macro . #[(class &optional table) "\302\303\304\305ED E\207" [class table semantic--find-tags-by-macro not memq (semantic-tag-class (car tags))] 5 (#$ . 8175)]))
#@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\304E E\207" [type table semantic--find-tags-by-macro semantic-tag-of-type-p (car tags)] 4 (#$ . 8603)]))
#@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\302E\207" [table semantic--find-tags-by-macro (semantic-tag-type-compound-p (car tags))] 3 (#$ . 9081)]))
#@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) "\211A@)\306=\204 \307\310\311\"\207\312\211\313\314\315!\313\2042 \n\211\262\2042 \262\f\2050 \316\f\"\262\203] \211\204] \304N\203L \316\304N\"\211\262\2042 \211\317N\206V \211\320N\262\262\2022 \266\203\211\262\205q \211\203o N\205q J\266\203\206\346 \211\211\321N\262\205\346 \211\211\321N\262\313\314\315!\313\204\245 \n\211\262\204\245 \262\f\205\243 \316\f\"\262\203\320 \211\204\320 \304N\203\277 \316\304N\"\211\262\204\245 \211\317N\206\311 \211\320N\262\262\202\245 \266\203\211\262\205\344 \211\203\342 N\205\344 J\266\203\262\211 \203\367
#\202\376 \322#)\207" [parent tag mode-local-active-mode major-mode mode-local-symbol-table #1=#:override 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-parent derived-mode-parent mode-local--overload-obsolete semantic-find-tags-by-scope-protection-default scopeprotection table] 13 (#$ . 9457)])
(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 @
BA\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 (#$ . 11140)])
#@119 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) "\305\211\306\307\310!\306\204\" \211\262\204\" \262\n\205 \311\n\"\262\203M \211\204M \302N\203< \311\302N\"\211\262\204\" \211\312N\206F \211\313N\262\262\202\" \266\203\211\262\205a \211\203_ N\205a J\266\203\206\326 \211\211\314N\262\205\326 \211\211\314N\262\306\307\310!\306\204\225 \211\262\204\225 \262\n\205\223 \311\n\"\262\203\300 \211\204\300 \302N\203\257 \311\302N\"\211\262\204\225 \211\312N\206\271 \211\313N\262\262\202\225 \266\203\211\262\205\324 \211\203\322 N\205\324 J\266\203\262\211\203\343 \f!\202\346 \315\f!)\207" [mode-local-active-mode major-mode mode-local-symbol-table #1=#:override table semantic-find-tags-included nil override-flag symbol-name intern-soft mode-local-parent derived-mode-parent mode-local--overload-obsolete semantic-find-tags-included-default] 13 (#$ . 12073)])
(put 'semantic-find-tags-included 'mode-local-overload t)
#@172 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@\211A@)\306=\203 \n@ B\nA\211\204\n \237*\207" [table result tags tag semantic-something-to-tag-table nil include] 3 (#$ . 13178)])
#@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 (#$ . 13587)]))
#@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 (#$ . 13984)]))
#@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 (#$ . 14408)]))
#@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 (#$ . 14977)])
#@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@\211A@)\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 (#$ . 15439)])
#@232 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.
Respects `semantic-case-fold'.
Use `semantic-find-first-tag-by-name' instead.
(defalias 'semantic-brute-find-first-tag-by-name #[(name streamorbuffer &optional search-parts search-include) "\306!\307\n #\211 \203 \f\202B \310 \f\204@ \203@ \f\2038 \311 @!\211\2038 \312\n
\f
$ A \202 \f**\207" [streamorbuffer stream name semantic-case-fold m children semantic-something-to-tag-table assoc-string nil semantic-tag-components-with-overlays semantic-brute-find-first-tag-by-name toklst search-parts search-include] 6 (#$ . 16007)])
#@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 (#$ . 16715)]))
#@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 (#$ . 17320)]))
#@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\3068) \"+\211<\203. \nG\307U\204( \n\211A@)\303=\203. \n\211@) \n\232)\207" [tag attribute ts type :type plist-get 2 1] 4]] 5 (#$ . 17833)])
#@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\3068) \"+\211<\203, \n\211A@)\307=\203) \n\211@)\202+ \n@\n\2054 \310 \n\")\207" [tag attribute ts regexp :type plist-get 2 type string-match] 4]] 5 (#$ . 18471)])
#@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 (#$ . 19174)])
#@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\3048) \"*\n\232\207" [tag property value plist-get 3] 3]] 5 (#$ . 19632)])
#@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\3048)\n\"*\207" [tag attr attribute plist-get 2] 3]] 5 (#$ . 20122)])
#@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\3058)\n\"* \232\207" [tag attr attribute value plist-get 2] 3]] 5 (#$ . 20634)])
#@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\217 @\211 \3101M :\205I @;\205I A@9\205I A@\205I \3118<\205I \3128<0\202O \210\307)\203\206 !\203` B\203\206 \313=\203s \314!\202w \315!\211\203\206 \316\f#\244A\211\204 * \237\211,\207" [streamorbuffer semantic-case-fold case-fold-search nl sl stream semantic-something-to-tag-table nil (error) 2 3 positiononly semantic-tag-components-with-overlays semantic-tag-components semantic-brute-find-tag-by-function tag --dolist-tail-- function search-parts] 6 (#$ . 21227)])
#@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 (#$ . 22462)])
#@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 overlayp overlay-start 0 overlay-end 1 2 o nomedian median] 4 (#$ . 23212)])
#@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 \fB\307 #\211\205[ \f\211 A@)\314=\205[ \f\211 \311
\312
\313
8)
\"+\211\204/ \fB\237+\207" [returnme position streamorbuffer nomedian current tag nil semantic-brute-find-tag-by-position type :members plist-get 2 token attribute nextstream] 5 (#$ . 24190)])
(provide 'semantic/find)
Mini Shell