Gecko [ 122.154.134.11 ]

Name	Size	Permission
advice.elc	60.71 KB	-rw-r--r--
assoc.elc	4.37 KB	-rw-r--r--
authors.elc	27.41 KB	-rw-r--r--
autoload.elc	15.7 KB	-rw-r--r--
avl-tree.elc	15.92 KB	-rw-r--r--
backquote.elc	4.46 KB	-rw-r--r--
benchmark.elc	3.33 KB	-rw-r--r--
bindat.elc	10.84 KB	-rw-r--r--
byte-opt.elc	34.22 KB	-rw-r--r--
byte-run.elc	6.65 KB	-rw-r--r--
bytecomp.elc	124.99 KB	-rw-r--r--
check-declare.elc	8.77 KB	-rw-r--r--
checkdoc.elc	65.08 KB	-rw-r--r--
cl-compat.elc	4.28 KB	-rw-r--r--
cl-extra.elc	21.48 KB	-rw-r--r--
cl-indent.elc	13.98 KB	-rw-r--r--
cl-loaddefs.el	39.57 KB	-rw-r--r--
cl-macs.elc	99.36 KB	-rw-r--r--
cl-seq.elc	43.98 KB	-rw-r--r--
cl-specs.el	13.87 KB	-rw-r--r--
cl.elc	20.74 KB	-rw-r--r--
copyright.elc	8.64 KB	-rw-r--r--
crm.elc	7.94 KB	-rw-r--r--
cust-print.elc	12.77 KB	-rw-r--r--
debug.elc	24.86 KB	-rw-r--r--
derived.elc	10.72 KB	-rw-r--r--
disass.elc	5.09 KB	-rw-r--r--
easy-mmode.elc	14.85 KB	-rw-r--r--
easymenu.elc	20.15 KB	-rw-r--r--
edebug.elc	100.82 KB	-rw-r--r--
eldoc.elc	15.31 KB	-rw-r--r--
elint.elc	19.76 KB	-rw-r--r--
elp.elc	12.78 KB	-rw-r--r--
ewoc.elc	28.62 KB	-rw-r--r--
find-func.elc	17.26 KB	-rw-r--r--
find-gc.elc	3.74 KB	-rw-r--r--
float-sup.elc	1.39 KB	-rw-r--r--
generic.elc	6.55 KB	-rw-r--r--
gulp.elc	4.82 KB	-rw-r--r--
helper.elc	3.84 KB	-rw-r--r--
levents.elc	10.29 KB	-rw-r--r--
lisp-mnt.elc	21.87 KB	-rw-r--r--
lisp-mode.elc	37.14 KB	-rw-r--r--
lisp.elc	21.61 KB	-rw-r--r--
lmenu.elc	11.67 KB	-rw-r--r--
lucid.elc	6.22 KB	-rw-r--r--
macroexp.elc	4.45 KB	-rw-r--r--
map-ynp.elc	6.3 KB	-rw-r--r--
pp.elc	5.09 KB	-rw-r--r--
re-builder.elc	22.36 KB	-rw-r--r--
regexp-opt.elc	4.43 KB	-rw-r--r--
regi.elc	6.15 KB	-rw-r--r--
ring.elc	6.41 KB	-rw-r--r--
rx.elc	26.61 KB	-rw-r--r--
shadow.elc	5.63 KB	-rw-r--r--
sregex.elc	12.45 KB	-rw-r--r--
syntax.elc	5.18 KB	-rw-r--r--
tcover-ses.elc	14.68 KB	-rw-r--r--
tcover-unsafep.elc	4.09 KB	-rw-r--r--
testcover.elc	13.41 KB	-rw-r--r--
timer.elc	22.73 KB	-rw-r--r--
tq.elc	3.94 KB	-rw-r--r--
trace.elc	5.28 KB	-rw-r--r--
unsafep.elc	5.01 KB	-rw-r--r--
warnings.elc	9.61 KB	-rw-r--r--

Code Editor : cl-indent.elc

