Anonymous avatar Anonymous committed 8df3eb0

Whitespace cleanup in cl-indent.el

Comments (0)

Files changed (2)

+2011-05-11  Didier Verna  <didier@xemacs.org>
+
+	* cl-indent.el: Whitespace cleanup.
+
 2011-05-08  Norbert Koch  <viteno@xemacs.org>
 
 	* Makefile (VERSION): XEmacs package 2.22 released.
 with the initial mandatory arguments, like this:
 
 \(defun foo (arg1 arg2 &rest rest
-            &key key1 key2)
+	    &key key1 key2)
   #|...|#)
 
 If non-nil, alignment is done with the first keyword
 \(or falls back to the previous case), as in:
 
 \(defun foo (arg1 arg2 &rest rest
-                      &key key1 key2)
+		      &key key1 key2)
   #|...|#)"
   :type 'boolean
   :group 'lisp-indent)
 (defcustom lisp-lambda-list-keyword-parameter-alignment nil
   "Whether to vertically align lambda-list keyword parameters together.
 If nil (the default), the parameters are aligned
-with their corresponding keyword, plus the value of 
+with their corresponding keyword, plus the value of
 `lisp-lambda-list-keyword-parameter-indentation', like this:
 
 \(defun foo (arg1 arg2 &key key1 key2
-                        key3 key4)
+			key3 key4)
   #|...|#)
 
 If non-nil, alignment is done with the first parameter
 \(or falls back to the previous case), as in:
 
 \(defun foo (arg1 arg2 &key key1 key2
-                            key3 key4)
+			    key3 key4)
   #|...|#)"
   :type 'boolean
   :group 'lisp-indent)
 (defvar lisp-indent-defun-method '(4 &lambda &body)
   "Defun-like indentation method.
 This applies when the value of the `common-lisp-indent-function' property
-is set to `defun'.") 
+is set to `defun'.")
 
 
 (defun extended-loop-p (loop-start)
     ;; Walk up list levels until we see something
     ;;  which does special things with subforms.
     (let ((depth 0)
-          ;; Path describes the position of point in terms of
-          ;;  list-structure with respect to containing lists.
-          ;; `foo' has a path of (0 3 1) in `((a b c (d foo) f) g)'.
-          (path ())
-          ;; set non-nil when somebody works out the indentation to use
-          calculated
+	  ;; Path describes the position of point in terms of
+	  ;;  list-structure with respect to containing lists.
+	  ;; `foo' has a path of (0 3 1) in `((a b c (d foo) f) g)'.
+	  (path ())
+	  ;; set non-nil when somebody works out the indentation to use
+	  calculated
 	  ;; If non-nil, this is an indentation to use
 	  ;; if nothing else specifies it more firmly.
 	  tentative-calculated
 	  (last-point indent-point)
-          ;; the position of the open-paren of the innermost containing list
-          (containing-form-start (elt state 1))
-          ;; the column of the above
-          sexp-column)
+	  ;; the position of the open-paren of the innermost containing list
+	  (containing-form-start (elt state 1))
+	  ;; the column of the above
+	  sexp-column)
       ;; Move to start of innermost containing list
       (goto-char containing-form-start)
       (setq sexp-column (current-column))
 
       ;; Look over successively less-deep containing forms
       (while (and (not calculated)
-                  (< depth lisp-indent-maximum-backtracking))
-        (let ((containing-sexp (point)))
-          (forward-char 1)
-          (parse-partial-sexp (point) indent-point 1 t)
-          ;; Move to the car of the relevant containing form
-          (let (tem function method tentative-defun)
-            (if (not (looking-at "\\sw\\|\\s_"))
-                ;; This form doesn't seem to start with a symbol
-                (setq function nil method nil)
-              (setq tem (point))
-              (forward-sexp 1)
-              (setq function (downcase (buffer-substring-no-properties
-                                        tem (point))))
-              (goto-char tem)
-              (setq tem (intern-soft function)
-                    method (get tem 'common-lisp-indent-function))
-              (cond ((and (null method)
-                          (string-match ":[^:]+" function))
-                     ;; The pleblisp package feature
-                     (setq function (substring function
-                                               (1+ (match-beginning 0)))
-                           method (get (intern-soft function)
-                                       'common-lisp-indent-function)))
-                    ((and (null method))
-                     ;; backwards compatibility
-                     (setq method (get tem 'lisp-indent-function)))))
-            (let ((n 0))
-              ;; How far into the containing form is the current form?
-              (if (< (point) indent-point)
-                  (while (condition-case ()
-                             (progn
-                               (forward-sexp 1)
-                               (if (>= (point) indent-point)
-                                   nil
-                                 (parse-partial-sexp (point)
-                                                     indent-point 1 t)
-                                 (setq n (1+ n))
-                                 t))
-                           (error nil))))
-              (setq path (cons n path)))
+		  (< depth lisp-indent-maximum-backtracking))
+	(let ((containing-sexp (point)))
+	  (forward-char 1)
+	  (parse-partial-sexp (point) indent-point 1 t)
+	  ;; Move to the car of the relevant containing form
+	  (let (tem function method tentative-defun)
+	    (if (not (looking-at "\\sw\\|\\s_"))
+		;; This form doesn't seem to start with a symbol
+		(setq function nil method nil)
+	      (setq tem (point))
+	      (forward-sexp 1)
+	      (setq function (downcase (buffer-substring-no-properties
+					tem (point))))
+	      (goto-char tem)
+	      (setq tem (intern-soft function)
+		    method (get tem 'common-lisp-indent-function))
+	      (cond ((and (null method)
+			  (string-match ":[^:]+" function))
+		     ;; The pleblisp package feature
+		     (setq function (substring function
+					       (1+ (match-beginning 0)))
+			   method (get (intern-soft function)
+				       'common-lisp-indent-function)))
+		    ((and (null method))
+		     ;; backwards compatibility
+		     (setq method (get tem 'lisp-indent-function)))))
+	    (let ((n 0))
+	      ;; How far into the containing form is the current form?
+	      (if (< (point) indent-point)
+		  (while (condition-case ()
+			     (progn
+			       (forward-sexp 1)
+			       (if (>= (point) indent-point)
+				   nil
+				 (parse-partial-sexp (point)
+						     indent-point 1 t)
+				 (setq n (1+ n))
+				 t))
+			   (error nil))))
+	      (setq path (cons n path)))
 
-            ;; backwards compatibility.
-            (cond ((null function))
-                  ((null method)
-                   (when (null (cdr path))
+	    ;; backwards compatibility.
+	    (cond ((null function))
+		  ((null method)
+		   (when (null (cdr path))
 		     ;; (package prefix was stripped off above)
 		     (cond ((string-match "\\`def"
 					  function)
 			    (setq tentative-defun t))
 			   ((string-match
-                             (eval-when-compile
-                              (concat "\\`\\("
-                                      (regexp-opt '("with" "without" "do"))
-                                      "\\)-"))
-                             function)
+			     (eval-when-compile
+			      (concat "\\`\\("
+				      (regexp-opt '("with" "without" "do"))
+				      "\\)-"))
+			     function)
 			    (setq method '(&lambda &body))))))
-                  ;; backwards compatibility.  Bletch.
-                  ((eq method 'defun)
-                   (setq method lisp-indent-defun-method)))
+		  ;; backwards compatibility.  Bletch.
+		  ((eq method 'defun)
+		   (setq method lisp-indent-defun-method)))
 
-            (cond ((and (or (eq (char-after (1- containing-sexp)) ?\')
+	    (cond ((and (or (eq (char-after (1- containing-sexp)) ?\')
 			    (and (not lisp-backquote-indentation)
 				 (eq (char-after (1- containing-sexp)) ?\`)))
-                        (not (eq (char-after (- containing-sexp 2)) ?\#)))
-                   ;; No indentation for "'(...)" elements
-                   (setq calculated (1+ sexp-column)))
-                  ((or (eq (char-after (1- containing-sexp)) ?\,)
-                       (and (eq (char-after (1- containing-sexp)) ?\@)
-                            (eq (char-after (- containing-sexp 2)) ?\,)))
-                   ;; ",(...)" or ",@(...)"
-                   (setq calculated normal-indent))
-                  ((eq (char-after (1- containing-sexp)) ?\#)
-                   ;; "#(...)"
-                   (setq calculated (1+ sexp-column)))
-                  ((null method)
+			(not (eq (char-after (- containing-sexp 2)) ?\#)))
+		   ;; No indentation for "'(...)" elements
+		   (setq calculated (1+ sexp-column)))
+		  ((or (eq (char-after (1- containing-sexp)) ?\,)
+		       (and (eq (char-after (1- containing-sexp)) ?\@)
+			    (eq (char-after (- containing-sexp 2)) ?\,)))
+		   ;; ",(...)" or ",@(...)"
+		   (setq calculated normal-indent))
+		  ((eq (char-after (1- containing-sexp)) ?\#)
+		   ;; "#(...)"
+		   (setq calculated (1+ sexp-column)))
+		  ((null method)
 		   ;; If this looks like a call to a `def...' form,
 		   ;; think about indenting it as one, but do it
 		   ;; tentatively for cases like
 			      path state indent-point
 			      sexp-column normal-indent)
 			     normal-indent tentative-calculated)))
-                  ((integerp method)
-                   ;; convenient top-level hack.
-                   ;;  (also compatible with lisp-indent-function)
-                   ;; The number specifies how many `distinguished'
-                   ;;  forms there are before the body starts
-                   ;; Equivalent to (4 4 ... &body)
-                   (setq calculated (cond ((cdr path)
-                                           normal-indent)
-                                          ((<= (car path) method)
-                                           ;; `distinguished' form
-                                           (list (+ sexp-column 4)
-                                                 containing-form-start))
-                                          ((= (car path) (1+ method))
-                                           ;; first body form.
-                                           (+ sexp-column lisp-body-indent))
-                                          (t
-                                           ;; other body form
-                                           normal-indent))))
+		  ((integerp method)
+		   ;; convenient top-level hack.
+		   ;;  (also compatible with lisp-indent-function)
+		   ;; The number specifies how many `distinguished'
+		   ;;  forms there are before the body starts
+		   ;; Equivalent to (4 4 ... &body)
+		   (setq calculated (cond ((cdr path)
+					   normal-indent)
+					  ((<= (car path) method)
+					   ;; `distinguished' form
+					   (list (+ sexp-column 4)
+						 containing-form-start))
+					  ((= (car path) (1+ method))
+					   ;; first body form.
+					   (+ sexp-column lisp-body-indent))
+					  (t
+					   ;; other body form
+					   normal-indent))))
 		  (t
 		   (setq calculated
 			 (common-lisp-indent-call-method
 			  function method path state indent-point
 			  sexp-column normal-indent)))))
-          (goto-char containing-sexp)
-          (setq last-point containing-sexp)
-          (unless calculated
+	  (goto-char containing-sexp)
+	  (setq last-point containing-sexp)
+	  (unless calculated
 	    (condition-case ()
 		(progn (backward-up-list 1)
 		       (setq depth (1+ depth)))
 
 (defun lisp-indent-report-bad-format (m)
   (error "%s has a badly-formed %s property: %s"
-         ;; Love those free variable references!!
-         lisp-indent-error-function 'common-lisp-indent-function m))
+	 ;; Love those free variable references!!
+	 lisp-indent-error-function 'common-lisp-indent-function m))
 
 
 ;; Lambda-list indentation is now done in LISP-INDENT-LAMBDA-LIST.
 ;; See also `lisp-lambda-list-keyword-alignment',
 ;; `lisp-lambda-list-keyword-parameter-alignment' and
-;; `lisp-lambda-list-keyword-parameter-indentation' -- dvl 
+;; `lisp-lambda-list-keyword-parameter-indentation' -- dvl
 
 (defvar lisp-indent-lambda-list-keywords-regexp
   "&\\(\
 			     (goto-char (match-beginning 0))
 			     (current-column)))
 			  (indented-keyword-posn
-			   (+ keyword-posn 
+			   (+ keyword-posn
 			      lisp-lambda-list-keyword-parameter-indentation)))
 		     (goto-char (match-end 0))
 		     (skip-chars-forward " \t")
 
 ;; Blame the crufty control structure on dynamic scoping
 ;;  -- not on me!
-(defun lisp-indent-259 
+(defun lisp-indent-259
     (method path state indent-point sexp-column normal-indent)
   (catch 'exit
     (let ((p path)
-          (containing-form-start (elt state 1))
-          n tem tail)
+	  (containing-form-start (elt state 1))
+	  n tem tail)
       ;; Isn't tail-recursion wonderful?
       (while p
-        ;; This while loop is for destructuring.
-        ;; p is set to (cdr p) each iteration.
-        (if (not (consp method)) (lisp-indent-report-bad-format method))
-        (setq n (1- (car p))
-              p (cdr p)
-              tail nil)
-        (while n
-          ;; This while loop is for advancing along a method
-          ;; until the relevant (possibly &rest/&body) pattern
-          ;; is reached.
-          ;; n is set to (1- n) and method to (cdr method)
-          ;; each iteration.
-          (setq tem (car method))
+	;; This while loop is for destructuring.
+	;; p is set to (cdr p) each iteration.
+	(if (not (consp method)) (lisp-indent-report-bad-format method))
+	(setq n (1- (car p))
+	      p (cdr p)
+	      tail nil)
+	(while n
+	  ;; This while loop is for advancing along a method
+	  ;; until the relevant (possibly &rest/&body) pattern
+	  ;; is reached.
+	  ;; n is set to (1- n) and method to (cdr method)
+	  ;; each iteration.
+	  (setq tem (car method))
 
-          (or (eq tem 'nil)             ;default indentation
-              (eq tem '&lambda)         ;lambda list
-              (and (eq tem '&body) (null (cdr method)))
-              (and (eq tem '&rest)
-                   (consp (cdr method))
-                   (null (cddr method)))
-              (integerp tem)            ;explicit indentation specified
-              (and (consp tem)          ;destructuring
-                   (eq (car tem) '&whole)
-                   (or (symbolp (cadr tem))
-                       (integerp (cadr tem))))
-              (and (symbolp tem)        ;a function to call to do the work.
-                   (null (cdr method)))
-              (lisp-indent-report-bad-format method))
+	  (or (eq tem 'nil)             ;default indentation
+	      (eq tem '&lambda)         ;lambda list
+	      (and (eq tem '&body) (null (cdr method)))
+	      (and (eq tem '&rest)
+		   (consp (cdr method))
+		   (null (cddr method)))
+	      (integerp tem)            ;explicit indentation specified
+	      (and (consp tem)          ;destructuring
+		   (eq (car tem) '&whole)
+		   (or (symbolp (cadr tem))
+		       (integerp (cadr tem))))
+	      (and (symbolp tem)        ;a function to call to do the work.
+		   (null (cdr method)))
+	      (lisp-indent-report-bad-format method))
 
-          (cond ((and tail (not (consp tem)))
-                 ;; indent tail of &rest in same way as first elt of rest
-                 (throw 'exit normal-indent))
-                ((eq tem '&body)
-                 ;; &body means (&rest <lisp-body-indent>)
-                 (throw 'exit
-                   (if (and (= n 0)     ;first body form
-                            (null p))   ;not in subforms
-                       (+ sexp-column
-                          lisp-body-indent)
-                       normal-indent)))
-                ((eq tem '&rest)
-                 ;; this pattern holds for all remaining forms
-                 (setq tail (> n 0)
-                       n 0
-                       method (cdr method)))
-                ((> n 0)
-                 ;; try next element of pattern
-                 (setq n (1- n)
-                       method (cdr method))
-                 (if (< n 0)
-                     ;; Too few elements in pattern.
-                     (throw 'exit normal-indent)))
-                ((eq tem 'nil)
+	  (cond ((and tail (not (consp tem)))
+		 ;; indent tail of &rest in same way as first elt of rest
+		 (throw 'exit normal-indent))
+		((eq tem '&body)
+		 ;; &body means (&rest <lisp-body-indent>)
+		 (throw 'exit
+		   (if (and (= n 0)     ;first body form
+			    (null p))   ;not in subforms
+		       (+ sexp-column
+			  lisp-body-indent)
+		       normal-indent)))
+		((eq tem '&rest)
+		 ;; this pattern holds for all remaining forms
+		 (setq tail (> n 0)
+		       n 0
+		       method (cdr method)))
+		((> n 0)
+		 ;; try next element of pattern
+		 (setq n (1- n)
+		       method (cdr method))
+		 (if (< n 0)
+		     ;; Too few elements in pattern.
+		     (throw 'exit normal-indent)))
+		((eq tem 'nil)
 		 (throw 'exit (if (consp normal-indent)
 				  normal-indent
 				(list normal-indent containing-form-start))))
 			(cond ((null p)
 			       (list (+ sexp-column 4) containing-form-start))
 			      ((null (cdr p))
-                               ;; Indentation within a lambda-list. -- dvl
-                               (list (lisp-indent-lambda-list
-                                      indent-point
-                                      sexp-column
-                                      containing-form-start)
-                                     containing-form-start))
-                              (t
-                               normal-indent))))
-                ((integerp tem)
-                 (throw 'exit
-                   (if (null p)         ;not in subforms
-                       (list (+ sexp-column tem) containing-form-start)
-                       normal-indent)))
-                ((symbolp tem)          ;a function to call
-                 (throw 'exit
-                   (funcall tem path state indent-point
-                            sexp-column normal-indent)))
-                (t
-                 ;; must be a destructing frob
-                 (if (not (null p))
-                     ;; descend
-               (setq method (cddr tem)
-                           n nil)
-               (setq tem (cadr tem))
-                   (throw 'exit
-                     (cond (tail
-                            normal-indent)
-                           ((eq tem 'nil)
-                            (list normal-indent
-                                  containing-form-start))
-                           ((integerp tem)
-                            (list (+ sexp-column tem)
-                                  containing-form-start))
-                           (t
-                            (funcall tem path state indent-point
-                                     sexp-column normal-indent))))))))))))
+			       ;; Indentation within a lambda-list. -- dvl
+			       (list (lisp-indent-lambda-list
+				      indent-point
+				      sexp-column
+				      containing-form-start)
+				     containing-form-start))
+			      (t
+			       normal-indent))))
+		((integerp tem)
+		 (throw 'exit
+		   (if (null p)         ;not in subforms
+		       (list (+ sexp-column tem) containing-form-start)
+		       normal-indent)))
+		((symbolp tem)          ;a function to call
+		 (throw 'exit
+		   (funcall tem path state indent-point
+			    sexp-column normal-indent)))
+		(t
+		 ;; must be a destructing frob
+		 (if (not (null p))
+		     ;; descend
+	       (setq method (cddr tem)
+			   n nil)
+	       (setq tem (cadr tem))
+		   (throw 'exit
+		     (cond (tail
+			    normal-indent)
+			   ((eq tem 'nil)
+			    (list normal-indent
+				  containing-form-start))
+			   ((integerp tem)
+			    (list (+ sexp-column tem)
+				  containing-form-start))
+			   (t
+			    (funcall tem path state indent-point
+				     sexp-column normal-indent))))))))))))
 
 (defun lisp-indent-tagbody (path state indent-point sexp-column normal-indent)
   (if (not (null (cdr path)))
       (beginning-of-line)
       (skip-chars-forward " \t")
       (list (cond ((looking-at "\\sw\\|\\s_")
-                   ;; a tagbody tag
-                   (+ sexp-column lisp-tag-indentation))
-                  ((integerp lisp-tag-body-indentation)
-                   (+ sexp-column lisp-tag-body-indentation))
-                  ((eq lisp-tag-body-indentation 't)
-                   (condition-case ()
-                       (progn (backward-sexp 1) (current-column))
-                     (error (1+ sexp-column))))
-                  (t (+ sexp-column lisp-body-indent)))
+		   ;; a tagbody tag
+		   (+ sexp-column lisp-tag-indentation))
+		  ((integerp lisp-tag-body-indentation)
+		   (+ sexp-column lisp-tag-body-indentation))
+		  ((eq lisp-tag-body-indentation 't)
+		   (condition-case ()
+		       (progn (backward-sexp 1) (current-column))
+		     (error (1+ sexp-column))))
+		  (t (+ sexp-column lisp-body-indent)))
 ;            (cond ((integerp lisp-tag-body-indentation)
 ;                   (+ sexp-column lisp-tag-body-indentation))
 ;                  ((eq lisp-tag-body-indentation 't)
 ;                   normal-indent)
 ;                  (t
 ;                   (+ sexp-column lisp-body-indent)))
-            (elt state 1)
-            ))))
+	    (elt state 1)
+	    ))))
 
 (defun lisp-indent-do (path state indent-point sexp-column normal-indent)
   (if (>= (car path) 3)
       (let ((lisp-tag-body-indentation lisp-body-indent))
-        (funcall (function lisp-indent-tagbody)
-                 path state indent-point sexp-column normal-indent))
+	(funcall (function lisp-indent-tagbody)
+		 path state indent-point sexp-column normal-indent))
     (funcall (function lisp-indent-259)
-             '((&whole nil &rest
-                ;; the following causes weird indentation
-                ;;(&whole 1 1 2 nil)
-                )
-               (&whole nil &rest 1))
-             path state indent-point sexp-column normal-indent)))
+	     '((&whole nil &rest
+		;; the following causes weird indentation
+		;;(&whole 1 1 2 nil)
+		)
+	       (&whole nil &rest 1))
+	     path state indent-point sexp-column normal-indent)))
 
 
 ;; LISP-INDENT-DEFMETHOD now supports the presence of more than one method
 		  (forward-sexp)
 		  (skip-chars-forward " \t\n"))
 		(> nqual 0)))
-         (append '(4) (make-list nqual 4) '(&lambda &body))
+	 (append '(4) (make-list nqual 4) '(&lambda &body))
 	 (get 'defun 'common-lisp-indent-function)))
    path state indent-point sexp-column normal-indent))
 
 
 (defun lisp-indent-function-lambda-hack (path state indent-point
-                                         sexp-column normal-indent)
+					 sexp-column normal-indent)
   ;; indent (function (lambda () <newline> <body-forms>)) kludgily.
   (if (or (cdr path) ; wtf?
-          (> (car path) 3))
+	  (> (car path) 3))
       ;; line up under previous body form
       normal-indent
     ;; line up under function rather than under lambda in order to
     ;;  conserve horizontal space.  (Which is what #' is for.)
     (condition-case ()
-        (save-excursion
-          (backward-up-list 2)
-          (forward-char 1)
-          (if (looking-at "\\(lisp:+\\)?function\\(\\Sw\\|\\S_\\)")
-              (+ lisp-body-indent -1 (current-column))
-              (+ sexp-column lisp-body-indent)))
+	(save-excursion
+	  (backward-up-list 2)
+	  (forward-char 1)
+	  (if (looking-at "\\(lisp:+\\)?function\\(\\Sw\\|\\S_\\)")
+	      (+ lisp-body-indent -1 (current-column))
+	      (+ sexp-column lisp-body-indent)))
        (error (+ sexp-column lisp-body-indent)))))
 
 
 
 (let ((l '((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))
+	   (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)
+	   (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)
-           ;; `else-body' style
-           (if          (nil nil &body))
-           ;; single-else style (then and else equally indented)
-           (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) ;barf
-           (handler-bind . let)
-           (restart-bind . let)
-           (locally 1)
-           ;(loop         lisp-indent-loop)
-           (:method (&lambda &body)) ; in `defgeneric'
-           (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))
-           ;; Combines the worst features of BLOCK, LET and TAGBODY
-           (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)))))
+	   (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)
+	   ;; `else-body' style
+	   (if          (nil nil &body))
+	   ;; single-else style (then and else equally indented)
+	   (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) ;barf
+	   (handler-bind . let)
+	   (restart-bind . let)
+	   (locally 1)
+	   ;(loop         lisp-indent-loop)
+	   (:method (&lambda &body)) ; in `defgeneric'
+	   (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))
+	   ;; Combines the worst features of BLOCK, LET and TAGBODY
+	   (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)))))
   (dolist (el l)
     (put (car el) 'common-lisp-indent-function
-         (if (symbolp (cdr el))
-             (get (cdr el) 'common-lisp-indent-function)
-             (car (cdr el))))))
+	 (if (symbolp (cdr el))
+	     (get (cdr el) 'common-lisp-indent-function)
+	     (car (cdr el))))))
 
 
 ;(defun foo (x)
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.