Gecko [ fernandoquevedodop.com ]

Name	Size	Permission
ede	[ DIR ]	drwxr-xr-x
semantic	[ DIR ]	drwxr-xr-x
srecode	[ DIR ]	drwxr-xr-x
cedet-cscope.elc	4.4 KB	-rw-r--r--
cedet-files.elc	2.41 KB	-rw-r--r--
cedet-global.elc	5.34 KB	-rw-r--r--
cedet-idutils.elc	5.2 KB	-rw-r--r--
cedet.elc	3.59 KB	-rw-r--r--
data-debug.elc	28.3 KB	-rw-r--r--
ede.elc	45.1 KB	-rw-r--r--
inversion.elc	12.96 KB	-rw-r--r--
mode-local.elc	31.84 KB	-rw-r--r--
pulse.elc	6.62 KB	-rw-r--r--
semantic.elc	45.79 KB	-rw-r--r--
srecode.elc	776 B	-rw-r--r--

Code Editor : mode-local.elc

;ELC���
;;; Compiled
;;; in Emacs version 27.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.

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

(require 'find-func)
#@425 Run FUNCTION on every file buffer found.
FUNCTION does not have arguments; when it is entered `current-buffer'
is the currently selected file buffer.
If optional argument PREDICATE is non-nil, only select file buffers
for which the function PREDICATE returns non-nil.
If optional argument BUFFERS is non-nil, it is a list of buffers to
walk through.  It defaults to `buffer-list'.

(fn FUNCTION &optional PREDICATE BUFFERS)
(defalias 'mode-local-map-file-buffers #[769 "\211\206�\300 \211\2050�\211@\301!\203)�\302!\203)�r\211q\210\203%� \203(� \210)A\266\202\202�\207" [buffer-list buffer-live-p buffer-file-name] 7 (#$ . 430)])
#@93 Return the mode parent of the major mode MODE.
Return nil if MODE has no parent.

(fn MODE)
(defalias 'get-mode-local-parent #[257 "\211\300N\206	�\211\301N\207" [mode-local-parent derived-mode-parent] 3 (#$ . 1074)])
(put 'get-mode-local-parent 'byte-optimizer 'byte-compile-inline-expand)
#@83 Is the major-mode in the current buffer equivalent to a mode in MODES.

(fn MODE)
(defalias 'mode-local-equivalent-mode-p #[257 "\300\203�B\262\211\301N\206�\211\302N\262\262\202�\211\207" [nil mode-local-parent derived-mode-parent] 5 (#$ . 1371)])
#@160 Run FUNCTION on every file buffer with major mode in MODES.
MODES can be a symbol or a list of symbols.
FUNCTION does not have arguments.

(fn FUNCTION MODES)
(defalias 'mode-local-map-mode-buffers #[514 "\211C\211\242<\204�\211\242C\240\210\300\301\302\303\304\305!\306\"\307$\"\207" [mode-local-map-file-buffers make-byte-code 0 "\302	!\303\211\204�\203�@\300\242>\262A\262\202�\207" vconcat vector [major-mode mode-local-equivalent-mode-p nil] 4] 11 (#$ . 1637)])
#@99 Hook run after a new file buffer is created.
The current buffer is the newly created file buffer.
(defvar mode-local-init-hook nil (#$ . 2123))
#@58 List of buffers whose `major-mode' has changed recently.
(defvar mode-local-changed-mode-buffers nil (#$ . 2273))
(defvar mode-local--init-mode nil)
#@179 Return non-nil if mode local is initialized in current buffer.
That is, if the current `major-mode' is equal to the major mode for
which mode local bindings have been activated.
(defalias 'mode-local-initialized-p #[0 "	=\207" [mode-local--init-mode major-mode] 2 (#$ . 2429)])
(put 'mode-local-initialized-p 'byte-optimizer 'byte-compile-inline-expand)
#@130 Initialize mode-local facilities.
This is run from `find-file-hook', and from `post-command-hook'
after changing the major mode.
(defalias 'mode-local-post-major-mode-change #[0 "\301\302\303\304#\210\304\305\306\307#\207" [mode-local-changed-mode-buffers remove-hook post-command-hook mode-local-post-major-mode-change nil mode-local-map-file-buffers #[0 "\300 \210\301\302!\207" [mode-local--activate-bindings run-hooks mode-local-init-hook] 2] #[0 "	=?\207" [mode-local--init-mode major-mode] 2]] 5 (#$ . 2791)])
#@46 Function called in `change-major-mode-hook'.
(defalias 'mode-local-on-major-mode-change #[0 "p\211\235\203\f�\210\202�\211B\210\301\302\303\304\305$\207" [mode-local-changed-mode-buffers add-hook post-command-hook mode-local-post-major-mode-change t nil] 5 (#$ . 3317)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias set-mode-local-parent mode-local--set-parent nil make-obsolete "27.1"] 4)
#@167 Set parent of major mode MODE to PARENT mode.
To work properly, this function should be called after PARENT mode
local variables have been defined.

(fn MODE PARENT)
(defalias 'mode-local--set-parent #[514 "\300\301#\210\302\303\"\207" [put mode-local-parent mode-local-map-mode-buffers mode-local--activate-bindings] 6 (#$ . 3740)])
(put 'mode-local--set-parent 'byte-optimizer 'byte-compile-inline-expand)
#@214 Make major mode MODE inherit behavior from PARENT mode.
DOCSTRING is optional and not used.
To work properly, this should be put after PARENT mode local variables
definition.

(fn MODE PARENT &optional DOCSTRING)
(defalias 'define-child-mode '(macro . #[770 "\300\301D\301DE\207" [mode-local--set-parent quote] 7 (#$ . 4158)]))
(make-obsolete 'define-child-mode 'define-derived-mode "27.1")
#@92 Return non-nil if THIS-MODE can use bindings of DESIRED-MODE.

(fn THIS-MODE DESIRED-MODE)
(defalias 'mode-local-use-bindings-p #[514 "\300\211\204�\203�=\262\211\301N\206�\211\302N\262\262\202�\211\207" [nil mode-local-parent derived-mode-parent] 6 (#$ . 4557)])
#@168 Buffer local mode bindings.
These symbols provide a hook for a `major-mode' to specify specific
behaviors.  Use the function `mode-local-bind' to define new bindings.
(defvar mode-local-symbol-table nil (#$ . 4839))
(make-variable-buffer-local 'mode-local-symbol-table)
#@42 Major mode in which bindings are active.
(defvar mode-local-active-mode nil (#$ . 5115))
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias new-mode-local-bindings mode-local--new-bindings nil make-obsolete "27.1"] 4)
#@48 Return a new empty mode bindings symbol table.
(defalias 'mode-local--new-bindings #[0 "\300\301!\207" [obarray-make 13] 2 (#$ . 5354)])
(put 'mode-local--new-bindings 'byte-optimizer 'byte-compile-inline-expand)
#@787 Define BINDINGS in the specified environment.
BINDINGS is a list of (VARIABLE . VALUE).
Optional argument PLIST is a property list each VARIABLE symbol will
be set to.  The following properties have special meaning:

- `constant-flag' if non-nil, prevent rebinding variables.
- `mode-variable-flag' if non-nil, define mode variables.
- `override-flag' if non-nil, define override functions.

The `override-flag' and `mode-variable-flag' properties are mutually
exclusive.

If optional argument MODE is non-nil, it must be a major mode symbol.
BINDINGS will be defined globally for this major mode.  If MODE is
nil, BINDINGS will be defined locally in the current buffer, in
variable `mode-local-symbol-table'.  The later should be done in MODE
hook.

(fn BINDINGS &optional PLIST MODE)
(defalias 'mode-local-bind #[769 "\301\302\"\203�\301\303\"\203�\304\305!\210\306\211\211\211\211\2031�\300N\206$�\307\310!\262\311\300#\210\202H�\301\302\"\203=�\304\312!\210\206F�\307\310!\211\262\203\324�@\262A\262\313@!\262\211A\262\314\"\211\262\203\300�J\232\204H�\315N\203\201�\304\316\"\210\202H�\302N\203\227�\301\303\"\203\227�\304\317\"\210\202H�\303N\203\255�\301\302\"\203\255�\304\320\"\210\202H�\321\322	\323!\"\"\210L\210\202H�\324\"\262\321\"\210L\210\202H�\207" [mode-local-symbol-table plist-get mode-variable-flag override-flag error "Bindings can't be both overrides and mode variables" nil obarray-make 13 put "Mode required to bind mode variables" symbol-name intern-soft constant-flag "Can't change the value of constant `%s'" "Can't rebind override `%s' as a mode variable" "Can't rebind mode variable `%s' as an override" setplist append symbol-plist intern] 14 (#$ . 5574)])
#@354 Return the mode local symbol bound with SYMBOL's name.
Return nil if the  mode local symbol doesn't exist.
If optional argument MODE is nil, lookup first into locally bound
symbols, then in those bound in current `major-mode' and its parents.
If MODE is non-nil, lookup into symbols bound in that major mode and
its parents.

(fn SYMBOL &optional MODE)
(defalias 'mode-local-symbol #[513 "\303!\304\204�\211\262\204�	\262\n\205�\305\n\"\262\203G�\211\204G�\302N\2036�\305\302N\"\211\262\204�\211\306N\206@�\211\307N\262\262\202�\207" [mode-local-active-mode major-mode mode-local-symbol-table symbol-name nil intern-soft mode-local-parent derived-mode-parent] 8 (#$ . 7328)])
(put 'mode-local-symbol 'byte-optimizer 'byte-compile-inline-expand)
#@409 Return the value of the mode local symbol bound with SYMBOL's name.
If optional argument MODE is non-nil, restrict lookup to that mode and
its parents (see the function `mode-local-symbol' for more details).
If optional argument PROPERTY is non-nil the mode local symbol must
have that property set.  Return nil if the symbol doesn't exist, or
doesn't have PROPERTY set.

(fn SYMBOL &optional MODE PROPERTY)
(defalias 'mode-local-symbol-value #[769 "\303!\304\204�\211\262\204�	\262\n\205�\305\n\"\262\203I�\211\204I�\302N\2038�\305\302N\"\211\262\204�\211\306N\206B�\211\307N\262\262\202�\266\203\211\262\205]�\211\203[�N\205]�J\207" [mode-local-active-mode major-mode mode-local-symbol-table symbol-name nil intern-soft mode-local-parent derived-mode-parent] 11 (#$ . 8100)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\210\310\305\306\311#\207" [put mode-local-symbol-value byte-optimizer byte-compile-inline-expand defalias activate-mode-local-bindings mode-local--activate-bindings nil make-obsolete "27.1"] 4)
#@353 Activate variables defined locally in MODE and its parents.
That is, copy mode local bindings into corresponding buffer local
variables.
If MODE is not specified it defaults to current `major-mode'.
Return the alist of buffer-local variables that have been changed.
Elements are (SYMBOL . PREVIOUS-VALUE), describing one variable.

(fn &optional MODE)
(defalias 'mode-local--activate-bindings #[256 "\302\303!\203	�\304 \207\305\211\211C\204�\306\301!\210\262\2034�B\262\211\307N\206-�\211\310N\262\262\202�\211\203\\�\211@\211\311N\211\262\203U�\312\313\314\315\316\317!\320\"\321\322%\"\210A\266\202\2025�\210\211\242\207" [major-mode mode-local--init-mode boundp keep-mode-if-same mode-local-on-major-mode-change nil make-local-variable mode-local-parent derived-mode-parent mode-local-symbol-table mapatoms make-byte-code 257 "\211\301N\205$�\302\303!!\304p\"\203�\300\211JB\300\242B\240\210\305!JL\262\207" vconcat vector [mode-variable-flag intern symbol-name local-variable-p make-local-variable] 5 "\n\n(fn VAR)"] 13 (#$ . 9156)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias deactivate-mode-local-bindings mode-local--deactivate-bindings nil make-obsolete "27.1"] 4)
#@231 Deactivate variables defined locally in MODE and its parents.
That is, kill buffer local variables set from the corresponding mode
local bindings.
If MODE is not specified it defaults to current `major-mode'.

(fn &optional MODE)
(defalias 'mode-local--deactivate-bindings #[256 "\211\204�\301\302!\210\262\303\205/�\304N\211\262\203�\305\306\"\210\211\307N\206(�\211\310N\262\262\202\f�\207" [major-mode kill-local-variable mode-local--init-mode nil mode-local-symbol-table mapatoms #[257 "\211\300N\205
�\301\302\303!!!\207" [mode-variable-flag kill-local-variable intern symbol-name] 5 "\n\n(fn VAR)"] mode-local-parent derived-mode-parent] 5 (#$ . 10387)])
#@355 With the local bindings of MODE symbol, evaluate BODY.
The current mode bindings are saved, BODY is evaluated, and the saved
bindings are restored, even in case of an abnormal exit.
Value is what BODY returns.
This is like `with-mode-local', except that MODE's value is used.
To use the symbol MODE (quoted), use `with-mode-local'.

(fn MODE &rest BODY)
(defalias 'with-mode-local-symbol '(macro . #[385 "\300\301!\300\302!\300\303!\300\304!\305\306B\307B	DE\310\311\312D\313\314E\313	\315\nDEBBBB\312D\316	D\317\320	D\321\nDEE\313\314E\315D\257E\207" [make-symbol "mode" "old-locals" "new-mode" "local" let (mode-local-active-mode) (nil) unwind-protect progn mode-local--deactivate-bindings setq mode-local-active-mode mode-local--activate-bindings dolist set car cdr] 17 (#$ . 11067)]))
(byte-code "\300\301\302\303#\300\207" [function-put with-mode-local-symbol lisp-indent-function 1] 4)
#@314 With the local bindings of MODE, evaluate BODY.
The current mode bindings are saved, BODY is evaluated, and the saved
bindings are restored, even in case of an abnormal exit.
Value is what BODY returns.
This is like `with-mode-local-symbol', except that MODE is quoted
and is not evaluated.

(fn MODE &rest BODY)
(defalias 'with-mode-local '(macro . #[385 "\300\301DBB\207" [with-mode-local-symbol quote] 5 (#$ . 11990)]))
(byte-code "\300\301\302\303#\300\207" [function-put with-mode-local lisp-indent-function 1] 4)
#@65 Return the value of the MODE local variable SYM.

(fn MODE SYM)
(defalias 'mode-local-value #[514 "\204�\303\304!\210\211\305\306!\307\204)�\211\262\204)�	\262\n\205'�\310\n\"\262\203T�\211\204T�\302N\203C�\310\302N\"\211\262\204)�\211\311N\206M�\211\312N\262\262\202)�\266\203\211\262\205h�\211\203f�N\205h�J\207" [mode-local-active-mode major-mode mode-local-symbol-table error "Missing major mode symbol" mode-variable-flag symbol-name nil intern-soft mode-local-parent derived-mode-parent] 13 (#$ . 12517)])
(put 'mode-local-value 'byte-optimizer 'byte-compile-inline-expand)
#@403 Assign new values to variables local in MODE.
MODE must be a major mode symbol.
ARGS is a list (SYM VAL SYM VAL ...).
The symbols SYM are variables; they are literal (not evaluated).
The values VAL are expressions; they are evaluated.
Set each SYM to the value of its VAL, locally in buffers already in
MODE, or in buffers switched to that mode.
Return the value of the last VAL.

(fn MODE &rest ARGS)
(defalias 'setq-mode-local '(macro . #[385 "\211\205v�\300\211\211\211\211\211\211\301\262\203S�\302\303\304	\"!\262T\262@\262A@\262DB\262\305\306DEB\262\307\310\306DDEB\262AA\262\202�\311\237\312\313B\314\306DF\315\316\317\300\nBBD\306DE\257\266\207\207" [nil 0 make-symbol format "tmp%d" cons quote set make-local-variable let* mode-local-bind list '(mode-variable-flag t) mode-local-map-mode-buffers function lambda] 17 (#$ . 13128)]))
(put 'setq-mode-local 'edebug-form-spec '(symbolp &rest symbolp form))
#@110 Define MODE local variable SYM with value VAL.
DOCSTRING is optional.

(fn MODE SYM VAL &optional DOCSTRING)
(defalias 'defvar-mode-local '(macro . #[1027 "\300\301F\302\303\304D\304	DE\305F\304DF\207" [progn setq-mode-local put mode-local-symbol quote 'variable-documentation] 11 (#$ . 14090)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put defvar-mode-local lisp-indent-function defun put edebug-form-spec (&define symbolp name def-form [&optional stringp])] 5)
#@110 Define MODE local constant SYM with value VAL.
DOCSTRING is optional.

(fn MODE SYM VAL &optional DOCSTRING)
(defalias 'defconst-mode-local '(macro . #[1027 "\300\301!\302C\303F\304\305\306\nD\306\fDEE\307\310BB\307\311	F\306\nD\257\207" [make-symbol "tmp" let setq-mode-local setq mode-local-symbol quote put ('constant-flag t) 'variable-documentation] 14 (#$ . 14591)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put defconst-mode-local lisp-indent-function defun put edebug-form-spec defvar-mode-local] 5)
#@142 Mark OLD overload as obsoleted by NEW overload.
WHEN is a string describing the first release where it was made obsolete.

(fn OLD NEW WHEN)
(defalias 'make-obsolete-overload #[771 "\300\301#\210\300\302#\210\300\303\304#\210\300\305#\207" [put mode-local--overload-obsoleted-by mode-local--overload-obsoleted-since mode-local-overload t mode-local--overload-obsolete] 7 (#$ . 15143)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias overload-obsoleted-by mode-local--overload-obsoleted-by nil make-obsolete "27.1"] 4)
#@111 Get the overload symbol obsoleted by OVERLOAD.
Return the obsolete symbol or nil if not found.

(fn OVERLOAD)
(defalias 'mode-local--overload-obsoleted-by #[257 "\211\300N\207" [mode-local--overload-obsolete] 3 (#$ . 15694)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\210\310\305\306\311#\207" [put mode-local--overload-obsoleted-by byte-optimizer byte-compile-inline-expand defalias overload-that-obsolete mode-local--overload-that-obsolete nil make-obsolete "27.1"] 4)
#@128 Return the overload symbol that obsoletes OVERLOAD.
Return the symbol found or nil if OVERLOAD is not obsolete.

(fn OVERLOAD)
(defalias 'mode-local--overload-that-obsolete #[257 "\211\300N\207" [mode-local--overload-obsoleted-by] 3 (#$ . 16181)])
(put 'mode-local--overload-that-obsolete 'byte-optimizer 'byte-compile-inline-expand)
#@202 Return the current OVERLOAD function, or nil if not found.
First, lookup for OVERLOAD into locally bound mode local symbols, then
in those bound in current `major-mode' and its parents.

(fn OVERLOAD)
(defalias 'fetch-overload #[257 "\211\303\304\305!\303\204!�\211\262\204!�	\262\n\205�\306\n\"\262\203L�\211\204L�\302N\203;�\306\302N\"\211\262\204!�\211\307N\206E�\211\310N\262\262\202!�\266\203\211\262\205`�\211\203^�N\205`�J\266\203\206\325�\211\211\311N\262\205\325�\211\211\311N\262\303\304\305!\303\204\224�\211\262\204\224�	\262\n\205\222�\306\n\"\262\203\277�\211\204\277�\302N\203\256�\306\302N\"\211\262\204\224�\211\307N\206\270�\211\310N\262\262\202\224�\266\203\211\262\205\323�\211\203\321�N\205\323�J\266\203\207" [mode-local-active-mode major-mode mode-local-symbol-table nil override-flag symbol-name intern-soft mode-local-parent derived-mode-parent mode-local--overload-obsolete] 12 (#$ . 16522)])
(put 'fetch-overload 'byte-optimizer 'byte-compile-inline-expand)
#@312 Return the form that handles overloading of function NAME.
ARGS are the arguments to the function.
BODY is code that would be run when there is no override defined.  The
default is to call the function `NAME-default' with the appropriate
arguments.
See also the function `define-overload'.

(fn NAME ARGS BODY)
(defalias 'mode-local--override #[771 "\300\301\302\"!\303\304\303\305\306!\"\"\307\310!\311\312\313	DDDC\314\315BB\2060�BCBBBE\207" [intern format "%s-default" delq &rest &optional copy-sequence make-symbol "override" let fetch-overload quote if funcall] 13 (#$ . 17559)])
#@283 Expand override forms that overload function NAME.
ARGS are the arguments to the function NAME.
BODY is code where override forms are searched for expansion.
Return result of expansion, or BODY if no expansion occurred.
See also the function `define-overload'.

(fn NAME ARGS BODY)
(defalias 'mode-local--expand-overrides #[771 "\211\300\301\211\203Z�@\262:\203D�@\302=\203%�\303A#\262\202D�@\304=\203;�\303A@AA#\262\202D�\305#\262\205L�@=\262B\262A\262\202�\203b�\202d�\211\237\207" [t nil :override mode-local--override :override-with-args mode-local--expand-overrides] 11 (#$ . 18166)])
#@204 Return the code that implements overloading of function NAME.
ARGS are the arguments to the function NAME.
BODY specifies the overload code.
See also the function `define-overload'.

(fn NAME ARGS BODY)
(defalias 'mode-local--overload-body #[771 "\300#=\203�\301#C\202�\211\207" [mode-local--expand-overrides mode-local--override] 8 (#$ . 18798)])
(put 'define-overloadable-function 'doc-string-elt 3)
#@1087 Define a new function, as with `defun', which can be overloaded.
NAME is the name of the function to create.
ARGS are the arguments to the function.
DOCSTRING is a documentation string to describe the function.  The
docstring will automatically have details about its overload symbol
appended to the end.
BODY is code that would be run when there is no override defined.  The
default is to call the function `NAME-default' with the appropriate
arguments.

BODY can also include an override form that specifies which part of
BODY is specifically overridden.  This permits specifying common code
run for both default and overridden implementations.
An override form is one of:

1. (:override [OVERBODY])
  2. (:override-with-args OVERARGS [OVERBODY])

OVERBODY is the code that would be run when there is no override
defined.  The default is to call the function `NAME-default' with the
appropriate arguments deduced from ARGS.
OVERARGS is a list of arguments passed to the override and
`NAME-default' function, in place of those deduced from ARGS.

(fn NAME ARGS DOCSTRING &rest BODY)
(defalias 'define-overloadable-function '(macro . #[899 "\300\301\302		#BBBB\303\304D\305BBE\207" [eval-and-compile defun mode-local--overload-body put quote ('mode-local-overload t)] 13 (#$ . 19218)]))
(byte-code "\300\301\302\303#\304\301\305\306#\210\304\307\310\311#\210\312\313\301\314#\210\315\313\301\316#\210\312\317\320\314#\210\315\317\320\316#\207" [function-put define-overloadable-function doc-string-elt 3 put edebug-form-spec (&define name lambda-list stringp def-body) :override-with-args lisp-indent-function 1 defalias define-overload nil make-obsolete "27.1" function-overload-p mode-local--function-overload-p] 5)
#@78 Return non-nil if SYMBOL is a function which can be overloaded.

(fn SYMBOL)
(defalias 'mode-local--function-overload-p #[257 "\211\205\f�\2119\205\f�\211\300N\207" [mode-local-overload] 3 (#$ . 20953)])
(put 'mode-local--function-overload-p 'byte-optimizer 'byte-compile-inline-expand)
#@445 Define a mode specific override of the function overload NAME.
Has meaning only if NAME has been created with `define-overloadable-function'.
MODE is the major mode this override is being defined for.
ARGS are the function arguments, which should match those of the same
named function created with `define-overload'.
DOCSTRING is the documentation string.
BODY is the implementation of this function.

(fn NAME MODE ARGS DOCSTRING &rest BODY)
(defalias 'define-mode-local-override '(macro . #[1156 "\300\301\302#!\303\304\305\301\306

$BBBB\307\310D\311\310\fDFE\312\310	BCD\313\310\nDFE\207" [intern format "%s-%s" progn eval-and-compile defun "%s\n\nOverride %s in `%s' buffers." put quote 'definition-name mode-local-bind '(override-flag t)] 16 (#$ . 21247)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put define-mode-local-override doc-string-elt 4 put edebug-form-spec (&define name symbolp lambda-list stringp def-body)] 5)
#@176 Interactively read in the name of a mode-local function.
PROMPT, INITIAL, HIST, and DEFAULT are the same as for `completing-read'.

(fn PROMPT &optional INITIAL HIST DEFAULT)
(defalias 'mode-local-read-function #[1025 "\301\302\303&\207" [obarray completing-read mode-local--function-overload-p t] 12 (#$ . 22224)])
(byte-code "\300\301\302\303#\210\304\305\306\302#\210\300\305\306\303#\207" [make-obsolete mode-local-read-function nil "27.1" defalias overload-docstring-extension mode-local--overload-docstring-extension] 4)
#@81 Return the doc string that augments the description of OVERLOAD.

(fn OVERLOAD)
(defalias 'mode-local--overload-docstring-extension #[257 "\300\211\301N\262\211\203�\302\303\211\304N$\262\211\305N\262\262\211\203+�\302\306\304N$\262\207" ["\nThis function can be overloaded with `define-mode-local-override'." mode-local--overload-obsolete format "%s\nIt has made the overload `%s' obsolete since %s." mode-local--overload-obsoleted-since mode-local--overload-obsoleted-by "%s\nThis overload is obsolete since %s;\nUse `%s' instead."] 9 (#$ . 22766)])
#@97 Augment the *Help* buffer for SYMBOL.
SYMBOL is a function that can be overridden.

(fn SYMBOL)
(defalias 'mode-local-augment-function-help #[257 "r\301q\210\302p!\210eb\210\303\304\305\306#\204�db\210\307 \210\310y\210\306\311\312!!\313\261*\207" [inhibit-read-only "*Help*" pop-to-buffer re-search-forward "^$" nil t beginning-of-line -1 substitute-command-keys mode-local--overload-docstring-extension "\n"] 5 (#$ . 23338)])
#@84 For `help-fns-describe-function-functions'; add overloads for SYMBOL.

(fn SYMBOL)
(defalias 'mode-local--describe-overload #[257 "\211\211\205
�\2119\205
�\211\305N\262\205+\306\307\310\311!\"!\206�\211rq\210\211\312\313\311!\312\204D�	\211\262\204D�\n\262\205B�\306\"\262\203o�\211\204o�\303N\203^�\306\303N\"\211\262\204D�\211\314N\206h�\211\315N\262\262\202D�\266\203\211\262\205\203�\211\203\201�N\205\203�J\266\203\206\370�\211\211\316N\262\205\370�\211\211\316N\262\312\313\311!\312\204\267�	\211\262\204\267�\n\262\205\265�\306\"\262\203\342�\211\204\342�\303N\203\321�\306\303N\"\211\262\204\267�\211\314N\206\333�\211\315N\262\262\202\267�\266\203\211\262\205\366�\211\203\364�N\205\366�J\266\203\262)\312C\317\320!!\321\261\210\322\323\"c\210\203\322\324#c\210\202 \322\325\"c\210\326\327\330\331\332\333!\334\"\335\336%\f\"\210\211\242\211\205'\211@\211\211\312\313\311!\312\204]	\211\262\204]\n\262\205[\306\"\262\203\210\211\204\210\303N\203w\306\303N\"\211\262\204]\211\314N\206\201\211\315N\262\262\202]\266\203\211\262\205\234\211\203\232N\205\234J\266\203\206\211\211\316N\262\205\211\211\316N\262\312\313\311!\312\204\320	\211\262\204\320\n\262\205\316\306\"\262\203\373\211\204\373\303N\203\352\306\303N\"\211\262\204\320\211\314N\206\364\211\315N\262\262\202\320\266\203\211\262\205\211\203
N\205J\266\203\262\211\203\322\337\n#c\210)\210A\266\202\2023\262\266\203\207" [describe-function-orig-buffer mode-local-active-mode major-mode mode-local-symbol-table obarray mode-local-overload intern-soft format "%s-default" symbol-name nil override-flag mode-local-parent derived-mode-parent mode-local--overload-obsolete substitute-command-keys mode-local--overload-docstring-extension "\n\n" format-message "default function: `%s'\n" "\noverride in buffer `%s': `%s'\n" "\nno override in buffer `%s'\n" mapatoms make-byte-code 257 "\211\301N\205\f�\300\300\242B\240\207" vconcat vector [mode-local-symbol-table] 4 "\n\n(fn SYM)" "\noverride in mode `%s': `%s'\n"] 18 (#$ . 23776)])
(add-hook 'help-fns-describe-function-functions 'mode-local--describe-overload)
#@52 Return non-nil if SYM is in XREFS.

(fn SYM XREFS)
(defalias 'xref-mode-local--override-present #[514 "\301\211\2041�\2031�\302\211A\262\242!\303!>\204!�\304\305\306D\"\210\211\307H\262@\232\203�\310\262\202�\211\207" [cl-struct-xref-elisp-location-tags nil xref-item-location type-of signal wrong-type-argument xref-elisp-location 1 t] 9 (#$ . 26014)])
#@77 For `elisp-xref-find-def-functions'; add overloads for SYMBOL.

(fn SYMBOL)
(defalias 'xref-mode-local-overload #[257 "\211\211\205
�\2119\205
�\211\305N\262\205\221\306\211K\"\307\310\311\312!\"!\211\205(�\306\211K\"\313C\313\314\315\316\317\320\321!\322\"\323\324%\"\210\325\242\326\"\240\210\242\211\203l\211@\211\211\313\327\312!\313\204q�\n\211\262\204q�	\262\205o�\307\"\262\203\234�\211\204\234�\303N\203\213�\307\303N\"\211\262\204q�\211\330N\206\225�\211\331N\262\262\202q�\266\203\211\262\205\260�\211\203\256�N\205\260�J\266\203\206%\211\211\332N\262\205%\211\211\332N\262\313\327\312!\313\204\344�\n\211\262\204\344�	\262\205\342�\307\"\262\203\211\204\303N\203\376�\307\303N\"\211\262\204\344�\211\330N\206\211\331N\262\262\202\344�\266\203\211\262\205#\211\203!N\205#J\266\203\262\211\2050\306\211K\"\203b\211\203b	B\310\f\333\334\312!\335\312	!GT[#	$\336\"\204`\337\333$B\262\266)\266A\266\202\202F�\210\340!\203\200\203\200\337\313#B\262\203\217\337\341#B\262\266\204\207" [obarray major-mode mode-local-active-mode mode-local-symbol-table elisp--xref-format-extra mode-local-overload find-lisp-object-file-name intern-soft format "%s-default" symbol-name nil mapatoms make-byte-code 257 "\211\301N\205\f�\300\300\242B\240\207" vconcat vector [mode-local-symbol-table] 4 "\n\n(fn SYM)" sort #[514 "\211\300N\232?\207" [mode-local-parent] 5 "\n\n(fn A B)"] override-flag mode-local-parent derived-mode-parent mode-local--overload-obsolete define-mode-local-override substring 0 xref-mode-local--override-present elisp--xref-make-xref functionp define-overloadable-function] 20 (#$ . 26385)])
(add-hook 'elisp-xref-find-def-functions 'xref-mode-local-overload)
#@108 Regexp used by `xref-find-definitions' when searching for a
  mode-local overloadable function definition.
(defconst xref-mode-local-find-overloadable-regexp "(define-overload\$able-function\$? +%s" (#$ . 28179))
#@186 Function used by `xref-find-definitions' when searching for an
  override of a mode-local overloadable function.
META-NAME is a cons (OVERLOADABLE-SYMBOL . MAJOR-MODE).

(fn META-NAME)
(defalias 'xref-mode-local-find-override #[257 "\211@A\300\301\302\303!\304\303!GT[##\305\306\307#\207" [format "(define-mode-local-override +%s +%s" substring symbol-name 0 re-search-forward nil t] 10 (#$ . 28401)])
(byte-code "\300\301\302\"\210\300\301\303\304B\"\207" [add-to-list find-function-regexp-alist (define-overloadable-function . xref-mode-local-find-overloadable-regexp) define-mode-local-override xref-mode-local-find-override] 4)
#@40 Print the SYMBOL binding.

(fn SYMBOL)
(defalias 'mode-local-print-binding #[257 "\211J\300\301\302\"!\210\211\203�\2119\203�\300\301\303\"!\210\202*�`\304!\210\212\211b\210\305 \210)\210n\2061�\300\306!\207" [princ format-message "\n     `%s' value is\n       " "`%s'" pp indent-sexp "\n"] 6 (#$ . 29045)])
#@38 Print bindings in TABLE.

(fn TABLE)
(defalias 'mode-local-print-bindings #[257 "\300C\300C\300C\300C\300C\301\302\303\304\305\306\n\n\n\n\n%\307\"\310\311%\"\210\242\2034�\312\313!\210\314\315\242\"\210\242\203C�\312\316!\210\314\315\242\"\210\242\203R�\312\317!\210\314\315\242\"\210\211\242\203a�\312\320!\210\314\315\242\"\210\242\205o�\312\321!\210\314\315\242\"\207" [nil mapatoms make-byte-code 257 "\211\305N\203�\211\306N\203�\301\301\242B\240\207\302\302\242B\240\207\211\307N\2034�\211\306N\203-�\304\304\242B\240\207\303\303\242B\240\207\300\300\242B\240\207" vconcat vector [mode-variable-flag constant-flag override-flag] 4 "\n\n(fn S)" princ "\n  !! Unspecified symbols\n" mapc mode-local-print-binding "\n  ** Mode local constants\n" "\n  ** Mode local variables\n" "\n  ** Final overloaded functions\n" "\n  ** Overloaded functions\n"] 17 (#$ . 29364)])
#@76 Display mode local bindings active in BUFFER-OR-MODE.

(fn BUFFER-OR-MODE)
(defalias 'mode-local-describe-bindings-2 #[257 "\302\211\303\304!\210\305!\203!�rq\210\262	\262)\303\306\307\"!\210\202:�9\2033�\262\303\310\311\"!\210\202:�\312\313\314D\"\210\203F�\303\315!\210\316!\210\211\205o�\211\300N\262\203^�\303\310\317\"!\210\316!\210\211\211\320N\206h�\211\321N\262\262\202F�\207" [mode-local-symbol-table major-mode nil princ "Mode local bindings active in " bufferp format "%S\n" format-message "`%s'\n" signal wrong-type-argument buffer-or-mode "\n- Buffer local\n" mode-local-print-bindings "\n- From `%s'\n" mode-local-parent derived-mode-parent] 7 (#$ . 30265)])
#@193 Display mode local bindings active in BUFFER-OR-MODE.
Optional argument INTERACTIVE-P is non-nil if the calling command was
invoked interactively.

(fn BUFFER-OR-MODE &optional INTERACTIVE-P)
(defalias 'mode-local-describe-bindings-1 #[513 "\306\307!\203
�\307\310D\"\210r\311\312 !q\210p\313 \210\314\211\315\211\315\316 \210\317\320!\210+\211rq\210\321!)\322!\210)\207" [default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only fboundp help-setup-xref mode-local-describe-bindings-1 get-buffer-create help-buffer kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook mode-local-describe-bindings-2 internal-temp-output-buffer-show standard-output] 8 (#$ . 30964)])
#@60 Display mode local bindings active in BUFFER.

(fn BUFFER)
(defalias 'describe-mode-local-bindings #[257 "\300!\211\262\205�\301\302\303!\"\207" [get-buffer mode-local-describe-bindings-1 called-interactively-p any] 5 (#$ . 31733) "b"])
#@66 Display mode local bindings active in MODE hierarchy.

(fn MODE)
(defalias 'describe-mode-local-bindings-in-mode #[257 "\300!\211\262\205�\301\302\303!\"\207" [intern-soft mode-local-describe-bindings-1 called-interactively-p any] 5 (#$ . 31980) (byte-code "\302\303\304\305\306	!%C\207" [obarray major-mode completing-read "Mode: " #[257 "\211\300N\207" [mode-local-symbol-table] 3 "\n\n(fn S)"] t symbol-name] 7)])
(byte-code "\300\301\302\"\210\300\303\304\"\210\305\306!\207" [add-hook find-file-hook mode-local-post-major-mode-change change-major-mode-hook mode-local-on-major-mode-change provide mode-local] 3)

${this.title}

Code Editor : mode-local.elc