emacs: lisp/emacs-lisp/cl-indent.el comparison

comparison lisp/emacs-lisp/cl-indent.el @ 22858:77090a500417

(lisp-indent-defun-method): New variable. (common-lisp-indent-function): Use it. (lisp-indent-259): Uncomment the `&lambda' code. (top-level let): Remove duplicate `catch' and `block'. Use `&lambda' when appropriate. Now the lambda lists are indented appropriately.

author	Richard M. Stallman <rms@gnu.org>
date	Fri, 31 Jul 1998 03:21:07 +0000
parents	6103b46f200a
children	edbc56db94ee

comparison

equal deleted inserted replaced

-:33b46ddf75b7
+:77090a500417
 :type 'integer
 :group 'lisp-indent)
 (defvar lisp-indent-error-function)
+(defvar lisp-indent-defun-method '(4 &lambda &body))
 ;;;###autoload
 (defun common-lisp-indent-function (indent-point state)
 (let ((normal-indent (current-column)))
 ;; Walk up list levels until we see something
 (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 tem (point))))
+(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))
 (setq path (cons n path)))
 ;; backwards compatibility.
 (cond ((null function))
 ((null method)
-(if (null (cdr path))
+(when (null (cdr path))
 ;; (package prefix was stripped off above)
 (setq method (cond ((string-match "\\`def"
 function)
-'(4 (&whole 4 &rest 1) &body))
+lisp-indent-defun-method)
 ((string-match "\\`\\(with\\|do\\)-"
 function)
-'(4 &body))))))
+'(&lambda &body))))))
 ;; backwards compatibility.  Bletch.
 ((eq method 'defun)
-(setq method '(4 (&whole 4 &rest 1) &body))))
+(setq method lisp-indent-defun-method)))
 (cond ((and (memq (char-after (1- containing-sexp)) '(?\' ?\`))
 (not (eql (char-after (- containing-sexp 2)) ?\#)))
 ;; No indentation for "'(...)" elements
 (setq calculated (1+ sexp-column)))
 		     (setq calculated (lisp-indent-259
 				       method path state indent-point
 				       sexp-column normal-indent))))))
 (goto-char containing-sexp)
 (setq last-point containing-sexp)
-(if (not calculated)
+(unless calculated
 (condition-case ()
 (progn (backward-up-list 1)
 (setq depth (1+ depth)))
 (error (setq depth lisp-indent-maximum-backtracking))))))
 calculated)))
 ;; 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)         ;abbrev for (&whole 4 (&rest 1))
+(eq tem '&lambda)     ;lambda list
 (and (eq tem '&body) (null (cdr method)))
 (and (eq tem '&rest)
-(consp (cdr method)) (null (cdr (cdr method))))
+(consp (cdr method)) (null (cddr method)))
 (integerp tem)            ;explicit indentation specified
 (and (consp tem)          ;destructuring
 (eq (car tem) '&whole)
-(or (symbolp (car (cdr tem)))
+(or (symbolp (cadr tem))
-(integerp (car (cdr 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)))
 (if (< n 0)
 ;; Too few elements in pattern.
 (throw 'exit normal-indent)))
 ((eq tem 'nil)
 (throw 'exit (list normal-indent containing-form-start)))
-;               ((eq tem '&lambda)
+((eq tem '&lambda)
-;                ;; abbrev for (&whole 4 &rest 1)
+(throw 'exit
-;                (throw 'exit
+(cond ((null p)
-;                  (cond ((null p)
+(list (+ sexp-column 4) containing-form-start))
-;                         (list (+ sexp-column 4) containing-form-start))
+((null (cdr p))
-;                        ((null (cdr p))
+(+ sexp-column 1))
-;                         (+ sexp-column 1))
+(t normal-indent))))
-;                        (t normal-indent))))
 ((integerp tem)
 (throw 'exit
 (if (null p)         ;not in subforms
 (list (+ sexp-column tem) containing-form-start)
 normal-indent)))
 sexp-column normal-indent)))
 (t
 ;; must be a destructing frob
 (if (not (null p))
 ;; descend
-(setq method (cdr (cdr tem))
+(setq method (cddr tem)
 n nil)
-(setq tem (car (cdr tem)))
+(setq tem (cadr tem))
 (throw 'exit
 (cond (tail
 normal-indent)
 ((eq tem 'nil)
 (list normal-indent
 (+ sexp-column lisp-body-indent)))
 (error (+ sexp-column lisp-body-indent)))))
 (let ((l '((block 1)
-	   (catch 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)))
-	   (block 1)
 	   (defvar      (4 2 2))
 	   (defconstant . defvar)
+(defcustom (4 2 2 2))
 	   (defparameter . defvar)
 	   (define-modify-macro
 			(4 &body))
-	   (define-setf-method
+	   (defsetf     (4 &lambda 4 &body))
-			(4 (&whole 4 &rest 1) &body))
+	   (defun       (4 &lambda &body))
-	   (defsetf     (4 (&whole 4 &rest 1) 4 &body))
+	   (define-setf-method . defun)
-	   (defun       (4 (&whole 4 &rest 1) &body))
+	   (define-setf-expander . defun)
 	   (defmacro . defun) (deftype . defun)
 	   (defpackage  (4 2))
 	   (defstruct   ((&whole 4 &rest (&whole 2 &rest 1))
 			 &rest (&whole 2 &rest 1)))
 	   (destructuring-bind
 	   (do          lisp-indent-do)
 	   (do* . do)
 	   (dolist      ((&whole 4 2 1) &body))
 	   (dotimes . dolist)
 	   (eval-when	1)
-	   (flet        ((&whole 4 &rest (&whole 1 (&whole 4 &rest 1) &body))
+	   (flet        ((&whole 4 &rest (&whole 1 &lambda &body)) &body))
-			 &body))
 	   (labels . flet)
 	   (macrolet . flet)
-(handler-case (4 &rest (&whole 2 (&whole 4 &rest 1) &body)))
+(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     ((&whole 4 &rest 1) &body))
+	   (lambda      (&lambda &rest lisp-indent-function-lambda-hack))
-	   (lambda      ((&whole 4 &rest 1)
-			 &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)
 	   (multiple-value-prog1 1)
 	   (multiple-value-setq
 			(4 2))
 	   (multiple-value-setf . multiple-value-setq)
 	   ;; Combines the worst features of BLOCK, LET and TAGBODY
-	   (prog        ((&whole 4 &rest 1) &rest lisp-indent-tagbody))
+	   (prog        (&lambda &rest lisp-indent-tagbody))
 	   (prog* . prog)
 	   (prog1 1)
 	   (prog2 2)
 	   (progn 0)
 	   (progv       (4 4 &body))
 	   (unless 1)
 	   (unwind-protect (5 &body))
 (when 1)
 (with-standard-io-syntax (2)))))
 (while l
-(put (car (car l)) 'common-lisp-indent-function
+(put (caar l) 'common-lisp-indent-function
-	 (if (symbolp (cdr (car l)))
+	 (if (symbolp (cdar l))
-	     (get (cdr (car l)) 'common-lisp-indent-function)
+	     (get (cdar l) 'common-lisp-indent-function)
-	     (car (cdr (car l)))))
+	     (car (cdar l))))
 (setq l (cdr l))))
 ;(defun foo (x)
 ;  (tagbody

Mercurial > emacs

comparison lisp/emacs-lisp/cl-indent.el @ 22858:77090a500417