* lisp/simple.el (blink-matching-open): Use syntax-class.

* lisp/emacs-lisp/lisp.el (up-list): Don't do nothing silently.

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index dadc344..96c9534 100644 (file)
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,5 +1,9 @@
 2010-09-20  Stefan Monnier  <monnier@iro.umontreal.ca>
 
+       * emacs-lisp/lisp.el (up-list): Don't do nothing silently.
+
+       * simple.el (blink-matching-open): Use syntax-class.
+
        * progmodes/pascal.el (pascal-mode): Use define-derived-mode.
        Set invisibility spec for pascal's outline mode.
        (pascal-outline-change): Clean up calling convention.

diff --git a/lisp/emacs-lisp/lisp.el b/lisp/emacs-lisp/lisp.el
index e799dcd..cfb56eb 100644 (file)
--- a/lisp/emacs-lisp/lisp.el
+++ b/lisp/emacs-lisp/lisp.el
@@ -141,15 +141,19 @@ A negative argument means move backward but still to a less deep spot.
 This command assumes point is not in a string or comment."
   (interactive "^p")
   (or arg (setq arg 1))
-  (let ((inc (if (> arg 0) 1 -1)))
+  (let ((inc (if (> arg 0) 1 -1))
+        pos)
     (while (/= arg 0)
-      (if forward-sexp-function
+      (if (null forward-sexp-function)
+          (goto-char (or (scan-lists (point) inc 1) (buffer-end arg)))
           (condition-case err
-              (while (let ((pos (point)))
+              (while (progn (setq pos (point))
                        (forward-sexp inc)
                        (/= (point) pos)))
             (scan-error (goto-char (nth 2 err))))
-        (goto-char (or (scan-lists (point) inc 1) (buffer-end arg))))
+        (if (= (point) pos)
+            (signal 'scan-error
+                    (list "Unbalanced parentheses" (point) (point)))))
       (setq arg (- arg inc)))))
 
 (defun kill-sexp (&optional arg)

diff --git a/lisp/simple.el b/lisp/simple.el
index 1ab737d..ca20a57 100644 (file)
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -5525,9 +5525,10 @@ The function should return non-nil if the two tokens do not match.")
                         ;; backward-sexp skips backward over prefix chars,
                         ;; so move back to the matching paren.
                         (while (and (< (point) (1- oldpos))
-                                    (let ((code (car (syntax-after (point)))))
-                                      (or (eq (logand 65536 code) 6)
-                                          (eq (logand 1048576 code) 1048576))))
+                                    (let ((code (syntax-after (point))))
+                                      (or (eq (syntax-class code) 6)
+                                          (eq (logand 1048576 (car code))
+                                              1048576))))
                           (forward-char 1))
                         (point))
                     (error nil))))))