Current File : //proc/self/root/kunden/usr/share/emacs/27.2/lisp/cedet/semantic/tag-ls.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/find] 2)
#@66 The tag attributes that can be ignored during a similarity test.
(defvar semantic-tag-similar-ignorable-attributes '(:prototype-flag) (#$ . 484))
#@254 Compare the names of TAG1 and TAG2.
If BLANKOK is false, then the names must exactly match.
If BLANKOK is true, then if either of TAG1 or TAG2 has blank
names, then that is ok, and this returns true, but if they both
have values, they must still match.
(defalias 'semantic--tag-similar-names-p #[(tag1 tag2 blankok) "\306\211\307\310\311!\307\204\"\211\262\204\"	\262\n\205 \312\n\"\262
\203M\211\204M\302N\203<\312\302N\"\211\262\204\"\211\313N\206F\211\314N\262
\262\202\"\266\203\211\262\205a\211\203_
N\205aJ\266\203\206\326\211\211\315N\262
\205\326\211\211\315N\262
\307\310\311!\307\204\225\211\262\204\225	\262\n\205\223\312\n\"\262
\203\300\211\204\300\302N\203\257\312\302N\"\211\262\204\225\211\313N\206\271\211\314N\262
\262\202\225\266\203\211\262\205\324\211\203\322
N\205\324J\266\203\262
\211\203\346\f
#\202\354\316\f
#)\207" [mode-local-active-mode major-mode mode-local-symbol-table #1=#:override tag1 tag2 semantic--tag-similar-names-p nil override-flag symbol-name intern-soft mode-local-parent derived-mode-parent mode-local--overload-obsolete semantic--tag-similar-names-p-default blankok] 13 (#$ . 637)])
(put 'semantic--tag-similar-names-p 'mode-local-overload t)
#@254 Compare the names of TAG1 and TAG2.
If BLANKOK is false, then the names must exactly match.
If BLANKOK is true, then if either of TAG1 or TAG2 has blank
names, then that is ok, and this returns true, but if they both
have values, they must still match.
(defalias 'semantic--tag-similar-names-p-default #[(tag1 tag2 blankok) "\211@)\n\211@)
\203&\f?\206)?\206)\f\306\230\206)\306\230\206)\f\230*\207" [tag1 tag tag2 n2 n1 blankok ""] 3 (#$ . 1903)])
#@137 Compare the types of TAG1 and TAG2.
This function can be overridden, for example to compare a fully
qualified with an unqualified type.
(defalias 'semantic--tag-similar-types-p #[(tag1 tag2) "\211\306\307	\310	8)\n\"+\204(\211\306\307	\310	8)\n\"+\204(\311\207\211\306\307	\310	8)\n\"+\203N\211\306\307	\310	8)\n\"+\204P\312\207\313\211\312\314\315!\312\204t\f\211\262\204t
\262\205r\316\"\262
\203\237\211\204\237\317N\203\216\316\317N\"\211\262\204t\211\320N\206\230\211\321N\262
\262\202t\266\203\211\262\205\263\211\203\261
N\205\263J\266\203\206*
\211\211\322N\262
\205*
\211\211\322N\262
\312\314\315!\312\204\351\f\211\262\204\351
\262\205\347\316\"\262
\203
\211\204
\317N\203
\316\317N\"\211\262\204\351\211\320N\206

\211\321N\262
\262\202\351\266\203\211\262\205(
\211\203&

N\205(
J\266\203\262
\211\203:
\"\202>
\323\")\207" [tag1 tag attribute tag2 mode-local-active-mode major-mode :type plist-get 2 t nil semantic--tag-similar-types-p override-flag symbol-name intern-soft mode-local-symbol-table mode-local-parent derived-mode-parent mode-local--overload-obsolete semantic--tag-similar-types-p-default #1=#:override] 13 (#$ . 2372)])
(put 'semantic--tag-similar-types-p 'mode-local-overload t)
#@137 Compare the types of TAG1 and TAG2.
This function can be overridden, for example to compare a fully
qualified with an unqualified type.
(defalias 'semantic--tag-similar-types-p-default #[(tag1 tag2) "\304	\211\305\306\n\307\n8)\"+\"\207" [tag1 tag2 tag attribute semantic-tag-of-type-p :type plist-get 2] 6 (#$ . 3684)])
#@509 Test to see if attribute ATTR is similar for VALUE1 and VALUE2.
IGNORABLE-ATTRIBUTES is described in `semantic-tag-similar-p'.
This function is internal, but allows customization of `semantic-tag-similar-p'
for a given mode at a more granular level.

Note that :type, :name, and anything in IGNORABLE-ATTRIBUTES will
not be passed to this function.

Modes that override this function can call `semantic--tag-attribute-similar-p-default'
to do the default equality tests if ATTR is not special for that mode.
(defalias 'semantic--tag-attribute-similar-p #[(attr value1 value2 ignorable-attributes) "\306\211\307\310\311!\307\204\"\211\262\204\"	\262\n\205 \312\n\"\262
\203M\211\204M\302N\203<\312\302N\"\211\262\204\"\211\313N\206F\211\314N\262
\262\202\"\266\203\211\262\205a\211\203_
N\205aJ\266\203\206\326\211\211\315N\262
\205\326\211\211\315N\262
\307\310\311!\307\204\225\211\262\204\225	\262\n\205\223\312\n\"\262
\203\300\211\204\300\302N\203\257\312\302N\"\211\262\204\225\211\313N\206\271\211\314N\262
\262\202\225\266\203\211\262\205\324\211\203\322
N\205\324J\266\203\262
\211\203\350\f
$\202\360\316\f
$)\207" [mode-local-active-mode major-mode mode-local-symbol-table #1=#:override attr value1 semantic--tag-attribute-similar-p nil override-flag symbol-name intern-soft mode-local-parent derived-mode-parent mode-local--overload-obsolete semantic--tag-attribute-similar-p-default value2 ignorable-attributes] 13 (#$ . 4018)])
(put 'semantic--tag-attribute-similar-p 'mode-local-overload t)
#@73 For ATTR, VALUE1, VALUE2 and IGNORABLE-ATTRIBUTES, test for similarity.
(defalias 'semantic--tag-attribute-similar-p-default #[(attr value1 value2 ignorable-attributes) "<\203\244@\30613	:\205/	@;\205/	A@9\205/	A@\205/\307	8<\205/\310	8<0\2025\210\311)\203\244\n<\203\244\n@\3121l	:\205h	@;\205h	A@9\205h	A@\205h\307	8<\205h\310	8<0\202n\210\311)\203\244\313\n\fGG=\204\202\311
\203\241\f\203\241\203\241\314\315\f@@$\fAA\202\202
+\207\n\232\204\254\311\207\313\207" [value1 tag value2 taglist2 taglist1 ans (error) 2 3 nil (error) t apply semantic-tag-similar-p ignorable-attributes] 5 (#$ . 5603)])
#@607 Test to see if TAG1 and TAG2 are similar.
Two tags are similar if their name, datatype, and various attributes
are the same.

Similar tags that have sub-tags such as arg lists or type members,
are similar w/out checking the sub-list of tags.
Optional argument IGNORABLE-ATTRIBUTES are attributes to ignore while comparing similarity.
By default, `semantic-tag-similar-ignorable-attributes' is referenced for
attributes, and IGNORABLE-ATTRIBUTES will augment this list.

Note that even though :name is not an attribute, it can be used to
indicate lax comparison of names via `semantic--tag-similar-names-p'
(defalias 'semantic-tag-similar-p #[(tag1 tag2 &rest ignorable-attributes) "\306\211\307\310\311!\307\204\"\211\262\204\"	\262\n\205 \312\n\"\262
\203M\211\204M\302N\203<\312\302N\"\211\262\204\"\211\313N\206F\211\314N\262
\262\202\"\266\203\211\262\205a\211\203_
N\205aJ\266\203\206\326\211\211\315N\262
\205\326\211\211\315N\262
\307\310\311!\307\204\225\211\262\204\225	\262\n\205\223\312\n\"\262
\203\300\211\204\300\302N\203\257\312\302N\"\211\262\204\225\211\313N\206\271\211\314N\262
\262\202\225\266\203\211\262\205\324\211\203\322
N\205\324J\266\203\262
\211\203\346\f
#\202\354\316\f
#)\207" [mode-local-active-mode major-mode mode-local-symbol-table #1=#:override tag1 tag2 semantic-tag-similar-p nil override-flag symbol-name intern-soft mode-local-parent derived-mode-parent mode-local--overload-obsolete semantic-tag-similar-p-default ignorable-attributes] 13 (#$ . 6254)])
(put 'semantic-tag-similar-p 'mode-local-overload t)
#@231 Test to see if TAG1 and TAG2 are similar.
Two tags are similar if their name, datatype, and various attributes
are the same.

IGNORABLE-ATTRIBUTES are tag attributes that can be ignored.

See `semantic-tag-similar-p' for details.
(defalias 'semantic-tag-similar-p-default #[(tag1 tag2 &optional ignorable-attributes) "	=\206\326\306\n\"\307	\310\f>#\2050\311	\"\2050	\211A@)\211\211A@)*=\312
8)	\312
8)\313\211\203\201\203\201@\211\314=\204w\f>\204w\315
\312
8)\"*AA)\202H\203\310\203\310\203\310@\211\314=\204\276\f>\204\276\316A@	\315
\312
8)\"*\n$)AA\202\201\205\324\205\324.\207" [tag1 tag2 ignorable-attributes semantic-tag-similar-ignorable-attributes ignore tag append semantic--tag-similar-names-p :name semantic--tag-similar-types-p 2 t :type plist-get semantic--tag-attribute-similar-p class A1 attr1 attr2 A2 A3 a attribute] 7 (#$ . 7878)])
#@657 Return the fully qualified package name of TAG in a package hierarchy.
STREAM-OR-BUFFER can be anything convertible by `semantic-something-to-stream',
but must be a toplevel semantic tag stream that contains TAG.
A Package Hierarchy is defined in UML by the way classes and methods
are organized on disk.  Some languages use this concept such that a
class can be accessed via it's fully qualified name, (such as Java.)
Other languages qualify names within a Namespace (such as C++) which
result in a different package like structure.

Languages which do not override this function will just search the
stream for a tag of class `package', and return that.
(defalias 'semantic-tag-full-package #[(tag &optional stream-or-buffer) "\306\206	!\307\211\310\311\312!\310\204*\211\262\204*\f\262
\205(\313
\"\262
\203U\211\204U\305N\203D\313\305N\"\211\262\204*\211\314N\206N\211\315N\262
\262\202*\266\203\211\262\205i\211\203g
N\205iJ\266\203\206\336\211\211\316N\262
\205\336\211\211\316N\262
\310\311\312!\310\204\235\211\262\204\235\f\262
\205\233\313
\"\262
\203\310\211\204\310\305N\203\267\313\305N\"\211\262\204\235\211\314N\206\301\211\315N\262
\262\202\235\266\203\211\262\205\334\211\203\332
N\205\334J\266\203\262
\211\203\356	\n\"\202\362\317	\n\"*\207" [stream-or-buffer tag stream mode-local-active-mode major-mode mode-local-symbol-table semantic-something-to-tag-table semantic-tag-full-package nil override-flag symbol-name intern-soft mode-local-parent derived-mode-parent mode-local--overload-obsolete semantic-tag-full-package-default #1=#:override] 13 (#$ . 8841)])
(put 'semantic-tag-full-package 'mode-local-overload t)
#@120 Default method for `semantic-tag-full-package' for TAG.
Return the name of the first tag of class `package' in STREAM.
(defalias 'semantic-tag-full-package-default #[(tag stream) "\305!\306\211\203\"\n@\211A@)\307=\203\n@	B\nA\211\204\n	\237*\242\211\205c\f\3101X:\205T@;\205TA@9\205TA@\205T\3118<\205T\3128<0\202Z\210\306)\205c\f\211@))\207" [stream result tags tag pack semantic-something-to-tag-table nil package (error) 2 3] 3 (#$ . 10558)])
#@930 Return the fully qualified name of TAG in the package hierarchy.
STREAM-OR-BUFFER can be anything convertible by `semantic-something-to-stream',
but must be a toplevel semantic tag stream that contains TAG.
A Package Hierarchy is defined in UML by the way classes and methods
are organized on disk.  Some languages use this concept such that a
class can be accessed via it's fully qualified name, (such as Java.)
Other languages qualify names within a Namespace (such as C++) which
result in a different package like structure.

Languages which do not override this function with
`tag-full-name' will combine `semantic-tag-full-package' and
`semantic-tag-name', separated with language separator character.
Override functions only need to handle STREAM-OR-BUFFER with a
tag stream value, or nil.

TODO - this function should probably also take a PARENT to TAG to
resolve issues where a method in a class in a package is present.
(defalias 'semantic-tag-full-name #[(tag &optional stream-or-buffer) "\306\206	!\307\211\310\311\312!\310\204*\211\262\204*\f\262
\205(\313
\"\262
\203U\211\204U\305N\203D\313\305N\"\211\262\204*\211\314N\206N\211\315N\262
\262\202*\266\203\211\262\205i\211\203g
N\205iJ\266\203\206\336\211\211\316N\262
\205\336\211\211\316N\262
\310\311\312!\310\204\235\211\262\204\235\f\262
\205\233\313
\"\262
\203\310\211\204\310\305N\203\267\313\305N\"\211\262\204\235\211\314N\206\301\211\315N\262
\262\202\235\266\203\211\262\205\334\211\203\332
N\205\334J\266\203\262
\211\203\356	\n\"\202\362\317	\n\"*\207" [stream-or-buffer tag stream mode-local-active-mode major-mode mode-local-symbol-table semantic-something-to-tag-table semantic-tag-full-name nil override-flag symbol-name intern-soft mode-local-parent derived-mode-parent mode-local--overload-obsolete semantic-tag-full-name-default #1=#:override] 13 (#$ . 11039)])
(byte-code "\300\301\302\303#\210\304\305\301\306#\207" [put semantic-tag-full-name mode-local-overload t make-obsolete-overload semantic-nonterminal-full-name "23.2"] 4)
#@99 Default method for `semantic-tag-full-name'.
Return the name of TAG found in the toplevel STREAM.
(defalias 'semantic-tag-full-name-default #[(tag stream) "\305	\"\211@)\211\203\f@\nQ\202\n*\207" [tag stream name pack semantic-type-relation-separator-character semantic-tag-full-package] 4 (#$ . 13135)])
#@236 Attempt to calculate the parent of TAG.
The default behavior (if not overridden with `tag-calculate-parent')
is to search a buffer found with TAG, and if externally defined,
search locally, then semanticdb for that tag (when enabled.)
(defalias 'semantic-tag-calculate-parent #[(tag) "\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 tag semantic-tag-calculate-parent nil override-flag symbol-name intern-soft mode-local-parent derived-mode-parent mode-local--overload-obsolete semantic-tag-calculate-parent-default] 13 (#$ . 13457)])
(put 'semantic-tag-calculate-parent 'mode-local-overload t)
#@41 Attempt to calculate the parent of TAG.
(defalias 'semantic-tag-calculate-parent-default #[(tag) "\302!\205+r\303!q\210\212\211\3048)\305	!\203\"\306	!\202%	\307H*b\210\310 *\207" [tag o semantic-tag-in-buffer-p semantic-tag-buffer 4 overlayp overlay-start 0 semantic-current-tag-parent] 3 (#$ . 14672)])
#@625 Return protection information about TAG with optional PARENT.
This function returns on of the following symbols:
   nil         - No special protection.  Language dependent.
   `public'    - Anyone can access this TAG.
   `private'   - Only methods in the local scope can access TAG.
   `protected' - Like private for outside scopes, like public for child
                 classes.
Some languages may choose to provide additional return symbols specific
to themselves.  Use of this function should allow for this.

The default behavior (if not overridden with `tag-protection'
is to return a symbol based on type modifiers.
(defalias 'semantic-tag-protection #[(tag &optional parent) "\204	\306	8)\203\307	!\203\310	!\311\211\312\313\314!\312\2049\n\211\262\2049\262\f\2057\315\f\"\262
\203d\211\204d\304N\203S\315\304N\"\211\262\2049\211\316N\206]\211\317N\262
\262\2029\266\203\211\262\205x\211\203v
N\205xJ\266\203\206\355\211\211\320N\262
\205\355\211\211\320N\262
\312\313\314!\312\204\254\n\211\262\204\254\262\f\205\252\315\f\"\262
\203\327\211\204\327\304N\203\306\315\304N\"\211\262\204\254\211\316N\206\320\211\317N\262
\262\202\254\266\203\211\262\205\353\211\203\351
N\205\353J\266\203\262
\211\203\373
	\"\202\377\321	\")\207" [parent tag mode-local-active-mode major-mode mode-local-symbol-table #1=#:override 4 semantic-tag-in-buffer-p semantic-tag-calculate-parent semantic-tag-protection nil override-flag symbol-name intern-soft mode-local-parent derived-mode-parent mode-local--overload-obsolete semantic-tag-protection-default] 13 (#$ . 14994)])
(byte-code "\300\301\302\303#\210\304\305\301\306#\207" [put semantic-tag-protection mode-local-overload t make-obsolete-overload semantic-nonterminal-protection "23.2"] 4)
#@98 Return the protection of TAG as a child of PARENT default action.
See `semantic-tag-protection'.
(defalias 'semantic-tag-protection-default #[(tag &optional parent) "\211\305\306\3078)	\"+\310\n\204]\203]@;\203W@\211\311\230\2046\f\312\230\2046\f\313\230\203:\314\202U\f\315\230\203D\316\202U\f\317\230\203N\320\202U\f\321\230\205U\322)A\202\n*\207" [tag attribute prot mods s :typemodifiers plist-get 2 nil "public" "extern" "export" public "private" private "protected" protected "package" package] 4 (#$ . 16815)])
#@496 Non-nil if TAG is not available via package access control.
For languages (such as Java) where a method is package protected,
this method will return nil if TAG, as found in PARENT is available
for access from a file in CURRENTPACKAGE.
If TAG is not protected by PACKAGE, also return t.  Use
`semantic-tag-protected-p' instead.
If PARENT is not provided, it will be derived when passed to
`semantic-tag-protection'.
If CURRENTPACKAGE is not provided, it will be derived from the current
buffer.
(defalias 'semantic-tag-package-protected-p #[(tag &optional parent currentpackage) "\305	\"\211\306=\204\307\202)\204\310\311p\"\310	\206!\f\230?\205(\307))\207" [tag parent tagpro currentpackage tagpack semantic-tag-protection package t semantic-tag-full-package nil] 4 (#$ . 17370)])
#@391 Non-nil if TAG is protected.
PROTECTION is a symbol which can be returned by the method
`semantic-tag-protection'.
PARENT is the parent data type which contains TAG.

For these PROTECTIONs, true is returned if TAG is:
@table @asis
@item nil
  Always true.
@item  private
  True if nil.
@item protected
  True if private or nil.
@item public
  True if private, protected, or nil.
@end table
(defalias 'semantic-tag-protected-p #[(tag protection &optional parent) "\204\304\207\305	\n\"\306=\203?\2061\307=\203'?\2061\306=\2061\310=\2051\310=?)\207" [protection tag parent tagpro t semantic-tag-protection private protected public] 3 (#$ . 18174)])
#@343 Return non-nil if TAG is abstract.
Optional PARENT is the parent tag of TAG.
In UML, abstract methods and classes have special meaning and behavior
in how methods are overridden.  In UML, abstract methods are italicized.

The default behavior (if not overridden with `tag-abstract-p'
is to return true if `abstract' is in the type modifiers.
(defalias 'semantic-tag-abstract-p #[(tag &optional parent) "\306\211\307\310\311!\307\204\"\211\262\204\"	\262\n\205 \312\n\"\262
\203M\211\204M\302N\203<\312\302N\"\211\262\204\"\211\313N\206F\211\314N\262
\262\202\"\266\203\211\262\205a\211\203_
N\205aJ\266\203\206\326\211\211\315N\262
\205\326\211\211\315N\262
\307\310\311!\307\204\225\211\262\204\225	\262\n\205\223\312\n\"\262
\203\300\211\204\300\302N\203\257\312\302N\"\211\262\204\225\211\313N\206\271\211\314N\262
\262\202\225\266\203\211\262\205\324\211\203\322
N\205\324J\266\203\262
\211\203\344\f
\"\202\350\316\f
\")\207" [mode-local-active-mode major-mode mode-local-symbol-table #1=#:override tag parent semantic-tag-abstract-p nil override-flag symbol-name intern-soft mode-local-parent derived-mode-parent mode-local--overload-obsolete semantic-tag-abstract-p-default] 13 (#$ . 18846)])
(byte-code "\300\301\302\303#\210\304\305\301\306#\207" [put semantic-tag-abstract-p mode-local-overload t make-obsolete-overload semantic-nonterminal-abstract "23.2"] 4)
#@103 Return non-nil if TAG is abstract as a child of PARENT default action.
See `semantic-tag-abstract-p'.
(defalias 'semantic-tag-abstract-p-default #[(tag &optional parent) "\211\304\305\3068)	\"+\307\n\2043\2033@;\203-@\310\230\206,@\311\230A\202\n*\207" [tag attribute abs mods :typemodifiers plist-get 2 nil "abstract" "virtual"] 4 (#$ . 20290)])
#@255 Return non-nil if TAG is leaf.
Optional PARENT is the parent tag of TAG.
In UML, leaf methods and classes have special meaning and behavior.

The default behavior (if not overridden with `tag-leaf-p'
is to return true if `leaf' is in the type modifiers.
(defalias 'semantic-tag-leaf-p #[(tag &optional parent) "\306\211\307\310\311!\307\204\"\211\262\204\"	\262\n\205 \312\n\"\262
\203M\211\204M\302N\203<\312\302N\"\211\262\204\"\211\313N\206F\211\314N\262
\262\202\"\266\203\211\262\205a\211\203_
N\205aJ\266\203\206\326\211\211\315N\262
\205\326\211\211\315N\262
\307\310\311!\307\204\225\211\262\204\225	\262\n\205\223\312\n\"\262
\203\300\211\204\300\302N\203\257\312\302N\"\211\262\204\225\211\313N\206\271\211\314N\262
\262\202\225\266\203\211\262\205\324\211\203\322
N\205\324J\266\203\262
\211\203\344\f
\"\202\350\316\f
\")\207" [mode-local-active-mode major-mode mode-local-symbol-table #1=#:override tag parent semantic-tag-leaf-p nil override-flag symbol-name intern-soft mode-local-parent derived-mode-parent mode-local--overload-obsolete semantic-tag-leaf-p-default] 13 (#$ . 20666)])
(byte-code "\300\301\302\303#\210\304\305\301\306#\207" [put semantic-tag-leaf-p mode-local-overload t make-obsolete-overload semantic-nonterminal-leaf "23.2"] 4)
#@95 Return non-nil if TAG is leaf as a child of PARENT default action.
See `semantic-tag-leaf-p'.
(defalias 'semantic-tag-leaf-p-default #[(tag &optional parent) "\211\304\305\3068)	\"+\307\n\204,\203,@;\203&@\310\230A\202\n*\207" [tag attribute leaf mods :typemodifiers plist-get 2 nil "final"] 4 (#$ . 22001)])
#@254 Return non-nil if TAG is static.
Optional PARENT is the parent tag of TAG.
In UML, static methods and attributes mean that they are allocated
in the parent class, and are not instance specific.
UML notation specifies that STATIC entries are underlined.
(defalias 'semantic-tag-static-p #[(tag &optional parent) "\306\211\307\310\311!\307\204\"\211\262\204\"	\262\n\205 \312\n\"\262
\203M\211\204M\302N\203<\312\302N\"\211\262\204\"\211\313N\206F\211\314N\262
\262\202\"\266\203\211\262\205a\211\203_
N\205aJ\266\203\206\326\211\211\315N\262
\205\326\211\211\315N\262
\307\310\311!\307\204\225\211\262\204\225	\262\n\205\223\312\n\"\262
\203\300\211\204\300\302N\203\257\312\302N\"\211\262\204\225\211\313N\206\271\211\314N\262
\262\202\225\266\203\211\262\205\324\211\203\322
N\205\324J\266\203\262
\211\203\344\f
\"\202\350\316\f
\")\207" [mode-local-active-mode major-mode mode-local-symbol-table #1=#:override tag parent semantic-tag-static-p nil override-flag symbol-name intern-soft mode-local-parent derived-mode-parent mode-local--overload-obsolete semantic-tag-static-p-default] 13 (#$ . 22337)])
(put 'semantic-tag-static-p 'mode-local-overload t)
#@99 Return non-nil if TAG is static as a child of PARENT default action.
See `semantic-tag-static-p'.
(defalias 'semantic-tag-static-p-default #[(tag &optional parent) "\211\304\305\3068)	\"+\307\n\204,\203,@;\203&@\310\230A\202\n*\207" [tag attribute static mods :typemodifiers plist-get 2 nil "static"] 4 (#$ . 23566)])
#@139 Return non-nil if TAG is a prototype.
For some languages, such as C, a prototype is a declaration of
something without an implementation.
(defalias 'semantic-tag-prototype-p #[(tag) "\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 tag semantic-tag-prototype-p nil override-flag symbol-name intern-soft mode-local-parent derived-mode-parent mode-local--overload-obsolete semantic-tag-prototype-p-default] 13 (#$ . 23911)])
(put 'semantic-tag-prototype-p 'mode-local-overload t)
#@32 Non-nil if TAG is a prototype.
(defalias 'semantic-tag-prototype-p-default #[(tag) "\303\304\3058)	\"*\211\203\n\2027\211A@)\306=\2036\211\307\304\3058)	\"+?\2027\310)\207" [tag attribute p :prototype-flag plist-get 2 type :members nil] 4 (#$ . 25009)])
(provide 'semantic/tag-ls)