ikan Uploader :
Directory : /usr/share/emacs/25.2/lisp/emacs-lisp/
Upload File : |
| Current File : //usr/share/emacs/25.2/lisp/emacs-lisp/lisp-mode.elc |
;ELC
;;; Compiled
;;; in Emacs version 25.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\304\305\306\260!\307E\302\310!\302\303\311\305\306\260!\307E\302\310!\302\312\306\313R!\314E\302\315!\302\303\316\317\306\260!\307EF\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" "\\(def\\(?:c\\(?:onst\\(?:ant\\)?\\|ustom\\)\\|ine-symbol-macro\\|parameter\\)\\)" "^\\s-*(defvar\\(?:-local\\)?\\s-+\\(" "[[:space:]\n]+[^)]" 1 "Types" "\\(cl-def\\(?:struct\\|type\\)\\|def\\(?:class\\|face\\|group\\|ine-\\(?:condition\\|error\\|widget\\)\\|package\\|struct\\|t\\(?:\\(?:hem\\|yp\\)e\\)\\)\\)" "\\s-+'?\\("] 10) (#$ . 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#\207" [put autoload doc-string-elt 3 defmethod defvar defconst defalias defvaralias define-category 2] 4)
#@61 The symbol property that holds the docstring position info.
(defvar lisp-doc-string-elt-property 'doc-string-elt (#$ . 3043))
(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 "\n\n(fn LIMIT)"])
#@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 \3148\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 (#$ . 3499)])
(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\202 0\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 "\n\n(fn LIMIT)"])
#@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\242DDB\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 (#$ . 4714)]))
(byte-code "\303\304\305\306#\210\307\304\310\311#\210\312\313\314\315\316\317\320\211\203* \211@\307\321!\322\323#\210A\266\202\202 \210\211\203A \211@\307\321!\322\324#\210A\266\202\202, \210\325\326\301\327#\210\330\211\203j \211@\326N\203c \301N\204c \307\301\326N#\210A\266\202\202I \210\331\326\301\332#\210\333\334\335\336\337\340\341\342\260\n\343B\344B!\210\345\334\335\336\337\340\341\342\260\n\346BC!\210\325\347\350\327#\210\351\211\203\277 \211@\347N\203\270 \350N\204\270 \307\350\347N#\210A\266\202\202\236 \210\331\347\350\332#\210\352\353 \354\334\335Q\355B\356\357\360\342R\361B\362\363Q\364B\365\366Q\367B\370\335Q\371B\372\335Q\373B\374\375B\376BBBBBBBBB\"!\210\377\353\n\201@ \334\335Q\306B\201A \360\342R\201B B\334\335Q\201C B\365\366Q\201D B\370\335Q\201E B\372\335Q\373B\201F BBBBBBB\"!\266\325\201G \201H \327#\210\201I \211\203|\211@\201G N\203u\201H N\204u\307\201H \201G N#\210A\266\202\202S\210\331\201G \201H \332#\207" [lisp-mode-symbol-regexp lisp-el-font-lock-keywords-1 lisp-cl-font-lock-keywords-1 function-put let-when-compile lisp-indent-function 1 put edebug-form-spec let ("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\\)" 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)) "[`‘]\\(\\(?:\\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\202 0\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?")))) (lambda (#1#) (defconst lisp-cl-font-lock-keywords-2 #1# "Gaudy level highlighting for Lisp modes.")) ("\\[\\(\\^\\)" 1 font-lock-negation-char-face prepend) "(\\(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)) ((0 font-lock-builtin-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)] 20)
#@54 Default expressions to highlight in Emacs Lisp mode.
(defvar lisp-el-font-lock-keywords lisp-el-font-lock-keywords-1 (#$ . 11619))
#@49 Default expressions to highlight in Lisp modes.
(defvar lisp-cl-font-lock-keywords lisp-cl-font-lock-keywords-1 (#$ . 11756))
#@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 \212b\210\301\302!\205 \303\304!)\211\205 \305\306!\"\211\205m \212\307!\203/ \304\225b\210\211 \262b\210\304u\210\3101T \211\311V\205P `W\205P \312\304!\210\211S\262\2029 0\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 (#$ . 11889)])
#@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 (#$ . 12559)])
#@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 "\3038\203* \3048\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 (#$ . 12940)])
#@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\310\307\332!\210$\307\333!\210\310\211\203n \334\202o \335\336\337BBB%\307\340!\210& \307\341!\210\342!\307\343!\210\336\211#\207" [lisp-mode-syntax-table paragraph-ignore-fill-prefix fill-paragraph-function adaptive-fill-function indent-line-function outline-regexp set-syntax-table make-local-variable t lisp-fill-paragraph #[0 "\300\301!\205 \302\207" [looking-at "\\s-+\"[^\n\"]+\"\\s-*$" ""] 2] lisp-indent-line ";;;\\(;* [^ \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 (#$ . 13443)])
#@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 (#$ . 15318)])
#@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 (#$ . 15505)])
#@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) (#$ . 15903))
(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)
(defconst lisp--prettify-symbols-alist '(("lambda" . 955)))
#@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) (#$ . 16678))
#@161 Hook run after entering Lisp mode.
No problems result if this variable is not bound.
`add-hook' automatically binds it. (This is true for all hook variables.)
(defvar lisp-mode-hook nil (#$ . 17496))
(byte-code "\300\301!\204\f \302\301\303\304#\210\300\207" [boundp lisp-mode-map put definition-name lisp-mode] 4)
(defvar lisp-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\305\306!\204 \302\306\307\310#\210\300\207" [lisp-mode-map variable-documentation put purecopy "Keymap for `lisp-mode'." boundp lisp-mode-syntax-table definition-name lisp-mode] 5)
(defvar lisp-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\302\305\306\307#\207" [lisp-mode-syntax-table variable-documentation put purecopy "Syntax table for `lisp-mode'." lisp-mode-abbrev-table definition-name lisp-mode] 5)
(defvar lisp-mode-abbrev-table (progn (define-abbrev-table 'lisp-mode-abbrev-table nil) lisp-mode-abbrev-table))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\302\305\306\307#\207" [lisp-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `lisp-mode'." lisp-mode derived-mode-parent prog-mode] 5)
#@470 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 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 (#$ . 18697) nil])
(defalias 'lisp-find-tag-default #[0 "\300 \211;\205 \301\302\"\203 \211\303\225\304O\202 \211\207" [find-tag-default string-match ":+" 0 nil] 4])
(defalias 'common-lisp-mode 'lisp-mode)
#@88 Send the current defun to the Lisp process made by \[run-lisp].
(fn &optional AND-GO)
(defalias 'lisp-eval-defun #[256 "\300\301!\207" [error "Process lisp does not exist"] 3 (#$ . 20301) nil])
(byte-code "\300\301\302\303#\210\304\301\302\305#\210\300\306\307\303#\210\304\306\307\310#\210\311\312\313\314\315DD\316\317\320\321\322&\210\323\312\324\325#\210\311\326\313\314\327DD\330\321\314\317\320&\207" [defalias lisp-comment-indent comment-indent-default nil make-obsolete "22.1" lisp-mode-auto-fill do-auto-fill "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)
#@156 Indent current line as Lisp code.
With argument, indent any additional lines of the same expression
rigidly along with this one.
(fn &optional WHOLE-EXP)
(defalias 'lisp-indent-line #[256 "\300 \301d`Z\302 \210`\303\301w\210\203 \304\305!\203 dZb\202[ \304\306!\2034 \304\307!\2044 \310 \210\311u\210\202O <\203= @\262iZ\262\312U\204O \211`|\210j\210dZ`V\205[ dZb\207" [calculate-lisp-indent nil beginning-of-line " " looking-at "\\s<\\s<\\s<" "\\s<" "\\s<\\s<" indent-for-comment -1 0] 7 (#$ . 21467) "P"])
#@581 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.
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\203 b\210\202 \307 \210`W\203- \310`\311#\262\202 \203m \203m \311\234\311V\203m \305\262\312\234\313\234\262\211Tb\210\203- `V\203- \310\311#\211A@\211\262\203i \211\262\210\202- \204\276 \211Tb\210\204 i\262\202\276 \310`\311\306$\210\314\315!\204\276 \212\313y\210`)V\203\256 `U\204\250 \316\313!\210\310`\311\306$\210\317 \210\202\276 b\210\304 \210\310`\311\306$\210\317 \210i\320\234\203\311 \305\202t \250\203\333 \203\333 b\210i \\\202t\203o\n\203\360 \204\360 \n\"\206t\212b\210\321\305w\210\314\322!)\203k\212b\210\317 \210\323\324\325 \"\204$\203T`Y\204$\316\326!\210\317 \210\202`\211)\203k\212Tb\210\310`\311\306$\210`)V\203k\306\305b\210\314\322!\203Ri\211\262\204e\325 \327 \210`W\203e\314\322!\203ei\262)\262\206t\211\202t\206t\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 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 (#$ . 21997)])
#@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\2042 b\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 (#$ . 23835)])
(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)
(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\203d Z\301X\203^ \211\310_\\D\202\203 D\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 "\n\n(fn COUNT STATE INDENT-POINT NORMAL-INDENT)"])
(defalias 'lisp-indent-defform #[514 "A@b\210\301y\210`AA@V\205 A@b\210i\\\207" [lisp-body-indent 1] 4 "\n\n(fn STATE INDENT-POINT)"])
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\210\300\310\302\311#\210\300\312\302\305#\210\300\313\302\305#\210\300\314\302\305#\210\300\315\302\307#\210\300\316\302\307#\210\300\317\302\307#\210\300\320\302\311#\210\300\321\302\307#\210\300\322\302\311#\210\300\323\302\307#\210\300\324\302\307#\210\300\325\302\307#\210\300\326\302\307#\207" [put autoload lisp-indent-function defun progn 0 prog1 1 prog2 2 save-excursion save-restriction save-current-buffer let let* while if 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 "\300C\301?\205 ``\300\211\211\211\211\211\n\204 \212\302\303!\210)\212\300\262\n\203+ ` W\202- ?\205m\262\300\262\204 m\211\262\204 \304`\300\210`\300\211%\262@\262 \305\233@\203f \306 \210\300\210\305\233\300\240\210\307\233@\203y \303y\210\310\233\300\240\210\2027 \311\262\2027 \n\203\237 \301X\203\237 \312\n[\300\"\244\262\n Z\262\301\262 \303y\210\n\203\264 \n`X\203\276 \311\262\202\276 \301X\203\276 \311\262\204Y V\203\325 A\262\nS\262\202\302 W\203\351 \300\nB\262\nT\262\202\325 `\262\313\300w\210m\204Y\314\315!\204Y @\203 @\301Y\203 @\262\202H\316\n@\203 \n@[\202 !\211\204+\211\262\202G\211\250\203;\n\211\262\240\210\202G\nA@[\240\210\211@\262\210\211\203YiU\204Y`|\210\211j\210\204 `U\211\262\204 `\262\202 )\207" [nil 0 forward-sexp 1 parse-partial-sexp 4 indent-for-comment 3 5 t make-list " " looking-at "\\s<\\|\n" calculate-lisp-indent] 17 (#$ . 27255) 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 (#$ . 28438) "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-*\".*[,\\.]$" derived-mode-p emacs-lisp-mode fill-paragraph t] 5 (#$ . 29296) "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 (#$ . 29913) "r\np"])
(provide 'lisp-mode)
Kontol Shell Bypass