Current File : //proc/thread-self/root/kunden/usr/share/emacs/27.2/lisp/emacs-lisp/lisp-mode.elc

;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.

;;; This file contains utf-8 non-ASCII characters,
;;; and so cannot be loaded into Emacs 22 or earlier.
(and (boundp 'emacs-version)
     (< (aref emacs-version (1- (length emacs-version))) ?A)
     (string-lessp emacs-version "23")
     (error "`%s' was compiled for Emacs 23 or later" #$))

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


(define-abbrev-table 'lisp-mode-abbrev-table nil "Abbrev table for Lisp mode.")
#@41 Parent syntax table used in Lisp modes.
(defvar lisp--mode-syntax-table (byte-code "\300 \301\211\302W\203\303
\304#\210\211T\262
\202\305\262
\211\306W\203,\303
\304#\210\211T\262
\202\307\262
\211\310W\203B\303
\304#\210\211T\262
\202/\311\262
\211\312W\203X\303
\304#\210\211T\262
\202E\303\313\314#\210\303\315\314#\210\303\316\314#\210\303\317\314#\210\303\320\321#\210\303\322\323#\210\303\324\325#\210\303\326\325#\210\303\327\325#\210\303\330\331#\210\303\332\304#\210\303\333\325#\210\303\334\335#\210\303\336\337#\210\303\340\341#\210\303\342\343#\210
\207" [make-syntax-table 0 48 modify-syntax-entry "_   " 58 65 91 97 123 128 32 "    " 160 9 12 10 ">   " 59 "<   " 96 "'   " 39 44 64 "_ p" 46 35 34 "\"    " 92 "\\   " 40 "()  " 41 ")(  "] 6) (#$ . 488))
#@35 Syntax table used in `lisp-mode'.
(defvar lisp-mode-syntax-table (byte-code "\301!\302\303\304#\210\302\305\304#\210\302\306\307#\210\302\310\311#\210\211\207" [lisp--mode-syntax-table make-syntax-table modify-syntax-entry 91 "_   " 93 35 "' 14" 124 "\" 23bn"] 5) (#$ . 1293))
(defconst lisp-mode-symbol-regexp "\\(?:\\sw\\|\\s_\\|\\\\.\\)+")
#@74 Imenu generic expression for Lisp mode.  See `imenu-generic-expression'.
(defvar lisp-imenu-generic-expression (byte-code "\301\302\303\304Q!\305E\302\306!\302\307\304Q!\305E\302\306!\302\310\311Q!\312E\302\313!\302\314\304Q!\305EF\207" [lisp-mode-symbol-regexp nil purecopy "^\\s-*(\\(cl-def\\(?:generic\\|ine-compiler-macro\\|m\\(?:acro\\|ethod\\)\\|subst\\|un\\)\\|def\\(?:advice\\|generic\\|ine-\\(?:advice\\|compil\\(?:ation-mode\\|er-macro\\)\\|derived-mode\\|g\\(?:\\(?:eneric\\|lobal\\(?:\\(?:ized\\)?-minor\\)\\)-mode\\)\\|inline\\|m\\(?:ethod-combination\\|inor-mode\\|odify-macro\\)\\|s\\(?:etf-expander\\|keleton\\)\\)\\|m\\(?:acro\\|ethod\\)\\|s\\(?:etf\\|ubst\\)\\|un\\*?\\)\\|ert-deftest\\)\\s-+\\(" "\\)" 2 "Variables" "^\\s-*(\\(def\\(?:c\\(?:onst\\(?:ant\\)?\\|ustom\\)\\|ine-symbol-macro\\|parameter\\)\\)\\s-+\\(" "^\\s-*(defvar\\(?:-local\\)?\\s-+\\(" "\\)[[:space:]\n]+[^)]" 1 "Types" "^\\s-*(\\(cl-def\\(?:struct\\|type\\)\\|def\\(?:class\\|face\\|group\\|ine-\\(?:condition\\|error\\|widget\\)\\|package\\|struct\\|t\\(?:\\(?:hem\\|yp\\)e\\)\\)\\)\\s-+'?\\("] 8) (#$ . 1647))
(byte-code "\300\301\302\303#\210\300\304\302\303#\210\300\305\302\303#\210\300\306\302\303#\210\300\307\302\303#\210\300\310\302\303#\210\300\311\302\312#\210\300\313\302\303#\210\300\314\302\303#\207" [put autoload doc-string-elt 3 defmethod defvar defconst defalias defvaralias define-category 2 defconstant defparameter] 4)
#@61 The symbol property that holds the docstring position info.
(defvar lisp-doc-string-elt-property 'doc-string-elt (#$ . 3085))
#@54 Alist of symbol/"pretty" characters to be displayed.
(defconst lisp-prettify-symbols-alist '(("lambda" . 955)) (#$ . 3217))
#@14 

(fn LIMIT)
(defalias 'lisp--match-hidden-arg #[257 "\300\301\302 \303 \304#\305\306!\210\211@\307Y\204\310\311!\203\"\312y\210`W\202-\310\313!\210\312y\210`\262\300\262
\204
\211\207" [nil parse-partial-sexp line-beginning-position line-end-position -1 skip-syntax-forward " )" 0 looking-at ";\\|$" 1 ".*"] 6 (#$ . 3347)])
#@73 Heuristically determine whether POS is an evaluated position.

(fn POS)
(defalias 'lisp--el-non-funcall-position-p #[257 "\300 \301\302\303\304\305!\306\"\307$\216\212\3101\224
b\210\311`Sf\312\"\206\220\313 \314
8\211\205k\315
!@b\210\3161M\311\317f\320\"\205I\211A\205I\315
\321\"@b\210\322\323!0\202Q\210\202\\\203\\\302\225b\210\324\202k\322\325!\205k\326\327\330!!\330\225b\210\211\331=\206\216\211\324=\203\201\332\330!\210`W\206\216\211\333=\205\216\332\321!\210`W\266\2030\202\226\210\317*\207" [match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 (error) eql 39 syntax-ppss 9 last (error) nil 40 2 looking-at "(\\_<let\\*?\\_>" let "(\\(?1:\\(?:\\sw\\|\\s_\\)+\\)\\_>" intern-soft match-string-no-properties 1 declare forward-sexp condition-case] 8 (#$ . 3685)])
#@14 

(fn LIMIT)
(defalias 'lisp--el-match-keyword #[257 "\30024\301\302\303#\2053\304\305\306!!\307
!\204*\310
!\203/\211\311N\204/\312\313\224!\204/\314\300\303\"\210\210\2020\207" [found re-search-forward "(\\(\\(?:\\sw\\|\\s_\\|\\\\.\\)+\\)\\_>" t intern-soft match-string 1 special-form-p macrop no-font-lock-keyword lisp--el-non-funcall-position-p 0 throw] 5 (#$ . 4523)])
#@238 Like `let*', but allow for compile time optimization.
Use BINDINGS as in regular `let*', but in BODY each usage should
be wrapped in `eval-when-compile'.
This will generate compile-time constants from BINDINGS.

(fn BINDINGS &rest BODY)
(defalias 'let-when-compile '(macro . #[385 "\300C\211\301\302\303\304\305\"\306\"\307\310%\240\210\211\242!\207" [nil make-byte-code 257 "\211C\211\242\204\303\304\300!\n\"\202Z\211\242
\211\242A\240\210\242\211@C\305A@\306\"C\307\310\311\312\313\301	\"\314\"\315$\316\203K\211A\262\242\317\211A\262\242DD
B\262
\2021\305\320\321\317DDE!\266\204\262
\207" vconcat vector [macroexpand-all-environment macroexpand-all macroexp-progn eval t make-byte-code 0 "\300\242\301\242!\207" vconcat vector [] 2 nil quote let funcall] 13 "\n\n(fn BINDINGS)"] 11 (#$ . 4914)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put let-when-compile lisp-indent-function 1 put edebug-form-spec let] 5)
(defalias 'elisp--font-lock-backslash #[0 "\301\224\301\225\212\302!)\303
8\205G\304
8?\205G\206`Sf\305=?\205G\30617\307\310\311\312\"\"!@0\2029\210\313\312T\"\232\205G\314\315BB\207" [font-lock-warning-face 0 syntax-ppss 3 5 10 (error) read-from-string format "\"%s\"" buffer-substring-no-properties nil face (help-echo "This \\ has no effect")] 9])
#@14 

(fn LIMIT)
(defalias 'lisp--match-confusable-symbol-character #[257 "\3012@\302\303#\2038\304 \305\306\307\310\311!\312\"\313$\216\306\224\206 `Sf\314=\2043\315\316 8\2043\317\301\303\"\210)\210\202\317\301\320\"\210\202\207" [help-uni-confusables-regexp matched re-search-forward t match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 92 8 syntax-ppss throw nil] 8 (#$ . 6245)])
(byte-code "\303\304\305\306\307\310\311\211\203\211@\312\313!\314\315#\210
A\266\202\202	\210\211\2035\211@\312\313!\314\316#\210
A\266\202\202 \210\317\320\301\321#\210\322\211\203^\211@\320
N\203W\301
N\204W\312\301\320N#\210
A\266\202\202=\210\323\320\301\324#\210\325\326\327\330\331\260\332B\333B!\210\334\326\327\330\331\260\335BC!\210\317\336\337\321#\210\340\211\203\255\211@\336
N\203\246\337
N\204\246\312\337\336N#\210
A\266\202\202\214\210\323\336\337\324#\210\341\342	\343\326\344Q\345B\346\347\331Q\350B\351\352Q\353B\354\355\356Q\357B\360\344Q\361B\362\344Q\363B\364\365B\366BBBBBBBBBB\"!\210\367\342\n\370\326\344Q\371B\372\331Q\373B\326\344Q\374B\355\356Q\375B\376\377Q\201@B\360\344Q\201AB\362\344Q\363B\201B\377Q\201CB\201DBBBBBBBBB\"!\266\317\201E\201F\321#\210\201G\211\203t
\211@\201E
N\203m
\201F
N\204m
\312\201F\201EN#\210
A\266\202\202K
\210\323\201E\201F\324#\207" [lisp-mode-symbol-regexp lisp-el-font-lock-keywords-1 lisp-cl-font-lock-keywords-1 ("defvar" "defconst" "defcustom" "defvaralias" "defvar-local" "defface" "define-symbol-macro" "defconstant" "defparameter") ("defgroup" "deftheme" "defclass" "defpackage" "defstruct" "deftype" "defstruct" "deftype" "cl-defstruct" "cl-deftype") "\\(cl-def\\(?:generic\\|m\\(?:acro\\|ethod\\)\\|s\\(?:\\(?:truc\\|ubs\\)t\\)\\|type\\|un\\)\\|def\\(?:a\\(?:dvice\\|lias\\)\\|c\\(?:lass\\|onst\\|ustom\\)\\|face\\|g\\(?:eneric\\|roup\\)\\|ine-\\(?:advice\\|derived-mode\\|g\\(?:\\(?:eneric\\|lobal\\(?:\\(?:ized\\)?-minor\\)\\)-mode\\)\\|inline\\|minor-mode\\|skeleton\\|widget\\)\\|m\\(?:acro\\|ethod\\)\\|subst\\|theme\\|un\\|var\\(?:-local\\|alias\\)?\\)\\|ert-deftest\\)" "\\(def\\(?:c\\(?:lass\\|onstant\\)\\|generic\\|ine-\\(?:co\\(?:mpiler-macro\\|ndition\\)\\|m\\(?:ethod-combination\\|odify-macro\\)\\|s\\(?:etf-expander\\|ymbol-macro\\)\\)\\|m\\(?:acro\\|ethod\\)\\|pa\\(?:ckage\\|rameter\\)\\|s\\(?:etf\\|\\(?:truc\\|ubs\\)t\\)\\|type\\|un\\|var\\)\\)" "\\(b\\(?:\\(?:loc\\|rea\\)k\\)\\|c\\(?:ase\\|case\\|o\\(?:mpiler-let\\|nd\\(?:ition-case\\)?\\)\\|typecase\\)\\|d\\(?:e\\(?:cla\\(?:im\\|re\\)\\|structuring-bind\\)\\|o\\(?:\\*\\|list\\|times\\)?\\)\\|e\\(?:case\\|typecase\\|val-when\\)\\|flet\\*?\\|go\\|handler-\\(?:bind\\|case\\)\\|i\\(?:f\\|gnore-errors\\|n-package\\)\\|l\\(?:a\\(?:bels\\|mbda\\)\\|et[*f]?\\|o\\(?:cally\\|op\\)\\)\\|m\\(?:acrolet\\|ultiple-value-\\(?:bind\\|prog1\\)\\)\\|pro\\(?:claim\\|g[*12nv]?\\)\\|re\\(?:start-\\(?:bind\\|case\\)\\|turn\\(?:-from\\)?\\)\\|symbol-macrolet\\|t\\(?:agbody\\|\\(?:h\\|ypecas\\)e\\)\\|un\\(?:less\\|wind-protect\\)\\|w\\(?:h\\(?:en\\|ile\\)\\|ith-\\(?:accessors\\|co\\(?:mpilation-unit\\|ndition-restarts\\)\\|hash-table-iterator\\|input-from-string\\|o\\(?:pen-\\(?:file\\|stream\\)\\|utput-to-string\\)\\|package-iterator\\|s\\(?:imple-restart\\|lots\\|tandard-io-syntax\\)\\)\\)\\)" "\\(cl-\\(?:assert\\|check-type\\)\\|error\\|signal\\|user-error\\|warn\\)" "\\(a\\(?:\\(?:bo\\|sse\\)rt\\)\\|c\\(?:error\\|heck-type\\)\\|error\\|signal\\|warn\\)" put intern lisp-define-type var type defvaralias lisp-font-lock-keywords-1 nil (saved-value saved-variable-comment) make-obsolete-variable "24.4" (lambda (#1=#:def-tmp-var) (defconst lisp-el-font-lock-keywords-1 #1# "Subdued level highlighting for Emacs Lisp mode.")) "(" "\\_>[ 	']*\\(([ 	']*\\)?\\(\\(setf\\)[ 	]+" "\\|" "\\)?" ((1 font-lock-keyword-face) (3 (let ((type (get (intern-soft (match-string 1)) 'lisp-define-type))) (cond ((eq type 'var) font-lock-variable-name-face) ((eq type 'type) font-lock-type-face) ((or (not (match-string 2)) (and (match-string 2) (match-string 4))) font-lock-function-name-face))) nil t)) (("^;;;###\\([-a-z]*autoload\\)" 1 font-lock-warning-face prepend)) (lambda (#1#) (defconst lisp-cl-font-lock-keywords-1 #1# "Subdued level highlighting for Lisp modes.")) ((1 font-lock-keyword-face) (3 (let ((type (get (intern-soft (match-string 1)) 'lisp-define-type))) (cond ((eq type 'var) font-lock-variable-name-face) ((eq type 'type) font-lock-type-face) ((or (not (match-string 2)) (and (match-string 2) (match-string 4))) font-lock-function-name-face))) nil t)) lisp-font-lock-keywords-2 lisp-el-font-lock-keywords-2 (saved-value saved-variable-comment) (lambda (#1#) (defconst lisp-el-font-lock-keywords-2 #1# "Gaudy level highlighting for Emacs Lisp mode.")) append ("\\[\\(\\^\\)" 1 font-lock-negation-char-face prepend) "\\_>" ((1 font-lock-warning-face)) (lisp--el-match-keyword . 1) "(\\(catch\\|throw\\|featurep\\|provide\\|require\\)\\_>[ 	']*\\(" ((1 font-lock-keyword-face) (2 font-lock-constant-face nil t)) "\\\\\\\\\\[\\(" "\\)\\]" ((1 font-lock-constant-face prepend)) ("\\(\\\\\\)\\([^\"\\]\\)" (1 (elisp--font-lock-backslash) prepend)) "[`‘]\\(\\(?:\\sw\\|\\s_\\|\\\\.\\)" "\\)['’]" ((1 font-lock-constant-face prepend)) "\\_<:" ((0 font-lock-builtin-face)) "\\_<\\&" font-lock-type-face #[257 "\30021\301\302\303#\2050\304\224\204\305`S\306\"\211<\203!\307
>\204'\211\307=\203,\310\300\303\"\210\210\2020\207" [found re-search-forward "\\(\\\\\\\\\\)\\(?:\\(\\\\\\\\\\)\\|\\((\\(?:\\?[0-9]*:\\)?\\|[|)]\\)\\)" t 2 get-text-property face font-lock-string-face throw] 5 "\n\n(fn BOUND)"] ((1 'font-lock-regexp-grouping-backslash prepend) (3 'font-lock-regexp-grouping-construct prepend)) ((lisp--match-hidden-arg (0 '(face font-lock-warning-face help-echo "Hidden behind deeper element; move to another line?"))) (lisp--match-confusable-symbol-character 0 '(face font-lock-warning-face help-echo "Confusable character"))) (lambda (#1#) (defconst lisp-cl-font-lock-keywords-2 #1# "Gaudy level highlighting for Lisp modes.")) ("\\[\\(\\^\\)" 1 font-lock-negation-char-face prepend) 1 "(\\(catch\\|throw\\|provide\\|require\\)\\_>[ 	']*\\(" ((1 font-lock-keyword-face) (2 font-lock-constant-face nil t)) ((1 font-lock-warning-face)) ((1 font-lock-constant-face prepend)) "\\(#:\\)\\(" "\\)" ((1 font-lock-comment-delimiter-face) (2 font-lock-doc-face)) ((0 font-lock-builtin-face)) "(\\(\\(do-\\|with-\\)" ((1 font-lock-keyword-face)) ((lisp--match-hidden-arg (0 '(face font-lock-warning-face help-echo "Hidden behind deeper element; move to another line?")))) lisp-font-lock-keywords lisp-el-font-lock-keywords (saved-value saved-variable-comment)] 21)
#@54 Default expressions to highlight in Emacs Lisp mode.
(defvar lisp-el-font-lock-keywords lisp-el-font-lock-keywords-1 (#$ . 12963))
#@49 Default expressions to highlight in Lisp modes.
(defvar lisp-cl-font-lock-keywords lisp-cl-font-lock-keywords-1 (#$ . 13100))
#@67 Default highlighting from Emacs Lisp mode used in Backtrace mode.
(defconst lisp-el-font-lock-keywords-for-backtraces lisp-el-font-lock-keywords (#$ . 13232))
#@67 Subdued highlighting from Emacs Lisp mode used in Backtrace mode.
(defconst lisp-el-font-lock-keywords-for-backtraces-1 lisp-el-font-lock-keywords-1 (#$ . 13397))
#@65 Gaudy highlighting from Emacs Lisp mode used in Backtrace mode.
(defconst lisp-el-font-lock-keywords-for-backtraces-2 (byte-code "\301\302\303\"\"\207" [lisp-el-font-lock-keywords-2 remove assoc lisp--match-hidden-arg] 4) (#$ . 13566))
#@169 Return true if a doc string may occur at STARTPOS inside a list.
LISTBEG is the position of the start of the innermost list
containing STARTPOS.

(fn LISTBEG STARTPOS)
(defalias 'lisp-string-in-doc-position-p #[514 "
\205\212
b\210\301\302!\205\303\304!)\211\205\305\306!\"\211\205m\212\307
!\203/\304\225b\210\211 \262
b\210\304u\210\3101T\211\311V\205P`W\205P\312\304!\210\211S\262
\20290\202X\210\202Y\210\211\311U\205l`X\205l\313d!\210`U)\207" [lisp-doc-string-elt-property looking-at "([ 	\n]*\\(\\(?:\\sw\\|\\s_\\|\\\\.\\)+\\)" match-string 1 function-get intern-soft functionp (error) 0 forward-sexp forward-comment] 6 (#$ . 13811)])
#@175 Return true if `:documentation' symbol ends at STARTPOS inside a list.
LISTBEG is the position of the start of the innermost list
containing STARTPOS.

(fn LISTBEG STARTPOS)
(defalias 'lisp-string-after-doc-keyword-p #[514 "
\205\212\211b\210\3001\301\302!\210\303\304!0\202\210\305)\207" [(error) backward-sexp 1 looking-at ":documentation\\_>" nil] 4 (#$ . 14481)])
#@195 Return syntactic face function for the position represented by STATE.
STATE is a `parse-partial-sexp' state, and the returned function is the
Lisp font lock syntactic face function.

(fn STATE)
(defalias 'lisp-font-lock-syntactic-face-function #[257 "\303
8\203*\304
8\211f\305=?\205)
A@\306
\"\204\"\307
\"\203&\202'	\262
\207\n\207" [font-lock-doc-face font-lock-string-face font-lock-comment-face 3 8 124 lisp-string-in-doc-position-p lisp-string-after-doc-keyword-p] 6 (#$ . 14862)])
#@72 Return fill prefix found at point.
Value for `adaptive-fill-function'.
(defalias 'lisp-adaptive-fill #[0 "\300\301!\205\302\207" [looking-at "\\s-+\"[^\n\"]+\"\\s-*$" ""] 2 (#$ . 15364)])
#@343 Common initialization routine for lisp modes.
The LISP-SYNTAX argument is used by code in inf-lisp.el and is
(uselessly) passed from pp.el, chistory.el, gnus-kill.el and
score-mode.el.  KEYWORDS-CASE-INSENSITIVE non-nil means that for
font-lock keywords will not be case sensitive.

(fn &optional LISP-SYNTAX KEYWORDS-CASE-INSENSITIVE ELISP)
(defalias 'lisp-mode-variables #[768 "\203\306!\210\307\301!\210\310\307\302!\210\311\307\303!\210\312\307\304!\210\313\307\305!\210\314\307\315!\210\316
\307\317!\210\320\307\321!\210\322\307\323!\210\324\307\325!\210\326\307\327!\210\330\307\331!\210\332\307\333!\210\334\307\335!\210\310\307\336!\210(\307\337!\210\310\211\203|\340\202}\341\342\343BBB)\307\344!\210*$\307\345!\210\346%\307\347!\210\342\211'\207" [lisp-mode-syntax-table paragraph-ignore-fill-prefix fill-paragraph-function adaptive-fill-function indent-line-function indent-region-function set-syntax-table make-local-variable t lisp-fill-paragraph lisp-adaptive-fill lisp-indent-line lisp-indent-region comment-indent-function lisp-comment-indent outline-regexp ";;;\\(;* [^ 	\n]\\|###autoload\\)\\|(" outline-level lisp-outline-level add-log-current-defun-function lisp-current-defun-name comment-start ";" comment-start-skip ";+ *" comment-add 1 comment-column 40 comment-use-syntax imenu-generic-expression multibyte-syntax-as-symbol (lisp-el-font-lock-keywords lisp-el-font-lock-keywords-1 lisp-el-font-lock-keywords-2) (lisp-cl-font-lock-keywords lisp-cl-font-lock-keywords-1 lisp-cl-font-lock-keywords-2) nil (nil nil (font-lock-mark-block-function . mark-defun) (font-lock-extra-managed-props help-echo) (font-lock-syntactic-face-function . lisp-font-lock-syntactic-face-function)) prettify-symbols-alist electric-pair-skip-whitespace chomp electric-pair-open-newline-between-pairs lisp-imenu-generic-expression font-lock-defaults lisp-prettify-symbols-alist] 7 (#$ . 15561)])
#@37 Lisp mode `outline-level' function.
(defalias 'lisp-outline-level #[0 "\300\225\300\224Z\301\302!\203\303\202\211\207" [0 looking-at "(\\|;;;###autoload" 1000] 3 (#$ . 17503)])
#@48 Return the name of the defun at point, or nil.
(defalias 'lisp-current-defun-name #[0 "\212`m\204	\300u\210\301 \210\302\303!\205>\304 \210\211`W\205>\305\306!\210\211`Y\205>\302\303!\203.\300u\210\305\300!\210\307\310w\210\311`\305\300!\210`\"\262
)\207" [1 beginning-of-defun looking-at "\\s(" end-of-defun forward-sexp -1 " 	\n'(" nil buffer-substring-no-properties] 5 (#$ . 17690)])
#@56 Keymap for commands shared by all sorts of Lisp modes.
(defvar lisp-mode-shared-map (byte-code "\301 \302
\"\210\303
\304\305#\210\303
\306\307#\210\211\207" [prog-mode-map make-sparse-keymap set-keymap-parent define-key "" indent-sexp "" backward-delete-char-untabify] 5) (#$ . 18088))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\210\300\314\302\303\315DD\316\306\317\310\311\312\313&	\207" [custom-declare-variable lisp-mode-hook funcall function #[0 "\300\207" [nil] 1] "Hook run when entering Lisp mode." :options (imenu-add-menubar-index) :type hook :group lisp lisp-interaction-mode-hook #[0 "\300\207" [nil] 1] "Hook run when entering Lisp Interaction mode." (eldoc-mode)] 10)
#@98 Keymap for ordinary Lisp mode.
All commands in `lisp-mode-shared-map' are inherited by this map.
(defvar lisp-mode-map (byte-code "\301 \301\302!\303\"\210\304\305\306#\210\304\307\310#\210\311\312\302B#\210\311
\313\314#\210\311
\315\316#\210\311
\317\320#\210
\207" [lisp-mode-shared-map make-sparse-keymap "Lisp" set-keymap-parent define-key "" lisp-eval-defun "" run-lisp bindings--define-key [menu-bar lisp] [run-lisp] (menu-item "Run inferior Lisp" run-lisp :help "Run an inferior Lisp process, input and output via buffer `*inferior-lisp*'") [ev-def] (menu-item "Eval defun" lisp-eval-defun :help "Send the current defun to the Lisp process made by M-x run-lisp") [ind-sexp] (menu-item "Indent sexp" indent-sexp :help "Indent each line of the list starting just after point")] 7) (#$ . 18803))
(defvar lisp-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [lisp-mode-hook variable-documentation put "Hook run after entering Lisp mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp lisp-mode-map definition-name lisp-mode] 4)
(defvar lisp-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [lisp-mode-abbrev-table lisp-mode-map variable-documentation put purecopy "Keymap for `lisp-mode'." boundp lisp-mode-syntax-table definition-name lisp-mode (lambda (#1=#:def-tmp-var) (defvar lisp-mode-syntax-table #1#)) make-syntax-table "Syntax table for `lisp-mode'." (lambda (#1#) (defvar lisp-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `lisp-mode'." derived-mode-parent prog-mode] 5)
#@485 Major mode for editing Lisp code for Lisps other than GNU Emacs Lisp.
Commands:
Delete converts tabs to spaces as it moves back.
Blank lines separate paragraphs.  Semicolons start comments.

\{lisp-mode-map}
Note that `run-lisp' may be used either to start an inferior Lisp job
or to switch back to an existing one.

In addition to any hooks its parent mode `prog-mode' might have run,
this mode runs the hook `lisp-mode-hook', as the final or penultimate step
during initialization.
(defalias 'lisp-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324
\325\"\204R
!=\204R\326
\325!C#\210\327!\210\330\f!\210
!\331\332\307\"\210\306\333!\210\334\306\335!\210\336\307\")\337\340!\207" [delay-mode-hooks major-mode mode-name lisp-mode-map lisp-mode-syntax-table lisp-mode-abbrev-table make-local-variable t prog-mode lisp-mode "Lisp" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table lisp-mode-variables nil find-tag-default-function lisp-find-tag-default comment-start-skip "\\(\\(^\\|[^\\\\\n]\\)\\(\\\\\\\\\\)*\\)\\(;+\\|#|\\) *" run-mode-hooks lisp-mode-hook local-abbrev-table imenu-case-fold-search] 5 (#$ . 20729) nil])
(defalias 'lisp-find-tag-default #[0 "\300 \211;\205\301\302\"\203\303
\304\225\"\202\211\207" [find-tag-default string-match ":+" substring 0] 4])
(byte-code "\300\301\302\"\210\303\304\305\306\307$\207" [defalias common-lisp-mode lisp-mode autoload lisp-eval-defun "inf-lisp" nil t] 5)
#@70 Like `comment-indent-default', but don't put space after open paren.
(defalias 'lisp-comment-indent #[0 "\300\301!\203 `\302\303!\210h\304=\203iiB\202\211b\210\305\262
\206\"\306 \207" [looking-at "\\s<\\s<" skip-syntax-backward " " 40 nil comment-indent-default] 3 (#$ . 22452)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\210\306\307\310\311\312DD\313\314\315\316\317&\210\320\307\321\322#\210\306\323\310\311\324DD\325\316\311\314\315&\207" [defalias lisp-mode-auto-fill do-auto-fill nil make-obsolete "23.1" custom-declare-variable lisp-indent-offset funcall function #[0 "\300\207" [nil] 1] "If non-nil, indent second line of expressions that many more columns." :group lisp :type (choice (const nil) integer) put safe-local-variable #[257 "\211?\206\211\250\207" [] 2 "\n\n(fn X)"] lisp-indent-function #[0 "\300\207" [lisp-indent-function] 1] "A function to be called by `calculate-lisp-indent'.\nIt indents the arguments of a Lisp function call.  This function\nshould accept two arguments: the indent-point, and the\n`parse-partial-sexp' state at that position.  One option for this\nfunction is `common-lisp-indent-function'."] 8)
#@269 Return Parse-Partial-Sexp State at POS, defaulting to point.
Like `syntax-ppss' but includes the character address of the last
complete sexp in the innermost containing list at position
2 (counting from 0).  This is important for lisp indentation.

(fn &optional POS)
(defalias 'lisp-ppss #[256 "\211\204`\262
\300
!\301
8\203%\302\3018!@\303
\304\211\300!%\262
\202&\211\207" [syntax-ppss 9 last parse-partial-sexp nil] 10 (#$ . 23618)])
#@76 compiler-macro for inlining `lisp-indent-state-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'lisp-indent-state-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block lisp-indent-state-p (and (memq (type-of cl-x) cl-struct-lisp-indent-state-tags) t)) nil] 9 (#$ . 24071)])
(put 'lisp-indent-state-p 'compiler-macro 'lisp-indent-state-p--cmacro)
#@13 

(fn CL-X)
(defalias 'lisp-indent-state-p #[257 "\301
!>\205	\302\207" [cl-struct-lisp-indent-state-tags type-of t] 3 (#$ . 24448)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put lisp-indent-state-p side-effect-free error-free put lisp-indent-state cl-deftype-satisfies] 5)
#@80 compiler-macro for inlining `lisp-indent-state-stack'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'lisp-indent-state-stack--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block lisp-indent-state-stack (progn (or (lisp-indent-state-p cl-x) (signal 'wrong-type-argument (list 'lisp-indent-state cl-x))) (aref cl-x 1))) nil] 9 (#$ . 24751)])
(put 'lisp-indent-state-stack 'compiler-macro 'lisp-indent-state-stack--cmacro)
#@68 Access slot "stack" of `lisp-indent-state' struct CL-X.

(fn CL-X)
(defalias 'lisp-indent-state-stack #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-lisp-indent-state-tags type-of signal wrong-type-argument lisp-indent-state 1] 5 (#$ . 25200)])
(byte-code "\300\301\302\303#\300\207" [function-put lisp-indent-state-stack side-effect-free t] 4)
#@79 compiler-macro for inlining `lisp-indent-state-ppss'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'lisp-indent-state-ppss--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block lisp-indent-state-ppss (progn (or (lisp-indent-state-p cl-x) (signal 'wrong-type-argument (list 'lisp-indent-state cl-x))) (aref cl-x 2))) nil] 9 (#$ . 25571)])
(put 'lisp-indent-state-ppss 'compiler-macro 'lisp-indent-state-ppss--cmacro)
#@67 Access slot "ppss" of `lisp-indent-state' struct CL-X.

(fn CL-X)
(defalias 'lisp-indent-state-ppss #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-lisp-indent-state-tags type-of signal wrong-type-argument lisp-indent-state 2] 5 (#$ . 26015)])
(byte-code "\300\301\302\303#\300\207" [function-put lisp-indent-state-ppss side-effect-free t] 4)
#@85 compiler-macro for inlining `lisp-indent-state-ppss-point'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'lisp-indent-state-ppss-point--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block lisp-indent-state-ppss-point (progn (or (lisp-indent-state-p cl-x) (signal 'wrong-type-argument (list 'lisp-indent-state cl-x))) (aref cl-x 3))) nil] 9 (#$ . 26383)])
(put 'lisp-indent-state-ppss-point 'compiler-macro 'lisp-indent-state-ppss-point--cmacro)
#@73 Access slot "ppss-point" of `lisp-indent-state' struct CL-X.

(fn CL-X)
(defalias 'lisp-indent-state-ppss-point #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-lisp-indent-state-tags type-of signal wrong-type-argument lisp-indent-state 3] 5 (#$ . 26857)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put lisp-indent-state-ppss-point side-effect-free t defalias copy-lisp-indent-state copy-sequence] 4)
#@54 Constructor for objects of type `lisp-indent-state'.
(defalias 'lisp-indent-initial-state #[0 "\300 `\301@T\302\"\303\304$\207" [lisp-ppss make-list nil record lisp-indent-state] 8 (#$ . 27299)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put lisp-indent-initial-state side-effect-free t cl-struct-define lisp-indent-state nil cl-structure-object record ((cl-tag-slot) (stack) (ppss) (ppss-point)) cl-struct-lisp-indent-state-tags] 11)
#@240 Move to next line and return calculated indent for it.
STATE is updated by side effect, the first state should be
created by `lisp-indent-initial-state'.  This function may move
by more than one line to cross a string literal.

(fn STATE)
(defalias 'lisp-indent-calc-next #[257 "\211\301H
\302H\303H\211
@\211\3028\304\305\210`\305\211	%\262\3028\2048
@U\2038AA\211\240\266\202=\3028\262
@\262m?\205I\3038\262
\203o\3068\304`d\305\211	\307&\262AA\211\240\266@\266\202`\262\202`\262\211Z\211\310W\203\204\211[\233\262\202\222\211\310V\203\222\311
\305\"\244\262\210\305\301y\301U\203\237\305\202\322\204\255\304``\"\211\262\202\322@\206\322\312!\211\262\250\203\305\211\240\262
\202\322\211:\203\317\211@\202\322\313\314!\262
\315\n!>\204\345\316\317\320\fD\"\210	\211\301I\266\315\n!>\204\377\316\317\320\fD\"\210	\211\303I\266\315\n!>\204
\316\317\320\fD\"\210	\211\302I\266\266\202\266\203\207" [cl-struct-lisp-indent-state-tags 1 2 3 parse-partial-sexp nil 8 syntax-table 0 make-list calculate-lisp-indent error "This shouldn't happen" type-of signal wrong-type-argument lisp-indent-state] 17 (#$ . 27790)])
#@58 Indent region as Lisp code, efficiently.

(fn START END)
(defalias 'lisp-indent-region #[514 "\212\301
!\262

b\210\302 \210\303 \304 ?\205\305\306`#\307!>\204(\310\311\312D\"\210
\313Hn\2033l\204?\314
8\204?\315\316!!\210\210\317\320!\262
`W\203zn\203Tl\204\\\211\203\\\315
!\210
\203A
`\317
\247\203o
@Y\203u\321#\210\266\202A\210\211\203\203\322
!\210\317\211\223\266\202)\207" [cl-struct-lisp-indent-state-tags copy-marker beginning-of-line lisp-indent-initial-state minibufferp make-progress-reporter "Indenting region..." type-of signal wrong-type-argument lisp-indent-state 2 3 lisp-indent-line calculate-lisp-indent nil lisp-indent-calc-next progress-reporter-do-update progress-reporter-done] 12 (#$ . 28990)])
#@58 Indent current line as Lisp code.

(fn &optional INDENT)
(defalias 'lisp-indent-line #[256 "d`Z\300 \210
\206\301\302 !\303\304w\210\211\203\305\306!\203#dZb\202Q\305\307!\2038\305\310!\2048\311 \210\312u\210\202E\211<\203A\211@\262
\313
!\210dZ`V\205QdZb\207" [beginning-of-line calculate-lisp-indent lisp-ppss " 	" nil looking-at "\\s<\\s<\\s<" "\\s<" "\\s<\\s<" indent-for-comment -1 indent-line-to] 5 (#$ . 29744) nil])
#@744 Return appropriate indentation for current line as Lisp code.
In usual case returns an integer: the column to indent to.
If the value is nil, that means don't change the indentation
because the line starts inside a string.

PARSE-START may be a buffer position to start parsing from, or a
parse state as returned by calling `parse-partial-sexp' up to the
beginning of the current line.

The value can also be a list of the form (COLUMN CONTAINING-SEXP-START).
This means that following lines at the same level of indentation
should not necessarily be indented the same as this line.
Then COLUMN is the column to indent to, and CONTAINING-SEXP-START
is the buffer position of the start of the containing expression.

(fn &optional PARSE-START)
(defalias 'calculate-lisp-indent #[256 "\212\304 \210`\305\211\306\305\211
\307!\204\250\203 b\210\202/\204+\310 \210\202/\262\204E`W\203E\311`\312#\262\2023\203\205\203\205\312\234\312V\203\205\305\262\313\234\314\234\262
\211Tb\210\203E`V\203E\311\312#\211A@\211\262\203\201\211\262\210\202E\204\326\211Tb\210\204\227i\262\202\326\311`\312\306$\210\315\316!\204\326\212\314y\210`)V\203\306`U\204\300\317\314!\210\311`\312\306$\210\320 \210\202\326b\210\304 \210\311`\312\306$\210\320 \210i\321\234\203\341\305\202\214
	\250\203\363
\203\363
b\210i	\\\202\214
\203\207
\n\203
\204
\n\"\206\214
\212b\210\322\305w\210\315\323!)\203\203
\212b\210\320 \210\324\325\326 \"\204<

\2032

T`Y\204<
\317\327!\210\320 \210\202
`\211)\203\203
\212Tb\210\311`\312\306$\210`)V\203\203
\306\305
b\210\315\323!\203j
i\211\262\204}
\326 \330 \210`W\203}
\315\323!\203}
i\262
)\262
\206\214
\211\202\214
\206\214
\211\262
)\266\206)\207" [calculate-lisp-indent-last-sexp lisp-indent-offset lisp-indent-function parse-sexp-ignore-comments beginning-of-line nil t markerp beginning-of-defun parse-partial-sexp 0 2 1 looking-at "\\s(" forward-sexp backward-prefix-chars 3 " 	" ":" looking-back "^[ 	]*\\|([ 	]+" line-beginning-position -1 backward-sexp] 14 (#$ . 30189)])
#@1247 This function is the normal value of the variable `lisp-indent-function'.
The function `calculate-lisp-indent' calls this to determine
if the arguments of a Lisp function call should be indented specially.

INDENT-POINT is the position at which the line being indented begins.
Point is located at the point to indent under (for default indentation);
STATE is the `parse-partial-sexp' state for that position.

If the current line is in a call to a Lisp function that has a non-nil
property `lisp-indent-function' (or the deprecated `lisp-indent-hook'),
it specifies how to indent.  The property value can be:

* `defun', meaning indent `defun'-style
  (this is also the case if there is no property and the function
  has a name that begins with "def", and three or more arguments);

* an integer N, meaning indent the first N arguments specially
  (like ordinary function arguments), and then indent any further
  arguments like a body;

* a function to call that returns the indentation (or nil).
  `lisp-indent-function' calls this function with the same two arguments
  that it itself received.

This function returns either the indentation to use, or nil if the
Lisp function does not specify a special indentation.

(fn INDENT-POINT STATE)
(defalias 'lisp-indent-function #[514 "i
\301\234Tb\210\302`\303\304$\210
\305\234\2039\306\307!\2049\212\301y\210`)V\2042b\210\310 \210\302`\303\304$\210\311 \210i\202\213`\312\301!\210`{\313\314\315!\316\"\206O\315!\317N\262
\211\320=\204i\211\204q
G\321V\203q\322\323\"\203q\324\"\202\211\211\250\203\201\325
$\202\211\211\205\211\211\"\266\202\207" [calculate-lisp-indent-last-sexp 1 parse-partial-sexp 0 t 2 looking-at "\\sw\\|\\s_" beginning-of-line backward-prefix-chars forward-sexp nil function-get intern-soft lisp-indent-function lisp-indent-hook defun 3 string-match "\\`def" lisp-indent-defform lisp-indent-specform] 10 (#$ . 32282)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\312\301\313\314#\207" [custom-declare-variable lisp-body-indent funcall function #[0 "\300\207" [2] 1] "Number of columns to indent the second line of a `(def...)' form." :group lisp :type integer put safe-local-variable integerp] 8)
#@47 

(fn COUNT STATE INDENT-POINT NORMAL-INDENT)
(defalias 'lisp-indent-specform #[1028 "\301\234\302\211b\210i\262

\\\262\301u\210\303\301!\210\304`\301\305$\210`W\203D\3061?S\262\303\301!\210\304`\301\305$0\202A\210\302\204 \307V\203dZ\301X\203^\211\310_\\D\202\203D\202\203\307U\203q\307U\204~\307U\203\202
X\203\202
\202\203\207" [lisp-body-indent 1 nil forward-sexp parse-partial-sexp t (error) 0 2] 13 (#$ . 34507)])
#@27 

(fn STATE INDENT-POINT)
(defalias 'lisp-indent-defform #[514 "
A@b\210\301y\210`AA@V\205
A@b\210i\\\207" [lisp-body-indent 1] 4 (#$ . 34977)])
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\210\300\310\302\305#\210\300\311\302\305#\210\300\312\302\305#\210\300\313\302\307#\210\300\314\302\307#\210\300\315\302\307#\210\300\316\302\317#\210\300\320\302\307#\210\300\321\302\317#\210\300\322\302\307#\210\300\323\302\307#\210\300\324\302\307#\210\300\325\302\307#\207" [put autoload lisp-indent-function defun progn 0 prog1 1 save-excursion save-restriction save-current-buffer let let* while if 2 catch condition-case handler-case handler-bind unwind-protect with-output-to-temp-buffer] 4)
#@168 Indent each line of the list starting just after point.
If optional arg ENDPOS is given, indent each line, stopping when
ENDPOS is encountered.

(fn &optional ENDPOS)
(defalias 'indent-sexp #[256 "\301 \302\203\202A\212\303\304!\210\305 `
W\203>\212\306`\")@\307V\203>\31019`
W\2055\303\304!\210\202(0\202=\210\202>\210\210`)!\262\212\311
!\312!>\204W\313\314\315D\"\210
\316H\317
8\203\230\320
8X\203\230\212\312!>\204x\313\314\315D\"\210\321Hb\210\322 \210\312!>\204\217\313\314\315D\"\210\211\321\305 I\266)`W\205\267\323\324w\210l\204\266
\203\266\324fz\325=\204\266\326!\210\327\266\202\204E)
\324\211\223\207" [cl-struct-lisp-indent-state-tags lisp-indent-initial-state copy-marker forward-sexp 1 line-end-position parse-partial-sexp 0 (scan-error) lisp-indent-calc-next type-of signal wrong-type-argument lisp-indent-state 2 4 8 3 indent-for-comment " 	" nil 60 indent-line-to t] 8 (#$ . 35705) nil])
#@141 Indent each line of the list starting just after point, or prettyprint it.
A prefix argument specifies pretty-printing.

(fn &optional ARG)
(defalias 'indent-pp-sexp #[256 "\211\203!\212\214`\300\301!\210`}\210\302 \210db\210`Sf\303=\203 \304\305!\210*\306 \207" [forward-sexp 1 pp-buffer 10 delete-char -1 indent-sexp] 4 (#$ . 36659) "P"])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\312\301\313\314#\207" [custom-declare-variable emacs-lisp-docstring-fill-column funcall function #[0 "\300\207" [65] 1] "Value of `fill-column' to use when filling a docstring.\nAny non-integer value means do not use a different value of\n`fill-column' when filling docstrings." :type (choice (integer) (const :tag "Use the current `fill-column'" t)) :group lisp put safe-local-variable #[257 "\211\300=\206\211\250\207" [t] 3 "\n\n(fn X)"]] 8)
#@256 Like \[fill-paragraph], but handle Emacs Lisp comments and docstrings.
If any of the current line is a comment, fill the comment or the
paragraph of it that point is in, preserving the comment's indentation
and initial semicolons.

(fn &optional JUSTIFY)
(defalias 'lisp-fill-paragraph #[256 "\304
!\206'\305P	\306P\n\250\203\307\310!\203\n\202\311
!+\206'\312\207" [paragraph-start paragraph-separate emacs-lisp-docstring-fill-column fill-column fill-comment-paragraph "\\|\\s-*\\([(;\"]\\|\\s-:\\|`(\\|#'(\\)" "\\|\\s-*\".*[,\\.]$" derived-mode-p emacs-lisp-mode fill-paragraph t] 5 (#$ . 37517) "P"])
#@412 Indent all lines of code, starting in the region, sideways by ARG columns.
Does not affect lines starting inside comments or strings, assuming that
the start of the region is not inside them.

Called from a program, takes args START, END, COLUMNS and NOCHANGE-REGEXP.
The last is a regexp which, if matched at the beginning of a line,
means don't indent that line.

(fn START END ARG &optional NOCHANGE-REGEXP)
(defalias 'indent-code-rigidly #[1027 "\300\212b\210\301 \262b\210n\204\302`\303y\210`\300\211%\262
`W\205[\304
\233@\204L
\2033\305!\204L\306 `\307\300w\210`|\210l\204K\310\311\\]\311\"\210\210\302`\303y\210`\300\211%\262
\202)\207" [nil point-marker parse-partial-sexp 1 3 looking-at current-indentation " 	" indent-to 0] 11 (#$ . 38141) "r\np"])
(provide 'lisp-mode)