upstream

5 files changed, 75 insertions, 26 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 4c7306174d6..61ef1a21065 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,22 @@
+2011-08-23  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * shell.el (shell-completion-vars): Set pcomplete-arg-quote-list.
+        * pcomplete.el (pcomplete-quote-argument): Fix thinko (bug#9161).
+
+        * pcomplete.el (pcomplete-parse-comint-arguments): Fix inf-loop.
+        Mark obsolete.
+        * shell.el (shell-parse-pcomplete-arguments): New function.
+        (shell-completion-vars): Use it instead (bug#9160).
+
+2011-08-22  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * progmodes/sh-script.el (sh-maybe-here-document): Disable magic in
+        strings and comments (bug#9333).
+
+        * emacs-lisp/debug.el (debug-arglist): New function.
+        (debug-convert-byte-code): Use it.  Handle lexical byte-codes.
+        (debug-on-entry-1): Handle interpreted closures (bug#9120).
+
 2011-08-22  Juri Linkov  <juri@jurta.org>
 
         * progmodes/compile.el (compilation-mode-font-lock-keywords):
@@ -45,8 +64,8 @@
         (font-lock-default-fontify-region)
         (font-lock-default-unfontify-region): Add docstrings (Bug#8624).
 
-        * progmodes/compile.el (compilation-error-properties): Fix
-        confusion between file struct and message struct (Bug#9319).
+        * progmodes/compile.el (compilation-error-properties):
+        Fix confusion between file struct and message struct (Bug#9319).
         (compilation-error-regexp-alist-alist): Fix 2011-05-09 change to
         `ant' regexp.
 
@@ -140,8 +159,8 @@
         binding variables (bug#9298).  Also clean up some unused
         autoloads.
 
-        * net/network-stream.el (network-stream-open-starttls): Support
-        using starttls.el without using gnutls-cli.
+        * net/network-stream.el (network-stream-open-starttls):
+        Support using starttls.el without using gnutls-cli.
 
 2011-08-17  Juri Linkov  <juri@jurta.org>
 
diff --git a/lisp/emacs-lisp/debug.el b/lisp/emacs-lisp/debug.el
index 157749500e7..8276030ccf8 100644
--- a/lisp/emacs-lisp/debug.el
+++ b/lisp/emacs-lisp/debug.el
@@ -778,6 +778,7 @@ Redefining FUNCTION also cancels it."
                          (not (debugger-special-form-p symbol))))
                 t nil nil (symbol-name fn)))
      (list (if (equal val "") fn (intern val)))))
+  ;; FIXME: Use advice.el.
   (when (debugger-special-form-p function)
     (error "Function %s is a special form" function))
   (if (or (symbolp (symbol-function function))
@@ -835,24 +836,30 @@ To specify a nil argument interactively, exit with an empty minibuffer."
     (message "Cancelling debug-on-entry for all functions")
     (mapcar 'cancel-debug-on-entry debug-function-list)))
 
+(defun debug-arglist (definition)
+  ;; FIXME: copied from ad-arglist.
+  "Return the argument list of DEFINITION."
+  (require 'help-fns)
+  (help-function-arglist definition 'preserve-names))
+
 (defun debug-convert-byte-code (function)
   (let* ((defn (symbol-function function))
          (macro (eq (car-safe defn) 'macro)))
     (when macro (setq defn (cdr defn)))
-    (unless (consp defn)
-      ;; Assume a compiled code object.
-      (let* ((contents (append defn nil))
+    (when (byte-code-function-p defn)
+      (let* ((args (debug-arglist defn))
              (body
-              (list (list 'byte-code (nth 1 contents)
-                          (nth 2 contents) (nth 3 contents)))))
-        (if (nthcdr 5 contents)
-            (setq body (cons (list 'interactive (nth 5 contents)) body)))
-        (if (nth 4 contents)
+              `((,(if (memq '&rest args) #'apply #'funcall)
+                 ,defn
+                 ,@(remq '&rest (remq '&optional args))))))
+        (if (> (length defn) 5)
+            (push `(interactive ,(aref defn 5)) body))
+        (if (aref defn 4)
             ;; Use `documentation' here, to get the actual string,
             ;; in case the compiled function has a reference
             ;; to the .elc file.
             (setq body (cons (documentation function) body)))
-        (setq defn (cons 'lambda (cons (car contents) body))))
+        (setq defn `(closure (t) ,args ,@body)))
       (when macro (setq defn (cons 'macro defn)))
       (fset function defn))))
 
@@ -861,11 +868,12 @@ To specify a nil argument interactively, exit with an empty minibuffer."
          (tail defn))
     (when (eq (car-safe tail) 'macro)
       (setq tail (cdr tail)))
-    (if (not (eq (car-safe tail) 'lambda))
+    (if (not (memq (car-safe tail) '(closure lambda)))
         ;; Only signal an error when we try to set debug-on-entry.
         ;; When we try to clear debug-on-entry, we are now done.
         (when flag
           (error "%s is not a user-defined Lisp function" function))
+      (if (eq (car tail) 'closure) (setq tail (cdr tail)))
       (setq tail (cdr tail))
       ;; Skip the docstring.
       (when (and (stringp (cadr tail)) (cddr tail))
@@ -875,9 +883,9 @@ To specify a nil argument interactively, exit with an empty minibuffer."
         (setq tail (cdr tail)))
       (unless (eq flag (equal (cadr tail) '(implement-debug-on-entry)))
         ;; Add/remove debug statement as needed.
-        (if flag
-            (setcdr tail (cons '(implement-debug-on-entry) (cdr tail)))
-          (setcdr tail (cddr tail)))))
+        (setcdr tail (if flag
+                         (cons '(implement-debug-on-entry) (cdr tail))
+                       (cddr tail)))))
     defn))
 
 (defun debugger-list-functions ()
diff --git a/lisp/pcomplete.el b/lisp/pcomplete.el
index 46a82e3720d..bdf2dadd16c 100644
--- a/lisp/pcomplete.el
+++ b/lisp/pcomplete.el
@@ -811,15 +811,19 @@ this is `comint-dynamic-complete-functions'."
       (while (< (point) end)
         (skip-chars-forward " \t\n")
         (push (point) begins)
-        (let ((skip t))
-          (while skip
-            (skip-chars-forward "^ \t\n")
-            (if (eq (char-before) ?\\)
-                (skip-chars-forward " \t\n")
-              (setq skip nil))))
+        (while
+            (progn
+              (skip-chars-forward "^ \t\n\\")
+              (when (eq (char-after) ?\\)
+                (forward-char 1)
+                (unless (eolp)
+                  (forward-char 1)
+                  t))))
         (push (buffer-substring-no-properties (car begins) (point))
               args))
       (cons (nreverse args) (nreverse begins)))))
+(make-obsolete 'pcomplete-parse-comint-arguments
+               'comint-parse-pcomplete-arguments "24.1")
 
 (defun pcomplete-parse-arguments (&optional expand-p)
   "Parse the command line arguments.  Most completions need this info."
@@ -879,7 +883,7 @@ Magic characters are those in `pcomplete-arg-quote-list'."
                        (or (run-hook-with-args-until-success
                             'pcomplete-quote-arg-hook filename index)
                            (when (memq c pcomplete-arg-quote-list)
-                             (string "\\" c))
+                             (string ?\\ c))
                            (char-to-string c))
                      (setq index (1+ index))))
                  filename
diff --git a/lisp/progmodes/sh-script.el b/lisp/progmodes/sh-script.el
index 31a4fbaef4d..7b949134c6c 100644
--- a/lisp/progmodes/sh-script.el
+++ b/lisp/progmodes/sh-script.el
@@ -460,6 +460,7 @@ This is buffer-local in every such buffer.")
     (define-key map "\C-c+" 'sh-add)
     (define-key map "\C-\M-x" 'sh-execute-region)
     (define-key map "\C-c\C-x" 'executable-interpret)
+    ;; FIXME: Use post-self-insert-hook.
     (define-key map "<" 'sh-maybe-here-document)
     (define-key map "(" 'skeleton-pair-insert-maybe)
     (define-key map "{" 'skeleton-pair-insert-maybe)
@@ -3659,6 +3660,7 @@ The document is bounded by `sh-here-document-word'."
       (save-excursion
         (backward-char 2)
         (sh-quoted-p))
+      (nth 8 (syntax-ppss))
       (let ((tabs (if (string-match "\\`-" sh-here-document-word)
                       (make-string (/ (current-indentation) tab-width) ?\t)
                     ""))
diff --git a/lisp/shell.el b/lisp/shell.el
index de811543ba0..01d1a688f0e 100644
--- a/lisp/shell.el
+++ b/lisp/shell.el
@@ -383,6 +383,21 @@ to `dirtrack-mode'."
   :group 'shell
   :type '(choice (const nil) regexp))
 
+(defun shell-parse-pcomplete-arguments ()
+  "Parse whitespace separated arguments in the current region."
+  (let ((begin (save-excursion (shell-backward-command 1) (point)))
+        (end (point))
+        begins args)
+    (save-excursion
+      (goto-char begin)
+      (while (< (point) end)
+        (skip-chars-forward " \t\n")
+        (push (point) begins)
+        (looking-at "\\(?:[^\s\t\n\\]\\|'[^']*'\\|\"\\(?:[^\"\\]\\|\\\\.\\)*\"\\|\\\\.\\)*\\(?:\\\\\\|'[^']*\\|\"\\(?:[^\"\\]\\|\\\\.\\)*\\)?")
+        (goto-char (match-end 0))
+        (push (buffer-substring-no-properties (car begins) (point))
+              args))
+      (cons (nreverse args) (nreverse begins)))))
 
 (defun shell-completion-vars ()
   "Setup completion vars for `shell-mode' and `read-shell-command'."
@@ -396,8 +411,9 @@ to `dirtrack-mode'."
   (set (make-local-variable 'comint-dynamic-complete-functions)
        shell-dynamic-complete-functions)
   (set (make-local-variable 'pcomplete-parse-arguments-function)
-       ;; FIXME: This function should be moved to shell.el.
-       #'pcomplete-parse-comint-arguments)
+       #'shell-parse-pcomplete-arguments)
+  (set (make-local-variable 'pcomplete-arg-quote-list)
+       (append "\\ \t\n\r\"'`$|&;(){}[]<>#" nil))
   (set (make-local-variable 'pcomplete-termination-string)
        (cond ((not comint-completion-addsuffix) "")
              ((stringp comint-completion-addsuffix)