Merge branch 'trunk' into xwidget

Conflicts:
	src/xdisp.c

6 files changed, 124 insertions, 75 deletions

diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 9077bdbb513..a3bd000a4f3 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -6892,7 +6892,7 @@ comment at the start of cc-engine.el for more info."
       (while (and (looking-at c-type-decl-prefix-key)
                   (if (and (c-major-mode-is 'c++-mode)
                            (match-beginning 3))
-                      ;; If the second submatch matches in C++ then
+                      ;; If the third submatch matches in C++ then
                       ;; we're looking at an identifier that's a
                       ;; prefix only if it specifies a member pointer.
                       (when (setq got-identifier (c-forward-name))
@@ -7193,19 +7193,23 @@ comment at the start of cc-engine.el for more info."
         ;; uncommon (e.g. some placements of "const" in C++) it's not worth
         ;; the effort to look for them.)
 
-        (unless (or at-decl-end (looking-at "=[^=]"))
-          ;; If this is a declaration it should end here or its initializer(*)
-          ;; should start here, so check for allowed separation tokens.  Note
-          ;; that this rule doesn't work e.g. with a K&R arglist after a
-          ;; function header.
-          ;;
-          ;; *) Don't check for C++ style initializers using parens
-          ;; since those already have been matched as suffixes.
-          ;;
-          ;; If `at-decl-or-cast' is then we've found some other sign that
-          ;; it's a declaration or cast, so then it's probably an
-          ;; invalid/unfinished one.
-          (throw 'at-decl-or-cast at-decl-or-cast))
+;;; 2008-04-16: commented out the next form, to allow the function to recognize
+;;; "foo (int bar)" in CC (an implicit type (in class foo) without a semicolon)
+;;; as a(n almost complete) declaration, enabling it to be fontified.
+        ;; CASE 13
+        ;; (unless (or at-decl-end (looking-at "=[^=]"))
+        ;; If this is a declaration it should end here or its initializer(*)
+        ;; should start here, so check for allowed separation tokens.  Note
+        ;; that this rule doesn't work e.g. with a K&R arglist after a
+        ;; function header.
+        ;;
+        ;; *) Don't check for C++ style initializers using parens
+        ;; since those already have been matched as suffixes.
+        ;;
+        ;; If `at-decl-or-cast' is then we've found some other sign that
+        ;; it's a declaration or cast, so then it's probably an
+        ;; invalid/unfinished one.
+        ;;  (throw 'at-decl-or-cast at-decl-or-cast))
 
         ;; Below are tests that only should be applied when we're certain to
         ;; not have parsed halfway through an expression.
diff --git a/lisp/progmodes/cfengine.el b/lisp/progmodes/cfengine.el
index 55d5b8b0be7..85a9074760d 100644
--- a/lisp/progmodes/cfengine.el
+++ b/lisp/progmodes/cfengine.el
@@ -387,10 +387,10 @@ Intended as the value of `indent-line-function'."
                               (skip-chars-forward " \t")
                               (current-column)))
           (error nil)))
-       ;; Inside a string and it starts before this line.
+       ;; Inside a string and it starts before this line: do nothing.
        ((and (nth 3 parse)
              (< (nth 8 parse) (save-excursion (beginning-of-line) (point))))
-        (indent-line-to 0))
+        )
 
        ;; Inside a defun, but not a nested list (depth is 1).  This is
        ;; a promise, usually.
diff --git a/lisp/progmodes/ebrowse.el b/lisp/progmodes/ebrowse.el
index 4957b58d469..6a71ab330a8 100644
--- a/lisp/progmodes/ebrowse.el
+++ b/lisp/progmodes/ebrowse.el
@@ -33,12 +33,12 @@
 
 ;;; Code:
 
+(require 'cl-lib)
 (require 'easymenu)
 (require 'view)
 (require 'ebuff-menu)
 
 (eval-when-compile
-  (require 'cl-lib)
   (require 'helper))
 
 
@@ -233,19 +233,6 @@ Compare items with `eq' or TEST if specified."
     found))
 
 
-(defun ebrowse-delete-if-not (predicate list)
-  "Remove elements not satisfying PREDICATE from LIST and return the result.
-This is a destructive operation."
-  (let (result)
-    (while list
-      (let ((next (cdr list)))
-        (when (funcall predicate (car list))
-          (setq result (nconc result list))
-          (setf (cdr list) nil))
-        (setq list next)))
-    result))
-
-
 (defmacro ebrowse-output (&rest body)
   "Eval BODY with a writable current buffer.
 Preserve buffer's modified state."
@@ -1310,17 +1297,17 @@ With PREFIX, insert that many filenames."
 
 (defun ebrowse-browser-buffer-list ()
   "Return a list of all tree or member buffers."
-  (ebrowse-delete-if-not 'ebrowse-buffer-p (buffer-list)))
+  (cl-delete-if-not 'ebrowse-buffer-p (buffer-list)))
 
 
 (defun ebrowse-member-buffer-list ()
   "Return a list of all member buffers."
-  (ebrowse-delete-if-not 'ebrowse-member-buffer-p (buffer-list)))
+  (cl-delete-if-not 'ebrowse-member-buffer-p (buffer-list)))
 
 
 (defun ebrowse-tree-buffer-list ()
   "Return a list of all tree buffers."
-  (ebrowse-delete-if-not 'ebrowse-tree-buffer-p (buffer-list)))
+  (cl-delete-if-not 'ebrowse-tree-buffer-p (buffer-list)))
 
 
 (defun ebrowse-known-class-trees-buffer-list ()
@@ -1341,7 +1328,7 @@ one buffer.  Prefer tree buffers over member buffers."
 
 (defun ebrowse-same-tree-member-buffer-list ()
   "Return a list of members buffers with same tree as current buffer."
-  (ebrowse-delete-if-not
+  (cl-delete-if-not
    (lambda (buffer)
      (eq (buffer-local-value 'ebrowse--tree buffer)
          ebrowse--tree))
diff --git a/lisp/progmodes/gdb-mi.el b/lisp/progmodes/gdb-mi.el
index 2c4d6a0e3d7..10472ec5815 100644
--- a/lisp/progmodes/gdb-mi.el
+++ b/lisp/progmodes/gdb-mi.el
@@ -1759,6 +1759,9 @@ static char *magick[] = {
 As long as GDB is in the recursive reading loop, it does not expect
 commands to be prefixed by \"-interpreter-exec console\".")
 
+(defun gdb-strip-string-backslash (string)
+  (replace-regexp-in-string "\\\\$" "" string))
+
 (defun gdb-send (proc string)
   "A comint send filter for gdb."
   (with-current-buffer gud-comint-buffer
@@ -1766,10 +1769,15 @@ commands to be prefixed by \"-interpreter-exec console\".")
       (remove-text-properties (point-min) (point-max) '(face))))
   ;; mimic <RET> key to repeat previous command in GDB
   (if (not (string= "" string))
-      (setq gdb-last-command string)
-    (if gdb-last-command (setq string gdb-last-command)))
-  (if (or (string-match "^-" string)
-          (> gdb-control-level 0))
+      (if gdb-continuation
+          (setq gdb-last-command (concat gdb-continuation
+                                         (gdb-strip-string-backslash string)
+                                         " "))
+        (setq gdb-last-command (gdb-strip-string-backslash string)))
+    (if gdb-last-command (setq string gdb-last-command))
+    (setq gdb-continuation nil))
+  (if (and (not gdb-continuation) (or (string-match "^-" string)
+          (> gdb-control-level 0)))
       ;; Either MI command or we are feeding GDB's recursive reading loop.
       (progn
         (setq gdb-first-done-or-error t)
@@ -1779,10 +1787,13 @@ commands to be prefixed by \"-interpreter-exec console\".")
             (setq gdb-control-level (1- gdb-control-level))))
     ;; CLI command
     (if (string-match "\\\\$" string)
-        (setq gdb-continuation (concat gdb-continuation string "\n"))
+        (setq gdb-continuation
+              (concat gdb-continuation (gdb-strip-string-backslash
+                                        string)
+                      " "))
       (setq gdb-first-done-or-error t)
       (let ((to-send (concat "-interpreter-exec console "
-                             (gdb-mi-quote string)
+                             (gdb-mi-quote (concat gdb-continuation string " "))
                              "\n")))
         (if gdb-enable-debug
             (push (cons 'mi-send to-send) gdb-debug-log))
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 915b52ce04d..62870f9085b 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -3091,7 +3091,12 @@ you are doing."
            ;; Stop collecting nodes after moving to a position with
            ;; indentation equaling min-indent. This is specially
            ;; useful for navigating nested definitions recursively.
-           tree)
+           (if (> num-children 0)
+               tree
+             ;; When there are no children, the collected tree is a
+             ;; single node intended to be added in the list of defuns
+             ;; of its parent.
+             (car tree)))
           (t
            (python-imenu--build-tree
             min-indent
@@ -3131,7 +3136,7 @@ you are doing."
                    (cons
                     (prog1
                         (python-imenu--build-tree
-                         prev-indent indent 1 (list (cons label pos)))
+                         prev-indent indent 0 (list (cons label pos)))
                       ;; Adjustment: after scanning backwards
                       ;; for all deeper children, we need to
                       ;; continue our scan for a parent from
diff --git a/lisp/progmodes/ruby-mode.el b/lisp/progmodes/ruby-mode.el
index 0292e40b986..0b83921504b 100644
--- a/lisp/progmodes/ruby-mode.el
+++ b/lisp/progmodes/ruby-mode.el
@@ -990,13 +990,14 @@ calculating indentation on the lines after it."
 (defun ruby-move-to-block (n)
   "Move to the beginning (N < 0) or the end (N > 0) of the
 current block, a sibling block, or an outer block.  Do that (abs N) times."
+  (back-to-indentation)
   (let ((signum (if (> n 0) 1 -1))
         (backward (< n 0))
-        (depth (or (nth 2 (ruby-parse-region (line-beginning-position)
-                                             (line-end-position)))
-                   0))
+        (depth (or (nth 2 (ruby-parse-region (point) (line-end-position))) 0))
         case-fold-search
         down done)
+    (when (looking-at ruby-block-mid-re)
+      (setq depth (+ depth signum)))
     (when (< (* depth signum) 0)
       ;; Moving end -> end or beginning -> beginning.
       (setq depth 0))
@@ -1033,22 +1034,16 @@ current block, a sibling block, or an outer block.  Do that (abs N) times."
             (unless (car state) ; Line ends with unfinished string.
               (setq depth (+ (nth 2 state) depth))))
           (cond
-           ;; Deeper indentation, we found a block.
-           ;; FIXME: We can't recognize empty blocks this way.
+           ;; Increased depth, we found a block.
            ((> (* signum depth) 0)
             (setq down t))
-           ;; Block found, and same indentation as when started, stop.
+           ;; We're at the same depth as when we started, and we've
+           ;; encountered a block before.  Stop.
            ((and down (zerop depth))
             (setq done t))
-           ;; Shallower indentation, means outer block, can stop now.
+           ;; Lower depth, means outer block, can stop now.
            ((< (* signum depth) 0)
-            (setq done t)))))
-        (if done
-            (save-excursion
-              (back-to-indentation)
-              ;; Not really at the first or last line of the block, move on.
-              (if (looking-at (concat "\\<\\(" ruby-block-mid-re "\\)\\>"))
-                  (setq done nil))))))
+            (setq done t)))))))
     (back-to-indentation)))
 
 (defun ruby-beginning-of-block (&optional arg)
@@ -1356,7 +1351,7 @@ If the result is do-end block, it will always be multiline."
     (progn
       (eval-and-compile
         (defconst ruby-percent-literal-beg-re
-          "\\(%\\)[qQrswWx]?\\([[:punct:]]\\)"
+          "\\(%\\)[qQrswWxIi]?\\([[:punct:]]\\)"
           "Regexp to match the beginning of percent literal.")
 
         (defconst ruby-syntax-methods-before-regexp
@@ -1392,7 +1387,7 @@ It will be properly highlighted even when the call omits parens.")
           (funcall
            (syntax-propertize-rules
             ;; $' $" $` .... are variables.
-            ;; ?' ?" ?` are ascii codes.
+            ;; ?' ?" ?` are character literals (one-char strings in 1.9+).
             ("\\([?$]\\)[#\"'`]"
              (1 (unless (save-excursion
                           ;; Not within a string.
@@ -1523,7 +1518,7 @@ It will be properly highlighted even when the call omits parens.")
             (save-match-data
               (save-excursion
                 (goto-char (nth 8 parse-state))
-                (looking-at "%\\(?:[QWrx]\\|\\W\\)")))))))
+                (looking-at "%\\(?:[QWrxI]\\|\\W\\)")))))))
 
       (defun ruby-syntax-propertize-expansions (start end)
         (save-excursion
@@ -1726,7 +1721,7 @@ See `font-lock-syntax-table'.")
 (defconst ruby-font-lock-keywords
   (list
    ;; functions
-   '("^\\s *def\\s +\\([^( \t\n]+\\)"
+   '("^\\s *def\\s +\\(?:[^( \t\n.]*\\.\\)?\\([^( \t\n]+\\)"
      1 font-lock-function-name-face)
    (list (concat
           "\\(^\\|[^.@$]\\|\\.\\.\\)\\("
@@ -1767,31 +1762,66 @@ See `font-lock-syntax-table'.")
              "yield")
            'symbols)
           "\\|"
-          ;; keyword-like methods on Kernel and Module
           (regexp-opt
-           '("alias_method"
+           ;; built-in methods on Kernel
+           '("__callee__"
+             "__dir__"
+             "__method__"
+             "abort"
+             "at_exit"
              "autoload"
+             "autoload?"
+             "binding"
+             "block_given?"
+             "caller"
+             "catch"
+             "eval"
+             "exec"
+             "exit"
+             "exit!"
+             "fail"
+             "fork"
+             "format"
+             "lambda"
+             "load"
+             "loop"
+             "open"
+             "p"
+             "print"
+             "printf"
+             "proc"
+             "putc"
+             "puts"
+             "raise"
+             "rand"
+             "readline"
+             "readlines"
+             "require"
+             "require_relative"
+             "sleep"
+             "spawn"
+             "sprintf"
+             "srand"
+             "syscall"
+             "system"
+             "throw"
+             "trap"
+             "warn"
+             ;; keyword-like private methods on Module
+             "alias_method"
              "attr"
              "attr_accessor"
              "attr_reader"
              "attr_writer"
-             "catch"
              "define_method"
              "extend"
-             "fail"
              "include"
-             "lambda"
-             "loop"
              "module_function"
+             "prepend"
              "private"
-             "proc"
              "protected"
              "public"
-             "raise"
              "refine"
-             "require"
-             "require_relative"
-             "throw"
              "using")
            'symbols)
           "\\)")
@@ -1799,12 +1829,16 @@ See `font-lock-syntax-table'.")
          '(if (match-beginning 4)
               font-lock-builtin-face
             font-lock-keyword-face))
+   ;; Perl-ish keywords
+   "\\_<\\(?:BEGIN\\|END\\)\\_>\\|^__END__$"
    ;; here-doc beginnings
    `(,ruby-here-doc-beg-re 0 (unless (ruby-singleton-class-p (match-beginning 0))
                                'font-lock-string-face))
    ;; variables
    '("\\(^\\|[^.@$]\\|\\.\\.\\)\\_<\\(nil\\|self\\|true\\|false\\)\\>"
      2 font-lock-variable-name-face)
+   ;; keywords that evaluate to certain values
+   '("\\_<__\\(?:LINE\\|ENCODING\\|FILE\\)__\\_>" 0 font-lock-variable-name-face)
    ;; symbols
    '("\\(^\\|[^:]\\)\\(:\\([-+~]@?\\|[/%&|^`]\\|\\*\\*?\\|<\\(<\\|=>?\\)?\\|>[>=]?\\|===?\\|=~\\|![~=]?\\|\\[\\]=?\\|@?\\(\\w\\|_\\)+\\([!?=]\\|\\b_*\\)\\|#{[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\)\\)"
      2 font-lock-constant-face)
@@ -1815,14 +1849,22 @@ See `font-lock-syntax-table'.")
      0 font-lock-variable-name-face)
    ;; constants
    '("\\(?:\\_<\\|::\\)\\([A-Z]+\\(\\w\\|_\\)*\\)"
-     1 font-lock-type-face)
+     1 (unless (eq ?\( (char-after)) font-lock-type-face))
    '("\\(^\\s *\\|[\[\{\(,]\\s *\\|\\sw\\s +\\)\\(\\(\\sw\\|_\\)+\\):[^:]" 2 font-lock-constant-face)
+   ;; conversion methods on Kernel
+   (list (concat "\\(?:^\\|[^.@$]\\|\\.\\.\\)"
+                 (regexp-opt '("Array" "Complex" "Float" "Hash"
+                               "Integer" "Rational" "String") 'symbols))
+         1 font-lock-builtin-face)
    ;; expression expansion
    '(ruby-match-expression-expansion
      2 font-lock-variable-name-face t)
-   ;; warn lower camel case
-                                        ;'("\\<[a-z]+[a-z0-9]*[A-Z][A-Za-z0-9]*\\([!?]?\\|\\>\\)"
-                                        ;  0 font-lock-warning-face)
+   ;; negation char
+   '("[^[:alnum:]_]\\(!\\)[^=]"
+     1 font-lock-negation-char-face)
+   ;; character literals
+   ;; FIXME: Support longer escape sequences.
+   '("\\?\\\\?\\S " 0 font-lock-string-face)
    )
   "Additional expressions to highlight in Ruby mode.")