Current File : //proc/self/root/kunden/usr/share/emacs/27.2/lisp/cedet/semantic/analyze/fcn.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.

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


(require 'semantic)
#@251 Split a tag NAME into a sequence.
Sometimes NAMES are gathered from the parser that are compounded,
such as in C++ where foo::bar means:
  "The class BAR in the namespace FOO."
Return the string NAME for no change, or a list if it needs to be split.
(defalias 'semantic-analyze-split-name #[(name) "\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\205aJ\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\324J\266\203\262
\211\203\343\f!\202\346\315\f!)\207" [mode-local-active-mode major-mode mode-local-symbol-table #1=#:override name semantic-analyze-split-name nil override-flag symbol-name intern-soft mode-local-parent derived-mode-parent mode-local--overload-obsolete semantic-analyze-split-name-default] 13 (#$ . 429)])
(put 'semantic-analyze-split-name 'mode-local-overload t)
#@33 Don't split up NAME by default.
(defalias 'semantic-analyze-split-name-default #[(name) "\207" [name] 1 (#$ . 1651)])
#@115 Assemble a NAMELIST into a string representing a compound name.
Return the string representing the compound name.
(defalias 'semantic-analyze-unsplit-name #[(namelist) "\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\205aJ\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\324J\266\203\262
\211\203\343\f!\202\346\315\f!)\207" [mode-local-active-mode major-mode mode-local-symbol-table #1=#:override namelist semantic-analyze-unsplit-name nil override-flag symbol-name intern-soft mode-local-parent derived-mode-parent mode-local--overload-obsolete semantic-analyze-unsplit-name-default] 13 (#$ . 1777)])
(put 'semantic-analyze-unsplit-name 'mode-local-overload t)
#@53 Concatenate the names in NAMELIST with a . between.
(defalias 'semantic-analyze-unsplit-name-default #[(namelist) "\301\302\303#\207" [namelist mapconcat identity "."] 4 (#$ . 2880)])
#@420 For a SEQUENCE of tags, all with good names, pick the best one.
If SEQUENCE is made up of namespaces, merge the namespaces together.
If SEQUENCE has several prototypes, find the non-prototype.
If SEQUENCE has some items w/ no type information, find the one with a type.
If SEQUENCE is all prototypes, or has no prototypes, get the first one.
Optional TAGCLASS indicates to restrict the return to only
tags of TAGCLASS.
(defalias 'semantic-analyze-select-best-tag #[(sequence &optional tagclass) "\3061-	:\205)	@;\205)	A@9\205)	A@\205)\307	8<\205)\310	8<0\202/\210\311)\2036C\n\203`\312!\311\211\203\\\n\f@\211A@)=\203U\f@B\fA\211\204D\237*G\307W\203j@\207\313\314!\210\315\311\"\211G\307W\203}@\207\311\211\204\261\203\261@\211\316\317	\307	8)\"+\204\247@\202\253@A\202\202\206\267
*\207" [sequence tag tagclass result tags notypeinfo (error) 2 3 nil semantic-something-to-tag-table require semantic/db-typecache semanticdb-typecache-merge-streams :type plist-get best attribute] 4 (#$ . 3072)])
#@151 Attempt to find a tag with PREFIX.
This is a wrapper on top of semanticdb, and semantic search functions.
Almost all searches use the same arguments.
(defalias 'semantic-analyze-find-tags-by-prefix #[(prefix) "\306\307!\203\307 \203\310\311!\312\"\207G\313p!\314\211\203?\315\316\314@\211@)\316	
&\317=\2038@\nBA\211\204\n\237+\207" [prefix l result tags tag semantic-case-fold fboundp semanticdb-minor-mode-p semanticdb-strip-find-results semanticdb-find-tags-for-completion name semantic-something-to-tag-table nil compare-strings 0 t] 9 (#$ . 4136)])
#@554 Return a concrete type tag based on input TYPE tag.
A concrete type is an actual declaration of a memory description,
such as a structure, or class.  A meta type is an alias,
or a typedef in C or C++.  If TYPE is concrete, it
is returned.  If it is a meta type, it will return the concrete
type defined by TYPE.
The default behavior always returns TYPE.
Override functions need not return a real semantic tag.
Just a name, or short tag will be ok.  It will be expanded here.
SCOPE is the scope object with additional items in which to search for names.
(defalias 'semantic-analyze-dereference-metatype #[(type scope &optional type-declaration) "\3062
\307\211\310\311\312!\310\204&\211\262\204&	\262\n\205$\313\n\"\262
\203Q\211\204Q\302N\203@\313\302N\"\211\262\204&\211\314N\206J\211\315N\262
\262\202&\266\203\211\262\205e\211\203c
N\205eJ\266\203\206\332\211\211\316N\262
\205\332\211\211\316N\262
\310\311\312!\310\204\231\211\262\204\231	\262\n\205\227\313\n\"\262
\203\304\211\204\304\302N\203\263\313\302N\"\211\262\204\231\211\314N\206\275\211\315N\262
\262\202\231\266\203\211\262\205\330\211\203\326
N\205\330J\266\203\262
\211\203\352\f
#\202\361\317\306\fD\")\211@A@\320
\"+D0\207" [mode-local-active-mode major-mode mode-local-symbol-table #1=#:override type scope default-behavior semantic-analyze-dereference-metatype nil override-flag symbol-name intern-soft mode-local-parent derived-mode-parent mode-local--overload-obsolete throw semantic-analyze-dereference-metatype-1 type-declaration ans-tuple ans-type ans-type-declaration] 13 (#$ . 4718)])
(put 'semantic-analyze-dereference-metatype 'mode-local-overload t)
#@115 Get the name of TAG's type.
The TYPE field in a tag can be nil (return nil)
or a string, or a non-positional tag.
(defalias 'semantic-analyze-type-to-name #[(type) "\3031-	:\205)	@;\205)	A@9\205)	A@\205)\304	8<\205)\305	8<0\202/\210\306)\203e\211\307\310	\304	8)\n\"+\203_\311\211\307\310	\304	8)\n\"+\211@)D!\207\211@)\207;\203l\207<\203t@\207\306\207" [type tag attribute (error) 2 3 nil :parent plist-get semantic-analyze-unsplit-name] 5 (#$ . 6441)])
#@369 Return the semantic tag for a type within the type of TAG.
TAG can be a variable, function or other type of tag.
The behavior of TAG's type is defined by `semantic-analyze-type'.
Optional SCOPE represents a calculated scope in which the
types might be found.  This can be nil.
If NOMETADEREF, then do not dereference metatypes.  This is
used by the analyzer debugger.
(defalias 'semantic-analyze-tag-type #[(tag &optional scope nometaderef) "\304\211\305\306\3078)	\"+\n#\207" [tag attribute scope nometaderef semantic-analyze-type :type plist-get 2] 5 (#$ . 6934)])
#@459 Return the semantic tag for TYPE-DECLARATION.
TAG can be a variable, function or other type of tag.
The type of tag (such as a class or struct) is a name.
Lookup this name in database, and return all slots/fields
within that types field.  Also handles anonymous types.
Optional SCOPE represents a calculated scope in which the
types might be found.  This can be nil.
If NOMETADEREF, then do not dereference metatypes.  This is
used by the analyzer debugger.
(defalias 'semantic-analyze-type #[(type-declaration &optional scope nometaderef) "\306\307!\210\310\211\n\203f\n\31119:\2055@;\2055A@9\2055A@\2055\3128<\2055\3138<0\202;\210\310)\203f\n\314\211\211A@)\f*=\203f\315\n!\204f
\203]\n\202\353\316\n\n#\202\353\317\n!\211\203\213	\320\230\204\213\205\321	\314#\211\204\224\322	!\202\224\323\324\n\211@)\"\210:\203\322@\3111\307:\205\303@;\205\303A@9\205\303A@\205\303\3128<\205\303\3138<0\202\311\210\310)\203\322\325\314\"
\203\332\202\353\326\216\327\330!\"\210\316\n#)*\207" [typetag name type-declaration tag class nometaderef require semantic/scope nil (error) 2 3 type semantic-tag-prototype-p semantic-analyze-dereference-metatype-stack semantic-analyze-type-to-name "" semantic-scope-find semanticdb-typecache-find error "Semantic tag %S has no type information" semantic-analyze-select-best-tag #[nil "\301\302\"\207" [scope semantic-scope-set-typecache nil] 3] semantic-scope-set-typecache semantic-scope-tag-get-scope scope] 5 (#$ . 7516)])
(autoload 'semantic-tag-similar-p "semantic/tag-ls")
#@252 Dereference metatypes repeatedly until we hit a real TYPE.
Uses `semantic-analyze-dereference-metatype'.
Argument SCOPE is the scope object with additional items in which to search.
Optional argument TYPE-DECLARATION is how TYPE was found referenced.
(defalias 'semantic-analyze-dereference-metatype-stack #[(type scope &optional type-declaration) "	\306\n	#\307\3102K\f\205J\311\f@\"?\205J\f@\fA@\306\n
#T\211\312V\203\313\314\211@)\"\210\315\310\316\"\210\2020\210,\207" [type type-declaration scope idx nexttype lasttypedeclaration semantic-analyze-dereference-metatype 0 metatype-recursion semantic-tag-similar-p 20 message "Possible metatype recursion for %S" throw nil lasttype tag] 7 (#$ . 9103)])
#@127 Do extra work after dereferencing a metatype.
ANS is the answer from the language specific query.
SCOPE is the current scope.
(defalias 'semantic-analyze-dereference-metatype-1 #[(ans scope) "\304\305!\210;\203*	\203\306\307	#\242\206\230\310\311!\211	\203(\312	\313\n!\"\210)\207\3141W:\205S@;\205SA@9\205SA@\205S\3158<\205S\3168<0\202Y\210\310)\205\230\211A@)\307=\205\230\317!\203\227	\203\306\211@)\307	#\242\206\230\310\311\211@)!\211	\203\225\312	\313\n!\"\210)\207\207" [ans scope tcsans tag require semantic/scope semantic-scope-find type nil semanticdb-typecache-find semantic-scope-set-typecache semantic-scope-tag-get-scope (error) 2 3 semantic-tag-prototype-p] 6 (#$ . 9845)])
(provide 'semantic/analyze/fcn)