;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:11:02 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/cedet/semantic.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!\210\300\303!\207" [require cedet semantic/tag semantic/lex] 2)
#@30 Current version of Semantic.
(defvar semantic-version "2.2" (#$ . 655))
#@395 Non-nil if this version of Semantic does not satisfy a specific version.
Arguments can be:

  (MAJOR MINOR &optional BETA)

  Values MAJOR and MINOR must be integers.  BETA can be an integer, or
excluded if a released version is required.

It is assumed that if the current version is newer than that specified,
everything passes.  Exceptions occur when known incompatibilities are
introduced.
(defalias 'semantic-require-version #[(major minor &optional beta) "\303\304!\210\305\306\307	\n\205\310\nPR\"\207" [major minor beta require inversion inversion-test semantic "." "beta"] 7 (#$ . 734)])
(byte-code "\300\301\302\303\304\305%\210\300\306\302\307\304\301%\210\310\311!\207" [custom-declare-group semantic nil "Parser Generator and parser framework." :group tools semantic-faces "Faces used for Semantic enabled tools." require semantic/fw] 6)
#@158 Variable that defines how to parse top level items in a buffer.
This variable is for internal use only, and its content depends on the
external parser used.
(defvar semantic--parse-table nil (#$ . 1595))
(byte-code "\300\301!\210\302\303\301\304#\207" [make-variable-buffer-local semantic--parse-table semantic-varalias-obsolete semantic-toplevel-bovine-table "23.2"] 4)
#@351 Association between symbols returned, and a string.
The string is used to represent a group of objects of the given type.
It is sometimes useful for a language to use a different string
in place of the default, even though that language will still
return a symbol.  For example, Java return's includes, but the
string can be replaced with `Imports'.
(defvar semantic-symbol->name-assoc-list '((type . "Types") (variable . "Variables") (function . "Functions") (include . "Dependencies") (package . "Provides")) (#$ . 1973))
(make-variable-buffer-local 'semantic-symbol->name-assoc-list)
#@371 Like `semantic-symbol->name-assoc-list' for type parts.
Some tags that have children (see `semantic-tag-children-compatibility')
will want to define the names of classes of tags differently than at
the top level.  For example, in C++, a Function may be called a
Method.  In addition, there may be new types of tags that exist only
in classes, such as protection labels.
(defvar semantic-symbol->name-assoc-list-for-type-parts nil (#$ . 2567))
(make-variable-buffer-local 'semantic-symbol->name-assoc-list-for-type-parts)
#@44 Value for `case-fold-search' when parsing.
(defvar semantic-case-fold nil (#$ . 3094))
(make-variable-buffer-local 'semantic-case-fold)
#@449 Function to call for each nonterminal production.
Return a list of non-terminals derived from the first argument, 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 the definition
  int a, b;
is easily parsed into one tag.  This function should take this
compound tag and turn it into two tags, one for A, and the other for B.
(defvar semantic-expand-nonterminal nil (#$ . 3237))
(make-variable-buffer-local 'semantic-expand-nonterminal)
#@375 A cache of the fully parsed buffer.
If no significant changes have been made (based on the state) then
this is returned instead of re-parsing the buffer.

  DO NOT USE THIS VARIABLE IN PROGRAMS.

If you need a tag list, use `semantic-fetch-tags'.  If you need the
cached values for some reason, chances are you can add a hook to
`semantic-after-toplevel-cache-change-hook'.
(defvar semantic--buffer-cache nil (#$ . 3803))
(byte-code "\300\301!\210\302\303\301\304#\207" [make-variable-buffer-local semantic--buffer-cache semantic-varalias-obsolete semantic-toplevel-bovine-cache "23.2"] 4)
#@43 A cached copy of unmatched syntax tokens.
(defvar semantic-unmatched-syntax-cache nil (#$ . 4399))
(make-variable-buffer-local 'semantic-unmatched-syntax-cache)
#@104 Non-nil if the unmatched syntax cache is out of date.
This is tracked with `semantic-change-function'.
(defvar semantic-unmatched-syntax-cache-check nil (#$ . 4567))
(make-variable-buffer-local 'semantic-unmatched-syntax-cache-check)
#@311 When non-nil, modifications do not require a reparse.
This prevents tags from being marked dirty, and it prevents top level
edits from causing a cache check.
Use this when writing programs that could cause a full reparse, but
will not change the tag structure, such as adding or updating
`top-level' comments.
(defvar semantic-edits-are-safe nil (#$ . 4808))
#@579 Hooks run when Semantic detects syntax not matched in a grammar.
Each individual piece of syntax (such as a symbol or punctuation
character) is called with this hook when it doesn't match in the
grammar, and multiple unmatched syntax elements are not grouped
together.  Each hook is called with one argument, which is a list
of syntax tokens created by the semantic lexer.  Use the functions
`semantic-lex-token-start', `semantic-lex-token-end' and
`semantic-lex-token-text' to get information about these tokens.
The current buffer is the buffer these tokens are derived from.
(defvar semantic-unmatched-syntax-hook nil (#$ . 5174))
#@250 Hooks run before a buffer is parsed for tags.
It is called before any request for tags is made via the function
`semantic-fetch-tags' by an application.
If any hook returns a nil value, the cached value is returned
immediately, even if it is empty.
(defvar semantic--before-fetch-tags-hook nil (#$ . 5815))
(semantic-varalias-obsolete 'semantic-before-toplevel-bovination-hook 'semantic--before-fetch-tags-hook "23.2")
#@306 Hooks run after a toplevel parse.
It is not run if the toplevel parse command is called, and buffer does
not need to be fully reparsed.
For language specific hooks, make sure you define this as a local hook.

This hook should not be used any more.
Use `semantic-after-toplevel-cache-change-hook' instead.
(defvar semantic-after-toplevel-bovinate-hook nil (#$ . 6241))
(make-obsolete-variable 'semantic-after-toplevel-bovinate-hook nil "23.2")
#@383 Hooks run after the buffer tag list has changed.
This list will change when a buffer is reparsed, or when the tag list
in a buffer is cleared.  It is *NOT* called if the current tag list is
partially reparsed.

Hook functions must take one argument, which is the new list of tags
associated with this buffer.

For language specific hooks, make sure you define this as a local hook.
(defvar semantic-after-toplevel-cache-change-hook nil (#$ . 6691))
#@293 Hooks run before the toplevel tag cache is flushed.
For language specific hooks, make sure you define this as a local
hook.  This hook is called before a corresponding
`semantic-after-toplevel-cache-change-hook' which is also called
during a flush when the cache is given a new value of nil.
(defvar semantic-before-toplevel-cache-flush-hook nil (#$ . 7147))
#@41 When non-nil, dump parsing information.
(custom-declare-variable 'semantic-dump-parse nil '(#$ . 7512) :group 'semantic :type 'boolean)
#@57 Optional name of the parser used to parse input stream.
(defvar semantic-parser-name "LL" (#$ . 7654))
(make-variable-buffer-local 'semantic-parser-name)
#@55 Internal variable used by `semantic-complete-symbol'.
(defvar semantic--completion-cache nil (#$ . 7814))
(make-variable-buffer-local 'semantic--completion-cache)
#@34 State of the current parse tree.
(defvar semantic-parse-tree-state 'needs-rebuild (#$ . 7983))
(make-variable-buffer-local 'semantic-parse-tree-state)
#@186 Indicate that the current buffer is unparseable.
It is also true that the parse tree will need either updating or
a rebuild.  This state will be changed when the user edits the buffer.
(defalias 'semantic-parse-tree-unparseable '(macro . #[nil "\300\207" [(setq semantic-parse-tree-state 'unparseable)] 1 (#$ . 8141)]))
#@67 Return non-nil if the current buffer has been marked unparseable.
(defalias 'semantic-parse-tree-unparseable-p '(macro . #[nil "\300\207" [(eq semantic-parse-tree-state 'unparseable)] 1 (#$ . 8467)]))
#@118 Indicate that the current parse tree needs to be updated.
The parse tree can be updated by `semantic-parse-changes'.
(defalias 'semantic-parse-tree-set-needs-update '(macro . #[nil "\300\207" [(setq semantic-parse-tree-state 'needs-update)] 1 (#$ . 8675)]))
#@63 Return non-nil if the current parse tree needs to be updated.
(defalias 'semantic-parse-tree-needs-update-p '(macro . #[nil "\300\207" [(eq semantic-parse-tree-state 'needs-update)] 1 (#$ . 8939)]))
#@118 Indicate that the current parse tree needs to be rebuilt.
The parse tree must be rebuilt by `semantic-parse-region'.
(defalias 'semantic-parse-tree-set-needs-rebuild '(macro . #[nil "\300\207" [(setq semantic-parse-tree-state 'needs-rebuild)] 1 (#$ . 9145)]))
#@63 Return non-nil if the current parse tree needs to be rebuilt.
(defalias 'semantic-parse-tree-needs-rebuild-p '(macro . #[nil "\300\207" [(eq semantic-parse-tree-state 'needs-rebuild)] 1 (#$ . 9411)]))
#@53 Indicate that the current parse tree is up to date.
(defalias 'semantic-parse-tree-set-up-to-date '(macro . #[nil "\300\207" [(setq semantic-parse-tree-state nil)] 1 (#$ . 9618)]))
#@57 Return non-nil if the current parse tree is up to date.
(defalias 'semantic-parse-tree-up-to-date-p '(macro . #[nil "\300\207" [(null semantic-parse-tree-state)] 1 (#$ . 9805)]))
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\305\306\313&\207" [custom-declare-variable semantic-inhibit-functions nil "List of functions to call with no arguments before Semantic is setup.\nIf any of these functions returns non-nil, the current buffer is not\nsetup to use Semantic." :group semantic :type hook semantic-new-buffer-setup-functions '((c-mode . semantic-default-c-setup) (c++-mode . semantic-default-c-setup) (html-mode . semantic-default-html-setup) (java-mode . wisent-java-default-setup) (js-mode . wisent-javascript-setup-parser) (python-mode . wisent-python-default-setup) (scheme-mode . semantic-default-scheme-setup) (srecode-template-mode . srecode-template-setup-parser) (texinfo-mode . semantic-default-texi-setup) (makefile-automake-mode . semantic-default-make-setup) (makefile-gmake-mode . semantic-default-make-setup) (makefile-makepp-mode . semantic-default-make-setup) (makefile-bsdmake-mode . semantic-default-make-setup) (makefile-imake-mode . semantic-default-make-setup) (makefile-mode . semantic-default-make-setup)) "Alist of functions to call to set up Semantic parsing in the buffer.\nEach element has the form (MODE . FN), where MODE is a value of\n`major-mode' for the buffer and FN is the corresponding function\nto call, with no arguments, to set up the parser.\n\nThese functions are called by `semantic-new-buffer-fcn', before\n`semantic-inhibit-functions'." (alist :key-type symbol :value-type function)] 8)
#@61 Hook run when a buffer is initialized with a parsing table.
(defvar semantic-init-hook nil (#$ . 11471))
#@61 Hook run when a buffer of a particular mode is initialized.
(defvar semantic-init-mode-hook nil (#$ . 11582))
(make-variable-buffer-local 'semantic-init-mode-hook)
#@233 Hook run when a buffer is initialized with a parsing table for DBs.
This hook is for database functions which intend to swap in a tag table.
This guarantees that the DB will go before other modes that require
a parse of the buffer.
(defvar semantic-init-db-hook nil (#$ . 11753))
(byte-code "\300\301\302\303#\210\300\304\305\303#\210\300\306\307\303#\207" [semantic-varalias-obsolete semantic-init-hooks semantic-init-hook "23.2" semantic-init-mode-hooks semantic-init-mode-hook semantic-init-db-hooks semantic-init-db-hook] 4)
#@60 Non-nil after `semantic-new-buffer-fcn' has been executed.
(defvar semantic-new-buffer-fcn-was-run nil (#$ . 12288))
(make-variable-buffer-local 'semantic-new-buffer-fcn-was-run)
#@62 Return non-nil if the current buffer was set up for parsing.
(defalias 'semantic-active-p #[nil "\207" [semantic-new-buffer-fcn-was-run] 1 (#$ . 12473)])
(put 'semantic-active-p 'byte-optimizer 'byte-compile-inline-expand)
#@62 Raise an error if current buffer was not parsed by Semantic.
(defalias 'semantic-error-if-unparsed #[nil "?\205\301\302!\207" [semantic-new-buffer-fcn-was-run error "Buffer was not parsed by Semantic."] 2 (#$ . 12703)])
(put 'semantic-error-if-unparsed 'byte-optimizer 'byte-compile-inline-expand)
#@134 Return non-nil if the unmatched syntax cache needs a refresh.
That is, if it is dirty or if the current parse tree isn't up to date.
(defalias 'semantic--umatched-syntax-needs-refresh-p #[nil "\206	??\207" [semantic-unmatched-syntax-cache-check semantic-parse-tree-state] 1 (#$ . 13011)])
(put 'semantic--umatched-syntax-needs-refresh-p 'byte-optimizer 'byte-compile-inline-expand)
#@211 Setup the current buffer to use Semantic.
If the major mode is ready for Semantic, and no
`semantic-inhibit-functions' disabled it, the current buffer is setup
to use Semantic, and `semantic-init-hook' is run.
(defalias 'semantic-new-buffer-fcn #[nil "	\236\211\203\f\nA \210)\2057\f?\2057\305\306!?\2057\307\310\311\312\313$\210\313\314 \210\311 \210\315\316!\210\315\317!\210\315\320!\207" [major-mode semantic-new-buffer-setup-functions entry semantic--parse-table semantic-new-buffer-fcn-was-run run-hook-with-args-until-success semantic-inhibit-functions add-hook clone-indirect-buffer-hook semantic-clear-toplevel-cache nil t semantic-lex-init run-hooks semantic-init-db-hook semantic-init-hook semantic-init-mode-hook] 6 (#$ . 13403)])
#@69 For use in a hook.  When only a partial reparse is needed, reparse.
(defalias 'semantic-fetch-tags-fast #[nil "\301\302\303\217\210\207" [semantic--buffer-cache nil (byte-code "\301=\203	\302 \210\301\207" [semantic-parse-tree-state needs-update semantic-fetch-tags] 2) ((error))] 3 (#$ . 14160)])
#@108 When non-nil, activate the interactive parsing debugger.
Do not set this yourself.  Call `semantic-debug'.
(defvar semantic-edebug nil (#$ . 14468))
#@103 Copied from elp.el.  Was `elp-elapsed-time'.
Arguments START and END bound the time being calculated.
(defalias 'semantic-elapsed-time #[(start end) "\302\303	\"!\207" [end start float-time time-subtract] 4 (#$ . 14624)])
(put 'semantic-elapsed-time 'byte-optimizer 'byte-compile-inline-expand)
#@208 Parse the current buffer.  Show output in a temp buffer.
Optional argument CLEAR will clear the cache before parsing.
If CLEAR is negative, it will do a full reparse, and also not display
the output buffer.
(defalias 'bovinate #[(&optional clear) "\203\304 \210\305=\203\306\307 \310 \307 \311\312	\313\314	\"!*\"\210\2031<?\205C\315\316!\210\317\320!\210\321 \210\322\n!c\210eb+\207" [clear start out end semantic-clear-toplevel-cache - -1 current-time semantic-fetch-tags message "Retrieving tags took %.2f seconds." float-time time-subtract pop-to-buffer "*Parser Output*" require pp erase-buffer pp-to-string] 6 (#$ . 14927) "P"])
#@510 Parse STREAM, starting at the first NONTERMINAL rule.
For bovine and wisent based parsers, STREAM is from the output of
`semantic-lex', and NONTERMINAL is a rule in the appropriate language
specific rules file.
The default parser table used for bovine or wisent based parsers is
`semantic--parse-table'.

Must return a list: (STREAM TAGS) where STREAM is the unused elements
from STREAM, and TAGS is the list of semantic tags found; usually only
one tag is returned with the exception of compound statements.
(defalias 'semantic-parse-stream #[(stream nonterminal) "\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\205hJ+\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\340J+)\211\203\362\"\202\370\317\")\207" [overload property mode symbol bind name semantic-parse-stream nil override-flag symbol-name intern-soft mode-local-symbol-table mode-local-parent derived-mode-parent overload-obsolete semantic-parse-stream-default mode-local-active-mode major-mode #1=#:override stream nonterminal] 5 (#$ . 15587)])
(put 'semantic-parse-stream 'mode-local-overload t)
#@188 Reparse changes in the current buffer.
The list of changes are tracked as a series of overlays in the buffer.
When overloading this function, use `semantic-changes-in-region' to
analyze.
(defalias 'semantic-parse-changes #[nil "\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\205hJ+\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\340J+)\211\203\356 \202\360\317 )\207" [overload property mode symbol bind name semantic-parse-changes nil override-flag symbol-name intern-soft mode-local-symbol-table mode-local-parent derived-mode-parent overload-obsolete semantic-parse-changes-default mode-local-active-mode major-mode #1=#:override] 5 (#$ . 17043)])
(put 'semantic-parse-changes 'mode-local-overload t)
#@718 Parse the area between START and END, and return any tags found.
If END needs to be extended due to a lexical token being too large, it
will be silently ignored.

Optional arguments:
NONTERMINAL is the rule to start parsing at.
DEPTH specifies the lexical depth to descend for parsers that use
lexical analysis as their first step.
RETURNONERROR specifies that parsing should stop on the first
unmatched syntax encountered.  When nil, parsing skips the syntax,
adding it to the unmatched syntax cache.

Must return a list of semantic tags which have been cooked
(repositioned properly) but which DO NOT HAVE OVERLAYS associated
with them.  When overloading this function, use `semantic--tag-expand'
to cook raw tags.
(defalias 'semantic-parse-region #[(start end &optional nonterminal depth returnonerror) "\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\205hJ+\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\340J+)\211\203\370%\202
\317%)\207" [overload property mode symbol bind name semantic-parse-region nil override-flag symbol-name intern-soft mode-local-symbol-table mode-local-parent derived-mode-parent overload-obsolete semantic-parse-region-default mode-local-active-mode major-mode #1=#:override start end nonterminal depth returnonerror] 7 (#$ . 18135)])
(put 'semantic-parse-region 'mode-local-overload t)
#@373 Parse the area between START and END, and return any tags found.
If END needs to be extended due to a lexical token being too large,
it will be silently ignored.
Optional arguments:
NONTERMINAL is the rule to start parsing at if it is known.
DEPTH specifies the lexical depth to scan.
RETURNONERROR specifies that parsing should end when encountering
unterminated syntax.
(defalias 'semantic-parse-region-default #[(start end &optional nonterminal depth returnonerror) "\203\n\306=\203\307\310\311 \"\210\214~\210	\nW\204	dV\203%\307\312\n	#\210\313\n\236A\2062\314\n	\f#

#\237)\207" [semantic--parse-table end start semantic-lex-block-streams depth nonterminal t error "No support found to parse buffer %S" buffer-name "Invalid parse region bounds %S, %S" semantic-repeat-parse-whole-stream semantic-lex returnonerror] 5 (#$ . 19862)])
#@96 Set the unmatched syntax cache.
Argument UNMATCHED-SYNTAX is the syntax to set into the cache.
(defalias 'semantic-set-unmatched-syntax-cache #[(unmatched-syntax) "\303\304\305	\"\207" [unmatched-syntax semantic-unmatched-syntax-cache semantic-unmatched-syntax-cache-check nil run-hook-with-args semantic-unmatched-syntax-hook] 3 (#$ . 20717)])
#@45 Clear the cache of unmatched syntax tokens.
(defalias 'semantic-clear-unmatched-syntax-cache #[nil "\302\303\211\207" [semantic-unmatched-syntax-cache semantic-unmatched-syntax-cache-check nil t] 2 (#$ . 21071)])
#@45 Return the list of unmatched syntax tokens.
(defalias 'semantic-unmatched-syntax-tokens #[nil "\204	\203\304\211\305\306\217\210)\207" [semantic-unmatched-syntax-cache-check semantic-parse-tree-state semantic-unmatched-syntax-hook semantic-unmatched-syntax-cache nil (byte-code "\300 \210\301 \207" [semantic-clear-toplevel-cache semantic-fetch-tags] 1) ((quit (message "semantic-unmatched-syntax-tokens: parsing of buffer canceled")))] 4 (#$ . 21292)])
#@138 Clear the toplevel tag cache for the current buffer.
Clearing the cache will force a complete reparse next time a tag list
is requested.
(defalias 'semantic-clear-toplevel-cache #[nil "\304\305!\210\306\307 \210\310 \210\311 \312\313	@\"\210\312\313	A\"\210)\314\315\316\317\320#\210\321\322\"\210\306\211\207" [semantic--buffer-cache l semantic-parse-tree-state semantic--completion-cache run-hooks semantic-before-toplevel-cache-flush-hook nil semantic-clear-unmatched-syntax-cache semantic-clear-parser-warnings semantic-overlay-lists mapc semantic-delete-overlay-maybe needs-rebuild remove-hook after-change-functions semantic-change-function t run-hook-with-args semantic-after-toplevel-cache-change-hook] 4 (#$ . 21760) nil])
#@41 Set the toplevel tag cache to TAGTABLE.
(defalias 'semantic--set-buffer-cache #[(tagtable) "\306\307\303!\210\306\211\310\311\312\306\313$\210\314\315	\"\210\306\314\316\"\210\317\320!\207" [tagtable semantic--buffer-cache semantic-unmatched-syntax-cache-check semantic-bovinate-nonterminal-check-obarray semantic-parse-tree-state semantic--completion-cache nil make-local-variable add-hook after-change-functions semantic-change-function t run-hook-with-args semantic-after-toplevel-cache-change-hook semantic-unmatched-syntax-hook run-hooks semantic-after-toplevel-bovinate-hook semantic-unmatched-syntax-cache] 6 (#$ . 22503)])
#@160 The type of working message to use when parsing.
'percent means we are doing a linear parse through the buffer.
'dynamic means we are reparsing specific tags.
(defvar semantic-working-type 'percent (#$ . 23149))
(semantic-varalias-obsolete 'semantic-bovination-working-type 'semantic-working-type "23.2")
#@180 The minimum size of a buffer before working messages are displayed.
Buffers smaller than this will parse silently.
Buffers larger than this will display the working progress bar.
(defvar semantic-minimum-working-buffer-size 5120 (#$ . 23461))
#@126 Return the message string displayed while parsing.
If optional argument ARG is non-nil it is appended to the message
string.
(defalias 'semantic-parser-working-message #[(&optional arg) "\302\205	\303\304\"	\205\303\305	\"\306R\207" [arg semantic-parser-name "Parsing" format " %s" " (%s)" "..."] 5 (#$ . 23711)])
(put 'semantic-parser-working-message 'byte-optimizer 'byte-compile-inline-expand)
#@399 Fetch semantic tags from the current buffer.
If the buffer cache is up to date, return that.
If the buffer cache is out of date, attempt an incremental reparse.
If the buffer has not been parsed before, or if the incremental reparse
fails, then parse the entire buffer.
If a lexical error had been previously discovered and the buffer
was marked unparseable, then do nothing, and return the cache.
(defalias 'semantic-fetch-tags #[nil "\203\266\306\307!\203\266\306\310!\203\266	\311=\204\266	\203\266\n\312]\313\211\314 \210	\315=\203G\316 	\317=\203:\320 \210\202B\321 \210\322\323\f\"\210\313\202\265	\317=\203\265$\203Z\324ed\"\202\232d%Y\205\210&\325=\205\210\326\327 '\330'\205x\331\332'\"(\205\202\331\333(\"\334R)\335\336#)\324ed\")\203\231\337)!\210)\313\211\211*+,\340 \210+\f-\341\342-\"\210)\343\f!\210+.\207" [semantic-new-buffer-fcn-was-run semantic-parse-tree-state gc-cons-threshold semantic-lex-block-streams res semantic--completion-cache run-hook-with-args-until-failure semantic-before-toplevel-bovination-hook semantic--before-fetch-tags-hook unparseable 10000000 nil garbage-collect needs-update semantic-parse-changes needs-rebuild semantic-fetch-tags semantic-clear-unmatched-syntax-cache run-hook-with-args semantic-after-partial-cache-change-hook semantic-parse-region percent make-progress-reporter buffer-name "Parsing" format " %s" " (%s)" "..." 0 100 progress-reporter-done semantic-clear-toplevel-cache mapc semantic--tag-link-to-buffer semantic--set-buffer-cache noninteractive semantic-minimum-working-buffer-size semantic-working-type arg semantic-parser-name semantic--progress-reporter semantic-parser-warnings semantic-unmatched-syntax-cache-check semantic-unmatched-syntax-cache tags semantic--buffer-cache] 7 (#$ . 24120)])
#@221 Refresh the current buffer's tags safely.

Return non-nil if the refresh was successful.
Return nil if there is some sort of syntax error preventing a reparse.

Does nothing if the current buffer doesn't need reparsing.
(defalias 'semantic-refresh-tags-safe #[nil "\306=\203\307\207\204\310\207\307\310\307\216\311\211\312\313\215\211\203\"\306
+\203)\307)\n*\207" [semantic-parse-tree-state inhibit-quit lexically-safe semantic-lex-unterminated-syntax-end-function semantic-flex-unterminated-syntax-end-function #1=#:ret unparseable nil t #[(#2=#:syntax #3=#:start #4=#:end) "\301\302\"\207" [#2# throw safe-refresh] 3] safe-refresh (byte-code "\212\212\300 \210*\301\207" [semantic-fetch-tags nil] 1)] 3 (#$ . 25932)])
#@34 Backward compatibility function.
(defalias 'semantic-bovinate-toplevel #[(&optional ignored) "\300 \207" [semantic-fetch-tags] 1 (#$ . 26675)])
(make-obsolete 'semantic-bovinate-toplevel 'semantic-fetch-tags "23.2")
#@369 Fetch available semantic tags from the current buffer.
That is, return tags currently in the cache without parsing the
current buffer.
Parse operations happen asynchronously when needed on Emacs idle time.
Use the `semantic-after-toplevel-cache-change-hook' and
`semantic-after-partial-cache-change-hook' hooks to synchronize with
new tags when they become available.
(defalias 'semantic-fetch-available-tags #[nil "\207" [semantic--buffer-cache] 1 (#$ . 26898)])
(put 'semantic-fetch-available-tags 'byte-optimizer 'byte-compile-inline-expand)
#@234 Iteratively parse the entire stream STREAM starting with NONTERM.
Optional argument RETURNONERROR indicates that the parser should exit
with the current results on a parse error.
This function returns semantic tags without overlays.
(defalias 'semantic-repeat-parse-whole-stream #[(stream nonterm &optional returnonerror) "\306\306\211
\203\256\307
\"\211A@\n\204\"\310\311
@A@\"\210\n@
=\203-\310\312!\210	\203E	@\203V\313\314\315	!\"\316	\f\"\202V\203O\306\202V
@B\n@\211\203\317\320!\203\203\321=\203
@\211\211A@\247\204\206AA\202\211A)@)\322_d\245\247\203\243@Y\205\251\323\"*\210\202\f,\207" [semantic-case-fold tag nontermsym case-fold-search result stream nil semantic-parse-stream error "Parse error @ %d" "Parser error: Infinite loop?" mapcar #[(tag) "\303\304\3058)	\"*\204\306\303\n#\210\207" [tag property nonterm reparse-symbol plist-get 3 semantic--tag-put-property] 4] semantic--tag-expand append boundp semantic--progress-reporter percent 100 progress-reporter-do-update nonterm returnonerror semantic-unmatched-syntax-cache semantic-working-type token value reporter] 5 (#$ . 27451)])
#@56 A list of parser warnings since the last full reparse.
(defvar semantic-parser-warnings nil (#$ . 28638))
(make-variable-buffer-local 'semantic-parser-warnings)
#@60 Clear the current list of parser warnings for this buffer.
(defalias 'semantic-clear-parser-warnings #[nil "\301\211\207" [semantic-parser-warnings nil] 2 (#$ . 28805)])
#@58 Add a parser WARNING that covers text from START to END.
(defalias 'semantic-push-parser-warning #[(warning start end) "	\nBBB\211\207" [warning start end semantic-parser-warnings] 3 (#$ . 28982)])
#@27 Dump any parser warnings.
(defalias 'semantic-dump-parser-warnings #[nil "\203\302\303!\210\304\305!\210\306 \210\307	!c\210eb)\207\310\311!\207" [semantic-parser-warnings pw pop-to-buffer "*Parser Warnings*" require pp erase-buffer pp-to-string message "No parser warnings."] 2 (#$ . 29189) nil])
#@469 NOTE: Use `semantic-parse-region' instead.

Bovinate between START and END starting with NONTERM.
Optional DEPTH specifies how many levels of parenthesis to enter.
This command will parse until an error is encountered, and return
the list of everything found until that moment.
This is meant for finding variable definitions at the beginning of
code blocks in methods.  If `bovine-inner-scope' can also support
commands, use `semantic-bovinate-from-nonterminal-full'.
(defalias 'semantic-bovinate-region-until-error #[(start end nonterm &optional depth) "\304	\n\305%\207" [start end nonterm depth semantic-parse-region t] 6 (#$ . 29499)])
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [put semantic-bovinate-region-until-error byte-optimizer byte-compile-inline-expand make-obsolete semantic-parse-region "23.2"] 4)
#@348 Bovinate from within a nonterminal lambda from START to END.
Argument NONTERM is the nonterminal symbol to start with.
Optional argument DEPTH is the depth of lists to dive into.  When used
in a `lambda' of a MATCH-LIST, there is no need to include a START and
END part.
Optional argument LENGTH specifies we are only interested in LENGTH
tokens.
(defalias 'semantic-bovinate-from-nonterminal #[(start end nonterm &optional depth length) "\305\306	\n\206	\307$\f\"A\242\207" [start end depth length nonterm semantic-parse-stream semantic-lex 1] 6 (#$ . 30335)])
(put 'semantic-bovinate-from-nonterminal 'byte-optimizer 'byte-compile-inline-expand)
#@428 NOTE: Use `semantic-parse-region' instead.

Bovinate from within a nonterminal lambda from START to END.
Iterates until all the space between START and END is exhausted.
Argument NONTERM is the nonterminal symbol to start with.
If NONTERM is nil, use `bovine-block-toplevel'.
Optional argument DEPTH is the depth of lists to dive into.
When used in a `lambda' of a MATCH-LIST, there is no need to include
a START and END part.
(defalias 'semantic-bovinate-from-nonterminal-full #[(start end nonterm &optional depth) "\304	\n\206	\305$\207" [start end nonterm depth semantic-parse-region 1] 5 (#$ . 30993)])
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [put semantic-bovinate-from-nonterminal-full byte-optimizer byte-compile-inline-expand make-obsolete semantic-parse-region "23.2"] 4)
#@112 Force a full refresh of the current buffer's tags.
Throw away all the old tags, and recreate the tag database.
(defalias 'semantic-force-refresh #[nil "\300 \210\301 \210\302\303!\207" [semantic-clear-toplevel-cache semantic-fetch-tags message "Buffer reparsed."] 2 (#$ . 31800) nil])
(defvar semantic-mode-map (byte-code "\302 \303\304\305#\210\303\306\307#\210\303\310\311#\210\303\312\313#\210\303\314\315#\210\303\316\317#\210\303\320\321#\210\303\322\323#\210\303\324\325#\210\303\326\327#\210\303\330\331#\210\303\332\333#\210\303\334\335#\210\303\336\337#\210\303\340\341#\210\303\342\343#\210\303\344\345#\210\303\346\347\350	\351\352\257#\210)\207" [map cedet-menu-map make-sparse-keymap define-key ",j" semantic-complete-jump-local ",J" semantic-complete-jump ",m" semantic-complete-jump-local-members ",g" semantic-symref-symbol ",G" semantic-symref ",p" senator-previous-tag ",n" senator-next-tag ",u" senator-go-to-up-reference ", " semantic-complete-analyze-inline "," senator-kill-tag ",\367" senator-copy-tag "," senator-yank-tag ",r" senator-copy-tag-to-register ",," semantic-force-refresh [3 44 up] senator-transpose-tags-up [3 44 down] senator-transpose-tags-down ",l" semantic-analyze-possible-completions [menu-bar cedet-menu] menu-item "Development" :enable (not (bound-and-true-p global-ede-mode))] 8))
(byte-code "\303\304!\303\305!\306\307\310#\210\306\311\312#\210\306\313\314#\210\306\315\316#\210\306\317\320#\210\306\321\322#\210\306\323\324#\210\306\325\326#\210\306\327\330#\210\306\331\332#\210\306	\333\334#\210\306	\335\336#\210\306	\337\340#\210\306	\341\342#\210\306	\343\344#\210\306	\345\346#\210\306	\347\350#\210\306	\351\352#\210\306	\353\354#\210\306	\355\356#\210\306\n\357\360#\210\306\n\361\362\305\363BBB#\210\306\n\364\362\304	\365BBB#\210\306\n\366\367#\210\306\n\370\371#\210\306\n\372\373#\210\306\n\374\375#\210\306\n\376\377#\210\306\n\201@\201A#\210\306\n\201B\201C#\210\306\n\201D\201E#\210*\303\207" [edit-menu navigate-menu cedet-menu-map make-sparse-keymap "Navigate Tags" "Edit Tags" define-key [semantic-analyze-possible-completions] (menu-item "List Completions" semantic-analyze-possible-completions :enable (semantic-active-p) :help "Display a list of completions for the tag at point") [semantic-complete-analyze-inline] (menu-item "Complete Tag Inline" semantic-complete-analyze-inline :enable (semantic-active-p) :help "Display inline completion for the tag at point") [semantic-completion-separator] ("--") [senator-transpose-tags-down] (menu-item "Transpose Tags Down" senator-transpose-tags-down :enable (and (semantic-active-p) (semantic-current-tag)) :help "Transpose the current tag and the next tag") [senator-transpose-tags-up] (menu-item "Transpose Tags Up" senator-transpose-tags-up :enable (and (semantic-active-p) (semantic-current-tag)) :help "Transpose the current tag and the previous tag") [semantic-edit-separator] ("--") [senator-yank-tag] (menu-item "Yank Tag" senator-yank-tag :enable (not (ring-empty-p senator-tag-ring)) :help "Yank the head of the tag ring into the buffer") [senator-copy-tag-to-register] (menu-item "Copy Tag To Register" senator-copy-tag-to-register :enable (and (semantic-active-p) (semantic-current-tag)) :help "Yank the head of the tag ring into the buffer") [senator-copy-tag] (menu-item "Copy Tag" senator-copy-tag :enable (and (semantic-active-p) (semantic-current-tag)) :help "Copy the current tag to the tag ring") [senator-kill-tag] (menu-item "Kill Tag" senator-kill-tag :enable (and (semantic-active-p) (semantic-current-tag)) :help "Kill the current tag, and copy it to the tag ring") [senator-narrow-to-defun] (menu-item "Narrow to Tag" senator-narrow-to-defun :enable (and (semantic-active-p) (semantic-current-tag)) :help "Narrow the buffer to the bounds of the current tag") [semantic-narrow-to-defun-separator] ("--") [semantic-symref-symbol] (menu-item "Find Tag References..." semantic-symref-symbol :enable (semantic-active-p) :help "Read a tag and list the references to it") [semantic-complete-jump] (menu-item "Find Tag Globally..." semantic-complete-jump :enable (semantic-active-p) :help "Read a tag name and find it in the current project") [semantic-complete-jump-local-members] (menu-item "Find Local Members ..." semantic-complete-jump-local-members :enable (semantic-active-p) :help "Read a tag name and find a local member with that name") [semantic-complete-jump-local] (menu-item "Find Tag in This Buffer..." semantic-complete-jump-local :enable (semantic-active-p) :help "Read a tag name and find it in this buffer") [semantic-navigation-separator] ("--") [senator-go-to-up-reference] (menu-item "Parent Tag" senator-go-to-up-reference :enable (semantic-active-p) :help "Navigate up one reference by tag") [senator-next-tag] (menu-item "Next Tag" senator-next-tag :enable (semantic-active-p) :help "Go to the next tag") [senator-previous-tag] (menu-item "Previous Tag" senator-previous-tag :enable (semantic-active-p) :help "Go to the previous tag") [semantic-force-refresh] (menu-item "Reparse Buffer" semantic-force-refresh :help "Force a full reparse of the current buffer" :visible semantic-mode :enable (semantic-active-p)) [semantic-edit-menu] menu-item (:visible semantic-mode) [navigate-menu] (:visible semantic-mode) [semantic-options-separator] ("--") [global-semantic-highlight-func-mode] (menu-item "Highlight Current Function" global-semantic-highlight-func-mode :help "Highlight the tag at point" :visible semantic-mode :button (:toggle . global-semantic-highlight-func-mode)) [global-semantic-stickyfunc-mode] (menu-item "Stick Top Tag to Headerline" global-semantic-stickyfunc-mode :help "Stick the tag scrolled off the top of the buffer into the header line" :visible semantic-mode :button (:toggle bound-and-true-p global-semantic-stickyfunc-mode)) [global-semantic-decoration-mode] (menu-item "Decorate Tags" global-semantic-decoration-mode :help "Decorate tags based on tag attributes" :visible semantic-mode :button (:toggle bound-and-true-p global-semantic-decoration-mode)) [global-semantic-idle-completions-mode] (menu-item "Show Tag Completions" global-semantic-idle-completions-mode :help "Show tag completions when idle" :visible semantic-mode :enable global-semantic-idle-scheduler-mode :button (:toggle . global-semantic-idle-completions-mode)) [global-semantic-idle-summary-mode] (menu-item "Show Tag Summaries" global-semantic-idle-summary-mode :help "Show tag summaries when idle" :visible semantic-mode :enable global-semantic-idle-scheduler-mode :button (:toggle . global-semantic-idle-summary-mode)) [global-semantic-idle-scheduler-mode] (menu-item "Reparse When Idle" global-semantic-idle-scheduler-mode :help "Keep a buffer's parse tree up to date when idle" :visible semantic-mode :button (:toggle . global-semantic-idle-scheduler-mode)) [global-semanticdb-minor-mode] (menu-item "Semantic Database" global-semanticdb-minor-mode :help "Store tag information in a database" :visible semantic-mode :button (:toggle . global-semanticdb-minor-mode))] 7)
#@113 Non-nil when the Semantic system caches have been loaded.
Prevent this load system from loading files in twice.
(defvar semantic-load-system-cache-loaded nil (#$ . 38894))
#@56 List of auxiliary minor modes in the Semantic package.
(defconst semantic-submode-list '(global-semantic-highlight-func-mode global-semantic-decoration-mode global-semantic-stickyfunc-mode global-semantic-idle-completions-mode global-semantic-idle-scheduler-mode global-semanticdb-minor-mode global-semantic-idle-summary-mode global-semantic-mru-bookmark-mode global-cedet-m3-minor-mode global-semantic-idle-local-symbol-highlight-mode global-semantic-highlight-edits-mode global-semantic-show-unmatched-syntax-mode global-semantic-show-parser-state-mode) (#$ . 39072))
(byte-code "\301\302\303\304\305\306\307\310\311\312\"B&\210\301\313\314\315\316\317\320\321\305\306\307\322&\207" [semantic-submode-list custom-declare-variable semantic-default-submodes '(global-semantic-idle-scheduler-mode global-semanticdb-minor-mode) "List of auxiliary Semantic minor modes enabled by `semantic-mode'.\nThe possible elements of this list include the following:\n\n `global-semanticdb-minor-mode'        - Maintain tag database.\n `global-semantic-idle-scheduler-mode' - Reparse buffer when idle.\n `global-semantic-idle-summary-mode'   - Show summary of tag at point.\n `global-semantic-idle-completions-mode' - Show completions when idle.\n `global-semantic-decoration-mode'     - Additional tag decorations.\n `global-semantic-highlight-func-mode' - Highlight the current tag.\n `global-semantic-stickyfunc-mode'     - Show current fun in header line.\n `global-semantic-mru-bookmark-mode'   - Provide `switch-to-buffer'-like\n                                         keybinding for tag names.\n `global-cedet-m3-minor-mode'          - A mouse 3 context menu.\n `global-semantic-idle-local-symbol-highlight-mode' - Highlight references\n                                         of the symbol under point.\nThe following modes are more targeted at people who want to see\n some internal information of the semantic parser in action:\n `global-semantic-highlight-edits-mode' - Visualize incremental parser by\n                                         highlighting not-yet parsed changes.\n `global-semantic-show-unmatched-syntax-mode' - Highlight unmatched lexical\n                                         syntax tokens.\n `global-semantic-show-parser-state-mode' - Display the parser cache state." :group semantic :type set mapcar #[(c) "\301D\207" [c const] 2] semantic-mode nil "Non-nil if Semantic mode is enabled.\nSee the command `semantic-mode' for a description of this minor mode.\nSetting this variable directly does not take effect;\neither customize it (see the info node `Easy Customization')\nor call the function `semantic-mode'." :set custom-set-minor-mode :initialize custom-initialize-default boolean] 12)
#@494 Toggle parser features (Semantic mode).
With a prefix argument ARG, enable Semantic mode if ARG is
positive, and disable it otherwise.  If called from Lisp, enable
Semantic mode if ARG is omitted or nil.

In Semantic mode, Emacs parses the buffers you visit for their
semantic content.  This information is used by a variety of
auxiliary minor modes, listed in `semantic-default-submodes';
all the minor modes in this list are also enabled when you enable
Semantic mode.

\{semantic-mode-map}
(defalias 'semantic-mode #[(&optional arg) "\306 	\307=\203\n?\202\310	!\311V\211\203\220\312\211\2035
@\2110>\203.\f\313!\210
A\211\204 *1\204X\3141\315\316!\203X;\203X\317!\203X\320\321!\210\322 \210\323\324\325\"\210\323\326\327\"\2102\203n\3303\331\332#\210\333 \3124\211\203\214
@4r4q\210\325 \210)
A\211\204x*\202\331\334\324\325\"\210\334\326\327\"\210\334\335\336\"\210\3303\337\312#\210\3303\340\312#\210\312\211\203\317
@\315\f!\203\310\341\f!\203\310\f\342!\210
A\211\204\265*\343 \210\312\21156\344\345\n\203\343\346\202\344\347\"\210\350\351!\203	
\352\302!\210\306 \203\374\306 \232\203	
\353\354\n\203
\355\202
\356\"\210)\357 \210\n\207" [#1=#:last-message arg semantic-mode semantic-submode-list mode --dolist-tail-- current-message toggle prefix-numeric-value 0 nil 1 t boundp semanticdb-default-system-save-directory file-exists-p require semantic/db-ebrowse semanticdb-load-ebrowse-caches add-hook mode-local-init-hook semantic-new-buffer-fcn completion-at-point-functions semantic-completion-at-point-function define-key [cedet-menu-separator] ("--") buffer-list remove-hook after-change-functions semantic-change-function [cedet-menu-separator] [semantic-options-separator] eval -1 semantic--tag-unlink-cache-from-buffer run-hooks semantic-mode-hook semantic-mode-on-hook semantic-mode-off-hook called-interactively-p any customize-mark-as-set message "Semantic mode %sabled" "en" "dis" force-mode-line-update semantic-default-submodes semantic-load-system-cache-loaded global-ede-mode cedet-menu-map b semantic--buffer-cache semantic-new-buffer-fcn-was-run] 5 (#$ . 41800) (list (or current-prefix-arg 'toggle))])
(byte-code "\301\302\303\304\300!\205\n\303\211%\207" [semantic-mode-map add-minor-mode semantic-mode nil boundp] 6)
(defalias 'semantic-completion-at-point-function #[nil "\300\207" [semantic-ia-complete-symbol] 1])
#@140 Toggle global use of `semantic-idle-completions-mode'.
If ARG is positive, enable, if it is negative, disable.
If ARG is nil, then toggle.
(autoload 'global-semantic-idle-completions-mode "semantic/idle" '(#$ . 44212) t nil)
#@343 Display a list of possible completions in a tooltip.

This is a minor mode which performs actions during idle time.
With prefix argument ARG, turn on if positive, otherwise off.  The
minor mode can be turned on only if semantic feature is available and
the current buffer was set up for parsing.  Return non-nil if the
minor mode is enabled.
(autoload 'semantic-idle-completions-mode "semantic/idle" '(#$ . 44444) t nil)
#@136 Toggle global use of `semantic-idle-summary-mode'.
If ARG is positive, enable, if it is negative, disable.
If ARG is nil, then toggle.
(autoload 'global-semantic-idle-summary-mode "semantic/idle" '(#$ . 44872) t nil)
#@452 Display a tag summary of the lexical token under the cursor.
Call `semantic-idle-summary-current-symbol-info' for getting the
current tag to display information.

This is a minor mode which performs actions during idle time.
With prefix argument ARG, turn on if positive, otherwise off.  The
minor mode can be turned on only if semantic feature is available and
the current buffer was set up for parsing.  Return non-nil if the
minor mode is enabled.
(autoload 'semantic-idle-summary-mode "semantic/idle" '(#$ . 45096) t nil)
#@203 Highlight the tag and symbol references of the symbol under point.
Call `semantic-analyze-current-context' to find the reference tag.
Call `semantic-symref-hits-in-region' to identify local references.
(autoload 'global-semantic-idle-local-symbol-highlight-mode "semantic/idle" '(#$ . 45629) t nil)
#@51 Set up buffer for parsing SRecode template files.
(autoload 'srecode-template-setup-parser "srecode/srecode-template" '(#$ . 45934) t nil)
(byte-code "\300\301!\210\302\303!\207" [provide semantic require semantic/util] 2)