HOME

Mini Shell 1.0
DIR:/proc/self/root/usr/share/emacs/26.1/lisp/emacs-lisp/
Current File : //proc/self/root/usr/share/emacs/26.1/lisp/emacs-lisp/cl-indent.elc
;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

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


(byte-code "\300\301\302\303\304\305%\210\306\307\310\311\312DD\313\314\315\304\301&\210\306\316\310\311\317DD\320\314\315\304\301&\210\306\321\310\311\322DD\323\314\315\304\301&\210\306\324\310\311\325DD\326\314\327\304\301&\210\306\330\310\311\331DD\332\314\315\304\301&\210\306\333\310\311\334DD\335\314\315\304\301&\210\306\336\310\311\337DD\340\314\315\304\301&\210\306\341\310\311\342DD\343\344\345\314\327\304\301&	\210\306\346\310\311\347DD\350\344\345\314\315\304\301&	\210\306\351\310\311\352DD\353\344\345\314\327\304\301&	\210\306\354\310\311\355DD\356\344\357\314\360\304\301&	\207" [custom-declare-group lisp-indent nil "Indentation in Lisp." :group lisp custom-declare-variable lisp-indent-maximum-backtracking funcall function #[0 "\300\207" [3] 1] "Maximum depth to backtrack out from a sublist for structured indentation.\nIf this variable is 0, no backtracking will occur and forms such as `flet'\nmay not be correctly indented." :type integer lisp-tag-indentation #[0 "\300\207" [1] 1] "Indentation of tags relative to containing list.\nThis variable is used by the function `lisp-indent-tagbody'." lisp-tag-body-indentation #[0 "\300\207" [3] 1] "Indentation of non-tagged lines relative to containing list.\nThis variable is used by the function `lisp-indent-tagbody' to indent normal\nlines (lines without tags).\nThe indentation is relative to the indentation of the parenthesis enclosing\nthe special form.  If the value is t, the body of tags will be indented\nas a block at the same indentation as the first s-expression following\nthe tag.  In this case, any forms before the first tag are indented\nby `lisp-body-indent'." lisp-backquote-indentation #[0 "\300\207" [t] 1] "Whether or not to indent backquoted lists as code.\nIf nil, indent backquoted lists as data, i.e., like quoted lists." boolean lisp-loop-keyword-indentation #[0 "\300\207" [3] 1] "Indentation of loop keywords in extended loop forms." lisp-loop-forms-indentation #[0 "\300\207" [5] 1] "Indentation of forms in extended loop forms." lisp-simple-loop-indentation #[0 "\300\207" [3] 1] "Indentation of forms in simple loop forms." lisp-lambda-list-keyword-alignment #[0 "\300\207" [nil] 1] "Whether to vertically align lambda-list keywords together.\nIf nil (the default), keyworded lambda-list parts are aligned\nwith the initial mandatory arguments, like this:\n\n(defun foo (arg1 arg2 &rest rest\n            &key key1 key2)\n  #|...|#)\n\nIf non-nil, alignment is done with the first keyword\n(or falls back to the previous case), as in:\n\n(defun foo (arg1 arg2 &rest rest\n                      &key key1 key2)\n  #|...|#)" :version "24.1" lisp-lambda-list-keyword-parameter-indentation #[0 "\300\207" [2] 1] "Indentation of lambda list keyword parameters.\nSee `lisp-lambda-list-keyword-parameter-alignment'\nfor more information." lisp-lambda-list-keyword-parameter-alignment #[0 "\300\207" [nil] 1] "Whether to vertically align lambda-list keyword parameters together.\nIf nil (the default), the parameters are aligned\nwith their corresponding keyword, plus the value of\n`lisp-lambda-list-keyword-parameter-indentation', like this:\n\n(defun foo (arg1 arg2 &key key1 key2\n                        key3 key4)\n  #|...|#)\n\nIf non-nil, alignment is done with the first parameter\n(or falls back to the previous case), as in:\n\n(defun foo (arg1 arg2 &key key1 key2\n                            key3 key4)\n  #|...|#)" lisp-indent-backquote-substitution-mode #[0 "\300\207" [t] 1] "How to indent substitutions in backquotes.\nIf t, the default, indent substituted forms normally.\nIf nil, do not apply special indentation rule to substituted\nforms.  If `corrected', subtract the `,' or `,@' from the form\ncolumn, indenting as if this character sequence were not present.\nIn any case, do not backtrack beyond a backquote substitution.\n\nUntil Emacs 25.1, the nil behavior was hard-wired." "25.1" (choice (const corrected) (const nil) (const t))] 10)
#@125 Defun-like indentation method.
This applies when the value of the `common-lisp-indent-function' property
is set to `defun'.
(defvar lisp-indent-defun-method '(4 &lambda &body) (#$ . 4376))
#@70 True if an extended loop form starts at LOOP-START.

(fn LOOP-START)
(defalias 'lisp-extended-loop-p #[257 "\3001\212\211b\210\301u\210\302\303!\210\304\301!\210\305\306!)0\207\210\307\207" [(error) 1 forward-sexp 2 backward-sexp looking-at "\\(:\\|\\sw\\)" t] 3 (#$ . 4571)])
#@179 Find the lisp indentation function for SYMBOL.
If NO-COMPAT is non-nil, do not retrieve indenters intended for
the standard lisp indent package.

(fn SYMBOL &optional NO-COMPAT)
(defalias 'lisp-indent-find-method #[513 "\300\301!\203\f\302N\206\303N\206\211?\205\304N\207" [derived-mode-p emacs-lisp-mode common-lisp-indent-function-for-elisp common-lisp-indent-function lisp-indent-function] 4 (#$ . 4857)])
#@77 Compute the indentation of loop form constituents.

(fn INDENT-POINT STATE)
(defalias 'common-lisp-loop-part-indentation #[514 "\212\211\304\234b\210i)\305=\203=\212\304\234b\210\211`Sf\306=\203!\307\2029`Sf\310=\2038\307u\210`Sf\306=\2038\311\2029\312\\\262)b\210\313 \210\314\304\234!\204Q\211	\\\202`\315\316!\203]\211\n\\\202`\211\\D\207" [lisp-indent-backquote-substitution-mode lisp-simple-loop-indentation lisp-loop-keyword-indentation lisp-loop-forms-indentation 1 corrected 44 -1 64 -2 0 beginning-of-line lisp-extended-loop-p looking-at "^\\s-*\\(:?\\sw+\\|;\\)"] 6 (#$ . 5282)])
#@3445 Function to indent the arguments of a Lisp function call.
This is suitable for use as the value of the variable
`lisp-indent-function'.  INDENT-POINT is the point at which the
indentation function is called, and STATE is the
`parse-partial-sexp' state at that position.  Browse the
`lisp-indent' customize group for options affecting the behavior
of this function.

If the indentation point is in a call to a Lisp function, that
function's `common-lisp-indent-function' property specifies how
this function should indent it.  Possible values for this
property are:

* defun, meaning indent according to `lisp-indent-defun-method';
  i.e., like (4 &lambda &body), as explained below.

* any other symbol, meaning a function to call.  The function should
  take the arguments: PATH STATE INDENT-POINT SEXP-COLUMN NORMAL-INDENT.
  PATH is a list of integers describing the position of point in terms of
  list-structure with respect to the containing lists.  For example, in
  ((a b c (d foo) f) g), foo has a path of (0 3 1).  In other words,
  to reach foo take the 0th element of the outermost list, then
  the 3rd element of the next list, and finally the 1st element.
  STATE and INDENT-POINT are as in the arguments to
  `common-lisp-indent-function'.  SEXP-COLUMN is the column of
  the open parenthesis of the innermost containing list.
  NORMAL-INDENT is the column the indentation point was
  originally in.  This function should behave like `lisp-indent-259'.

* an integer N, meaning indent the first N arguments like
  function arguments, and any further arguments like a body.
  This is equivalent to (4 4 ... &body).

* a list.  The list element in position M specifies how to indent the Mth
  function argument.  If there are fewer elements than function arguments,
  the last list element applies to all remaining arguments.  The accepted
  list elements are:

  * nil, meaning the default indentation.

  * an integer, specifying an explicit indentation.

  * &lambda.  Indent the argument (which may be a list) by 4.

  * &rest.  When used, this must be the penultimate element.  The
    element after this one applies to all remaining arguments.

  * &body.  This is equivalent to &rest lisp-body-indent, i.e., indent
    all remaining elements by `lisp-body-indent'.

  * &whole.  This must be followed by nil, an integer, or a
    function symbol.  This indentation is applied to the
    associated argument, and as a base indent for all remaining
    arguments.  For example, an integer P means indent this
    argument by P, and all remaining arguments by P, plus the
    value specified by their associated list element.

  * a symbol.  A function to call, with the 6 arguments specified above.

  * a list, with elements as described above.  This applies when the
    associated function argument is itself a list.  Each element of the list
    specifies how to indent the associated argument.

For example, the function `case' has an indent property
(4 &rest (&whole 2 &rest 1)), meaning:
  * indent the first argument by 4.
  * arguments after the first should be lists, and there may be any number
    of them.  The first list element has an offset of 2, all the rest
    have an offset of 2+1=3.

If the current mode is actually `emacs-lisp-mode', look for a
`common-lisp-indent-function-for-elisp' property before looking
at `common-lisp-indent-function' and, if set, use its value
instead.

(fn INDENT-POINT STATE)
(defalias 'common-lisp-indent-function #[514 "\212\211\301\234b\210\302\303\304!\203\305\202\306!\2053\2063`Sf\307=\203-\310u\210`Sf\311=\2062`Sf\311=?)\203<\312\"\207\313\"\207" [lisp-indent-backquote-substitution-mode 1 looking-at derived-mode-p emacs-lisp-mode "(\\(cl-\\)?loop" "([Ll][Oo][Oo][Pp]" 64 -1 44 common-lisp-loop-part-indentation common-lisp-indent-function-1] 5 (#$ . 5897)])
#@27 

(fn INDENT-POINT STATE)
(defalias 'common-lisp-indent-function-1 #[514 "i\305\306\211\211\307\234\306b\210i\262\204\fW\203\f`\307u\210\310`\307\311$\210\306\211\211\211\312\313!\2048\306\262\306\262\202\237`\262\314\307!\210\315`\"\227\262b\210\316\317!\203x\320\321!\311\"\204x\322\323\"\203x\321\305\225\306O!\211\262\203x\320\311\"\203x\324!\262\321!\262\320!\262\204\237\322\325\"\203\237\305\224T\306O\262\321!\262\320!\262\305`W\203\317\3261\310\314\307!\210`Y?\205\304\310`\307\311$\210\211T\262\3110\202\314\210\202\317\204\247\211B\262\210\203\204\376	A\204\322\327\"\203\361\311\262\202\322\330\"\203\331\262\202\332=\203	\262Sf\333=\204\n\204+Sf\334=\203+\335Zf\336=\204+T\262	\202\347Sf\337=\204DSf\340=\203p\335Zf\337=\203p\341=\203ZS\262Sf\340=\203ZS\262\203h\262\262\202p\211\262\n\204\347Sf\336=\203T\262	\202\347\204\237\211\203\347\342	\f&\262\262\f\202\347\250\203\326	A\203\257\202\321	@X\203\300\343\\D\202\321	@TU\203\317\f\\\202\321\262	\202\347\342\f&\262	\266\211b\210\204\3441\345\307!\210T\211\2620\202\210\211\262\210\210\202\206\266\206\207" [lisp-indent-maximum-backtracking lisp-indent-defun-method lisp-backquote-indentation lisp-indent-backquote-substitution-mode lisp-body-indent 0 nil 1 parse-partial-sexp t looking-at "\\sw\\|\\s_" forward-sexp buffer-substring-no-properties derived-mode-p emacs-lisp-mode lisp-indent-find-method intern-soft string-match "\\`cl-" symbol-name ":[^:]+" (error) "\\`def" "\\`\\(\\(?:do\\|with\\(?:out\\)?\\)\\)-" (&lambda &body) defun 39 96 2 35 44 64 corrected common-lisp-indent-call-method 4 (error) backward-up-list] 22 (#$ . 9753)])
#@74 

(fn FUNCTION METHOD PATH STATE INDENT-POINT SEXP-COLUMN NORMAL-INDENT)
(defalias 'common-lisp-indent-call-method #[1799 "9\203%\202!\301&)\207" [lisp-indent-error-function lisp-indent-259] 14 (#$ . 11561)])
#@10 

(fn M)
(defalias 'lisp-indent-report-bad-format #[257 "\301\302\303$\207" [lisp-indent-error-function error "%s has a badly-formed %s property: %s" common-lisp-indent-function] 6 (#$ . 11802)])
#@51 Regular expression matching lambda-list keywords.
(defvar lisp-indent-lambda-list-keywords-regexp "&\\(optional\\|rest\\|key\\|allow-other-keys\\|aux\\|whole\\|body\\|environment\\)\\([ 	]\\|$\\)" (#$ . 12006))
#@55 

(fn INDENT-POINT SEXP-COLUMN CONTAINING-FORM-START)
(defalias 'lisp-indent-lambda-list #[771 "\304\212b\210\305 \210\306\304w\210`\262\307!)\203J	\203E\212b\210\310 \311\312\313\314\315!\316\"\317$\216\320\321#\203<\312\224b\210i\202>T)\262)\202\226T\202\226\212b\210\322y\210\304\210\310 \311\312\313\314\315!\323\"\317$\216\324\321#\203\220\312\224b\210i\211\n\\\312\225b\210\306\304w\210l\203\202\211\202\213\203\212i\202\213\211\266\202\202\222T)\262)\207" [lisp-indent-lambda-list-keywords-regexp lisp-lambda-list-keyword-alignment lisp-lambda-list-keyword-parameter-indentation lisp-lambda-list-keyword-parameter-alignment nil beginning-of-line " 	" looking-at match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 re-search-forward t -1 [set-match-data evaporate] re-search-backward] 11 (#$ . 12223)])
#@65 

(fn METHOD PATH STATE INDENT-POINT SEXP-COLUMN NORMAL-INDENT)
(defalias 'lisp-indent-259 #[1542 "\3012\305\302\234\303\211\211\205\302\n:\204\304!\210@S\262A\262\303\262\203\n@\262\303=\204\212\305=\204\212\306=\203G\nA\203\212\307=\203[\nA:\203[\nAA\203\212\250\204\212:\203z@\310=\203zA@9\204\212A@\250\204\2129\203\205\nA\203\212\304!\210\211\203\234:\204\234\311\301\"\210\202&\306=\203\275\311\301\312U\203\266\204\266\\\202\270\"\210\202&\307=\203\323\312V\262\312\262\nA\262\202&\312V\203\361S\262\nA\262\312W\203&\311\301\"\210\202&\303=\203\311\301:\203\202	D\"\210\202&\305=\203@\311\301\204%\313\\D\202;A\2049\314\n\n#D\202;\"\210\202&\250\203]\311\301\204V\\D\202X\"\210\202&9\203u\311\301\f\f\f\f\f%\"\210\202&\203\204AA\262\303\262\202&A@\262\311\301\203\224\202\275\303=\203\242D\202\275\250\203\261\\D\202\275\f\f\f\f\f%\"\210\202&\266\2050\207" [lisp-body-indent exit 1 nil lisp-indent-report-bad-format &lambda &body &rest &whole throw 0 4 lisp-indent-lambda-list] 19 (#$ . 13109)])
#@58 

(fn PATH STATE INDENT-POINT SEXP-COLUMN NORMAL-INDENT)
(defalias 'lisp-indent-tagbody #[1285 "A\203\207\212b\210\303 \210\304\305w\210\306\307!\203\\\202D	\250\203(	\\\202D	\310=\203A\3111;\312\313!\210i0\202D\210T\202D\n\\\313\234)D\207" [lisp-tag-indentation lisp-tag-body-indentation lisp-body-indent beginning-of-line " 	" nil looking-at "\\sw\\|\\s_" t (error) backward-sexp 1] 8 (#$ . 14303)])
#@58 

(fn PATH STATE INDENT-POINT SEXP-COLUMN NORMAL-INDENT)
(defalias 'lisp-indent-do #[1285 "@\302Y\203\303%)\207\304\305&\207" [lisp-body-indent lisp-tag-body-indentation 3 lisp-indent-tagbody lisp-indent-259 ((&whole nil &rest) (&whole nil &rest 1))] 12 (#$ . 14730)])
#@58 

(fn PATH STATE INDENT-POINT SEXP-COLUMN NORMAL-INDENT)
(defalias 'lisp-indent-defmethod #[1285 "\300\301@\302Y\203?\212\303 \210\304u\210\305\306!\210\307\310w\210\311\312!\203-\211T\262\305 \210\307\310w\210\202\211\301V)\203?\313\314\315\316\"\317#\202B\320\321N\262&\207" [lisp-indent-259 0 3 beginning-of-defun 1 forward-sexp 2 " 	\n" nil looking-at "\\sw\\|\\s_" append (4) make-list 4 (&lambda &body) defun common-lisp-indent-function] 12 (#$ . 15026)])
#@58 

(fn PATH STATE INDENT-POINT SEXP-COLUMN NORMAL-INDENT)
(defalias 'lisp-indent-function-lambda-hack #[1285 "A\204\f@\301V\203
\207\3021-\212\303\304!\210\305u\210\306\307!\203'\310\311i#\202*\\)0\207\210\\\207" [lisp-body-indent 3 (error) backward-up-list 2 1 looking-at "\\(lisp:+\\)?function\\(\\Sw\\|\\S_\\)" + -1] 9 (#$ . 15516)])
(byte-code "\300\211\211\203%\211@\301@\302A9\203A\302N\202A@#\210A\266\202\202\266\301\303\304\305#\210\301\306\304\307#\210\310\311!\207" [((block 1) (case (4 &rest (&whole 2 &rest 1))) (ccase . case) (ecase . case) (typecase . case) (etypecase . case) (ctypecase . case) (catch 1) (cond (&rest (&whole 2 &rest 1))) (defvar (4 2 2)) (defclass (6 4 (&whole 2 &rest 1) (&whole 2 &rest 1))) (defconstant . defvar) (defcustom (4 2 2 2)) (defparameter . defvar) (defconst . defcustom) (define-condition . defclass) (define-modify-macro (4 &lambda &body)) (defsetf (4 &lambda 4 &body)) (defun (4 &lambda &body)) (defgeneric (4 &lambda &body)) (define-setf-method . defun) (define-setf-expander . defun) (defmacro . defun) (defsubst . defun) (deftype . defun) (defmethod lisp-indent-defmethod) (defpackage (4 2)) (defstruct ((&whole 4 &rest (&whole 2 &rest 1)) &rest (&whole 2 &rest 1))) (destructuring-bind ((&whole 6 &rest 1) 4 &body)) (do lisp-indent-do) (do* . do) (dolist ((&whole 4 2 1) &body)) (dotimes . dolist) (eval-when 1) (flet ((&whole 4 &rest (&whole 1 &lambda &body)) &body)) (labels . flet) (macrolet . flet) (generic-flet . flet) (generic-labels . flet) (handler-case (4 &rest (&whole 2 &lambda &body))) (restart-case . handler-case) (if (nil nil &body)) (if (&rest nil)) (lambda (&lambda &rest lisp-indent-function-lambda-hack)) (let ((&whole 4 &rest (&whole 1 1 2)) &body)) (let* . let) (compiler-let . let) (handler-bind . let) (restart-bind . let) (locally 1) (:method (&lambda &body)) (multiple-value-bind ((&whole 6 &rest 1) 4 &body)) (multiple-value-call (4 &body)) (multiple-value-prog1 1) (multiple-value-setq (4 2)) (multiple-value-setf . multiple-value-setq) (pprint-logical-block (4 2)) (print-unreadable-object ((&whole 4 1 &rest 1) &body)) (prog (&lambda &rest lisp-indent-tagbody)) (prog* . prog) (prog1 1) (prog2 2) (progn 0) (progv (4 4 &body)) (return 0) (return-from (nil &body)) (symbol-macrolet . let) (tagbody lisp-indent-tagbody) (throw 1) (unless 1) (unwind-protect (5 &body)) (when 1) (with-accessors . multiple-value-bind) (with-condition-restarts . multiple-value-bind) (with-compilation-unit (&lambda &body)) (with-output-to-string (4 2)) (with-slots . multiple-value-bind) (with-standard-io-syntax (2))) put common-lisp-indent-function if common-lisp-indent-function-for-elisp 2 with-output-to-string 0 provide cl-indent] 8)