merge upstream

12 files changed, 367 insertions, 295 deletions

diff --git a/lisp/progmodes/ada-xref.el b/lisp/progmodes/ada-xref.el
index d29fa8c1d36..1ca83a97a59 100644
--- a/lisp/progmodes/ada-xref.el
+++ b/lisp/progmodes/ada-xref.el
@@ -342,9 +342,9 @@ CROSS-PREFIX is the prefix to use for the `gnatls' command."
                 )
             (kill-buffer nil))))
 
-    (set 'ada-xref-runtime-library-specs-path
+    (setq ada-xref-runtime-library-specs-path
          (reverse ada-xref-runtime-library-specs-path))
-    (set 'ada-xref-runtime-library-ali-path
+    (setq ada-xref-runtime-library-ali-path
          (reverse ada-xref-runtime-library-ali-path))
     ))
 
@@ -582,8 +582,8 @@ as defined in the project file."
 
     (while dirs
       (if (file-directory-p (car dirs))
-          (set 'list (append list (file-name-all-completions string (car dirs)))))
-      (set 'dirs (cdr dirs)))
+          (setq list (append list (file-name-all-completions string (car dirs)))))
+      (setq dirs (cdr dirs)))
     (cond ((equal flag 'lambda)
            (assoc string list))
           (flag
@@ -702,11 +702,11 @@ is non-nil, prompt the user to select one.  If none are found, return
 
          ((file-exists-p first-choice)
           ;; filename.adp
-          (set 'selected first-choice))
+          (setq selected first-choice))
 
          ((= (length prj-files) 1)
           ;; Exactly one project file was found in the current directory
-          (set 'selected (car prj-files)))
+          (setq selected (car prj-files)))
 
          ((and (> (length prj-files) 1) (not no-user-question))
           ;;  multiple project files in current directory, ask the user
@@ -732,7 +732,7 @@ is non-nil, prompt the user to select one.  If none are found, return
                     (> choice (length prj-files)))
               (setq choice (string-to-number
                             (read-from-minibuffer "Enter No. of your choice: "))))
-            (set 'selected (nth (1- choice) prj-files))))
+            (setq selected (nth (1- choice) prj-files))))
 
          ((= (length prj-files) 0)
           ;; No project file in the current directory; ask user
@@ -742,7 +742,7 @@ is non-nil, prompt the user to select one.  If none are found, return
                    (concat "project file [" ada-last-prj-file "]:")
                    nil ada-last-prj-file))
             (unless (string= ada-last-prj-file "")
-              (set 'selected ada-last-prj-file))))
+              (setq selected ada-last-prj-file))))
          )))
 
     (or selected "default.adp")
@@ -792,9 +792,9 @@ is non-nil, prompt the user to select one.  If none are found, return
 
     (setq prj-file (expand-file-name prj-file))
     (if (string= (file-name-extension prj-file) "gpr")
-        (set 'project (ada-gnat-parse-gpr project prj-file))
+        (setq project (ada-gnat-parse-gpr project prj-file))
 
-      (set 'project (ada-parse-prj-file-1 prj-file project))
+      (setq project (ada-parse-prj-file-1 prj-file project))
       )
 
     ;; Store the project properties
@@ -842,7 +842,7 @@ Return new value of PROJECT."
                           (substitute-in-file-name (match-string 2)))))
 
            ((string= (match-string 1) "build_dir")
-            (set 'project
+            (setq project
                  (plist-put project 'build_dir
                             (file-name-as-directory (match-string 2)))))
 
@@ -884,7 +884,7 @@ Return new value of PROJECT."
 
            (t
             ;; any other field in the file is just copied
-            (set 'project (plist-put project
+            (setq project (plist-put project
                                      (intern (match-string 1))
                                      (match-string 2))))))
 
@@ -900,21 +900,21 @@ Return new value of PROJECT."
         (let ((sep (plist-get project 'ada_project_path_sep)))
           (setq ada_project_path (reverse ada_project_path))
           (setq ada_project_path (mapconcat 'identity ada_project_path sep))
-          (set 'project (plist-put project 'ada_project_path ada_project_path))
+          (setq project (plist-put project 'ada_project_path ada_project_path))
           ;; env var needed now for ada-gnat-parse-gpr
           (setenv "ADA_PROJECT_PATH" ada_project_path)))
 
-    (if debug_post_cmd (set 'project (plist-put project 'debug_post_cmd (reverse debug_post_cmd))))
-    (if debug_pre_cmd (set 'project (plist-put project 'debug_pre_cmd (reverse debug_pre_cmd))))
-    (if casing (set 'project (plist-put project 'casing (reverse casing))))
-    (if check_cmd (set 'project (plist-put project 'check_cmd (reverse check_cmd))))
-    (if comp_cmd (set 'project (plist-put project 'comp_cmd (reverse comp_cmd))))
-    (if make_cmd (set 'project (plist-put project 'make_cmd (reverse make_cmd))))
-    (if run_cmd (set 'project (plist-put project 'run_cmd (reverse run_cmd))))
+    (if debug_post_cmd (setq project (plist-put project 'debug_post_cmd (reverse debug_post_cmd))))
+    (if debug_pre_cmd (setq project (plist-put project 'debug_pre_cmd (reverse debug_pre_cmd))))
+    (if casing (setq project (plist-put project 'casing (reverse casing))))
+    (if check_cmd (setq project (plist-put project 'check_cmd (reverse check_cmd))))
+    (if comp_cmd (setq project (plist-put project 'comp_cmd (reverse comp_cmd))))
+    (if make_cmd (setq project (plist-put project 'make_cmd (reverse make_cmd))))
+    (if run_cmd (setq project (plist-put project 'run_cmd (reverse run_cmd))))
 
     (if gpr_file
         (progn
-          (set 'project (ada-gnat-parse-gpr project gpr_file))
+          (setq project (ada-gnat-parse-gpr project gpr_file))
           ;; append Ada source and object directories to others from Emacs project file
           (setq src_dir (append (plist-get project 'src_dir) src_dir))
           (setq obj_dir (append (plist-get project 'obj_dir) obj_dir))
@@ -930,8 +930,8 @@ Return new value of PROJECT."
     (ada-initialize-runtime-library (or (ada-xref-get-project-field 'cross_prefix) ""))
     ;;)
 
-    (if obj_dir (set 'project (plist-put project 'obj_dir (reverse obj_dir))))
-    (if src_dir (set 'project (plist-put project 'src_dir (reverse src_dir))))
+    (if obj_dir (setq project (plist-put project 'obj_dir (reverse obj_dir))))
+    (if src_dir (setq project (plist-put project 'src_dir (reverse src_dir))))
 
     project
     ))
@@ -1052,9 +1052,9 @@ existing buffer `*gnatfind*', if there is one."
       (if old-contents
           (progn
             (goto-char 1)
-            (set 'buffer-read-only nil)
+            (setq buffer-read-only nil)
             (insert old-contents)
-            (set 'buffer-read-only t)
+            (setq buffer-read-only t)
             (goto-char (point-max)))))
     )
   )
