WWWWWW

Current Directory: /usr/share/emacs/24.3/lisp/cedet/semantic
Viewing File: /usr/share/emacs/24.3/lisp/cedet/semantic/tag.elc
;ELC
;;; Compiled by mockbuild@buildfarm01-new.corp.cloudlinux.com on Tue Nov 11 12:57:11 2025
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/cedet/semantic/tag.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/fw semantic/lex] 2)
#@54 Version string of semantic tags made with this code.
(defconst semantic-tag-version "2.0" (#$ . 639))
#@191 Version string of semantic tags which are not currently compatible.
These old style tags may be loaded from a file with semantic db.
In this case, we must flush the old tags and start over.
(defconst semantic-tag-incompatible-version "1.0" (#$ . 748))
#@265 Return the name of TAG.
For functions, variables, classes, typedefs, etc., this is the identifier
that is being defined.  For tags without an obvious associated name, this
may be the statement type, e.g., this may return @code{print} for python's
print statement.
(defalias 'semantic-tag-name #[(tag) "@\207" [tag] 1 (#$ . 1007)])
(put 'semantic-tag-name 'byte-optimizer 'byte-compile-inline-expand)
#@696 Return the class of TAG.
That is, the symbol 'variable, 'function, 'type, or other.
There is no limit to the symbols that may represent the class of a tag.
Each parser generates tags with classes defined by it.

For functional languages, typical tag classes are:

@table @code
@item type
Data types, named map for a memory block.
@item function
A function or method, or named execution location.
@item variable
A variable, or named storage for data.
@item include
Statement that represents a file from which more tags can be found.
@item package
Statement that declares this file's package name.
@item code
Code that has not name or binding to any other symbol, such as in a script.
@end table

(defalias 'semantic-tag-class #[(tag) "A@\207" [tag] 1 (#$ . 1415)])
(put 'semantic-tag-class 'byte-optimizer 'byte-compile-inline-expand)
#@117 Return the list of public attributes of TAG.
That is a property list: (ATTRIBUTE-1 VALUE-1 ATTRIBUTE-2 VALUE-2...).
(defalias 'semantic-tag-attributes #[(tag) "\3018\207" [tag 2] 2 (#$ . 2257)])
(put 'semantic-tag-attributes 'byte-optimizer 'byte-compile-inline-expand)
#@116 Return the list of private properties of TAG.
That is a property list: (PROPERTY-1 VALUE-1 PROPERTY-2 VALUE-2...).
(defalias 'semantic-tag-properties #[(tag) "\3018\207" [tag 3] 2 (#$ . 2535)])
(put 'semantic-tag-properties 'byte-optimizer 'byte-compile-inline-expand)
#@223 Return the OVERLAY part of TAG.
That is, an overlay or an unloaded buffer representation.
This function can also return an array of the form [ START END ].
This occurs for tags that are not currently linked into a buffer.
(defalias 'semantic-tag-overlay #[(tag) "\3018\207" [tag 4] 2 (#$ . 2812)])
(put 'semantic-tag-overlay 'byte-optimizer 'byte-compile-inline-expand)
#@100 Return the cons cell whose car is the OVERLAY part of TAG.
That function is for internal use only.
(defalias 'semantic--tag-overlay-cdr #[(tag) "\301\233\207" [tag 4] 2 (#$ . 3190)])
(put 'semantic--tag-overlay-cdr 'byte-optimizer 'byte-compile-inline-expand)
#@83 Set the overlay part of TAG with OVERLAY.
That function is for internal use only.
(defalias 'semantic--tag-set-overlay #[(tag overlay) "\302\233)	\240\207" [tag overlay 4] 2 (#$ . 3457)])
(put 'semantic--tag-set-overlay 'byte-optimizer 'byte-compile-inline-expand)
#@35 Return the start location of TAG.
(defalias 'semantic-tag-start #[(tag) "\3028)\303	!\203\304	!\202	\305H)\207" [tag o 4 semantic-overlay-p semantic-overlay-start 0] 2 (#$ . 3731)])
(put 'semantic-tag-start 'byte-optimizer 'byte-compile-inline-expand)
#@33 Return the end location of TAG.
(defalias 'semantic-tag-end #[(tag) "\3028)\303	!\203\304	!\202	\305H)\207" [tag o 4 semantic-overlay-p semantic-overlay-end 1] 2 (#$ . 3997)])
(put 'semantic-tag-end 'byte-optimizer 'byte-compile-inline-expand)
#@56 Return the location (START END) of data TAG describes.
(defalias 'semantic-tag-bounds #[(tag) "\211\3028)\303	!\203\304	!\202	\305H*\211\3028)\303	!\203.\306	!\2021	\307H*D\207" [tag o 4 semantic-overlay-p semantic-overlay-start 0 semantic-overlay-end 1] 4 (#$ . 4255)])
(put 'semantic-tag-bounds 'byte-optimizer 'byte-compile-inline-expand)
#@62 In TAG, set the START and END location of data it describes.
(defalias 'semantic-tag-set-bounds #[(tag start end) "\3058)\306	!\203\307	\n#\202%\310\n\"\211\305\233)\f\240*)\207" [tag o start end overlay 4 semantic-overlay-p semantic-overlay-move vector] 5 (#$ . 4619)])
#@107 Return the buffer TAG resides in IFF tag is already in a buffer.
If a tag is not in a buffer, return nil.
(defalias 'semantic-tag-in-buffer-p #[(tag) "\3028)\303	!\205\304	!\205\305	!)\207" [tag o 4 semantic-overlay-p semantic-overlay-live-p semantic-overlay-buffer] 2 (#$ . 4911)])
#@162 From TAG, extract the value of PROPERTY.
Return the value found, or nil if PROPERTY is not one of the
properties of TAG.
That function is for internal use only.
(defalias 'semantic--tag-get-property #[(tag property) "\302\3038)	\"\207" [tag property plist-get 3] 3 (#$ . 5209)])
(put 'semantic--tag-get-property 'byte-optimizer 'byte-compile-inline-expand)
#@171 Return the buffer TAG resides in.
If TAG has an originating file, read that file into a (maybe new)
buffer, and return it.
Return nil if there is no buffer for this tag.
(defalias 'semantic-tag-buffer #[(tag) "\304!\211\203\f	\2023\305\306\3078)\n\"*\2053\310 \311\216\312\305\306\3078)\n\"*!*)\207" [tag buff property save-match-data-internal semantic-tag-in-buffer-p :filename plist-get 3 match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) find-file-noselect] 5 (#$ . 5576)])
#@312 Return the major mode active for TAG.
TAG defaults to the tag at point in current buffer.
If TAG has a :mode property return it.
If point is inside TAG bounds, return the major mode active at point.
Return the major mode active at beginning of TAG otherwise.
See also the function `semantic-ctxt-current-mode'.
(defalias 'semantic-tag-mode #[(&optional tag) "\204\306 \307\310\3118)	\"*\206n\312!\211\3138)\314\n!\2030\315\n!\2023\n\316H*\211\3138)\314\n!\203I\317\n!\202L\n\320H*\212
\203X
q\210`\fY\203d`W\204g\fb\210\321\322!\210\323 ,\207" [tag property o end start buffer semantic-current-tag :mode plist-get 3 semantic-tag-buffer 4 semantic-overlay-p semantic-overlay-start 0 semantic-overlay-end 1 require semantic/ctxt semantic-ctxt-current-mode] 5 (#$ . 6125)])
#@103 Return the cons cell whose car is the ATTRIBUTES part of TAG.
That function is for internal use only.
(defalias 'semantic--tag-attributes-cdr #[(tag) "AA\207" [tag] 1 (#$ . 6936)])
(put 'semantic--tag-attributes-cdr 'byte-optimizer 'byte-compile-inline-expand)
#@243 Change value in TAG of ATTRIBUTE to VALUE.
If ATTRIBUTE already exists, its value is set to VALUE, otherwise the
new ATTRIBUTE VALUE pair is added.
Return TAG.
Use this function in a parser when not all attributes are known at the
same time.
(defalias 'semantic-tag-put-attribute #[(tag attribute value) "\211AA)\211:\203	\304\305	@\n#!\240\210)\207" [tag plist-cdr attribute value semantic-tag-make-plist plist-put] 7 (#$ . 7205)])
(put 'semantic-tag-put-attribute 'byte-optimizer 'byte-compile-inline-expand)
#@295 Change value in TAG of ATTRIBUTE to VALUE without side effects.
All cons cells in the attribute list are replicated so that there
are no side effects if TAG is in shared lists.
If ATTRIBUTE already exists, its value is set to VALUE, otherwise the
new ATTRIBUTE VALUE pair is added.
Return TAG.
(defalias 'semantic-tag-put-attribute-no-side-effect #[(tag attribute value) "\211AA)\211:\203	\304\305\306	@!\n#!\240\210)\207" [tag plist-cdr attribute value semantic-tag-make-plist plist-put copy-sequence] 7 (#$ . 7730)])
#@179 From TAG, return the value of ATTRIBUTE.
ATTRIBUTE is a symbol whose specification value to get.
Return the value found, or nil if ATTRIBUTE is not one of the
attributes of TAG.
(defalias 'semantic-tag-get-attribute #[(tag attribute) "\302\3038)	\"\207" [tag attribute plist-get 2] 3 (#$ . 8263)])
(put 'semantic-tag-get-attribute 'byte-optimizer 'byte-compile-inline-expand)
#@103 Return the cons cell whose car is the PROPERTIES part of TAG.
That function is for internal use only.
(defalias 'semantic--tag-properties-cdr #[(tag) "\301\233\207" [tag 3] 2 (#$ . 8649)])
(put 'semantic--tag-properties-cdr 'byte-optimizer 'byte-compile-inline-expand)
#@198 Change value in TAG of PROPERTY to VALUE.
If PROPERTY already exists, its value is set to VALUE, otherwise the
new PROPERTY VALUE pair is added.
Return TAG.
That function is for internal use only.
(defalias 'semantic--tag-put-property #[(tag property value) "\304\233)\211:\203	\305\306	@\n#!\240\210)\207" [tag plist-cdr property value 3 semantic-tag-make-plist plist-put] 7 (#$ . 8926)])
#@331 Change value in TAG of PROPERTY to VALUE without side effects.
All cons cells in the property list are replicated so that there
are no side effects if TAG is in shared lists.
If PROPERTY already exists, its value is set to VALUE, otherwise the
new PROPERTY VALUE pair is added.
Return TAG.
That function is for internal use only.
(defalias 'semantic--tag-put-property-no-side-effect #[(tag property value) "\304\233)\211:\203	\305\306\307	@!\n#!\240\210)\207" [tag plist-cdr property value 3 semantic-tag-make-plist plist-put copy-sequence] 7 (#$ . 9331)])
#@244 Return the name of the file from which TAG originated.
Return nil if that information can't be obtained.
If TAG is from a loaded buffer, then that buffer's filename is used.
If TAG is unlinked, but has a :filename property, then that is used.
(defalias 'semantic-tag-file-name #[(tag) "\303!\211\203\304	!\202\305\306\3078)\n\"*)\207" [tag buffer property semantic-tag-in-buffer-p buffer-file-name :filename plist-get 3] 4 (#$ . 9903)])
#@54 Return non-nil if TAG is most likely a semantic tag.
(defalias 'semantic-tag-p #[(tag) "\300\301\302\217\207" [nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error))] 3 (#$ . 10358)])
(put 'semantic-tag-p 'byte-optimizer 'byte-compile-inline-expand)
#@42 Return non-nil if class of TAG is CLASS.
(defalias 'semantic-tag-of-class-p #[(tag class) "\211A@)	=\207" [tag class] 3 (#$ . 10660)])
(put 'semantic-tag-of-class-p 'byte-optimizer 'byte-compile-inline-expand)
#@99 Return the members of the type that TAG describes.
That is the value of the `:members' attribute.
(defalias 'semantic-tag-type-members #[(tag) "\302\303\3048)	\"*\207" [tag attribute :members plist-get 2] 3 (#$ . 10878)])
(put 'semantic-tag-type-members 'byte-optimizer 'byte-compile-inline-expand)
#@247 Return the value of the `:type' attribute of TAG.
For a function it would be the data type of the return value.
For a variable, it is the storage type of that variable.
For a data type, the type is the style of datatype, such as
struct or union.
(defalias 'semantic-tag-type #[(tag) "\302\303\3048)	\"*\207" [tag attribute :type plist-get 2] 3 (#$ . 11190)])
(put 'semantic-tag-type 'byte-optimizer 'byte-compile-inline-expand)
#@51 Return non-nil if TAG has positional information.
(defalias 'semantic-tag-with-position-p #[(tag) "\302\303\304\217)\205!\3058)\306	!\203\307	!\206 \310	!)\207" [tag o nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) 4 semantic-overlay-p semantic-overlay-live-p arrayp] 3 (#$ . 11630)])
#@276 Compare TAG1 and TAG2 and return non-nil if they are equivalent.
Use `equal' on elements the name, class, and position.
Use this function if tags are being copied and regrouped to test
for if two tags represent the same thing, but may be constructed
of different cons cells.
(defalias 'semantic-equivalent-tag-p #[(tag1 tag2) "\211@)\n\211@)\232\205\263\n\211A@)\211\211A@)*=\205\263\305	8)\2046\n\305	8)?\206\263\305	8)\205\263\n\305	8)\205\263\211\211\305	8)\306\f!\203_\307\f!\202b\f\310H*	\211\305	8)\306\f!\203x\311\f!\202{\f\312H+D\n\211\211\305	8)\306\f!\203\224\307\f!\202\227\f\310H*	\211\305	8)\306\f!\203\255\311\f!\202\260\f\312H+D\232\207" [tag1 tag tag2 class o 4 semantic-overlay-p semantic-overlay-start 0 semantic-overlay-end 1] 5 (#$ . 11986)])
#@233 Test to see if TAG1 and TAG2 are similar.
Uses `semantic-tag-similar-p' but also recurses through sub-tags, such
as argument lists and type members.
Optional argument IGNORABLE-ATTRIBUTES is passed down to
`semantic-tag-similar-p'.
(defalias 'semantic-tag-similar-with-subtags-p #[(tag1 tag2 &rest ignorable-attributes) "\303	\n#\207" [tag1 tag2 ignorable-attributes semantic-tag-similar-p] 4 (#$ . 12800)])
#@328 Compare TAG's type against TYPE.  Non nil if equivalent.
TYPE can be a string, or a tag of class 'type.
This can be complex since some tags might have a :type that is a tag,
while other tags might just have a string.  This function will also be
return true of TAG's type is compared directly to the declaration of a
data type.
(defalias 'semantic-tag-of-type-p #[(tag type) "\211\306\307\3108)	\"+\211;\203\n\202=\n\311\312\313\217)\203<\n\305\211\211A@)*=\203<\n\211@)\202=\314
;\203G
\202j
\311\312\313\217)\203i
\305\211\211A@)*=\203i
\211@)\202j\314\f\205\331
;\203{\f
\230\206\331\n;\203\207\n\230\206\331\f\230\205\331\n\211\306\307\3108)	\"+\203\330
\211\306\307\3108)	\"+\203\330\n\211\306\307\3108)	\"+
\211\306\307\3108)	\"+\232\202\331\315+\207" [tag attribute tagtype class tagtypestring type :type plist-get 2 nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) "" t typestring] 5 (#$ . 13216)])
#@147 Return non-nil the type of TAG is compound.
Compound implies a structure or similar data type.
Returns the list of tag members if it is compound.
(defalias 'semantic-tag-type-compound-p #[(tag) "\211\304\305\3068)	\"+\211\307\310\311\217)\205;\n\312\211\211A@)*=\205;\n\211\313\305\3068)	\"+)\207" [tag attribute tagtype class :type plist-get 2 nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) type :members] 4 (#$ . 14252)])
#@283 Return non-nil if TAG is a FAUX tag.
FAUX tags are created to represent a construct that is
not known to exist in the code.

Example: When the class browser sees methods to a class, but
cannot find the class, it will create a faux tag to represent the
class to store those methods.
(defalias 'semantic-tag-faux-p #[(tag) "\302\303\3048)	\"*\207" [tag property :faux-flag plist-get 3] 3 (#$ . 14758)])
#@365 Create a property list with ARGS.
Args is a property list of the form (KEY1 VALUE1 ... KEYN VALUEN).
Where KEY is a symbol, and VALUE is the value for that symbol.
The return value will be a new property list, with these KEY/VALUE
pairs eliminated:

  - KEY associated to nil VALUE.
  - KEY associated to an empty string VALUE.
  - KEY associated to a zero VALUE.
(defalias 'semantic-tag-make-plist #[(args) "\304\211\211\203/@A@AA\305\235\204\247\203&\306!\204	\nBB\202\n+\207" [val key plist args nil ("" nil) zerop] 3 (#$ . 15172)])
#@248 Create a generic semantic tag.
NAME is a string representing the name of this tag.
CLASS is the symbol that represents the class of tag this is,
such as 'variable, or 'function.
ATTRIBUTES is a list of additional attributes belonging to this tag.
(defalias 'semantic-tag #[(name class &rest attributes) "	\303\n!\304\211\257\207" [name class attributes semantic-tag-make-plist nil] 5 (#$ . 15738)])
(put 'semantic-tag 'byte-optimizer 'byte-compile-inline-expand)
#@305 Create a semantic tag of class 'variable.
NAME is the name of this variable.
TYPE is a string or semantic tag representing the type of this variable.
Optional DEFAULT-VALUE is a string representing the default value of this
variable.  ATTRIBUTES is a list of additional attributes belonging to this
tag.
(defalias 'semantic-tag-new-variable #[(name type &optional default-value &rest attributes) "\304\305\306\307	\310\n&\207" [name type default-value attributes apply semantic-tag variable :type :default-value] 9 (#$ . 16210)])
(put 'semantic-tag-new-variable 'byte-optimizer 'byte-compile-inline-expand)
#@312 Create a semantic tag of class 'function.
NAME is the name of this function.
TYPE is a string or semantic tag representing the type of this function.
ARG-LIST is a list of strings or semantic tags representing the
arguments of this function.
ATTRIBUTES is a list of additional attributes belonging to this tag.
(defalias 'semantic-tag-new-function #[(name type arg-list &rest attributes) "\304\305\306\307	\310\n&\207" [name type arg-list attributes apply semantic-tag function :type :arguments] 9 (#$ . 16827)])
(put 'semantic-tag-new-function 'byte-optimizer 'byte-compile-inline-expand)
#@815 Create a semantic tag of class 'type.
NAME is the name of this type.
TYPE is a string or semantic tag representing the type of this type.
MEMBERS is a list of strings or semantic tags representing the
elements that make up this type if it is a composite type.
PARENTS is a cons cell.  (EXPLICIT-PARENTS . INTERFACE-PARENTS)
EXPLICIT-PARENTS can be a single string (Just one parent) or a
list of parents (in a multiple inheritance situation).  It can also
be nil.
INTERFACE-PARENTS is a list of strings representing the names of
all INTERFACES, or abstract classes inherited from.  It can also be
nil.
This slot can be interesting because the form:
     ( nil "string")
is a valid parent where there is no explicit parent, and only an
interface.
ATTRIBUTES is a list of additional attributes belonging to this tag.
(defalias 'semantic-tag-new-type #[(name type members parents &rest attributes) "\305\306\301\307	\310\n\311@\312A\f&\f\207" [name type members parents attributes apply semantic-tag :type :members :superclasses :interfaces] 13 (#$ . 17427)])
(put 'semantic-tag-new-type 'byte-optimizer 'byte-compile-inline-expand)
#@285 Create a semantic tag of class 'include.
NAME is the name of this include.
SYSTEM-FLAG represents that we were able to identify this include as belonging
to the system, as opposed to belonging to the local project.
ATTRIBUTES is a list of additional attributes belonging to this tag.
(defalias 'semantic-tag-new-include #[(name system-flag &rest attributes) "\303\304\305\306	\n&\207" [name system-flag attributes apply semantic-tag include :system-flag] 7 (#$ . 18566)])
(put 'semantic-tag-new-include 'byte-optimizer 'byte-compile-inline-expand)
#@235 Create a semantic tag of class 'package.
NAME is the name of this package.
DETAIL is extra information about this package, such as a location where
it can be found.
ATTRIBUTES is a list of additional attributes belonging to this tag.
(defalias 'semantic-tag-new-package #[(name detail &rest attributes) "\303\304\305\306	\n&\207" [name detail attributes apply semantic-tag package :detail] 7 (#$ . 19123)])
(put 'semantic-tag-new-package 'byte-optimizer 'byte-compile-inline-expand)
#@182 Create a semantic tag of class 'code.
NAME is a name for this code.
DETAIL is extra information about the code.
ATTRIBUTES is a list of additional attributes belonging to this tag.
(defalias 'semantic-tag-new-code #[(name detail &rest attributes) "\303\304\305\306	\n&\207" [name detail attributes apply semantic-tag code :detail] 7 (#$ . 19615)])
(put 'semantic-tag-new-code 'byte-optimizer 'byte-compile-inline-expand)
#@147 Set TAG to be a new FAUX tag.
FAUX tags represent constructs not found in the source code.
You can identify a faux tag with `semantic-tag-faux-p'
(defalias 'semantic-tag-set-faux #[(tag) "\301\302\303#\207" [tag semantic--tag-put-property :faux-flag t] 4 (#$ . 20045)])
(put 'semantic-tag-set-faux 'byte-optimizer 'byte-compile-inline-expand)
#@23 Set TAG name to NAME.
(defalias 'semantic-tag-set-name #[(tag name) "	\240\207" [tag name] 2 (#$ . 20395)])
(put 'semantic-tag-set-name 'byte-optimizer 'byte-compile-inline-expand)
#@375 Create a tag proxy symbol.
FUNCTION will be used to resolve the proxy.  It should take 3
two arguments, DATA and TAG.  TAG is a proxy tag that needs
to be resolved, and DATA is the DATA passed into this function.
DATA is data to help resolve the proxy.  DATA can be an EIEIO object,
such that FUNCTION is a method.
FUNCTION should return a list of tags, preferably one tag.
(defalias 'semantic-create-tag-proxy #[#'data "\303\304!\305\306	#\210\305\307\n#\210)\207" [sym function data make-symbol ":tag-proxy" put proxy-function proxy-data] 4 (#$ . 20584)])
#@244 Set TAG to be a proxy.  The proxy can be resolved with PROXY.
This function will also make TAG be a faux tag with
`semantic-tag-set-faux', and possibly set the tag's
:filename with FILENAME.
To create a proxy, see `semantic-create-tag-proxy'.
(defalias 'semantic-tag-set-proxy #[(tag proxy &optional filename) "\303\304\305#)\210\303\306	#\210\n\205\303\307\n#\207" [tag proxy filename semantic--tag-put-property :faux-flag t :proxy :filename] 4 (#$ . 21153)])
#@168 Resolve the proxy in TAG.
The return value is whatever format the proxy was setup as.
It should be a list of complete tags.
If TAG has no proxy, then just return tag.
(defalias 'semantic-tag-resolve-proxy #[(tag) "\305\306\3078)	\"*\211\310N\n\311N\n\203\"\f\"\202#+\207" [tag property proxy function data :proxy plist-get 3 proxy-function proxy-data] 4 (#$ . 21628)])
#@113 Clone TAG, creating a new TAG.
If optional argument NAME is not nil it specifies a new name for the
cloned tag.
(defalias 'semantic-tag-clone #[(tag &optional name) "\206		\211@)	\211A@)\302	\303	8)!\302	\304	8)!	\305	8)\257\207" [name tag copy-sequence 2 3 4] 7 (#$ . 22018)])
(put 'semantic-tag-clone 'byte-optimizer 'byte-compile-inline-expand)
#@472 Return a copy of TAG unlinked from the originating buffer.
If optional argument NAME is non-nil it specifies a new name for the
copied tag.
If optional argument KEEP-FILE is non-nil, and TAG was linked to a
buffer, the originating buffer file name is kept in the `:filename'
property of the copied tag.
If KEEP-FILE is a string, and the originating buffer is NOT available,
then KEEP-FILE is stored on the `:filename' property.
This runs the tag hook `unlink-copy-hook`.
(defalias 'semantic-tag-copy #[(tag &optional name keep-file) "		\206
\211@)\211A@)\306\3078)!\306\3108)!\3118)\257*\203B\312\n\313\314\n!\206@;\205@#\210\315!\203\231\n\316\n\211\3118)\317\f!\203_\320\f!\202b\f\321H*\n\211\3118)\317\f!\203x\322\f!\202{\f\323H*\"\211\311\233)
\240*\210\317\3118)!\203\231\324\n\325\"\210\n)\207" [tag name copy keep-file o overlay copy-sequence 2 3 4 semantic--tag-put-property :filename semantic-tag-file-name semantic-tag-with-position-p vector semantic-overlay-p semantic-overlay-start 0 semantic-overlay-end 1 semantic--tag-run-hooks unlink-copy-hook] 7 (#$ . 22381)])
#@97 Copy private properties from TAG1 to TAG2.
Return TAG2.
This function is for internal use only.
(defalias 'semantic--tag-copy-properties #[(tag1 tag2) "\304	8)\211\203\305\n@\nA@#\210\nAA\211\204)\207" [tag1 tag plist tag2 3 semantic--tag-put-property] 5 (#$ . 23512)])
#@264 Make a deep copy of TAG, applying FILTER to each child-tag.
No properties are copied except for :filename.
Overlay will be a vector.
FILTER takes TAG as an argument, and should return a `semantic-tag'.
It is safe for FILTER to modify the input tag and return it.
(defalias 'semantic-tag-deep-copy-one-tag #[(tag &optional filter) "\204\305	\306\307\310\217)\204\311\312	\313D\"\210	\314	8)\315	!	\211@)	\211A@)\316	\317	8)\"\n\205>\320\nD\205v\321	\211\314	8)\322\f!\203X\323\f!\202[\f\324H*	\211\314	8)\322\f!\203q\325\f!\202t\f\326H*\"\257!*\207" [filter tag fn ol o identity nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) signal wrong-type-argument semantic-tag-p 4 semantic-tag-file-name semantic--tag-deep-copy-attributes 2 :filename vector semantic-overlay-p semantic-overlay-start 0 semantic-overlay-end 1] 10 (#$ . 23799)])
#@260 Make a deep copy of ATTRS, applying FILTER to each child-tag.

It is safe to modify ATTR, and return a permutation of that list.

FILTER takes TAG as an argument, and should returns a semantic-tag.
It is safe for FILTER to modify the input tag and return it.
(defalias 'semantic--tag-deep-copy-attributes #[(attrs &optional filter) "@\205@9\204\302\303!\210@\304A@	\"\305AA	\"BB\207" [attrs filter error "Bad Attribute List in tag" semantic--tag-deep-copy-value semantic--tag-deep-copy-attributes] 5 (#$ . 24721)])
#@261 Make a deep copy of VALUE, applying FILTER to each child-tag.

It is safe to modify VALUE, and return a permutation of that list.

FILTER takes TAG as an argument, and should returns a semantic-tag.
It is safe for FILTER to modify the input tag and return it.
(defalias 'semantic--tag-deep-copy-value #[(value &optional filter) "\303\304\305\217)\203\306\n\"\207<\203$@\303\304\305\217)\203$\307\n\"\207\207" [value tag filter nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) semantic-tag-deep-copy-one-tag semantic--tag-deep-copy-tag-list] 3 (#$ . 25252)])
#@268 Make a deep copy of TAGS, applying FILTER to each child-tag.

It is safe to modify the TAGS list, and return a permutation of that list.

FILTER takes TAG as an argument, and should returns a semantic-tag.
It is safe for FILTER to modify the input tag and return it.
(defalias 'semantic--tag-deep-copy-tag-list #[(tags &optional filter) "@\205$@\303\304\305\217)\203\306@\n\"\307A\n\"B\207@\307A\n\"B\207" [tags tag filter nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) semantic-tag-deep-copy-one-tag semantic--tag-deep-copy-tag-list] 4 (#$ . 25881)])
#@60 Return the value of the `:typemodifiers' attribute of TAG.
(defalias 'semantic-tag-modifiers #[(tag) "\302\303\3048)	\"*\207" [tag attribute :typemodifiers plist-get 2] 3 (#$ . 26503)])
(put 'semantic-tag-modifiers 'byte-optimizer 'byte-compile-inline-expand)
#@371 Return the documentation of TAG.
That is the value defined by the `:documentation' attribute.
Optional argument BUFFER indicates where to get the text from.
If not provided, then only the POSITION can be provided.

If you want to get documentation for languages that do not store
the documentation string in the tag itself, use
`semantic-documentation-for-tag' instead.
(defalias 'semantic-tag-docstring #[(tag &optional buffer) "\305\306\3078)	\"*\211;\203\n\202\264\310\n!\203_\n\211A@;\203-A@\202[\311\211\211A@\247\204?AA\202AA)@)\211\211A@\247\204UAA\202WA)A)\")\202\264\312\n!\203\263\f\203\263r\fq\210\313\n\211T\"@\211A@;\203\201A@\202\257\311\211\211A@\247\204\223AA\202\225A)@)\211\211A@\247\204\251AA\202\253A)A)\"*\202\264\314)\207" [tag attribute p token buffer :documentation plist-get 2 semantic-lex-token-with-text-p buffer-substring-no-properties semantic-lex-token-without-text-p semantic-lex nil] 5 (#$ . 26776)])
#@213 Return the parent of TAG.
That is the value of the `:parent' attribute.
If a definition can occur outside an actual parent structure, but
refers to that parent by name, then the :parent attribute should be used.
(defalias 'semantic-tag-named-parent #[(tag) "\302\303\3048)	\"*\207" [tag attribute :parent plist-get 2] 3 (#$ . 27767)])
(put 'semantic-tag-named-parent 'byte-optimizer 'byte-compile-inline-expand)
#@69 Return the list of superclass names of the type that TAG describes.
(defalias 'semantic-tag-type-superclasses #[(tag) "\303\304\3058)	\"*\211;\203\nC\202I\n\306\307\310\217)\203,\n\211@)C\202I\n:\203C\n@\306\307\310\217)\203C\311\312\n\"\202I\n:\205I\n)\207" [tag attribute supers :superclasses plist-get 2 nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) mapcar #[(s) "\211@)\207" [s tag] 2]] 4 (#$ . 28191)])
#@121 Find the superclass NAME in the list of SUPERS.
If a simple search doesn't do it, try splitting up the names
in SUPERS.
(defalias 'semantic--tag-find-parent-by-name #[(name supers) "\306\307	\n\"\211\204J\310\311!\210\n\306\211\203I\f@\211\211@)\312!\211\f;\2032\fC\2025\f\237
	
@\230\203A+\fA\211\204*)\207" [stag name supers S --dolist-tail-- tag nil semantic-find-first-tag-by-name require semantic/analyze/fcn semantic-analyze-split-name sname splitparts parts] 4 (#$ . 28682)])
#@188 Return the inheritance protection in TAG from PARENTSTRING.
PARENTSTRING is the name of the parent being inherited.
The return protection is a symbol, 'public, 'protection, and 'private.
(defalias 'semantic-tag-type-superclass-protection #[(tag parentstring) "\306\307\3108)	\"*\211;\203\311\202\224\n\312\313\314\217)\203>\n\315\307\3108)	\"*\316\317\"A\206:\311)\202\224\n:\203M\n@;\203M\311\202\224\n:\205\224\n@\312\313\314\217)\205\224\320\f\n\"\211\205t
\315\307\3108)	\"*\316\321\"A\206\223\322\232\203\222\323\324\"\203\216\325\202\223\311\202\223\311*)\207" [tag attribute supers prot parentstring stag :superclasses plist-get 2 public nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) :protection assoc (("public" . public) ("protected" . protected) ("private" . private)) semantic--tag-find-parent-by-name (("public" . public) ("protected" . protected) ("private" . private)) "unspecified" semantic-tag-of-type-p "class" private] 4 (#$ . 29198)])
#@63 Return the list of interfaces of the type that TAG describes.
(defalias 'semantic-tag-type-interfaces #[(tag) "\302\303\3048)	\"*\207" [tag attribute :interfaces plist-get 2] 3 (#$ . 30256)])
(put 'semantic-tag-type-interfaces 'byte-optimizer 'byte-compile-inline-expand)
#@107 Return the arguments of the function that TAG describes.
That is the value of the `:arguments' attribute.
(defalias 'semantic-tag-function-arguments #[(tag) "\302\303\3048)	\"*\207" [tag attribute :arguments plist-get 2] 3 (#$ . 30541)])
(put 'semantic-tag-function-arguments 'byte-optimizer 'byte-compile-inline-expand)
#@112 Return the exceptions the function that TAG describes can throw.
That is the value of the `:throws' attribute.
(defalias 'semantic-tag-function-throws #[(tag) "\302\303\3048)	\"*\207" [tag attribute :throws plist-get 2] 3 (#$ . 30875)])
(put 'semantic-tag-function-throws 'byte-optimizer 'byte-compile-inline-expand)
#@220 Return the parent of the function that TAG describes.
That is the value of the `:parent' attribute.
A function has a parent if it is a method of a class, and if the
function does not appear in body of its parent class.
(defalias 'semantic-tag-function-parent #[(tag) "\211\302\303\3048)	\"+\207" [tag attribute :parent plist-get 2] 4 (#$ . 31205)])
(put 'semantic-tag-function-parent 'byte-optimizer 'byte-compile-inline-expand)
#@111 Return non-nil if TAG describes a destructor function.
That is the value of the `:destructor-flag' attribute.
(defalias 'semantic-tag-function-destructor-p #[(tag) "\302\303\3048)	\"*\207" [tag attribute :destructor-flag plist-get 2] 3 (#$ . 31648)])
(put 'semantic-tag-function-destructor-p 'byte-optimizer 'byte-compile-inline-expand)
#@113 Return non-nil if TAG describes a constructor function.
That is the value of the `:constructor-flag' attribute.
(defalias 'semantic-tag-function-constructor-p #[(tag) "\302\303\3048)	\"*\207" [tag attribute :constructor-flag plist-get 2] 3 (#$ . 31998)])
(put 'semantic-tag-function-constructor-p 'byte-optimizer 'byte-compile-inline-expand)
#@115 Return the default value of the variable that TAG describes.
That is the value of the attribute `:default-value'.
(defalias 'semantic-tag-variable-default #[(tag) "\302\303\3048)	\"*\207" [tag attribute :default-value plist-get 2] 3 (#$ . 32353)])
(put 'semantic-tag-variable-default 'byte-optimizer 'byte-compile-inline-expand)
#@119 Return non-nil if the variable that TAG describes is a constant.
That is the value of the attribute `:constant-flag'.
(defalias 'semantic-tag-variable-constant-p #[(tag) "\302\303\3048)	\"*\207" [tag attribute :constant-flag plist-get 2] 3 (#$ . 32695)])
(put 'semantic-tag-variable-constant-p 'byte-optimizer 'byte-compile-inline-expand)
#@122 Return non-nil if the include that TAG describes is a system include.
That is the value of the attribute `:system-flag'.
(defalias 'semantic-tag-include-system-p #[(tag) "\302\303\3048)	\"*\207" [tag attribute :system-flag plist-get 2] 3 (#$ . 33047)])
(put 'semantic-tag-include-system-p 'byte-optimizer 'byte-compile-inline-expand)
#@363 Return a filename representation of TAG.
The default action is to return the `semantic-tag-name'.
Some languages do not use full filenames in their include statements.
Override this method to translate the code representation
into a filename.  (A relative filename if necessary.)

See `semantic-dependency-tag-file' to expand an include
tag to a full file name.
(defalias 'semantic-tag-include-filename #[(tag) "\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-tag-include-filename nil override-flag symbol-name intern-soft mode-local-symbol-table mode-local-parent derived-mode-parent overload-obsolete semantic-tag-include-filename-default mode-local-active-mode major-mode #1=#:override tag] 5 (#$ . 33394)])
(put 'semantic-tag-include-filename 'mode-local-overload t)
#@71 Return a filename representation of TAG.
Returns `semantic-tag-name'.
(defalias 'semantic-tag-include-filename-default #[(tag) "\211@)\207" [tag] 2 (#$ . 34698)])
#@103 Return detail information from code that TAG describes.
That is the value of the attribute `:detail'.
(defalias 'semantic-tag-code-detail #[(tag) "\302\303\3048)	\"*\207" [tag attribute :detail plist-get 2] 3 (#$ . 34870)])
(put 'semantic-tag-code-detail 'byte-optimizer 'byte-compile-inline-expand)
#@233 Create a semantic tag of class alias.
NAME is a name for this alias.
META-TAG-CLASS is the class of the tag this tag is an alias.
VALUE is the aliased definition.
ATTRIBUTES is a list of additional attributes belonging to this tag.
(defalias 'semantic-tag-new-alias #[(name meta-tag-class value &rest attributes) "\304\305\306\307	\310\n&\207" [name meta-tag-class value attributes apply semantic-tag alias :aliasclass :definition] 9 (#$ . 35183)])
(put 'semantic-tag-new-alias 'byte-optimizer 'byte-compile-inline-expand)
#@42 Return the class of tag TAG is an alias.
(defalias 'semantic-tag-alias-class #[(tag) "\302\303\3048)	\"*\207" [tag attribute :aliasclass plist-get 2] 3 (#$ . 35715)])
(put 'semantic-tag-alias-class 'byte-optimizer 'byte-compile-inline-expand)
#@237 Return the definition TAG is an alias.
The returned value is a tag of the class that
`semantic-tag-alias-class' returns for TAG.
The default is to return the value of the :definition attribute.
Return nil if TAG is not of class 'alias.
(defalias 'semantic-tag-alias-definition #[(tag) "\306\211\211A@)	*=\205 \307\211\310\311\211\f\312
!\310\f\204?\211\204?\f\205=\313\f\"\f\203l\204l\f\314N\203[\313\f\314N\"\211\204?\f\211\315N\206f\f\316N)\211\204C,\211\205\200\203~
N\205\200
J+\206\n\211\317N)\205\n\211\317N)\310\311\211\f\312
!\310\f\204\277\211\204\277\f\205\275\313\f\"\f\203\354\204\354\f\314N\203\333\313\f\314N\"\211\204\277\f\211\315N\206\346\f\316N)\211\204\303,\211\205\203\376
N\205
J+)\211\203!\202\320\321\3228)\"*)\207" [tag class overload property mode symbol alias semantic-tag-alias-definition nil override-flag symbol-name intern-soft mode-local-symbol-table mode-local-parent derived-mode-parent overload-obsolete :definition plist-get 2 bind name mode-local-active-mode major-mode #1=#:override attribute] 5 (#$ . 35971)])
(put 'semantic-tag-alias-definition 'mode-local-overload t)
#@218 Return a list of components for TAG.
A Component is a part of TAG which itself may be a TAG.
Examples include the elements of a structure in a
tag of class `type, or the list of arguments to a
tag of class 'function.
(defalias 'semantic-tag-components #[(tag) "\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-tag-components nil override-flag symbol-name intern-soft mode-local-symbol-table mode-local-parent derived-mode-parent overload-obsolete semantic-tag-components-default mode-local-active-mode major-mode #1=#:override tag] 5 (#$ . 37210)])
(put 'semantic-tag-components 'mode-local-overload t)
#@95 Return a list of components for TAG.
Perform the described task in `semantic-tag-components'.
(defalias 'semantic-tag-components-default #[(tag) "\303\211\211A@)	*=\203!\211\304\305\3068)\n\"+\207\307\211\211A@)	*=\203B\211\310\305\3068)\n\"+\207\311\207" [tag class attribute type :members plist-get 2 function :arguments nil] 4 (#$ . 38345)])
#@451 Return the list of top level components belonging to TAG.
Children are any sub-tags which contain overlays.

Default behavior is to get `semantic-tag-components' in addition
to the components of an anonymous types (if applicable.)

Note for language authors:
  If a mode defines a language tag that has tags in it with overlays
you should still return them with this function.
Ignoring this step will prevent several features from working correctly.
(defalias 'semantic-tag-components-with-overlays #[(tag) "\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-tag-components-with-overlays nil override-flag symbol-name intern-soft mode-local-symbol-table mode-local-parent derived-mode-parent overload-obsolete semantic-tag-components-with-overlays-default mode-local-active-mode major-mode #1=#:override tag] 5 (#$ . 38721)])
(put 'semantic-tag-components-with-overlays 'mode-local-overload t)
#@226 Return the list of top level components belonging to TAG.
Children are any sub-tags which contain overlays.
The default action collects regular components of TAG, in addition
to any components belonging to an anonymous type.
(defalias 'semantic-tag-components-with-overlays-default #[(tag) "\306!\211\307\310\3118)	\"+\312\211\f\203B\f\312\313\314\217)\203B\306\f!\211\203B\315@!\203;@\nBA\211\204/
\203Y\315
@!\203R
@\nB
A\211\204F\n\237,\207" [tag attribute all-children anon-type-children type explicit-children semantic-tag-components :type plist-get 2 nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) semantic-tag-with-position-p] 5 (#$ . 40146)])
#@217 Return children of TAG.
If POSITIONONLY is nil, use `semantic-tag-components'.
If POSITIONONLY is non-nil, use `semantic-tag-components-with-overlays'.
DO NOT use this fcn in new code.  Use one of the above instead.
(defalias 'semantic-tag-children-compatibility #[(tag &optional positiononly) "\203\302	!\207\303	!\207" [positiononly tag semantic-tag-components-with-overlays semantic-tag-components] 2 (#$ . 40887)])
#@81 Narrow to the region specified by the bounds of TAG.
See `semantic-tag-bounds'.
(defalias 'semantic-narrow-to-tag #[(&optional tag) "\204\302 \211\3038)\304	!\203\305	!\202	\306H*\211\3038)\304	!\2035\307	!\2028	\310H*}\207" [tag o semantic-current-tag 4 semantic-overlay-p semantic-overlay-start 0 semantic-overlay-end 1] 4 (#$ . 41315) nil])
#@59 Execute BODY with the buffer narrowed to the current tag.
(defalias 'semantic-with-buffer-narrowed-to-current-tag '(macro . #[(&rest body) "\301\302BB\207" [body save-restriction (semantic-narrow-to-tag (semantic-current-tag))] 3 (#$ . 41685)]))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put semantic-with-buffer-narrowed-to-current-tag lisp-indent-function 0 add-hook edebug-setup-hook #[nil "\300\301\302\303#\207" [put semantic-with-buffer-narrowed-to-current-tag edebug-form-spec (def-body)] 4]] 4)
#@34 Narrow to TAG, and execute BODY.
(defalias 'semantic-with-buffer-narrowed-to-tag '(macro . #[(tag &rest body) "\302\303D	BB\207" [tag body save-restriction semantic-narrow-to-tag] 3 (#$ . 42207)]))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put semantic-with-buffer-narrowed-to-tag lisp-indent-function 1 add-hook edebug-setup-hook #[nil "\300\301\302\303#\207" [put semantic-with-buffer-narrowed-to-tag edebug-form-spec (def-body)] 4]] 4)
#@317 Onto TAG, add to the value of HOOK the function FUNCTION.
FUNCTION is added (if necessary) at the beginning of the hook list
unless the optional argument APPEND is non-nil, in which case
FUNCTION is added at the end.
HOOK should be a symbol, and FUNCTION may be any valid function.
See also the function `add-hook'.
(defalias 'semantic-tag-add-hook #[(tag hook function &optional append) "	\306\3078)\n\"*\310\303\f
#\210\311	#\210)\207" [tag hook property semantic--tag-hook-value function append plist-get 3 add-hook semantic--tag-put-property] 4 (#$ . 42666)])
#@294 Onto TAG, remove from the value of HOOK the function FUNCTION.
HOOK should be a symbol, and FUNCTION may be any valid function.  If
FUNCTION isn't the value of HOOK, or, if FUNCTION doesn't appear in
the list of hooks to run in HOOK, then nothing is done.
See also the function `remove-hook'.
(defalias 'semantic-tag-remove-hook #[(tag hook function) "	\305\3068)\n\"*\307\303\f\"\210\310	#\210)\207" [tag hook property semantic--tag-hook-value function plist-get 3 remove-hook semantic--tag-put-property] 4 (#$ . 43247)])
#@176 Run for TAG all expressions saved on the property HOOK.
Each hook expression must take at least one argument, the TAG.
For any given situation, additional ARGS may be passed.
(defalias 'semantic--tag-run-hooks #[(tag hook &rest args) "	\306\3078)\n\"*B\310\311\312\217*\207" [tag hook property args arglist semantic--tag-hook-value plist-get 3 err (byte-code "\301\302\303#\207" [arglist apply run-hook-with-args semantic--tag-hook-value] 4) ((error (message "Error: %S" err)))] 3 (#$ . 43787)])
#@103 Convert TAGS from using an overlay to using an overlay proxy.
This function is for internal use only.
(defalias 'semantic--tag-unlink-list-from-buffer #[(tags) "\301\302\"\207" [tags mapcar semantic--tag-unlink-from-buffer] 3 (#$ . 44301)])
(put 'semantic--tag-unlink-list-from-buffer 'byte-optimizer 'byte-compile-inline-expand)
#@102 Convert TAG from using an overlay to using an overlay proxy.
This function is for internal use only.
(defalias 'semantic--tag-unlink-from-buffer #[(tag) "\304\305\306\217)\205>\3078)\310	!\2030\311\312	!\313	!\"\211\307\233)\n\240*\210\314	!\210\315\316\"\210\317!\320\321\"*\207" [tag o overlay tags nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) 4 semantic-overlay-p vector semantic-overlay-start semantic-overlay-end semantic-overlay-delete semantic--tag-run-hooks unlink-hook semantic-tag-components-with-overlays mapcar semantic--tag-unlink-from-buffer] 6 (#$ . 44639)])
#@103 Convert TAGS from using an overlay proxy to using an overlay.
This function is for internal use only.
(defalias 'semantic--tag-link-list-to-buffer #[(tags) "\301\302\"\207" [tags mapc semantic--tag-link-to-buffer] 3 (#$ . 45293)])
(put 'semantic--tag-link-list-to-buffer 'byte-optimizer 'byte-compile-inline-expand)
#@102 Convert TAG from using an overlay proxy to using an overlay.
This function is for internal use only.
(defalias 'semantic--tag-link-to-buffer #[(tag) "\304\305\306\217)\205P\3078)\310	!\203B	G\311U\203B\312	\313H	\314Hp#	\211\307\233)\n\240*\210\315	\316#\210\317\320\304#\210\321\322\"\210\323!\324\325\"*\207" [tag o overlay tags nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) 4 vectorp 2 semantic-make-overlay 0 1 semantic-overlay-put semantic semantic--tag-put-property :filename semantic--tag-run-hooks link-hook semantic-tag-components-with-overlays mapc semantic--tag-link-to-buffer] 5 (#$ . 45617)])
#@103 Convert all tags in the current cache to use overlay proxies.
This function is for internal use only.
(defalias 'semantic--tag-unlink-cache-from-buffer #[nil "\301\302!\210\303 \304\305\")\207" [tags require semantic semantic-fetch-tags mapcar semantic--tag-unlink-from-buffer] 3 (#$ . 46306)])
#@96 Convert all tags in the current cache to use overlays.
This function is for internal use only.
(defalias 'semantic--tag-link-cache-to-buffer #[nil "\300\301!\210\302\303\304\217\207" [require semantic nil (byte-code "\302\303	\")\207" [semantic--buffer-cache tags mapc semantic--tag-link-to-buffer] 3) ((error (byte-code "\300\301!\210\302 \210\303\207" [message "Error recovering tag list" semantic-clear-toplevel-cache nil] 2)))] 3 (#$ . 46609)])
#@122 Return non-nil if TAG is expanded.
This function is for internal use only.
See also the function `semantic--expand-tag'.
(defalias 'semantic--tag-expanded-p #[(tag) ":\205%@\301\302\303\217)\203#\304@\3058)!\203#A\211\202?\207" [tag nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) vectorp 4] 4 (#$ . 47067)])
(put 'semantic--tag-expanded-p 'byte-optimizer 'byte-compile-inline-expand)
#@468 Function used to expand a tag.
It is passed each tag production, and must return a list of tags
derived from it, or nil if it does not need to be expanded.

Languages with compound definitions should use this function to expand
from one compound symbol into several.  For example, in C or Java the
following definition is easily parsed into one tag:

  int a, b;

This function should take this compound tag and turn it into two tags,
one for A, and the other for B.
(defvar semantic-tag-expand-function nil (#$ . 47526))
(make-variable-buffer-local 'semantic-tag-expand-function)
#@499 Convert TAG from a raw state to a cooked state, and expand it.
Returns a list of cooked tags.

  The parser returns raw tags with positional data START END at the
end of the tag data structure (a list for now).  We convert it from
that to a cooked state that uses an overlay proxy, that is, a vector
[START END].

  The raw tag is changed with side effects and maybe expanded in
several derived tags when the variable `semantic-tag-expand-function'
is set.

This function is for internal use only.
(defalias 'semantic--tag-expand #[(tag) "\211:\205'@\302\303\304\217)\203%\305@\3068)!\203%A\211\202?)\203-\207\302\307\310\217\210	\203?	!\206AC\207C\207" [tag semantic-tag-expand-function nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) vectorp 4 (byte-code "\303\233)\304	A@\305	8\"\211\303\233)\n\240*\210	\306\241\210)\306\207" [tag ocdr overlay 4 vector 2 nil] 6) ((error (byte-code "\301\302!\210\303!\207" [tag message "A Rule must return a single tag-line list!" debug] 2)))] 4 (#$ . 48114)])
#@44 Signal that TAG is an invalid foreign tag.
(defalias 'semantic-foreign-tag-invalid '(macro . #[(tag) "\301\302\303\304DDE\207" [tag signal 'wrong-type-argument quote semantic-foreign-tag-p] 5 (#$ . 49204)]))
#@158 Return non-nil if TAG is a foreign tag.
That is, a tag unlinked from the originating buffer, which carries the
originating buffer file name, and major mode.
(defalias 'semantic-foreign-tag-p #[(tag) "\302\303\304\217)\205\305\306\3078)	\"*\207" [tag property nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) :foreign-flag plist-get 3] 3 (#$ . 49420)])
(put 'semantic-foreign-tag-p 'byte-optimizer 'byte-compile-inline-expand)
#@64 Check that TAG is a valid foreign tag.
Signal an error if not.
(defalias 'semantic-foreign-tag-check #[(tag) "\211\302\303\304\217)\205\305\306\3078)	\"*)\206\"\310\311\312\"\207" [tag property nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) :foreign-flag plist-get 3 signal wrong-type-argument (semantic-foreign-tag-p tag)] 4 (#$ . 49914)])
(put 'semantic-foreign-tag-check 'byte-optimizer 'byte-compile-inline-expand)
#@155 Return a copy of TAG as a foreign tag, or nil if it can't be done.
TAG defaults to the tag at point in current buffer.
See also `semantic-foreign-tag-p'.
(defalias 'semantic-foreign-tag #[(&optional tag) "\204\304 \305\306\307\217)\205C\310\305\311#\305\312\313\217\211\314\315\3168)\"*\205B\317\n\320\321!#\210\317\n\322	#\210\317\n\323\311#\210\n*\207" [tag doc ftag property semantic-current-tag nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) semantic-tag-copy t (semantic-documentation-for-tag tag) ((error)) :filename plist-get 3 semantic--tag-put-property :mode semantic-tag-mode :documentation :foreign-flag] 6 (#$ . 50406)])
#@134 Obtain a foreign tag from TAG.
TAG defaults to the tag at point in current buffer.
Return the obtained foreign tag or nil if failed.
(defalias 'semantic-obtain-foreign-tag #[(&optional tag) "\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-obtain-foreign-tag nil override-flag symbol-name intern-soft mode-local-symbol-table mode-local-parent derived-mode-parent overload-obsolete semantic-foreign-tag mode-local-active-mode major-mode #1=#:override tag] 5 (#$ . 51118)])
(put 'semantic-obtain-foreign-tag 'mode-local-overload t)
#@163 Insert FOREIGN-TAG into the current buffer.
The default behavior assumes the current buffer is a language file,
and attempts to insert a prototype/function call.
(defalias 'semantic-insert-foreign-tag-default #[(foreign-tag) "\301!c\207" [foreign-tag semantic-format-tag-prototype] 2 (#$ . 52181)])
#@171 Insert FOREIGN-TAG into the current buffer.
Signal an error if FOREIGN-TAG is not a valid foreign tag.
This function is overridable with the symbol `insert-foreign-tag'.
(defalias 'semantic-insert-foreign-tag #[(foreign-tag) "\211\211\306\307\310\217)\205	\311\312	\313	8)\n\"*)\206$\314\315\316\")\210\317\211\306\320\211\f\321
!\306\f\204U\211\204U\205S\322\"\f\203\202\204\202\f\323N\203q\322\f\323N\"\211\204U\f\211\324N\206|\f\325N)\211\204Y,\211\205\226\n\203\224
\nN\205\226
J+\206\211\326N)\205\211\326N)\306\320\211\f\321
!\306\f\204\325\211\204\325\205\323\322\"\f\203\204\f\323N\203\361\322\f\323N\"\211\204\325\f\211\324N\206\374\f\325N)\211\204\331,\211\205\n\203
\nN\205
J+)\211\203&!\210\202*\327!\210)\330\331!!\207" [foreign-tag tag property overload mode symbol nil (byte-code ":\205#@;\205#A@9\205#A@\205#\3018<\205#\3028<\207" [tag 2 3] 2) ((error)) :foreign-flag plist-get 3 signal wrong-type-argument (semantic-foreign-tag-p tag) semantic-insert-foreign-tag override-flag symbol-name intern-soft mode-local-symbol-table mode-local-parent derived-mode-parent overload-obsolete semantic-insert-foreign-tag-default message semantic-format-tag-summarize bind name mode-local-active-mode major-mode #1=#:override] 5 (#$ . 52488)])
(put 'semantic-insert-foreign-tag 'mode-local-overload t)
#@107 Insert foreign tags into log-edit mode.

Override semantic-insert-foreign-tag in `log-edit-mode' buffers.
(defalias 'semantic-insert-foreign-tag-log-edit-mode #[(foreign-tag) "\301\302!\303Qc\207" [foreign-tag "(" semantic-format-tag-name "): "] 3 (#$ . 53937)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-insert-foreign-tag-log-edit-mode definition-name semantic-insert-foreign-tag mode-local-bind ((semantic-insert-foreign-tag . semantic-insert-foreign-tag-log-edit-mode)) (override-flag t) log-edit-mode] 4)
#@109 Insert foreign tags into log-edit mode.

Override semantic-insert-foreign-tag in `change-log-mode' buffers.
(defalias 'semantic-insert-foreign-tag-change-log-mode #[(foreign-tag) "\301\302!\303Qc\207" [foreign-tag "(" semantic-format-tag-name "): "] 3 (#$ . 54483)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put semantic-insert-foreign-tag-change-log-mode definition-name semantic-insert-foreign-tag mode-local-bind ((semantic-insert-foreign-tag . semantic-insert-foreign-tag-change-log-mode)) (override-flag t) change-log-mode] 4)
(defconst semantic-token-version semantic-tag-version)
(defconst semantic-token-incompatible-version semantic-tag-incompatible-version)
#@288 Return the parent of the type that TAG describes.
The return value is a list.  A value of nil means no parents.
The `car' of the list is either the parent class, or a list
of parent classes.  The `cdr' of the list is the list of
interfaces, or abstract classes which are parents of TAG.
(defalias 'semantic-token-type-parent #[(tag) "\302\303\3048)	\"*\211\305\303\3048)	\"+B\207" [tag attribute :superclasses plist-get 2 :interfaces] 5 (#$ . 55175)])
(byte-code "\300\301\302\303#\210\304\301\305\306#\210\307\310\311\306#\210\312\313\314\306#\210\315\316!\207" [put semantic-token-type-parent byte-optimizer byte-compile-inline-expand make-obsolete "use `semantic-tag-type-superclass' and `semantic-tag-type-interfaces' instead" "23.2" semantic-alias-obsolete semantic-tag-make-assoc-list semantic-tag-make-plist semantic-varalias-obsolete semantic-expand-nonterminal semantic-tag-expand-function provide semantic/tag] 4)
F1l3 Manager