;ELC���
;;; Compiled by mockbuild@c6b8.bsys.dev.centos.org on Thu Feb 19 13:02:53 2015
;;; from file /builddir/build/BUILD/emacs-23.1/lisp/emacs-lisp/cl-indent.el
;;; in Emacs version 23.1.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.
(if (and (boundp 'emacs-version)
	 (< (aref emacs-version (1- (length emacs-version))) ?A)
	 (or (and (boundp 'epoch::version) epoch::version)
	     (string-lessp emacs-version "19.29")))
    (error "`cl-indent.el' was compiled for Emacs 19.29 or later"))

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

(custom-declare-group 'lisp-indent nil "Indentation in Lisp." :group 'lisp)
#@182 *Maximum depth to backtrack out from a sublist for structured indentation.
If this variable is 0, no backtracking will occur and forms such as `flet'
may not be correctly indented.
(custom-declare-variable 'lisp-indent-maximum-backtracking '3 '(#$ . -697) :type 'integer :group 'lisp-indent)
#@112 *Indentation of tags relative to containing list.
This variable is used by the function `lisp-indent-tagbody'.
(custom-declare-variable 'lisp-tag-indentation '1 '(#$ . -996) :type 'integer :group 'lisp-indent)
#@478 *Indentation of non-tagged lines relative to containing list.
This variable is used by the function `lisp-indent-tagbody' to indent normal
lines (lines without tags).
The indentation is relative to the indentation of the parenthesis enclosing
the special form.  If the value is t, the body of tags will be indented
as a block at the same indentation as the first s-expression following
the tag.  In this case, any forms before the first tag are indented
by `lisp-body-indent'.
(custom-declare-variable 'lisp-tag-body-indentation '3 '(#$ . -1213) :type 'integer :group 'lisp-indent)
#@119 *Whether or not to indent backquoted lists as code.
If nil, indent backquoted lists as data, i.e., like quoted lists.
(custom-declare-variable 'lisp-backquote-indentation 't '(#$ . -1802) :type 'boolean :group 'lisp-indent)
#@55 *Indentation of loop keywords in extended loop forms.
(custom-declare-variable 'lisp-loop-keyword-indentation '3 '(#$ . -2032) :type 'integer :group 'lisp-indent)
#@47 *Indentation of forms in extended loop forms.
(custom-declare-variable 'lisp-loop-forms-indentation '5 '(#$ . -2201) :type 'integer :group 'lisp-indent)
#@45 *Indentation of forms in simple loop forms.
(custom-declare-variable 'lisp-simple-loop-indentation '3 '(#$ . -2360) :type 'integer :group 'lisp-indent)
#@79 Indentation for function with `common-lisp-indent-function' property `defun'.
(defvar lisp-indent-defun-method '(4 &lambda &body) (#$ . 2518))
#@53 True if an extended loop form starts at LOOP-START.
(defalias 'extended-loop-p #[(loop-start) "\300\301\302\217\207" [nil (byte-code "\212b\210\301u\210\302\303!\210\304\301!\210\305\306!)\207" [loop-start 1 forward-sexp 2 backward-sexp looking-at "\\sw"] 2) ((error t))] 3 (#$ . 2667)])
#@52 Compute the indentation of loop form constituents.
(defalias 'common-lisp-loop-part-indentation #[(indent-point state) "\212\306\234b\210i)\nb\210\307 \210\310\306\234!\204�	\\\202,�\311\312!\203)�	\f\\\202,�	
\\)\207" [state loop-indentation indent-point lisp-simple-loop-indentation lisp-loop-keyword-indentation lisp-loop-forms-indentation 1 beginning-of-line extended-loop-p looking-at "^\\s-*\$:?\\sw+\\|;\$"] 3 (#$ . 2962)])
#@3222 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.
(defalias 'common-lisp-indent-function #[(indent-point state) "\212\302\234b\210\303\304!)\203�\305	\"\207\306	\"\207" [state indent-point 1 looking-at "([Ll][Oo][Oo][Pp]" common-lisp-loop-part-indentation common-lisp-indent-function-1] 3 (#$ . 3408)])
(defalias 'common-lisp-indent-function-1 #[(indent-point state) "i\306\307\211\211	\n\310\234\307$%&'\fb\210i%\204\275'(W\203\275`)\310u\210\311`	\310\312$\210\307\211\211\211*+,-\313\314!\204P�\307\211,+\202\231�`-\315\310!\210\316-`\"\227,-b\210\317,!\211-\320N\211+\204\216�\321\322,\"\203\216�,\306\224T\307O,\317,!\320N+\202\231�+\204\231�-\323N+\306.`	W\203\251�\307\324\325\217\204\242�.&B&),\203\350�+\204\335�&A\204\350�\321\326,\"\203\317�\312*\202\350�\321\327,\"\203\350�\330+\202\350�+\331=\203\350�/+)Sf\332=\204\377�0\204)Sf\333=\203)\334Zf\335=\204T%\202\247)Sf\336=\204,)Sf\337=\2032)\334Zf\336=\2032%\202\247)Sf\335=\203BT%\202\247+\204`*\203\247\340,/&\n	&\211$\202\247+\250\203\230&A\203p\202\223&@+X\203\201\341\\\fD\202\223&@+TU\203\2221\\\202\223%\202\247\340,+&\n	&%,)b\210)%\204\271\307\342\343\217\210)\202�%\206\304$.\207" [normal-indent indent-point state sexp-column containing-form-start last-point 0 nil 1 parse-partial-sexp t looking-at "\\sw\\|\\s_" forward-sexp buffer-substring-no-properties intern-soft common-lisp-indent-function string-match ":[^:]+" lisp-indent-function (byte-code "\302\303!\210`Y?\205�\304`\303\305$\210	T\305\207" [indent-point n forward-sexp 1 parse-partial-sexp t] 5) ((error)) "\\`def" "\\`\$\\(?:do\\|with\\(?:out\$?\\)\\)-" (&lambda &body) defun 39 96 2 35 44 64 common-lisp-indent-call-method 4 (byte-code "\301\302!\210T\301\207" [depth backward-up-list 1] 2) ((error (byte-code "\302\207" [lisp-indent-maximum-backtracking depth nil] 1))) tentative-calculated calculated path depth lisp-indent-maximum-backtracking containing-sexp tentative-defun method function tem n lisp-indent-defun-method lisp-backquote-indentation lisp-body-indent] 9])
(defalias 'common-lisp-indent-call-method #[(function method path state indent-point sexp-column normal-indent) "\n9\203�\n\f
%\202�\306\n\f
&)\207" [function lisp-indent-error-function method path state indent-point lisp-indent-259 sexp-column normal-indent] 7])
(defalias 'lisp-indent-report-bad-format #[(m) "\302\303\304	$\207" [lisp-indent-error-function m error "%s has a badly-formed %s property: %s" common-lisp-indent-function] 5])
(defalias 'lisp-indent-259 #[(method path state indent-point sexp-column normal-indent) "\300\301\215\207" [exit (byte-code "	\306\234\307\211\211\205\305:\204�\310!\210@SA\307\f\203
�@\211\307=\204\230�\311=\204\230�\312=\203I�A\203\230�\313=\203a�A:\203a�\211AA)\203\230�\250\204\230�:\203\210�@\314=\203\210�\211A@)9\204\230�\211A@)\250\204\230�9\203\223�A\203\230�\310!\210\n\203\252�:\204\252�\315\316\"\210\202)�\312=\203\314�\315\316\f\317U\203\305�\204\305�\\\202\307�\"\210\202)�\313=\203\340�\f\317V\317A\202)�\f\317V\203\375�\fSA\f\317W\203)�\315\316\"\210\202)�\307=\203\315\316:\203\202
D\"\210\202)�\311=\203B\315\316\204/\320\\
D\202=A\204;T\202=\"\210\202)�\250\203^\315\316\204W\\
D\202Y\"\210\202)�9\203t\315\316	%\"\210\202)�\203\210\211AA)\307\211\202*�\211A@)\315\316\n\203\233\202\300\307=\203\250
D\202\300\250\203\266\\
D\202\300	%\"\210\202)�-\207" [path state tail tem n containing-form-start 1 nil lisp-indent-report-bad-format &lambda &body &rest &whole throw exit 0 4 p method x normal-indent sexp-column lisp-body-indent indent-point] 9)] 2])
(defalias 'lisp-indent-tagbody #[(path state indent-point sexp-column normal-indent) "A\203�	\207\212\nb\210\306 \210\307\310w\210\311\312!\203�\f\\\202:�
\250\203)�
\\\202:�
\313=\2036�\310\314\315\217\202:�\\\316\234)D\207" [path normal-indent indent-point sexp-column lisp-tag-indentation lisp-tag-body-indentation beginning-of-line " 	" nil looking-at "\\sw\\|\\s_" t (byte-code "\300\301!\210i\207" [backward-sexp 1] 2) ((error (1+ sexp-column))) 1 lisp-body-indent state] 3])
(defalias 'lisp-indent-do #[(path state indent-point sexp-column normal-indent) "@\306Y\203�	\307\f
\n%)\207\310\311\f
\n&\207" [path lisp-body-indent lisp-tag-body-indentation state indent-point sexp-column 3 lisp-indent-tagbody lisp-indent-259 ((&whole nil &rest) (&whole nil &rest 1)) normal-indent] 7])
#@33 Indentation function defmethod.
(defalias 'lisp-indent-defmethod #[(path state indent-point sexp-column normal-indent) "\305@\306Y\203(�A\204(�\212	\307\234b\210\307u\210\310\306!\210\311 \210\312\313!)\203(�\314\202+�\315\316N	\n\f&\207" [path state indent-point sexp-column normal-indent lisp-indent-259 3 1 forward-sexp backward-sexp looking-at ":\\|\\sw+" (4 4 (&whole 4 &rest 4) &body) defun common-lisp-indent-function] 7 (#$ . 11241)])
(defalias 'lisp-indent-function-lambda-hack #[(path state indent-point sexp-column normal-indent) "A\204\f�@\302V\203�	\207\303\304\305\217\207" [path normal-indent 3 nil (byte-code "\212\302\303!\210\304u\210\305\306!\203�\307\310i#\202�	\\)\207" [lisp-body-indent sexp-column backward-up-list 2 1 looking-at "\$lisp:+\$?function\$\\Sw\\|\\S_\$" + -1] 4) ((error (+ sexp-column lisp-body-indent)))] 3])
(byte-code "\303\211\304\211\203*�\n@\305	@\306	A9\203�	A\306N\202!�	A@#\210\nA\211\204\n�+\304\207" [l el #:--cl-dolist-temp-- ((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)) (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-output-to-string (4 2)) (with-slots . multiple-value-bind) (with-standard-io-syntax (2))) nil put common-lisp-indent-function] 7)

${this.title}

Code Editor : cl-indent.elc