@@ -1194,9 +1194,9 @@ project file."
         (objects   (getenv "ADA_OBJECTS_PATH"))
         (build-dir (ada-xref-get-project-field 'build_dir)))
     (if include
-        (set 'include (concat path-separator include)))
+        (setq include (concat path-separator include)))
     (if objects
-        (set 'objects (concat path-separator objects)))
+        (setq objects (concat path-separator objects)))
     (cons
      (concat "ADA_INCLUDE_PATH="
              (mapconcat (lambda(x) (expand-file-name x build-dir))
@@ -1303,7 +1303,7 @@ If ARG is non-nil, ask for user confirmation."
 
     ;;  Guess the command if it wasn't specified
     (if (not command)
-        (set 'command (list (file-name-sans-extension (buffer-name)))))
+        (setq command (list (file-name-sans-extension (buffer-name)))))
 
     ;; Modify the command to run remotely
     (setq command (ada-remote (mapconcat 'identity command
@@ -1316,7 +1316,7 @@ If ARG is non-nil, ask for user confirmation."
 
     ;; Run the command
     (with-current-buffer (get-buffer-create "*run*")
-      (set 'buffer-read-only nil)
+      (setq buffer-read-only nil)
 
       (erase-buffer)
       (start-process "run" (current-buffer) shell-file-name
@@ -1352,7 +1352,7 @@ project file."
 
     ;;  If the command was not given in the project file, start a bare gdb
     (if (not cmd)
-        (set 'cmd (concat ada-prj-default-debugger
+        (setq cmd (concat ada-prj-default-debugger
                           " "
                           (or executable-name
                               (file-name-sans-extension (buffer-file-name))))))
@@ -1368,18 +1368,18 @@ project file."
         ;;  chance to fully manage it.  Then it works fine with Enlightenment
         ;;  as well
         (let ((frame (make-frame '((visibility . nil)))))
-          (set 'cmd (concat
+          (setq cmd (concat
                      cmd " --editor-window="
                      (cdr (assoc 'outer-window-id (frame-parameters frame)))))
           (select-frame frame)))
 
     ;;  Add a -fullname switch
     ;;  Use the remote machine
-    (set 'cmd (ada-remote (concat cmd " -fullname ")))
+    (setq cmd (ada-remote (concat cmd " -fullname ")))
 
     ;;  Ask for confirmation if required
     (if (or arg ada-xref-confirm-compile)
-        (set 'cmd (read-from-minibuffer "enter command to debug: " cmd)))
+        (setq cmd (read-from-minibuffer "enter command to debug: " cmd)))
 
     (let ((old-comint-exec (symbol-function 'comint-exec)))
 
@@ -1387,13 +1387,13 @@ project file."
       ;;  FIXME: This is evil but luckily a nop under Emacs-21.3.50 !  -stef
       (fset 'gud-gdb-massage-args (lambda (_file args) args))
 
-      (set 'pre-cmd  (mapconcat 'identity pre-cmd  ada-command-separator))
+      (setq pre-cmd  (mapconcat 'identity pre-cmd  ada-command-separator))
       (if (not (equal pre-cmd ""))
           (setq pre-cmd (concat pre-cmd ada-command-separator)))
 
-      (set 'post-cmd (mapconcat 'identity post-cmd "\n"))
+      (setq post-cmd (mapconcat 'identity post-cmd "\n"))
       (if post-cmd
-          (set 'post-cmd (concat post-cmd "\n")))
+          (setq post-cmd (concat post-cmd "\n")))
 
 
       ;;  Temporarily replaces the definition of `comint-exec' so that we
@@ -1403,7 +1403,7 @@ project file."
             `(lambda (buffer name command startfile switches)
                (let (compilation-buffer-name-function)
                  (save-excursion
-                   (set 'compilation-buffer-name-function
+                   (setq compilation-buffer-name-function
                         (lambda(x) (buffer-name buffer)))
                    (compile (ada-quote-cmd
                              (concat ,pre-cmd
@@ -1498,12 +1498,12 @@ by replacing the file extension with `.ali'."
   "Search for FILE in DIR-LIST."
   (let (found)
     (while (and (not found) dir-list)
-      (set 'found (concat (file-name-as-directory (car dir-list))
+      (setq found (concat (file-name-as-directory (car dir-list))
                           (file-name-nondirectory file)))
 
       (unless (file-exists-p found)
-          (set 'found nil))
-      (set 'dir-list (cdr dir-list)))
+          (setq found nil))
+      (setq dir-list (cdr dir-list)))
     found))
 
 (defun ada-find-ali-file-in-dir (file)
@@ -1558,11 +1558,11 @@ the project file."
             (while specs
               (if (string-match (concat (regexp-quote (car specs)) "$")
                                 file)
-                  (set 'is-spec t))
-              (set 'specs (cdr specs)))))
+                  (setq is-spec t))
+              (setq specs (cdr specs)))))
 
       (if is-spec
-          (set 'ali-file-name
+          (setq ali-file-name
                (ada-find-ali-file-in-dir
                 (concat (file-name-base (ada-other-file-name)) ".ali"))))
 
@@ -1589,8 +1589,8 @@ the project file."
                   (while (and (not ali-file-name)
                               (string-match "^\\(.*\\)[.-][^.-]*" parent-name))
 
-                    (set 'parent-name (match-string 1 parent-name))
-                    (set 'ali-file-name (ada-find-ali-file-in-dir
+                    (setq parent-name (match-string 1 parent-name))
+                    (setq ali-file-name (ada-find-ali-file-in-dir
                                          (concat parent-name ".ali")))
                     )
                   ali-file-name)))
@@ -1686,18 +1686,18 @@ macros `ada-name-of', `ada-line-of', `ada-column-of', `ada-file-of',..."
           (if (and (= (char-before) ?\")
                    (= (char-after (+ (length (match-string 0)) (point))) ?\"))
               (forward-char -1))
-          (set 'identifier (regexp-quote (concat "\"" (match-string 0) "\""))))
+          (setq identifier (regexp-quote (concat "\"" (match-string 0) "\""))))
 
       (if (ada-in-string-p)
           (error "Inside string or character constant"))
       (if (looking-at (concat ada-keywords "[^a-zA-Z_]"))
           (error "No cross-reference available for reserved keyword"))
       (if (looking-at "[a-zA-Z0-9_]+")
-          (set 'identifier (match-string 0))
+          (setq identifier (match-string 0))
         (error "No identifier around")))
 
     ;; Build the identlist
-    (set 'identlist    (ada-make-identlist))
+    (setq identlist    (ada-make-identlist))
     (ada-set-name      identlist (downcase identifier))
     (ada-set-line      identlist
                        (number-to-string (count-lines 1 (point))))
@@ -1725,7 +1725,7 @@ Information is extracted from the ali file."
          (concat "^X [0-9]+ " (file-name-nondirectory (ada-file-of identlist)))
          nil t)
         (let ((bound (save-excursion (re-search-forward "^X " nil t))))
-          (set 'declaration-found
+          (setq declaration-found
                (re-search-forward
                 (concat "^"    (ada-line-of identlist)
                         "."    (ada-column-of identlist)
@@ -1743,7 +1743,7 @@ Information is extracted from the ali file."
       ;; Since we already know the number of the file, search for a direct
       ;; reference to it
       (goto-char (point-min))
-      (set 'declaration-found t)
+      (setq declaration-found t)
       (ada-set-ali-index
        identlist
        (number-to-string (ada-find-file-number-in-ali
@@ -1771,7 +1771,7 @@ Information is extracted from the ali file."
             ;; If still not found, then either the declaration is unknown
             ;; or the source file has been modified since the ali file was
             ;; created
-            (set 'declaration-found nil)
+            (setq declaration-found nil)
             )
           )
 
@@ -1786,7 +1786,7 @@ Information is extracted from the ali file."
               (beginning-of-line))
             (unless (looking-at (concat "[0-9]+.[0-9]+[ *]"
                                         (ada-name-of identlist) "[ <{=\(\[]"))
-              (set 'declaration-found nil))))
+              (setq declaration-found nil))))
 
       ;; Still no success ! The ali file must be too old, and we need to
       ;; use a basic algorithm based on guesses.  Note that this only happens
@@ -1794,7 +1794,7 @@ Information is extracted from the ali file."
       ;; automatically
       (unless declaration-found
         (if (ada-xref-find-in-modified-ali identlist)
-            (set 'declaration-found t)
+            (setq declaration-found t)
           ;; No more idea to find the declaration.  Give up
           (progn
             (kill-buffer ali-buffer)
@@ -1814,7 +1814,7 @@ Information is extracted from the ali file."
             (forward-line 1)
             (beginning-of-line)
             (while (looking-at "^\\.\\(.*\\)")
-              (set 'current-line (concat current-line (match-string 1)))
+              (setq current-line (concat current-line (match-string 1)))
               (forward-line 1))
             )
 
@@ -1860,7 +1860,7 @@ This function is disabled for operators, and only works for identifiers."
           (goto-char (point-max))
           (while (re-search-backward my-regexp nil t)
             (save-excursion
-              (set 'line-ali (count-lines 1 (point)))
+              (setq line-ali (count-lines 1 (point)))
               (beginning-of-line)
               ;; have a look at the line and column numbers
               (if (looking-at "^\\([0-9]+\\).\\([0-9]+\\)[ *]")
@@ -1948,7 +1948,7 @@ opens a new window to show the declaration."
 
     ;; Get all the possible locations
     (string-match "^\\([0-9]+\\)[a-zA-Z+*]\\([0-9]+\\)[ *]" ali-line)
-    (set 'locations (list (list (match-string 1 ali-line) ;; line
+    (setq locations (list (list (match-string 1 ali-line) ;; line
                                 (match-string 2 ali-line) ;; column
                                 (ada-declare-file-of identlist))))
     (while (string-match "\\([0-9]+\\)[bc]\\(<[^>]+>\\)?\\([0-9]+\\)"
@@ -1968,16 +1968,16 @@ opens a new window to show the declaration."
             (goto-char (point-min))
             (re-search-forward "^D \\([a-zA-Z0-9_.-]+\\)" nil t
                                (string-to-number file-number))
-            (set 'file (match-string 1))
+            (setq file (match-string 1))
             )
         ;; Else get the nearest file
-        (set 'file (ada-declare-file-of identlist)))
+        (setq file (ada-declare-file-of identlist)))
 
-      (set 'locations (append locations (list (list line col file)))))
+      (setq locations (append locations (list (list line col file)))))
 
     ;; Add the specs at the end again, so that from the last body we go to
     ;; the specs
-    (set 'locations (append locations (list (car locations))))
+    (setq locations (append locations (list (car locations))))
 
     ;; Find the new location we want to go to.
     ;; If we are on none of the locations listed, we simply go to the specs.
@@ -1996,10 +1996,10 @@ opens a new window to show the declaration."
                 col       (nth 1 locations)
                 file      (nth 2 locations)
                 locations nil)
-        (set 'locations (cdr locations))))
+        (setq locations (cdr locations))))
 
     ;;  Find the file in the source path
-    (set 'file (ada-get-ada-file-name file (ada-file-of identlist)))
+    (setq file (ada-get-ada-file-name file (ada-file-of identlist)))
 
     ;; Kill the .ali buffer
     (kill-buffer (current-buffer))
@@ -2044,10 +2044,10 @@ the declaration and documentation of the subprograms one is using."
                   " "
                   (shell-quote-argument (file-name-as-directory (car dirs)))
                   "*.ali")))
-        (set 'dirs (cdr dirs)))
+        (setq dirs (cdr dirs)))
 
       ;;  Now parse the output
-      (set 'case-fold-search t)
+      (setq case-fold-search t)
       (goto-char (point-min))
       (while (re-search-forward regexp nil t)
         (save-excursion
@@ -2058,12 +2058,12 @@ the declaration and documentation of the subprograms one is using."
                 (setq line   (match-string 1)
                       column (match-string 2))
                 (re-search-backward "^X [0-9]+ \\(.*\\)$")
-                (set 'file (list (match-string 1) line column))
+                (setq file (list (match-string 1) line column))
 
                 ;;  There could be duplicate choices, because of the structure
                 ;;  of the .ali files
                 (unless (member file list)
-                  (set 'list (append list (list file))))))))
+                  (setq list (append list (list file))))))))
 
       ;;  Current buffer is still "*grep*"
       (kill-buffer "*grep*")
@@ -2078,7 +2078,7 @@ the declaration and documentation of the subprograms one is using."
 
      ;;  Only one choice => Do the cross-reference
      ((= (length list) 1)
-      (set 'file (ada-find-src-file-in-dir (caar list)))
+      (setq file (ada-find-src-file-in-dir (caar list)))
       (if file
           (ada-xref-change-buffer file
                                   (string-to-number (nth 1 (car list)))
@@ -2117,10 +2117,10 @@ the declaration and documentation of the subprograms one is using."
                 (string-to-number
                  (read-from-minibuffer "Enter No. of your choice: "))))
         )
-      (set 'choice (1- choice))
+      (setq choice (1- choice))
       (kill-buffer "*choice list*")
 
-      (set 'file (ada-find-src-file-in-dir (car (nth choice list))))
+      (setq file (ada-find-src-file-in-dir (car (nth choice list))))
       (if file
           (ada-xref-change-buffer file
                                   (string-to-number (nth 1 (nth choice list)))
@@ -2144,7 +2144,7 @@ If OTHER-FRAME is non-nil, creates a new frame to show the file."
     (if ada-xref-other-buffer
         (if other-frame
             (find-file-other-frame file)
-          (set 'declaration-buffer (find-file-noselect file))
+          (setq declaration-buffer (find-file-noselect file))
           (set-buffer declaration-buffer)
           (switch-to-buffer-other-window declaration-buffer)
           )
diff --git a/lisp/progmodes/antlr-mode.el b/lisp/progmodes/antlr-mode.el
index 56680f23a8e..bf90db54002 100644
--- a/lisp/progmodes/antlr-mode.el
+++ b/lisp/progmodes/antlr-mode.el
@@ -178,10 +178,6 @@
                 (set-buffer-modified-p nil)))))))
 (put 'save-buffer-state-x 'lisp-indent-function 0)
 
-;; get rid of byte-compile warnings
-(eval-when-compile
-  (require 'cc-mode))
-
 (defvar outline-level)
 (defvar imenu-use-markers)
 (defvar imenu-create-index-function)
diff --git a/lisp/progmodes/bat-mode.el b/lisp/progmodes/bat-mode.el
index 2b6f9d3434d..60b332170b0 100644
--- a/lisp/progmodes/bat-mode.el
+++ b/lisp/progmodes/bat-mode.el
@@ -120,6 +120,7 @@
 (defvar bat-mode-syntax-table
   (let ((table (make-syntax-table)))
     (modify-syntax-entry ?\n ">" table)
+    (modify-syntax-entry ?\" "\"" table)
     ;; Beware: `w' should not be used for non-alphabetic chars.
     (modify-syntax-entry ?~ "_" table)
     (modify-syntax-entry ?% "." table)
diff --git a/lisp/progmodes/cc-awk.el b/lisp/progmodes/cc-awk.el
index b5216b43ed9..3ef9730ecdb 100644
--- a/lisp/progmodes/cc-awk.el
+++ b/lisp/progmodes/cc-awk.el
@@ -61,6 +61,7 @@
 (cc-bytecomp-defun c-backward-token-1)
 (cc-bytecomp-defun c-beginning-of-statement-1)
 (cc-bytecomp-defun c-backward-sws)
+(cc-bytecomp-defun c-forward-sws)
 
 (defvar awk-mode-syntax-table
   (let ((st (make-syntax-table)))
diff --git a/lisp/progmodes/cc-bytecomp.el b/lisp/progmodes/cc-bytecomp.el
index 337a5292417..c9835bbefe2 100644
--- a/lisp/progmodes/cc-bytecomp.el
+++ b/lisp/progmodes/cc-bytecomp.el
@@ -244,7 +244,9 @@ Having cyclic cc-require's will result in infinite recursion.  That's
 somewhat intentional."
   `(progn
      (eval-when-compile
-       (setq cc-bytecomp-noruntime-functions byte-compile-noruntime-functions)
+       (if (boundp 'byte-compile-noruntime-functions) ; in case load uncompiled
+           (setq cc-bytecomp-noruntime-functions
+                 byte-compile-noruntime-functions))
        (cc-bytecomp-load (symbol-name ,cc-part)))
      ;; Hack to suppress spurious "might not be defined at runtime" warnings.
      ;; The basic issue is that
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index b9345b2ae6a..c8a9c461a9d 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -6479,6 +6479,15 @@ comment at the start of cc-engine.el for more info."
            (c-go-list-forward)
          t)))
 
+(defmacro c-pull-open-brace (ps)
+  ;; Pull the next open brace from PS (which has the form of paren-state),
+  ;; skipping over any brace pairs.  Returns NIL when PS is exhausted.
+  `(progn
+     (while (consp (car ,ps))
+       (setq ,ps (cdr ,ps)))
+     (prog1 (car ,ps)
+       (setq ,ps (cdr ,ps)))))
+
 (defun c-back-over-member-initializers ()
   ;; Test whether we are in a C++ member initializer list, and if so, go back
   ;; to the introducing ":", returning the position of the opening paren of
@@ -6896,32 +6905,38 @@ comment at the start of cc-engine.el for more info."
 
       ;; Skip over type decl prefix operators.  (Note similar code in
       ;; `c-font-lock-declarators'.)
-      (while (and (looking-at c-type-decl-prefix-key)
-                  (if (and (c-major-mode-is 'c++-mode)
-                           (match-beginning 3))
-                      ;; 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))
-                        (if (looking-at "\\(::\\)")
-                            ;; We only check for a trailing "::" and
-                            ;; let the "*" that should follow be
-                            ;; matched in the next round.
-                            (progn (setq got-identifier nil) t)
-                          ;; It turned out to be the real identifier,
-                          ;; so stop.
-                          nil))
-                    t))
-
-        (if (eq (char-after) ?\()
+      (if (and c-recognize-typeless-decls
+               (equal c-type-decl-prefix-key "\\<\\>"))
+          (when (eq (char-after) ?\()
             (progn
               (setq paren-depth (1+ paren-depth))
-              (forward-char))
-          (unless got-prefix-before-parens
-            (setq got-prefix-before-parens (= paren-depth 0)))
-          (setq got-prefix t)
-          (goto-char (match-end 1)))
-        (c-forward-syntactic-ws))
+              (forward-char)))
+        (while (and (looking-at c-type-decl-prefix-key)
+                    (if (and (c-major-mode-is 'c++-mode)
+                             (match-beginning 3))
+                        ;; 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))
+                          (if (looking-at "\\(::\\)")
+                              ;; We only check for a trailing "::" and
+                              ;; let the "*" that should follow be
+                              ;; matched in the next round.
+                              (progn (setq got-identifier nil) t)
+                            ;; It turned out to be the real identifier,
+                            ;; so stop.
+                            nil))
+                      t))
+
+          (if (eq (char-after) ?\()
+              (progn
+                (setq paren-depth (1+ paren-depth))
+                (forward-char))
+            (unless got-prefix-before-parens
+              (setq got-prefix-before-parens (= paren-depth 0)))
+            (setq got-prefix t)
+            (goto-char (match-end 1)))
+          (c-forward-syntactic-ws)))
 
       (setq got-parens (> paren-depth 0))
 
@@ -8403,15 +8418,6 @@ comment at the start of cc-engine.el for more info."
           (back-to-indentation)
           (vector (point) open-paren-pos))))))
 
-(defmacro c-pull-open-brace (ps)
-  ;; Pull the next open brace from PS (which has the form of paren-state),
-  ;; skipping over any brace pairs.  Returns NIL when PS is exhausted.
-  `(progn
-     (while (consp (car ,ps))
-       (setq ,ps (cdr ,ps)))
-     (prog1 (car ,ps)
-       (setq ,ps (cdr ,ps)))))
-
 (defun c-most-enclosing-decl-block (paren-state)
   ;; Return the buffer position of the most enclosing decl-block brace (in the
   ;; sense of c-looking-at-decl-block) in the PAREN-STATE structure, or nil if
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index 0116e9ec3dd..80e6189822b 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -2816,7 +2816,8 @@ is in effect when this is matched (see `c-identifier-syntax-table')."
                      "\\>")
                   "")
                 "\\)")
-  (java idl) "\\([\[\(]\\)")
+  java "\\([\[\(\)]\\)"
+  idl "\\([\[\(]\\)")
 (c-lang-defvar c-type-decl-suffix-key (c-lang-const c-type-decl-suffix-key)
   'dont-doc)
 
@@ -2937,7 +2938,7 @@ calls before a brace block.  This setting does not affect declarations
 that are preceded by a declaration starting keyword, so
 e.g. `c-typeless-decl-kwds' may still be used when it's set to nil."
   t nil
-  (c c++ objc) t)
+  (c c++ objc java) t)
 (c-lang-defvar c-recognize-typeless-decls
   (c-lang-const c-recognize-typeless-decls))
 
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 74818b7e1ea..4c776290722 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -217,12 +217,16 @@ control).  See \"cc-mode.el\" for more info."
      (t (error "CC Mode is incompatible with this version of Emacs")))
     map))
 
-(defun c-define-abbrev-table (name defs)
+(defun c-define-abbrev-table (name defs &optional doc)
   ;; Compatibility wrapper for `define-abbrev' which passes a non-nil
   ;; sixth argument for SYSTEM-FLAG in emacsen that support it
   ;; (currently only Emacs >= 21.2).
-  (let ((table (or (symbol-value name)
-                   (progn (define-abbrev-table name nil)
+  (let ((table (or (and (boundp name) (symbol-value name))
+                   (progn (condition-case nil
+                              (define-abbrev-table name nil doc)
+                            (wrong-number-of-arguments ;E.g. Emacs<23.
+                             (eval `(defvar ,name nil ,doc))
+                             (define-abbrev-table name nil)))
                           (symbol-value name)))))
     (while defs
       (condition-case nil
@@ -1241,27 +1245,22 @@ This function is called from `c-common-init', once per mode initialization."
 
 ;; Support for C
 
-;;;###autoload
-(defvar c-mode-syntax-table nil
+(defvar c-mode-syntax-table
+  (funcall (c-lang-const c-make-mode-syntax-table c))
   "Syntax table used in c-mode buffers.")
-(or c-mode-syntax-table
-    (setq c-mode-syntax-table
-          (funcall (c-lang-const c-make-mode-syntax-table c))))
 
-(defvar c-mode-abbrev-table nil
-  "Abbreviation table used in c-mode buffers.")
 (c-define-abbrev-table 'c-mode-abbrev-table
   '(("else" "else" c-electric-continued-statement 0)
-    ("while" "while" c-electric-continued-statement 0)))
+    ("while" "while" c-electric-continued-statement 0))
+  "Abbreviation table used in c-mode buffers.")
 
-(defvar c-mode-map ()
+(defvar c-mode-map
+  (let ((map (c-make-inherited-keymap)))
+    ;; Add bindings which are only useful for C.
+    (define-key map "\C-c\C-e"  'c-macro-expand)
+    map)
   "Keymap used in c-mode buffers.")
-(if c-mode-map
-    nil
-  (setq c-mode-map (c-make-inherited-keymap))
-  ;; add bindings which are only useful for C
-  (define-key c-mode-map "\C-c\C-e"  'c-macro-expand)
-  )
+
 
 (easy-menu-define c-c-menu c-mode-map "C Mode Commands"
                   (cons "C" (c-lang-const c-mode-menu c)))
@@ -1326,30 +1325,25 @@ Key bindings:
 
 ;; Support for C++
 
-;;;###autoload
-(defvar c++-mode-syntax-table nil
+(defvar c++-mode-syntax-table
+  (funcall (c-lang-const c-make-mode-syntax-table c++))
   "Syntax table used in c++-mode buffers.")
-(or c++-mode-syntax-table
-    (setq c++-mode-syntax-table
-          (funcall (c-lang-const c-make-mode-syntax-table c++))))
 
-(defvar c++-mode-abbrev-table nil
-  "Abbreviation table used in c++-mode buffers.")
 (c-define-abbrev-table 'c++-mode-abbrev-table
   '(("else" "else" c-electric-continued-statement 0)
     ("while" "while" c-electric-continued-statement 0)
-    ("catch" "catch" c-electric-continued-statement 0)))
+    ("catch" "catch" c-electric-continued-statement 0))
+  "Abbreviation table used in c++-mode buffers.")
 
-(defvar c++-mode-map ()
+(defvar c++-mode-map
+  (let ((map (c-make-inherited-keymap)))
+    ;; Add bindings which are only useful for C++.
+    (define-key map "\C-c\C-e" 'c-macro-expand)
+    (define-key map "\C-c:"    'c-scope-operator)
+    (define-key map "<"        'c-electric-lt-gt)
+    (define-key map ">"        'c-electric-lt-gt)
+    map)
   "Keymap used in c++-mode buffers.")
-(if c++-mode-map
-    nil
-  (setq c++-mode-map (c-make-inherited-keymap))
-  ;; add bindings which are only useful for C++
-  (define-key c++-mode-map "\C-c\C-e" 'c-macro-expand)
-  (define-key c++-mode-map "\C-c:"    'c-scope-operator)
-  (define-key c++-mode-map "<"        'c-electric-lt-gt)
-  (define-key c++-mode-map ">"        'c-electric-lt-gt))
 
 (easy-menu-define c-c++-menu c++-mode-map "C++ Mode Commands"
                   (cons "C++" (c-lang-const c-mode-menu c++)))
@@ -1386,26 +1380,21 @@ Key bindings:
 
 ;; Support for Objective-C
 
-;;;###autoload
-(defvar objc-mode-syntax-table nil
+(defvar objc-mode-syntax-table
+  (funcall (c-lang-const c-make-mode-syntax-table objc))
   "Syntax table used in objc-mode buffers.")
-(or objc-mode-syntax-table
-    (setq objc-mode-syntax-table
-          (funcall (c-lang-const c-make-mode-syntax-table objc))))
 
-(defvar objc-mode-abbrev-table nil
-  "Abbreviation table used in objc-mode buffers.")
 (c-define-abbrev-table 'objc-mode-abbrev-table
   '(("else" "else" c-electric-continued-statement 0)
-    ("while" "while" c-electric-continued-statement 0)))
+    ("while" "while" c-electric-continued-statement 0))
+  "Abbreviation table used in objc-mode buffers.")
 
-(defvar objc-mode-map ()
+(defvar objc-mode-map
+  (let ((map (c-make-inherited-keymap)))
+    ;; Add bindings which are only useful for Objective-C.
+    (define-key map "\C-c\C-e" 'c-macro-expand)
+    map)
   "Keymap used in objc-mode buffers.")
-(if objc-mode-map
-    nil
-  (setq objc-mode-map (c-make-inherited-keymap))
-  ;; add bindings which are only useful for Objective-C
-  (define-key objc-mode-map "\C-c\C-e" 'c-macro-expand))
 
 (easy-menu-define c-objc-menu objc-mode-map "ObjC Mode Commands"
                   (cons "ObjC" (c-lang-const c-mode-menu objc)))
@@ -1444,28 +1433,22 @@ Key bindings:
 
 ;; Support for Java
 
-;;;###autoload
-(defvar java-mode-syntax-table nil
+(defvar java-mode-syntax-table
+  (funcall (c-lang-const c-make-mode-syntax-table java))
   "Syntax table used in java-mode buffers.")
-(or java-mode-syntax-table
-    (setq java-mode-syntax-table
-          (funcall (c-lang-const c-make-mode-syntax-table java))))
 
-(defvar java-mode-abbrev-table nil
-  "Abbreviation table used in java-mode buffers.")
 (c-define-abbrev-table 'java-mode-abbrev-table
   '(("else" "else" c-electric-continued-statement 0)
     ("while" "while" c-electric-continued-statement 0)
     ("catch" "catch" c-electric-continued-statement 0)
-    ("finally" "finally" c-electric-continued-statement 0)))
+    ("finally" "finally" c-electric-continued-statement 0))
+  "Abbreviation table used in java-mode buffers.")
 
-(defvar java-mode-map ()
+(defvar java-mode-map
+  (let ((map (c-make-inherited-keymap)))
+    ;; Add bindings which are only useful for Java.
+    map)
   "Keymap used in java-mode buffers.")
-(if java-mode-map
-    nil
-  (setq java-mode-map (c-make-inherited-keymap))
-  ;; add bindings which are only useful for Java
-  )
 
 ;; Regexp trying to describe the beginning of a Java top-level
 ;; definition.  This is not used by CC Mode, nor is it maintained
@@ -1510,24 +1493,18 @@ Key bindings:
 
 ;; Support for CORBA's IDL language
 
-;;;###autoload
-(defvar idl-mode-syntax-table nil
+(defvar idl-mode-syntax-table
+  (funcall (c-lang-const c-make-mode-syntax-table idl))
   "Syntax table used in idl-mode buffers.")
-(or idl-mode-syntax-table
-    (setq idl-mode-syntax-table
-          (funcall (c-lang-const c-make-mode-syntax-table idl))))
 
-(defvar idl-mode-abbrev-table nil
+(c-define-abbrev-table 'idl-mode-abbrev-table nil
   "Abbreviation table used in idl-mode buffers.")
-(c-define-abbrev-table 'idl-mode-abbrev-table nil)
 
-(defvar idl-mode-map ()
+(defvar idl-mode-map
+  (let ((map (c-make-inherited-keymap)))
+    ;; Add bindings which are only useful for IDL.
+    map)
   "Keymap used in idl-mode buffers.")
-(if idl-mode-map
-    nil
-  (setq idl-mode-map (c-make-inherited-keymap))
-  ;; add bindings which are only useful for IDL
-  )
 
 (easy-menu-define c-idl-menu idl-mode-map "IDL Mode Commands"
                   (cons "IDL" (c-lang-const c-mode-menu idl)))
@@ -1564,32 +1541,27 @@ Key bindings:
 
 ;; Support for Pike
 
-;;;###autoload
-(defvar pike-mode-syntax-table nil
+(defvar pike-mode-syntax-table
+  (funcall (c-lang-const c-make-mode-syntax-table pike))
   "Syntax table used in pike-mode buffers.")
-(or pike-mode-syntax-table
-    (setq pike-mode-syntax-table
-          (funcall (c-lang-const c-make-mode-syntax-table pike))))
 
-(defvar pike-mode-abbrev-table nil
-  "Abbreviation table used in pike-mode buffers.")
 (c-define-abbrev-table 'pike-mode-abbrev-table
   '(("else" "else" c-electric-continued-statement 0)
-    ("while" "while" c-electric-continued-statement 0)))
+    ("while" "while" c-electric-continued-statement 0))
+  "Abbreviation table used in pike-mode buffers.")
 
-(defvar pike-mode-map ()
+(defvar pike-mode-map
+  (let ((map (c-make-inherited-keymap)))
+    ;; Additional bindings.
+    (define-key map "\C-c\C-e" 'c-macro-expand)
+    map)
   "Keymap used in pike-mode buffers.")
-(if pike-mode-map
-    nil
-  (setq pike-mode-map (c-make-inherited-keymap))
-  ;; additional bindings
-  (define-key pike-mode-map "\C-c\C-e" 'c-macro-expand))
 
 (easy-menu-define c-pike-menu pike-mode-map "Pike Mode Commands"
                   (cons "Pike" (c-lang-const c-mode-menu pike)))
 
 ;;;###autoload (add-to-list 'auto-mode-alist '("\\.\\(u?lpc\\|pike\\|pmod\\(\\.in\\)?\\)\\'" . pike-mode))
-;;;###autoload (add-to-list 'interpreter-mode-alist '("pike" . pike-mode))
+;;;###autoload (add-to-list 'interpreter-mode-alist '("\\`pike\\'" . pike-mode))
 
 ;;;###autoload
 (define-derived-mode pike-mode prog-mode "Pike"
@@ -1623,37 +1595,28 @@ Key bindings:
 ;; Support for AWK
 
 ;;;###autoload (add-to-list 'auto-mode-alist '("\\.awk\\'" . awk-mode))
-;;;###autoload (add-to-list 'interpreter-mode-alist '("awk" . awk-mode))
-;;;###autoload (add-to-list 'interpreter-mode-alist '("mawk" . awk-mode))
-;;;###autoload (add-to-list 'interpreter-mode-alist '("nawk" . awk-mode))
-;;;###autoload (add-to-list 'interpreter-mode-alist '("gawk" . awk-mode))
-
-;;; Autoload directives must be on the top level, so we construct an
-;;; autoload form instead.
-;;;###autoload (autoload 'awk-mode "cc-mode" "Major mode for editing AWK code." t)
+;;;###autoload (add-to-list 'interpreter-mode-alist '("\\`[gmn]?awk\\'" . awk-mode))
 
-(defvar awk-mode-abbrev-table nil
-  "Abbreviation table used in awk-mode buffers.")
 (c-define-abbrev-table 'awk-mode-abbrev-table
   '(("else" "else" c-electric-continued-statement 0)
-    ("while" "while" c-electric-continued-statement 0)))
+    ("while" "while" c-electric-continued-statement 0))
+  "Abbreviation table used in awk-mode buffers.")
 
-(defvar awk-mode-map ()
+(defvar awk-mode-map
+  (let ((map (c-make-inherited-keymap)))
+    ;; Add bindings which are only useful for awk.
+    (define-key map "#" 'self-insert-command)
+    (define-key map "/" 'self-insert-command)
+    (define-key map "*" 'self-insert-command)
+    (define-key map "\C-c\C-n" 'undefined) ; #if doesn't exist in awk.
+    (define-key map "\C-c\C-p" 'undefined)
+    (define-key map "\C-c\C-u" 'undefined)
+    (define-key map "\M-a" 'c-beginning-of-statement) ; 2003/10/7
+    (define-key map "\M-e" 'c-end-of-statement)       ; 2003/10/7
+    (define-key map "\C-\M-a" 'c-awk-beginning-of-defun)
+    (define-key map "\C-\M-e" 'c-awk-end-of-defun)
+    map)
   "Keymap used in awk-mode buffers.")
-(if awk-mode-map
-    nil
-  (setq awk-mode-map (c-make-inherited-keymap))
-  ;; add bindings which are only useful for awk.
-  (define-key awk-mode-map "#" 'self-insert-command)
-  (define-key awk-mode-map "/" 'self-insert-command)
-  (define-key awk-mode-map "*" 'self-insert-command)
-  (define-key awk-mode-map "\C-c\C-n" 'undefined) ; #if doesn't exist in awk.
-  (define-key awk-mode-map "\C-c\C-p" 'undefined)
-  (define-key awk-mode-map "\C-c\C-u" 'undefined)
-  (define-key awk-mode-map "\M-a" 'c-beginning-of-statement) ; 2003/10/7
-  (define-key awk-mode-map "\M-e" 'c-end-of-statement) ; 2003/10/7
-  (define-key awk-mode-map "\C-\M-a" 'c-awk-beginning-of-defun)
-  (define-key awk-mode-map "\C-\M-e" 'c-awk-end-of-defun))
 
 (easy-menu-define c-awk-menu awk-mode-map "AWK Mode Commands"
                   (cons "AWK" (c-lang-const c-mode-menu awk)))
diff --git a/lisp/progmodes/cperl-mode.el b/lisp/progmodes/cperl-mode.el
index 770e78bb3b1..1eea6972707 100644
--- a/lisp/progmodes/cperl-mode.el
+++ b/lisp/progmodes/cperl-mode.el
@@ -412,15 +412,15 @@ Affects: `cperl-font-lock', `cperl-electric-lbrace-space',
  "use cperl-vc-rcs-header or cperl-vc-sccs-header instead."
  "22.1")
 
-(defcustom cperl-clobber-mode-lists
-  (not
-   (and
-    (boundp 'interpreter-mode-alist)
-    (assoc "miniperl" interpreter-mode-alist)
-    (assoc "\\.\\([pP][Llm]\\|al\\)$" auto-mode-alist)))
-  "*Whether to install us into `interpreter-' and `extension' mode lists."
-  :type 'boolean
-  :group 'cperl)
+;;; (defcustom cperl-clobber-mode-lists
+;;;   (not
+;;;    (and
+;;;     (boundp 'interpreter-mode-alist)
+;;;     (assoc "miniperl" interpreter-mode-alist)
+;;;     (assoc "\\.\\([pP][Llm]\\|al\\)$" auto-mode-alist)))
+;;;   "*Whether to install us into `interpreter-' and `extension' mode lists."
+;;;   :type 'boolean
+;;;   :group 'cperl)
 
 (defcustom cperl-info-on-command-no-prompt nil
   "*Not-nil (and non-null) means not to prompt on C-h f.
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 7004836e69f..5eecc347f03 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -52,12 +52,12 @@
 ;; Extra functions `python-nav-forward-statement',
 ;; `python-nav-backward-statement',
 ;; `python-nav-beginning-of-statement', `python-nav-end-of-statement',
-;; `python-nav-beginning-of-block' and `python-nav-end-of-block' are
-;; included but no bound to any key.  At last but not least the
-;; specialized `python-nav-forward-sexp' allows easy navigation
-;; between code blocks.  If you prefer `cc-mode'-like `forward-sexp'
-;; movement, setting `forward-sexp-function' to nil is enough, You can
-;; do that using the `python-mode-hook':
+;; `python-nav-beginning-of-block', `python-nav-end-of-block' and
+;; `python-nav-if-name-main' are included but no bound to any key.  At
+;; last but not least the specialized `python-nav-forward-sexp' allows
+;; easy navigation between code blocks.  If you prefer `cc-mode'-like
+;; `forward-sexp' movement, setting `forward-sexp-function' to nil is
+;; enough, You can do that using the `python-mode-hook':
 
 ;; (add-hook 'python-mode-hook
 ;;           (lambda () (setq forward-sexp-function nil)))
@@ -225,7 +225,7 @@
 ;;;###autoload
 (add-to-list 'auto-mode-alist (cons (purecopy "\\.py\\'")  'python-mode))
 ;;;###autoload
-(add-to-list 'interpreter-mode-alist (cons (purecopy "python") 'python-mode))
+(add-to-list 'interpreter-mode-alist (cons (purecopy "\\`python[0-9.]*\\'") 'python-mode))
 
 (defgroup python nil
   "Python Language's flying circus support for Emacs."
@@ -1327,9 +1327,7 @@ backward to previous statement."
 (defun python-nav-beginning-of-block ()
   "Move to start of current block."
   (interactive "^")
-  (let ((starting-pos (point))
-        (block-regexp (python-rx
-                       line-start (* whitespace) block-start)))
+  (let ((starting-pos (point)))
     (if (progn
           (python-nav-beginning-of-statement)
           (looking-at (python-rx block-start)))
@@ -1422,9 +1420,6 @@ backwards."
     (let* ((forward-p (if (> dir 0)
                           (and (setq dir 1) t)
                         (and (setq dir -1) nil)))
-           (re-search-fn (if forward-p
-                             're-search-forward
-                           're-search-backward))
            (context-type (python-syntax-context-type)))
       (cond
        ((memq context-type '(string comment))
@@ -1583,6 +1578,29 @@ This command assumes point is not in a string or comment."
   (or arg (setq arg 1))
   (python-nav-up-list (- arg)))
 
+(defun python-nav-if-name-main ()
+  "Move point at the beginning the __main__ block.
+When \"if __name__ == '__main__':\" is found returns its
+position, else returns nil."
+  (interactive)
+  (let ((point (point))
+        (found (catch 'found
+                 (goto-char (point-min))
+                 (while (re-search-forward
+                         (python-rx line-start
+                                    "if" (+ space)
+                                    "__name__" (+ space)
+                                    "==" (+ space)
+                                    (group-n 1 (or ?\" ?\'))
+                                    "__main__" (backref 1) (* space) ":")
+                         nil t)
+                   (when (not (python-syntax-context-type))
+                     (beginning-of-line)
+                     (throw 'found t))))))
+    (if found
+        (point)
+      (ignore (goto-char point)))))
+
 
 ;;; Shell integration
 
@@ -2114,17 +2132,58 @@ Returns the output.  See `python-shell-send-string-no-output'."
 (define-obsolete-function-alias
   'python-send-string 'python-shell-internal-send-string "24.3")
 
+(defun python-shell-buffer-substring (start end &optional nomain)
+  "Send buffer substring from START to END formatted for shell.
+This is a wrapper over `buffer-substring' that takes care of
+different transformations for the code sent to be evaluated in
+the python shell:
+  1. When Optional Argument NOMAIN is non-nil everything under an
+     \"if __name__ == '__main__'\" block will be removed.
+  2. When a subregion of the buffer is sent, it takes care of
+     appending extra empty lines so tracebacks are correct.
+  3. Wraps indented regions under an \"if True:\" block so the
+     interpreter evaluates them correctly."
+  (let ((substring (buffer-substring-no-properties start end))
+        (fillstr (make-string (1- (line-number-at-pos start)) ?\n))
+        (toplevel-block-p (save-excursion
+                            (goto-char start)
+                            (or (zerop (line-number-at-pos start))
+                                (progn
+                                  (python-util-forward-comment 1)
+                                  (zerop (current-indentation)))))))
+    (with-temp-buffer
+      (python-mode)
+      (insert fillstr)
+      (insert substring)
+      (goto-char (point-min))
+      (when (not toplevel-block-p)
+        (insert "if True:")
+        (delete-region (point) (line-end-position)))
+      (when nomain
+        (let* ((if-name-main-start-end
+                (and nomain
+                     (save-excursion
+                       (when (python-nav-if-name-main)
+                         (cons (point)
+                               (progn (python-nav-forward-sexp)
+                                      (point)))))))
+               ;; Oh destructuring bind, how I miss you.
+               (if-name-main-start (car if-name-main-start-end))
+               (if-name-main-end (cdr if-name-main-start-end)))
+          (when if-name-main-start-end
+            (goto-char if-name-main-start)
+            (delete-region if-name-main-start if-name-main-end)
+            (insert
+             (make-string
+              (- (line-number-at-pos if-name-main-end)
+                 (line-number-at-pos if-name-main-start)) ?\n)))))
+      (buffer-substring-no-properties (point-min) (point-max)))))
+
 (defun python-shell-send-region (start end)
   "Send the region delimited by START and END to inferior Python process."
   (interactive "r")
   (python-shell-send-string
-   (concat
-    (let ((line-num (line-number-at-pos start)))
-      ;; When sending a region, add blank lines for non sent code so
-      ;; backtraces remain correct.
-      (make-string (1- line-num) ?\n))
-    (buffer-substring start end))
-   nil t))
+   (python-shell-buffer-substring start end) nil t))
 
 (defun python-shell-send-buffer (&optional arg)
   "Send the entire buffer to inferior Python process.
@@ -2133,13 +2192,9 @@ by \"if __name__== '__main__':\""
   (interactive "P")
   (save-restriction
     (widen)
-    (let ((str (buffer-substring (point-min) (point-max))))
-      (and
-       (not arg)
-       (setq str (replace-regexp-in-string
-                  (python-rx if-name-main)
-                  "if __name__ == '__main__ ':" str)))
-      (python-shell-send-string str))))
+    (python-shell-send-string
+     (python-shell-buffer-substring
+      (point-min) (point-max) (not arg)))))
 
 (defun python-shell-send-defun (arg)
   "Send the current defun to inferior Python process.
@@ -2266,13 +2321,17 @@ and use the following as the value of this variable:
 LINE is used to detect the context on how to complete given
 INPUT."
   (let* ((prompt
-          ;; Get the last prompt for the inferior process
-          ;; buffer. This is used for the completion code selection
-          ;; heuristic.
+          ;; Get last prompt of the inferior process buffer (this
+          ;; intentionally avoids using `comint-last-prompt' because
+          ;; of incompatibilities with Emacs 24.x).
           (with-current-buffer (process-buffer process)
-            (buffer-substring-no-properties
-             (overlay-start comint-last-prompt-overlay)
-             (overlay-end comint-last-prompt-overlay))))
+            (save-excursion
+              (buffer-substring-no-properties
+               (- (point) (length line))
+               (progn
+                 (re-search-backward "^")
+                 (python-util-forward-comment)
+                 (point))))))
          (completion-context
           ;; Check whether a prompt matches a pdb string, an import
           ;; statement or just the standard prompt and use the
@@ -2602,8 +2661,7 @@ JUSTIFY should be used (if applicable) as in `fill-paragraph'."
 (defun python-fill-string (&optional justify)
   "String fill function for `python-fill-paragraph'.
 JUSTIFY should be used (if applicable) as in `fill-paragraph'."
-  (let* ((marker (point-marker))
-         (str-start-pos
+  (let* ((str-start-pos
           (set-marker
            (make-marker)
            (or (python-syntax-context 'string)
@@ -2669,7 +2727,7 @@ JUSTIFY should be used (if applicable) as in `fill-paragraph'."
              ;; Again indent only if a newline is added.
              (indent-according-to-mode))))) t)
 
-(defun python-fill-decorator (&optional justify)
+(defun python-fill-decorator (&optional _justify)
   "Decorator fill function for `python-fill-paragraph'.
 JUSTIFY should be used (if applicable) as in `fill-paragraph'."
   t)
@@ -2831,8 +2889,7 @@ The skeleton will be bound to python-skeleton-NAME."
 
 (defun python-skeleton-add-menu-items ()
   "Add menu items to Python->Skeletons menu."
-  (let ((skeletons (sort python-skeleton-available 'string<))
-        (items))
+  (let ((skeletons (sort python-skeleton-available 'string<)))
     (dolist (skeleton skeletons)
       (easy-menu-add-item
        nil '("Python" "Skeletons")
@@ -2920,7 +2977,7 @@ Runs COMMAND, a shell command, as if by `compile'.  See
   (let ((process-environment (python-shell-calculate-process-environment))
         (exec-path (python-shell-calculate-exec-path)))
     (compilation-start command nil
-                       (lambda (mode-name)
+                       (lambda (_modename)
                          (format python-check-buffer-name command)))))
 
 
@@ -3031,7 +3088,7 @@ It must be a function with two arguments: TYPE and NAME.")
   "Return imenu label for parent node using TYPE and NAME."
   (format "%s..." (python-imenu-format-item-label type name)))
 
-(defun python-imenu-format-parent-item-jump-label (type name)
+(defun python-imenu-format-parent-item-jump-label (type _name)
   "Return imenu label for parent node jump using TYPE and NAME."
   (if (string= type "class")
       "*class definition*"
@@ -3145,7 +3202,7 @@ To this:
                 (cons name (cdar pos))
                 (python-imenu-create-flat-index (cddr item) name))))))
     (or alist
-        (let* ((fn (lambda (type name) name))
+        (let* ((fn (lambda (_type name) name))
                (python-imenu-format-item-label-function fn)
               (python-imenu-format-parent-item-label-function fn)
               (python-imenu-format-parent-item-jump-label-function fn))
@@ -3550,7 +3607,7 @@ if that value is non-nil."
 
   (add-to-list 'hs-special-modes-alist
                `(python-mode "^\\s-*\\(?:def\\|class\\)\\>" nil "#"
-                             ,(lambda (arg)
+                             ,(lambda (_arg)
                                 (python-nav-end-of-defun)) nil))
 
   (set (make-local-variable 'mode-require-final-newline) t)
diff --git a/lisp/progmodes/ruby-mode.el b/lisp/progmodes/ruby-mode.el
index c8fae7ba1e6..9dc2c4fb6c9 100644
--- a/lisp/progmodes/ruby-mode.el
+++ b/lisp/progmodes/ruby-mode.el
@@ -137,6 +137,7 @@ This should only be called after matching against `ruby-here-doc-beg-re'."
 
 (defconst ruby-symbol-chars "a-zA-Z0-9_"
   "List of characters that symbol names may contain.")
+
 (defconst ruby-symbol-re (concat "[" ruby-symbol-chars "]")
   "Regexp to match symbols.")
 
@@ -254,11 +255,13 @@ Also ignores spaces after parenthesis when 'space."
             ("for" for-body "end")
             ("[" expseq "]")
             ("{" hashvals "}")
+            ("{" insts "}")
             ("while" insts "end")
             ("until" insts "end")
             ("unless" insts "end")
             ("if" if-body "end")
             ("case"  cases "end"))
+      (formal-params ("opening-|" exp "|"))
       (for-body (for-head ";" insts))
       (for-head (id "in" exp))
       (cases (exp "then" insts) ;; FIXME: Ruby also allows (exp ":" insts).
@@ -285,10 +288,20 @@ Also ignores spaces after parenthesis when 'space."
   (save-excursion
     (skip-chars-backward " \t")
     (not (or (bolp)
-             (memq (char-before) '(?\; ?- ?+ ?* ?/ ?:))
+             (and (memq (char-before) '(?\; ?- ?+ ?* ?/ ?: ?.))
+                  ;; Make sure it's not the end of a regexp.
+                  (not (eq (car (syntax-after (1- (point)))) 7)))
              (and (memq (char-before) '(?\? ?=))
-                  (not (memq (char-syntax (char-before (1- (point))))
-                             '(?w ?_))))))))
+                  (let ((tok (ruby-smie--backward-token)))
+                    (or (equal tok "?")
+                        (string-match "\\`\\s." tok))))))))
+
+(defun ruby-smie--opening-pipe-p ()
+  (save-excursion
+    (if (eq ?| (char-before)) (forward-char -1))
+    (skip-chars-backward " \t\n")
+    (or (eq ?\{ (char-before))
+        (looking-back "\\_<do" (- (point) 2)))))
 
 (defun ruby-smie--forward-token ()
   (skip-chars-forward " \t")
@@ -299,12 +312,16 @@ Also ignores spaces after parenthesis when 'space."
         (if (eolp) (forward-char 1) (forward-comment 1))
         ";")
     (forward-comment (point-max))
+    (if (looking-at ":\\s.+")
+        (progn (goto-char (match-end 0)) (match-string 0)) ;; bug#15208.
     (let ((tok (smie-default-forward-token)))
       (cond
        ((member tok '("unless" "if" "while" "until"))
         (if (save-excursion (forward-word -1) (ruby-smie--bosp))
             tok "iuwu-mod"))
-       (t tok)))))
+         ((equal tok "|")
+          (if (ruby-smie--opening-pipe-p) "opening-|" tok))
+         (t tok))))))
 
 (defun ruby-smie--backward-token ()
   (let ((pos (point)))
@@ -314,10 +331,14 @@ Also ignores spaces after parenthesis when 'space."
         (progn (skip-chars-forward " \t")
                ";")
       (let ((tok (smie-default-backward-token)))
+        (when (and (eq ?: (char-before)) (string-match "\\`\\s." tok))
+          (forward-char -1) (setq tok (concat ":" tok))) ;; bug#15208.
         (cond
          ((member tok '("unless" "if" "while" "until"))
           (if (ruby-smie--bosp)
               tok "iuwu-mod"))
+         ((equal tok "|")
+          (if (ruby-smie--opening-pipe-p) "opening-|" tok))
          (t tok))))))
 
 (defun ruby-smie-rules (kind token)
@@ -332,7 +353,19 @@ Also ignores spaces after parenthesis when 'space."
        ;; For (invalid) code between switch and case.
        ;; (if (smie-parent-p "switch") 4)
        0))
-    (`(:before . ,(or `"else" `"then" `"elsif")) 0)
+    (`(:before . "do")
+     (when
+         (save-excursion
+           (forward-word 1)   ;Skip "do"
+           (skip-chars-forward " \t")
+           (and (equal (save-excursion (ruby-smie--forward-token)) "opening-|")
+                (save-excursion (forward-sexp 1)
+                                (skip-chars-forward " \t")
+                                (or (eolp)
+                                    (looking-at comment-start-skip)))))
+       ;; `(column . ,(smie-indent-virtual))
+       (smie-rule-parent)))
+    (`(:before . ,(or `"else" `"then" `"elsif" `"rescue")) 0)
     (`(:before . ,(or `"when"))
      (if (not (smie-rule-sibling-p)) 0)) ;; ruby-indent-level
     ;; Hack attack: Since newlines are separators, don't try to align args that
@@ -903,6 +936,10 @@ Can be one of `heredoc', `modifier', `expr-qstr', `expr-re'."
                       (not (looking-at "[a-z_]"))))
                (and (looking-at ruby-operator-re)
                     (not (ruby-special-char-p))
+                    (save-excursion
+                      (forward-char -1)
+                      (or (not (looking-at ruby-operator-re))
+                          (not (eq (char-before) ?:))))
                     ;; Operator at the end of line.
                     (let ((c (char-after (point))))
                       (and
@@ -1825,11 +1862,11 @@ See `font-lock-syntax-table'.")
              "using")
            'symbols))
          1 'font-lock-builtin-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))
+   ;; Perl-ish keywords
+   "\\_<\\(?:BEGIN\\|END\\)\\_>\\|^__END__$"
    ;; variables
    `(,(concat ruby-font-lock-keyword-beg-re
               "\\_<\\(nil\\|self\\|true\\|false\\)\\>")
@@ -1931,8 +1968,7 @@ The variable `ruby-indent-level' controls the amount of indentation.
                                      "\\)\\'")) 'ruby-mode))
 
 ;;;###autoload
-(dolist (name (list "ruby" "rbx" "jruby" "ruby1.9" "ruby1.8"))
-  (add-to-list 'interpreter-mode-alist (cons (purecopy name) 'ruby-mode)))
+(add-to-list 'interpreter-mode-alist (cons (purecopy "\\`\\(rbx\\|j?ruby\\(1\\.[89]\\)?\\)\\'") 'ruby-mode))
 
 (provide 'ruby-mode)
 
diff --git a/lisp/progmodes/sh-script.el b/lisp/progmodes/sh-script.el
index c8b65e0a029..3ea2afb6fc3 100644
--- a/lisp/progmodes/sh-script.el
+++ b/lisp/progmodes/sh-script.el
@@ -1,7 +1,6 @@
 ;;; sh-script.el --- shell-script editing commands for Emacs
 
-;; Copyright (C) 1993-1997, 1999, 2001-2013 Free Software Foundation,
-;; Inc.
+;; Copyright (C) 1993-1997, 1999, 2001-2013 Free Software Foundation, Inc.
 
 ;; Author: Daniel Pfeiffer <occitan@esperanto.org>
 ;; Version: 2.0f
@@ -673,7 +672,9 @@ removed when closing the here document."
           "." "alias" "bg" "bind" "builtin" "caller" "compgen" "complete"
           "declare" "dirs" "disown" "enable" "fc" "fg" "help" "history"
           "jobs" "kill" "let" "local" "popd" "printf" "pushd" "shopt"
-          "source" "suspend" "typeset" "unalias")
+          "source" "suspend" "typeset" "unalias"
+          ;; bash4
+          "mapfile" "readarray")
 
     ;; The next entry is only used for defining the others
     (bourne sh-append shell
@@ -737,6 +738,7 @@ implemented as aliases.  See `sh-feature'."
   :type '(repeat (cons (symbol :tag "Shell")
                        (choice (repeat string)
                                (sexp :format "Evaluate: %v"))))
+  :version "24.4"                       ; bash4 additions
   :group 'sh-script)
 
 
@@ -2168,11 +2170,18 @@ the visited file executable, and NO-QUERY-FLAG (the second argument)
 controls whether to query about making the visited file executable.
 
 Calls the value of `sh-set-shell-hook' if set."
-  (interactive (list (completing-read (format "Shell \(default %s\): "
-                                              sh-shell-file)
-                                      interpreter-mode-alist
-                                      (lambda (x) (eq (cdr x) 'sh-mode))
-                                      nil nil nil sh-shell-file)
+  (interactive (list (completing-read
+                      (format "Shell \(default %s\): "
+                              sh-shell-file)
+                      ;; This used to use interpreter-mode-alist, but that is
+                      ;; no longer appropriate now that uses regexps.
+                      ;; Maybe there could be a separate variable that lists
+                      ;; the shells, used here and to construct i-mode-alist.
+                      ;; But the following is probably good enough:
+                      (append (mapcar (lambda (e) (symbol-name (car e)))
+                                      sh-ancestor-alist)
+                              '("csh" "rc" "sh"))
+                      nil nil nil nil sh-shell-file)
                      (eq executable-query 'function)
                      t))
   (if (string-match "\\.exe\\'" shell)