emacs: lisp/emacs-lisp/lisp-mode.el comparison

comparison lisp/emacs-lisp/lisp-mode.el @ 51261:a3a1d78e827e

(lisp-font-lock-syntactic-face-function): Don't infinite lop at bob. (emacs-lisp-mode): Mark its main custom group to be `lisp'. (prin1-char): New fun. (eval-last-sexp-1): Use it. Use with-syntax-table as well. (eval-defun-1): Don't replace `defvar' with `defconst'.

author	Stefan Monnier <monnier@iro.umontreal.ca>
date	Tue, 27 May 2003 14:17:17 +0000
parents	152c21ba1618
children	0e0d3c3dca7f

comparison

equal deleted inserted replaced

-:a51376ab4a2e
+:a3a1d78e827e
 ;;; lisp-mode.el --- Lisp mode, and its idiosyncratic commands
-;; Copyright (C) 1985, 1986, 1999, 2000, 2001 Free Software Foundation, Inc.
+;; Copyright (C) 1985, 1986, 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
 ;; Maintainer: FSF
 ;; Keywords: lisp, languages
 ;; This file is part of GNU Emacs.
 	       ;; This might be a docstring.
 	       (save-excursion
 		 (let ((n 0))
 		   (goto-char (nth 8 state))
 		   (condition-case nil
-		       (while (progn (backward-sexp 1) (setq n (1+ n))))
+		       (while (and (not (bobp))
+				   (progn (backward-sexp 1) (setq n (1+ n)))))
 		     (scan-error nil))
 		   (when (> n 0)
 		     (let ((sym (intern-soft
 				 (buffer-substring
 				  (point) (progn (forward-sexp 1) (point))))))
 (setq major-mode 'emacs-lisp-mode)
 (setq mode-name "Emacs-Lisp")
 (lisp-mode-variables)
 (setq imenu-case-fold-search nil)
 (run-hooks 'emacs-lisp-mode-hook))
+(put 'emacs-lisp-mode 'custom-mode-group 'lisp)
 (defvar lisp-mode-map
 (let ((map (make-sparse-keymap)))
 (set-keymap-parent map lisp-mode-shared-map)
 (define-key map "\e\C-x" 'lisp-eval-defun)
 				 (nth 0 value)
 				 (nth 2 value)
 				 (nth 1 value))
 	  (goto-char (min (point-max) point)))))))
+(defun prin1-char (char)
+"Return a string representing CHAR as a character rather than as an integer.
+If CHAR is not a character, return nil."
+(and (integerp char)
+(char-valid-p (event-basic-type char))
+(concat
+	"?"
+	(mapconcat
+	 (lambda (modif)
+	   (cond ((eq modif 'super) "\\s-")
+		 (t (string ?\\ (upcase (aref (symbol-name modif) 0)) ?-))))
+	 (event-modifiers char) "")
+	(string (event-basic-type char)))))
 (defun eval-last-sexp-1 (eval-last-sexp-arg-internal)
 "Evaluate sexp before point; print value in minibuffer.
 With argument, print output into current buffer."
 (let ((standard-output (if eval-last-sexp-arg-internal (current-buffer) t)))
 (let ((value
 	   (eval (let ((stab (syntax-table))
 		       (opoint (point))
 		       ignore-quotes
 		       expr)
-		   (unwind-protect
+		   (with-syntax-table emacs-lisp-mode-syntax-table
-		       (save-excursion
+		     ;; If this sexp appears to be enclosed in `...'
-			 (set-syntax-table emacs-lisp-mode-syntax-table)
+		     ;; then ignore the surrounding quotes.
-			 ;; If this sexp appears to be enclosed in `...'
+		     (setq ignore-quotes
-			 ;; then ignore the surrounding quotes.
+			   (or (eq (following-char) ?\')
-			 (setq ignore-quotes
+			       (eq (preceding-char) ?\')))
-			       (or (eq (following-char) ?\')
+		     (forward-sexp -1)
-				   (eq (preceding-char) ?\')))
+		     ;; If we were after `?\e' (or similar case),
-			 (forward-sexp -1)
+		     ;; use the whole thing, not just the `e'.
-			 ;; If we were after `?\e' (or similar case),
+		     (when (eq (preceding-char) ?\\)
-			 ;; use the whole thing, not just the `e'.
+		       (forward-char -1)
-			 (when (eq (preceding-char) ?\\)
+		       (when (eq (preceding-char) ??)
-			   (forward-char -1)
+			 (forward-char -1)))
-			   (when (eq (preceding-char) ??)
-			     (forward-char -1)))
+		     ;; Skip over `#N='s.
+		     (when (eq (preceding-char) ?=)
-			 ;; Skip over `#N='s.
+		       (let (labeled-p)
-			 (when (eq (preceding-char) ?=)
+			 (save-excursion
-			   (let (labeled-p)
+			   (skip-chars-backward "0-9#=")
-			     (save-excursion
+			   (setq labeled-p (looking-at "\\(#[0-9]+=\\)+")))
-			       (skip-chars-backward "0-9#=")
+			 (when labeled-p
-			       (setq labeled-p (looking-at "\\(#[0-9]+=\\)+")))
+			   (forward-sexp -1))))
-			     (when labeled-p
-			       (forward-sexp -1))))
+		     (save-restriction
+		       ;; vladimir@cs.ualberta.ca 30-Jul-1997: skip ` in
-			 (save-restriction
+		       ;; `variable' so that the value is returned, not the
-			   ;; vladimir@cs.ualberta.ca 30-Jul-1997: skip ` in
+		       ;; name
-			   ;; `variable' so that the value is returned, not the
+		       (if (and ignore-quotes
-			   ;; name
+				(eq (following-char) ?`))
-			   (if (and ignore-quotes
+			   (forward-char))
-				    (eq (following-char) ?`))
+		       (narrow-to-region (point-min) opoint)
-			       (forward-char))
+		       (setq expr (read (current-buffer)))
-			   (narrow-to-region (point-min) opoint)
+		       ;; If it's an (interactive ...) form, it's more
-			   (setq expr (read (current-buffer)))
+		       ;; useful to show how an interactive call would
-			   ;; If it's an (interactive ...) form, it's more
+		       ;; use it.
-			   ;; useful to show how an interactive call would
+		       (and (consp expr)
-			   ;; use it.
+			    (eq (car expr) 'interactive)
-			   (and (consp expr)
+			    (setq expr
-				(eq (car expr) 'interactive)
+				  (list 'call-interactively
-				(setq expr
+					(list 'quote
-				      (list 'call-interactively
+					      (list 'lambda
-					    (list 'quote
+						    '(&rest args)
-						  (list 'lambda
+						    expr
-							'(&rest args)
+						    'args)))))
-							expr
+		       expr))))))
-							'args)))))
-			   expr))
-		     (set-syntax-table stab))))))
 (let ((unabbreviated (let ((print-length nil) (print-level nil))
 			     (prin1-to-string value)))
 	    (print-length eval-expression-print-length)
 	    (print-level eval-expression-print-level)
+	    (char-string (prin1-char value))
 	    (beg (point))
 	    end)
 	(prog1
 	    (prin1 value)
+	  (if (and (eq standard-output t) char-string)
+	      (princ (concat " = " char-string)))
 	  (setq end (point))
 	  (when (and (bufferp standard-output)
 		     (or (not (null print-length))
 			 (not (null print-level)))
 		     (not (string= unabbreviated
 ;; The code in edebug-defun should be consistent with this, but not
 ;; the same, since this gets a macroexpended form.
 (cond ((not (listp form))
 	 form)
 	((and (eq (car form) 'defvar)
-	      (cdr-safe (cdr-safe form)))
+	      (cdr-safe (cdr-safe form))
-	 ;; Force variable to be bound.
+	      (boundp (cadr form)))
-	 (cons 'defconst (cdr form)))
+	 ;; Force variable to be re-set.
+	 `(progn (defvar ,(nth 1 form) nil ,@(nthcdr 3 form))
+		 (setq ,(nth 1 form) ,(nth 2 form))))
 	;; `defcustom' is now macroexpanded to
 	;; `custom-declare-variable' with a quoted value arg.
 	((and (eq (car form) 'custom-declare-variable)
 	      (default-boundp (eval (nth 1 form))))
 	 ;; Force variable to be bound.
 (not (looking-at "\\sw\\|\\s_")))
 ;; car of form doesn't seem to be a symbol
 (progn
 (if (not (> (save-excursion (forward-line 1) (point))
 calculate-lisp-indent-last-sexp))
-(progn (goto-char calculate-lisp-indent-last-sexp)
+		(progn (goto-char calculate-lisp-indent-last-sexp)
-(beginning-of-line)
+		       (beginning-of-line)
-(parse-partial-sexp (point)
+		       (parse-partial-sexp (point)
-					 calculate-lisp-indent-last-sexp 0 t)))
+					   calculate-lisp-indent-last-sexp 0 t)))
-;; Indent under the list or under the first sexp on the same
+	    ;; Indent under the list or under the first sexp on the same
-;; line as calculate-lisp-indent-last-sexp.  Note that first
+	    ;; line as calculate-lisp-indent-last-sexp.  Note that first
-;; thing on that line has to be complete sexp since we are
+	    ;; thing on that line has to be complete sexp since we are
 ;; inside the innermost containing sexp.
 (backward-prefix-chars)
 (current-column))
 (let ((function (buffer-substring (point)
 					(progn (forward-sexp 1) (point))))

Mercurial > emacs

comparison lisp/emacs-lisp/lisp-mode.el @ 51261:a3a1d78e827e