Merge from trunk.

17 files changed, 277 insertions, 121 deletions

diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el
index 76b9f304164..509bb203f78 100644
--- a/lisp/progmodes/cc-cmds.el
+++ b/lisp/progmodes/cc-cmds.el
@@ -4382,11 +4382,8 @@ Optional prefix ARG means justify paragraph as well."
   (let ((fill-paragraph-function
          ;; Avoid infinite recursion.
          (if (not (eq fill-paragraph-function 'c-fill-paragraph))
-             fill-paragraph-function))
-        (start-point (point-marker)))
-    (c-mask-paragraph
-     t nil (lambda () (fill-region-as-paragraph (point-min) (point-max) arg)))
-    (goto-char start-point))
+             fill-paragraph-function)))
+    (c-mask-paragraph t nil 'fill-paragraph arg))
   ;; Always return t.  This has the effect that if filling isn't done
   ;; above, it isn't done at all, and it's therefore effectively
   ;; disabled in normal code.
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 2e0294341da..be0f86ddd7e 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -2074,7 +2074,7 @@ comment at the start of cc-engine.el for more info."
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; We maintain a simple cache of positions which aren't in a literal, so as to
 ;; speed up testing for non-literality.
-(defconst c-state-nonlit-pos-interval 10000)
+(defconst c-state-nonlit-pos-interval 3000)
 ;; The approximate interval between entries in `c-state-nonlit-pos-cache'.
 
 (defvar c-state-nonlit-pos-cache nil)
@@ -2129,7 +2129,7 @@ comment at the start of cc-engine.el for more info."
     (widen)
     (save-excursion
       (let ((c c-state-nonlit-pos-cache)
-            pos npos lit)
+            pos npos lit macro-beg)
         ;; Trim the cache to take account of buffer changes.
         (while (and c (> (car c) c-state-nonlit-pos-cache-limit))
           (setq c (cdr c)))
@@ -2139,16 +2139,32 @@ comment at the start of cc-engine.el for more info."
           (setq c (cdr c)))
         (setq pos (or (car c) (point-min)))
 
-        (while (<= (setq npos (+ pos c-state-nonlit-pos-interval))
-                   here)
-          (setq lit (car (cddr (c-state-pp-to-literal pos npos))))
-          (setq pos (or (cdr lit) npos)) ; end of literal containing npos.
+        (while
+            ;; Add an element to `c-state-nonlit-pos-cache' each iteration.
+            (and
+             (<= (setq npos (+ pos c-state-nonlit-pos-interval)) here)
+             (progn
+               (setq lit (car (cddr (c-state-pp-to-literal pos npos))))
+               (cond
+                ((null lit)
+                 (setq pos npos)
+                 t)
+                ((<= (cdr lit) here)
+                 (setq pos (cdr lit))
+                 t)
+                (t
+                 (setq pos (car lit))
+                 nil))))
+
           (goto-char pos)
           (when (and (c-beginning-of-macro) (/= (point) pos))
-            (c-syntactic-end-of-macro)
-            (or (eobp) (forward-char))
-            (setq pos (point)))
-          (setq c-state-nonlit-pos-cache (cons pos c-state-nonlit-pos-cache)))
+              (setq macro-beg (point))
+              (c-syntactic-end-of-macro)
+              (or (eobp) (forward-char))
+              (setq pos (if (<= (point) here)
+                            (point)
+                          macro-beg)))
+            (setq c-state-nonlit-pos-cache (cons pos c-state-nonlit-pos-cache)))
 
         (if (> pos c-state-nonlit-pos-cache-limit)
             (setq c-state-nonlit-pos-cache-limit pos))
@@ -4351,6 +4367,78 @@ comment at the start of cc-engine.el for more info."
               (t 'c)))                  ; Assuming the range is valid.
     range))
 
+(defsubst c-determine-limit-get-base (start try-size)
+  ;; Get a "safe place" approximately TRY-SIZE characters before START.
+  ;; This doesn't preserve point.
+  (let* ((pos (max (- start try-size) (point-min)))
+         (base (c-state-safe-place pos))
+         (s (parse-partial-sexp base pos)))
+    (if (or (nth 4 s) (nth 3 s))        ; comment or string
+        (nth 8 s)
+      (point))))
+
+(defun c-determine-limit (how-far-back &optional start try-size)
+  ;; Return a buffer position HOW-FAR-BACK non-literal characters from START
+  ;; (default point).  This is done by going back further in the buffer then
+  ;; searching forward for literals.  The position found won't be in a
+  ;; literal.  We start searching for the sought position TRY-SIZE (default
+  ;; twice HOW-FAR-BACK) bytes back from START.  This function must be fast.
+  ;; :-)
+  (save-excursion
+    (let* ((start (or start (point)))
+           (try-size (or try-size (* 2 how-far-back)))
+           (base (c-determine-limit-get-base start try-size))
+           (pos base)
+
+           (s (parse-partial-sexp pos pos)) ; null state.
+           stack elt size
+           (count 0))
+      (while (< pos start)
+        ;; Move forward one literal each time round this loop.
+        ;; Move forward to the start of a comment or string.
+        (setq s (parse-partial-sexp
+                 pos
+                 start
+                 nil                    ; target-depth
+                 nil                    ; stop-before
+                 s                      ; state
+                 'syntax-table))        ; stop-comment
+
+        ;; Gather details of the non-literal-bit - starting pos and size.
+        (setq size (- (if (or (nth 4 s) (nth 3 s))
+                          (nth 8 s)
+                        (point))
+                      pos))
+        (if (> size 0)
+            (setq stack (cons (cons pos size) stack)))
+
+        ;; Move forward to the end of the comment/string.
+        (if (or (nth 4 s) (nth 3 s))
+            (setq s (parse-partial-sexp
+                     (point)
+                     start
+                     nil                ; target-depth
+                     nil                ; stop-before
+                     s                  ; state
+                     'syntax-table)))   ; stop-comment
+        (setq pos (point)))
+    
+      ;; Now try and find enough non-literal characters recorded on the stack.
+      ;; Go back one recorded literal each time round this loop.
+      (while (and (< count how-far-back)
+                  stack)
+        (setq elt (car stack)
+              stack (cdr stack))
+        (setq count (+ count (cdr elt))))
+
+      ;; Have we found enough yet?
+      (cond
+       ((>= count how-far-back)
+        (+ (car elt) (- count how-far-back)))
+       ((eq base (point-min))
+        (point-min))
+       (t
+        (c-determine-limit (- how-far-back count) base try-size))))))
 
 ;; `c-find-decl-spots' and accompanying stuff.
 
@@ -4487,13 +4575,14 @@ comment at the start of cc-engine.el for more info."
   ;; Call CFD-FUN for each possible spot for a declaration, cast or
   ;; label from the point to CFD-LIMIT.
   ;;
-  ;; CFD-FUN is called with point at the start of the spot.  It's
-  ;; passed two arguments: The first is the end position of the token
-  ;; preceding the spot, or 0 for the implicit match at bob.  The
-  ;; second is a flag that is t when the match is inside a macro.  If
-  ;; CFD-FUN adds `c-decl-end' properties somewhere below the current
-  ;; spot, it should return non-nil to ensure that the next search
-  ;; will find them.
+  ;; CFD-FUN is called with point at the start of the spot.  It's passed two
+  ;; arguments: The first is the end position of the token preceding the spot,
+  ;; or 0 for the implicit match at bob.  The second is a flag that is t when
+  ;; the match is inside a macro.  Point should be moved forward by at least
+  ;; one token.
+  ;;
+  ;; If CFD-FUN adds `c-decl-end' properties somewhere below the current spot,
+  ;; it should return non-nil to ensure that the next search will find them.
   ;;
   ;; Such a spot is:
   ;; o  The first token after bob.
@@ -4867,7 +4956,8 @@ comment at the start of cc-engine.el for more info."
       (goto-char cfd-continue-pos)
       (if (= cfd-continue-pos cfd-limit)
           (setq cfd-match-pos cfd-limit)
-        (c-find-decl-prefix-search)))))
+        (c-find-decl-prefix-search))))) ; Moves point, sets cfd-continue-pos,
+                                        ; cfd-match-pos, etc.
 
 
 ;; A cache for found types.
@@ -7306,6 +7396,7 @@ comment at the start of cc-engine.el for more info."
     (let ((start (point))
           start-char
           (c-promote-possible-types t)
+          lim
           ;; Turn off recognition of angle bracket arglists while parsing
           ;; types here since the protocol reference list might then be
           ;; considered part of the preceding name or superclass-name.
@@ -7333,6 +7424,7 @@ comment at the start of cc-engine.el for more info."
 ;             (c-forward-token-2) ; 2006/1/13 This doesn't move if the token's
 ;             at EOB.
               (goto-char (match-end 0))
+              (setq lim (point))
               (c-skip-ws-forward)
               (c-forward-type))
 
@@ -7357,7 +7449,7 @@ comment at the start of cc-engine.el for more info."
                 t))))
 
           (progn
-            (c-backward-syntactic-ws)
+            (c-backward-syntactic-ws lim)
             (c-clear-c-type-property start (1- (point)) 'c-decl-end)
             (c-put-c-type-property (1- (point)) 'c-decl-end)
             t)
@@ -7500,14 +7592,17 @@ comment at the start of cc-engine.el for more info."
     (save-restriction
       ;; If we're in a macro, our search range is restricted to it.  Narrow to
       ;; the searchable range.
-      (let* ((macro-start (c-query-macro-start))
-             (lim (max (or lim (point-min)) (or macro-start (point-min))))
+      (let* ((macro-start (save-excursion (and (c-beginning-of-macro) (point))))
+             (macro-end (save-excursion (and macro-start (c-end-of-macro) (point))))
+             (low-lim (max (or lim (point-min))   (or macro-start (point-min))))
              before-lparen after-rparen
-             (pp-count-out 20)) ; Max number of paren/brace constructs before we give up
-        (narrow-to-region lim (c-point 'eol))
+             (pp-count-out 20)) ; Max number of paren/brace constructs before
+                                ; we give up
+        (narrow-to-region low-lim (or macro-end (point-max)))
 
         ;; Search backwards for the defun's argument list.  We give up if we
-        ;; encounter a "}" (end of a previous defun) or BOB.
+        ;; encounter a "}" (end of a previous defun) an "=" (which can't be in
+        ;; a knr region) or BOB.
         ;;
         ;; The criterion for a paren structure being the arg list is:
         ;; o - there is non-WS stuff after it but before any "{"; AND
@@ -7527,12 +7622,13 @@ comment at the start of cc-engine.el for more info."
         (catch 'knr
           (while (> pp-count-out 0) ; go back one paren/bracket pair each time.
             (setq pp-count-out (1- pp-count-out))
-            (c-syntactic-skip-backward "^)]}")
+            (c-syntactic-skip-backward "^)]}=")
             (cond ((eq (char-before) ?\))
                    (setq after-rparen (point)))
                   ((eq (char-before) ?\])
                    (setq after-rparen nil))
-                  (t ; either } (hit previous defun) or no more parens/brackets
+                  (t ; either } (hit previous defun) or = or no more
+                     ; parens/brackets.
                    (throw 'knr nil)))
 
             (if after-rparen
@@ -7548,18 +7644,18 @@ comment at the start of cc-engine.el for more info."
                    ;; It can't be the arg list if next token is ; or {
                    (progn (goto-char after-rparen)
                           (c-forward-syntactic-ws)
-                          (not (memq (char-after) '(?\; ?\{))))
+                          (not (memq (char-after) '(?\; ?\{ ?\=))))
 
                    ;; Is the thing preceding the list an identifier (the
                    ;; function name), or a macro expansion?
                    (progn
                      (goto-char before-lparen)
                      (eq (c-backward-token-2) 0)
-                     (or (c-on-identifier)
+                     (or (eq (c-on-identifier) (point))
                          (and (eq (char-after) ?\))
                               (c-go-up-list-backward)
                               (eq (c-backward-token-2) 0)
-                              (c-on-identifier))))
+                              (eq (c-on-identifier) (point)))))
 
                    ;; Have we got a non-empty list of comma-separated
                    ;; identifiers?
@@ -8047,6 +8143,23 @@ comment at the start of cc-engine.el for more info."
             next-open-brace (c-pull-open-brace paren-state)))
     open-brace))
 
+(defun c-cheap-inside-bracelist-p (paren-state)
+  ;; Return the position of the L-brace if point is inside a brace list
+  ;; initialization of an array, etc.  This is an approximate function,
+  ;; designed for speed over accuracy.  It will not find every bracelist, but
+  ;; a non-nil result is reliable.  We simply search for "= {" (naturally with
+  ;; syntactic whitespace allowed).  PAREN-STATE is the normal thing that it
+  ;; is everywhere else.
+  (let (b-pos)
+    (save-excursion
+      (while
+          (and (setq b-pos (c-pull-open-brace paren-state))
+               (progn (goto-char b-pos)
+                      (c-backward-sws)
+                      (c-backward-token-2)
+                      (not (looking-at "=")))))
+      b-pos)))
+
 (defun c-inside-bracelist-p (containing-sexp paren-state)
   ;; return the buffer position of the beginning of the brace list
   ;; statement if we're inside a brace list, otherwise return nil.
@@ -9340,7 +9453,7 @@ comment at the start of cc-engine.el for more info."
 
            ;; CASE 5B.1: Member init list.
            ((eq (char-after tmp-pos) ?:)
-            (if (or (> tmp-pos indent-point)
+            (if (or (>= tmp-pos indent-point)
                     (= (c-point 'bosws) (1+ tmp-pos)))
                 (progn
                   ;; There is no preceding member init clause.
diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index e7d00815708..2d116e1ecdc 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -446,10 +446,12 @@
               ;; `parse-sexp-lookup-properties' (when it exists).
               (parse-sexp-lookup-properties
                (cc-eval-when-compile
-                 (boundp 'parse-sexp-lookup-properties))))
+                 (boundp 'parse-sexp-lookup-properties)))
+              (BOD-limit
+               (c-determine-limit 1000)))
           (goto-char
            (let ((here (point)))
-             (if (eq (car (c-beginning-of-decl-1)) 'same)
+             (if (eq (car (c-beginning-of-decl-1 BOD-limit)) 'same)
                  (point)
                here)))
           ,(c-make-font-lock-search-form regexp highlights))
@@ -1240,6 +1242,7 @@ casts and declarations are fontified.  Used on level 2 and higher."
           ;; it finds any.  That's necessary so that we later will
           ;; stop inside them to fontify types there.
           (c-parse-and-markup-<>-arglists t)
+          lbrace ; position of some {.
           ;; The font-lock package in Emacs is known to clobber
           ;; `parse-sexp-lookup-properties' (when it exists).
           (parse-sexp-lookup-properties
@@ -1351,7 +1354,6 @@ casts and declarations are fontified.  Used on level 2 and higher."
               (or (looking-at c-typedef-key)
                   (goto-char start-pos)))
 
-            ;; Now analyze the construct.
             ;; In QT, "more" is an irritating keyword that expands to nothing.
             ;; We skip over it to prevent recognition of "more slots: <symbol>"
             ;; as a bitfield declaration.
@@ -1360,6 +1362,8 @@ casts and declarations are fontified.  Used on level 2 and higher."
                         (concat "\\(more\\)\\([^" c-symbol-chars "]\\|$\\)")))
               (goto-char (match-end 1))
               (c-forward-syntactic-ws))
+
+            ;; Now analyze the construct.
             (setq decl-or-cast (c-forward-decl-or-cast-1
                                 match-pos context last-cast-end))
 
@@ -1428,6 +1432,39 @@ casts and declarations are fontified.  Used on level 2 and higher."
               (c-fontify-recorded-types-and-refs)
               nil)
 
+             ;; Restore point, since at this point in the code it has been
+             ;; left undefined by c-forward-decl-or-cast-1 above.
+             ((progn (goto-char start-pos) nil))
+
+             ;; If point is inside a bracelist, there's no point checking it
+             ;; being at a declarator.
+             ((let ((paren-state (c-parse-state)))
+                (setq lbrace (c-cheap-inside-bracelist-p paren-state)))
+              ;; Move past this bracelist to prevent an endless loop.
+              (goto-char lbrace)
+              (unless (c-safe (progn (forward-list) t))
+                (goto-char start-pos)
+                (c-forward-token-2))
+              nil)
+
+             ;; If point is just after a ")" which is followed by an
+             ;; identifier which isn't a label, or at the matching "(", we're
+             ;; at either a macro invocation, a cast, or a
+             ;; for/while/etc. statement.  The cast case is handled above.
+             ;; None of these cases can contain a declarator.
+             ((or (and (eq (char-before match-pos) ?\))
+                       (c-on-identifier)
+                       (save-excursion (not (c-forward-label))))
+                  (and (eq (char-after) ?\()
+                       (save-excursion
+                         (and
+                          (progn (c-backward-token-2) (c-on-identifier))
+                          (save-excursion (not (c-forward-label)))
+                          (progn (c-backward-token-2)
+                                 (eq (char-after) ?\())))))
+              (c-forward-token-2)       ; Must prevent looping.
+              nil)
+
              ((and (not c-enums-contain-decls)
                    ;; An optimization quickly to eliminate scans of long enum
                    ;; declarations in the next cond arm.
@@ -1441,13 +1478,14 @@ casts and declarations are fontified.  Used on level 2 and higher."
                             (progn
                               (c-backward-token-2)
                               (looking-at c-brace-list-key)))))))
-              t)
+              (c-forward-token-2)
+              nil)
 
              (t
               ;; Are we at a declarator?  Try to go back to the declaration
               ;; to check this.  If we get there, check whether a "typedef"
               ;; is there, then fontify the declarators accordingly.
-              (let ((decl-search-lim (max (- (point) 50000) (point-min)))
+              (let ((decl-search-lim (c-determine-limit 1000))
                     paren-state bod-res encl-pos is-typedef
                     c-recognize-knr-p) ; Strictly speaking, bogus, but it
                                        ; speeds up lisp.h tremendously.
diff --git a/lisp/progmodes/cc-guess.el b/lisp/progmodes/cc-guess.el
index fcd6a443b67..4dd802ead0b 100644
--- a/lisp/progmodes/cc-guess.el
+++ b/lisp/progmodes/cc-guess.el
@@ -85,6 +85,7 @@ Discard an examined offset if its absolute value is greater than this.
 
 The offset of a line included in the indent information returned by
 `c-guess-basic-syntax'."
+  :version "24.1"
   :type 'integer
   :group 'c)
 
@@ -92,6 +93,7 @@ The offset of a line included in the indent information returned by
   "The maximum region size for examining indent information with `c-guess'.
 It takes a long time to examine indent information from a large region;
 this option helps you limit that time. `nil' means no limit."
+  :version "24.1"
   :type 'integer
   :group 'c)
 
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index b74d878516d..374c9b434d1 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -490,6 +490,7 @@ that requires a literal mode spec at compile time."
   (make-local-variable 'paragraph-ignore-fill-prefix)
   (make-local-variable 'adaptive-fill-mode)
   (make-local-variable 'adaptive-fill-regexp)
+  (make-local-variable 'fill-paragraph-handle-comment)
 
   ;; now set their values
   (set (make-local-variable 'parse-sexp-ignore-comments) t)
@@ -500,6 +501,9 @@ that requires a literal mode spec at compile time."
   (set (make-local-variable 'comment-line-break-function)
        'c-indent-new-comment-line)
 
+  ;; For the benefit of adaptive file, which otherwise mis-fills.
+  (setq fill-paragraph-handle-comment nil)
+
   ;; Install `c-fill-paragraph' on `fill-paragraph-function' so that a
   ;; direct call to `fill-paragraph' behaves better.  This still
   ;; doesn't work with filladapt but it's better than nothing.
@@ -1151,7 +1155,8 @@ Note that the style variables are always made local to the buffer."
   ;; `c-set-fl-decl-start' for the detailed functionality.
   (cons (c-set-fl-decl-start beg) end))
 
-(defvar c-standard-font-lock-fontify-region-function nil
+(defvar c-standard-font-lock-fontify-region-function
+  (default-value 'font-lock-fontify-region-function)
   "Standard value of `font-lock-fontify-region-function'")
 
 (defun c-font-lock-fontify-region (beg end &optional verbose)
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index f152209956f..c1d8f9db23f 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -74,11 +74,14 @@ If Emacs lacks asynchronous process support, this hook is run
 after `call-process' inserts the grep output into the buffer.")
 
 (defvar compilation-filter-start nil
-  "Start of the text inserted by `compilation-filter'.
-This is bound to a buffer position before running `compilation-filter-hook'.")
+  "Position of the start of the text inserted by `compilation-filter'.
+This is bound before running `compilation-filter-hook'.")
 
 (defvar compilation-first-column 1
-  "*This is how compilers number the first column, usually 1 or 0.")
+  "*This is how compilers number the first column, usually 1 or 0.
+If this is buffer-local in the destination buffer, Emacs obeys
+that value, otherwise it uses the value in the *compilation*
+buffer.  This enables a major-mode to specify its own value.")
 
 (defvar compilation-parse-errors-filename-function nil
   "Function to call to post-process filenames while parsing error messages.
@@ -547,7 +550,10 @@ Otherwise they are interpreted as character positions, with
 each character occupying one column.
 The default is to use screen columns, which requires that the compilation
 program and Emacs agree about the display width of the characters,
-especially the TAB character."
+especially the TAB character.
+If this is buffer-local in the destination buffer, Emacs obeys
+that value, otherwise it uses the value in the *compilation*
+buffer.  This enables a major-mode to specify its own value."
   :type 'boolean
   :group 'compilation
   :version "20.4")
@@ -1058,6 +1064,7 @@ FMTS is a list of format specs for transforming the file name.
          (marker
           (if marker-line (compilation--loc->marker (cadr marker-line))))
          (screen-columns compilation-error-screen-columns)
+         (first-column compilation-first-column)
          end-marker loc end-loc)
     (if (not (and marker (marker-buffer marker)))
         (setq marker nil)               ; no valid marker for this file
@@ -1078,7 +1085,10 @@ FMTS is a list of format specs for transforming the file name.
                ;; Obey the compilation-error-screen-columns of the target
                ;; buffer if its major mode set it buffer-locally.
                (if (local-variable-p 'compilation-error-screen-columns)
-                   compilation-error-screen-columns screen-columns)))
+                   compilation-error-screen-columns screen-columns))
+              (compilation-first-column
+               (if (local-variable-p 'compilation-first-column)
+                   compilation-first-column first-column)))
           (save-excursion
           (save-restriction
             (widen)
@@ -2271,6 +2281,7 @@ This is the value of `next-error-function' in Compilation buffers."
   (when reset
     (setq compilation-current-error nil))
   (let* ((screen-columns compilation-error-screen-columns)
+         (first-column compilation-first-column)
          (last 1)
          (msg (compilation-next-error (or n 1) nil
                                       (or compilation-current-error
@@ -2309,7 +2320,10 @@ This is the value of `next-error-function' in Compilation buffers."
                ;; Obey the compilation-error-screen-columns of the target
                ;; buffer if its major mode set it buffer-locally.
                (if (local-variable-p 'compilation-error-screen-columns)
-                   compilation-error-screen-columns screen-columns)))
+                   compilation-error-screen-columns screen-columns))
+              (compilation-first-column
+               (if (local-variable-p 'compilation-first-column)
+                   compilation-first-column first-column)))
           (save-restriction
             (widen)
             (goto-char (point-min))
diff --git a/lisp/progmodes/cwarn.el b/lisp/progmodes/cwarn.el
index 90147700d77..74ca5a6d76f 100644
--- a/lisp/progmodes/cwarn.el
+++ b/lisp/progmodes/cwarn.el
@@ -1,6 +1,6 @@
 ;;; cwarn.el --- highlight suspicious C and C++ constructions
 
-;; Copyright (C) 1999-2012  Free Software Foundation, Inc.
+;; Copyright (C) 1999-2012 Free Software Foundation, Inc.
 
 ;; Author: Anders Lindgren <andersl@andersl.com>
 ;; Keywords: c, languages, faces
@@ -117,7 +117,6 @@
 (defgroup cwarn nil
   "Highlight suspicious C and C++ constructions."
   :version "21.1"
-  :link '(url-link "http://www.andersl.com/emacs")
   :group 'faces)
 
 (defvar cwarn-mode nil
@@ -129,7 +128,7 @@ instead.")
 (defcustom cwarn-configuration
   '((c-mode (not reference))
     (c++-mode t))
-  "*List of items each describing which features are enable for a mode.
+  "List of items each describing which features are enable for a mode.
 Each item is on the form (mode featurelist), where featurelist can be
 on one of three forms:
 
@@ -158,7 +157,7 @@ keyword list."
   :group 'cwarn)
 
 (defcustom cwarn-verbose t
-  "*When nil, CWarn mode will not generate any messages.
+  "When nil, CWarn mode will not generate any messages.
 
 Currently, messages are generated when the mode is activated and
 deactivated."
@@ -166,7 +165,7 @@ deactivated."
   :type 'boolean)
 
 (defcustom cwarn-mode-text " CWarn"
-  "*String to display in the mode line when CWarn mode is active.
+  "String to display in the mode line when CWarn mode is active.
 
 \(When the string is not empty, make sure that it has a leading space.)"
   :tag "CWarn mode text"                ; To separate it from `global-...'
@@ -174,7 +173,7 @@ deactivated."
   :type 'string)
 
 (defcustom cwarn-load-hook nil
-  "*Functions to run when CWarn mode is first loaded."
+  "Functions to run when CWarn mode is first loaded."
   :tag "Load Hook"
   :group 'cwarn
   :type 'hook)
@@ -192,7 +191,9 @@ Note, in addition to enabling this minor mode, the major mode must
 be included in the variable `cwarn-configuration'.  By default C and
 C++ modes are included.
 
-With ARG, turn CWarn mode on if and only if arg is positive."
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise.  If called from Lisp, enable the mode
+if ARG is omitted or nil."
   :group 'cwarn :lighter cwarn-mode-text
   (cwarn-font-lock-keywords cwarn-mode)
   (if font-lock-mode (font-lock-fontify-buffer)))
@@ -204,6 +205,7 @@ With ARG, turn CWarn mode on if and only if arg is positive."
 This function is designed to be added to hooks, for example:
   (add-hook 'c-mode-hook 'turn-on-cwarn-mode)"
   (cwarn-mode 1))
+(make-obsolete 'turn-on-cwarn-mode 'cwarn-mode "24.1")
 
 ;;}}}
 ;;{{{ Help functions
@@ -247,29 +249,6 @@ If ADDP is non-nil, install else remove."
                    nil keywords)))))
 
 ;;}}}
-;;{{{ Backward compatibility
-
-;; This piece of code will be part of CC mode as of Emacs 20.4.
-(if (not (fboundp 'c-at-toplevel-p))
-(defun c-at-toplevel-p ()
-  "Return a determination as to whether point is at the `top-level'.
-Being at the top-level means that point is either outside any
-enclosing block (such function definition), or inside a class
-definition, but outside any method blocks.
-
-If point is not at the top-level (e.g. it is inside a method
-definition), then nil is returned.  Otherwise, if point is at a
-top-level not enclosed within a class definition, t is returned.
-Otherwise, a 2-vector is returned where the zeroth element is the
-buffer position of the start of the class declaration, and the first
-element is the buffer position of the enclosing class' opening
-brace."
-  (let ((state (c-parse-state)))
-    (or (not (c-most-enclosing-brace state))
-        (c-search-uplist-for-classkey state))))
-)
-
-;;}}}
 ;;{{{ Font-lock keywords and match functions
 
 ;; This section contains font-lock keywords.  A font lock keyword can
@@ -368,7 +347,7 @@ The semicolon after a `do { ... } while (x);' construction is not matched."
   "Turn on CWarn mode in the current buffer if applicable.
 The mode is turned if some feature is enabled for the current
 `major-mode' in `cwarn-configuration'."
-  (if (cwarn-is-enabled major-mode) (turn-on-cwarn-mode)))
+  (when (cwarn-is-enabled major-mode) (cwarn-mode 1)))
 
 ;;;###autoload
 (define-globalized-minor-mode global-cwarn-mode
diff --git a/lisp/progmodes/f90.el b/lisp/progmodes/f90.el
index 25f8107340a..df6fdfd7cd9 100644
--- a/lisp/progmodes/f90.el
+++ b/lisp/progmodes/f90.el
@@ -1,4 +1,4 @@
-;;; f90.el --- Fortran-90 mode (free format)
+;;; f90.el --- Fortran-90 mode (free format)  -*- lexical-binding: t -*-
 
 ;; Copyright (C) 1995-1997, 2000-2012  Free Software Foundation, Inc.
 
@@ -2319,7 +2319,6 @@ escape character."
 
 ;; Local Variables:
 ;; coding: utf-8
-;; lexical-binding: t
 ;; End:
 
 ;;; f90.el ends here
diff --git a/lisp/progmodes/flymake.el b/lisp/progmodes/flymake.el
index fee45fcb3e8..07393c6954d 100644
--- a/lisp/progmodes/flymake.el
+++ b/lisp/progmodes/flymake.el
@@ -1,6 +1,6 @@
 ;;; flymake.el -- a universal on-the-fly syntax checker
 
-;; Copyright (C) 2003-2012  Free Software Foundation, Inc.
+;; Copyright (C) 2003-2012 Free Software Foundation, Inc.
 
 ;; Author:  Pavel Kobyakov <pk_at_work@yahoo.com>
 ;; Maintainer: Pavel Kobyakov <pk_at_work@yahoo.com>
@@ -1331,9 +1331,10 @@ For the format of LINE-ERR-INFO, see `flymake-ler-make-ler'."
 
 ;;;###autoload
 (define-minor-mode flymake-mode
-  "Minor mode to do on-the-fly syntax checking.
-When called interactively, toggles the minor mode.
-With arg, turn Flymake mode on if and only if arg is positive."
+  "Toggle on-the-fly syntax checking.
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise.  If called from Lisp, enable the mode
+if ARG is omitted or nil."
   :group 'flymake :lighter flymake-mode-line
   (cond
 
diff --git a/lisp/progmodes/gdb-mi.el b/lisp/progmodes/gdb-mi.el
index ff2a5f3f3e7..301714ec55f 100644
--- a/lisp/progmodes/gdb-mi.el
+++ b/lisp/progmodes/gdb-mi.el
@@ -1,6 +1,6 @@
 ;;; gdb-mi.el --- User Interface for running GDB
 
-;; Copyright (C) 2007-2012  Free Software Foundation, Inc.
+;; Copyright (C) 2007-2012 Free Software Foundation, Inc.
 
 ;; Author: Nick Roberts <nickrob@gnu.org>
 ;; Maintainer: FSF
@@ -26,7 +26,7 @@
 ;;; Credits:
 
 ;; This file was written by Nick Roberts following the general design
-;; used in gdb-ui.el for Emacs 22.1 - 23.1.  It is currently being developed
+;; used in gdb-ui.el for Emacs 22.1 - 23.1.  It was further developed
 ;; by Dmitry Dzhus <dima@sphinx.net.ru> as part of the Google Summer
 ;; of Code 2009 Project "Emacs GDB/MI migration".
 
@@ -45,7 +45,7 @@
 
 ;; This file uses GDB/MI as the primary interface to GDB.  It runs gdb with
 ;; GDB/MI (-interp=mi) and access CLI using "-interpreter-exec console
-;; cli-command".  This code works without gdb-ui.el and uses MI tokens instead
+;; cli-command".  This code replaces gdb-ui.el and uses MI tokens instead
 ;; of queues.  Eventually MI should be asynchronous.
 
 ;; Windows Platforms:
@@ -779,9 +779,9 @@ detailed description of this mode.
   (gud-def gud-pp
            (gud-call
             (concat
-             "pp1 " (if (eq (buffer-local-value
-                             'major-mode (window-buffer)) 'speedbar-mode)
-                        (gdb-find-watch-expression) "%e")) arg)
+             "pp " (if (eq (buffer-local-value
+                            'major-mode (window-buffer)) 'speedbar-mode)
+                       (gdb-find-watch-expression) "%e")) arg)
            nil   "Print the Emacs s-expression.")
 
   (define-key gud-minor-mode-map [left-margin mouse-1]
diff --git a/lisp/progmodes/glasses.el b/lisp/progmodes/glasses.el
index fb0489f185c..b49739a94d5 100644
--- a/lisp/progmodes/glasses.el
+++ b/lisp/progmodes/glasses.el
@@ -1,6 +1,6 @@
 ;;; glasses.el --- make cantReadThis readable
 
-;; Copyright (C) 1999-2012  Free Software Foundation, Inc.
+;; Copyright (C) 1999-2012 Free Software Foundation, Inc.
 
 ;; Author: Milan Zamazal <pdm@zamazal.org>
 ;; Maintainer: Milan Zamazal <pdm@zamazal.org>
@@ -316,8 +316,10 @@ recognized according to the current value of the variable `glasses-separator'."
 ;;;###autoload
 (define-minor-mode glasses-mode
   "Minor mode for making identifiers likeThis readable.
-When this mode is active, it tries to add virtual separators (like underscores)
-at places they belong to."
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise.  If called from Lisp, enable the mode
+if ARG is omitted or nil.  When this mode is active, it tries to
+add virtual separators (like underscores) at places they belong to."
   :group 'glasses :lighter " o^o"
   (save-excursion
     (save-restriction
diff --git a/lisp/progmodes/grep.el b/lisp/progmodes/grep.el
index 697af76acc9..54d678323f6 100644
--- a/lisp/progmodes/grep.el
+++ b/lisp/progmodes/grep.el
@@ -374,6 +374,9 @@ Notice that using \\[next-error] or \\[compile-goto-error] modifies
     ("^Binary file \\(.+\\) matches$" 1 nil nil 0 1))
   "Regexp used to match grep hits.  See `compilation-error-regexp-alist'.")
 
+(defvar grep-first-column 0             ; bug#10594
+  "Value to use for `compilation-first-column' in grep buffers.")
+
 (defvar grep-error "grep hit"
   "Message to print when no matches are found.")
 
diff --git a/lisp/progmodes/gud.el b/lisp/progmodes/gud.el
index 5fabe5086db..121a023cd54 100644
--- a/lisp/progmodes/gud.el
+++ b/lisp/progmodes/gud.el
@@ -749,7 +749,7 @@ directory and source-file directory for your debugger."
            "Evaluate C dereferenced pointer expression at point.")
 
   ;; For debugging Emacs only.
-  (gud-def gud-pv "pv1 %e"      "\C-v" "Print the value of the lisp variable.")
+  (gud-def gud-pv "pv %e"      "\C-v" "Print the value of the lisp variable.")
 
   (gud-def gud-until  "until %l" "\C-u" "Continue to current line.")
   (gud-def gud-run    "run"      nil    "Run the program.")
@@ -1646,8 +1646,8 @@ and source-file directory for your debugger."
   (gud-common-init command-line nil 'gud-pdb-marker-filter)
   (set (make-local-variable 'gud-minor-mode) 'pdb)
 
-  (gud-def gud-break  "break %f:%l"  "\C-b" "Set breakpoint at current line.")
-  (gud-def gud-remove "clear %f:%l"  "\C-d" "Remove breakpoint at current line")
+  (gud-def gud-break  "break %d%f:%l"  "\C-b" "Set breakpoint at current line.")
+  (gud-def gud-remove "clear %d%f:%l"  "\C-d" "Remove breakpoint at current line")
   (gud-def gud-step   "step"         "\C-s" "Step one source line with display.")
   (gud-def gud-next   "next"         "\C-n" "Step one line (skip functions).")
   (gud-def gud-cont   "continue"     "\C-r" "Continue with display.")
diff --git a/lisp/progmodes/hideshow.el b/lisp/progmodes/hideshow.el
index 0884d28ad5a..104a8f96727 100644
--- a/lisp/progmodes/hideshow.el
+++ b/lisp/progmodes/hideshow.el
@@ -1,6 +1,6 @@
 ;;; hideshow.el --- minor mode cmds to selectively display code/comment blocks
 
-;; Copyright (C) 1994-2012  Free Software Foundation, Inc.
+;; Copyright (C) 1994-2012 Free Software Foundation, Inc.
 
 ;; Author: Thien-Thi Nguyen <ttn@gnu.org>
 ;;      Dan Nicolaescu <dann@ics.uci.edu>
@@ -928,6 +928,10 @@ This can be useful if you have huge RCS logs in those comments."
 ;;;###autoload
 (define-minor-mode hs-minor-mode
   "Minor mode to selectively hide/show code and comment blocks.
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise.  If called from Lisp, enable the mode
+if ARG is omitted or nil.
+
 When hideshow minor mode is on, the menu bar is augmented with hideshow
 commands and the hideshow commands are enabled.
 The value '(hs . t) is added to `buffer-invisibility-spec'.
diff --git a/lisp/progmodes/pascal.el b/lisp/progmodes/pascal.el
index db15e3c6f27..95f1adec40e 100644
--- a/lisp/progmodes/pascal.el
+++ b/lisp/progmodes/pascal.el
@@ -1,6 +1,6 @@
 ;;; pascal.el --- major mode for editing pascal source in Emacs -*- lexical-binding: t -*-
 
-;; Copyright (C) 1993-2012  Free Software Foundation, Inc.
+;; Copyright (C) 1993-2012 Free Software Foundation, Inc.
 
 ;; Author: Espen Skoglund <esk@gnu.org>
 ;; Keywords: languages
@@ -1394,8 +1394,12 @@ The default is a name found in the buffer around point."
 (define-obsolete-function-alias 'pascal-outline 'pascal-outline-mode "22.1")
 (define-minor-mode pascal-outline-mode
   "Outline-line minor mode for Pascal mode.
-When in Pascal Outline mode, portions
-of the text being edited may be made invisible. \\<pascal-outline-map>
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise.  If called from Lisp, enable the mode
+if ARG is omitted or nil.
+
+When enabled, portions of the text being edited may be made
+invisible. \\<pascal-outline-map>
 
 Pascal Outline mode provides some additional commands.
 
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 0c29891cd92..15d98ce48af 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -67,6 +67,7 @@
 ;;; Code:
 
 (require 'comint)
+(require 'ansi-color)
 
 (eval-when-compile
   (require 'compile)
@@ -1386,7 +1387,6 @@ For running multiple processes in multiple buffers, see `run-python' and
 
 \\{inferior-python-mode-map}"
   :group 'python
-  (require 'ansi-color) ; for ipython
   (setq mode-line-process '(":%s"))
   (set (make-local-variable 'comint-input-filter) 'python-input-filter)
   (add-hook 'comint-preoutput-filter-functions #'python-preoutput-filter
@@ -1530,7 +1530,6 @@ behavior, change `python-remove-cwd-from-path' to nil."
   (interactive (if current-prefix-arg
                    (list (read-string "Run Python: " python-command) nil t)
                  (list python-command)))
-  (require 'ansi-color) ; for ipython
   (unless cmd (setq cmd python-command))
   (python-check-version cmd)
   (setq python-command cmd)
diff --git a/lisp/progmodes/sql.el b/lisp/progmodes/sql.el
index 2e59d8f8517..f8f62d113e6 100644
--- a/lisp/progmodes/sql.el
+++ b/lisp/progmodes/sql.el
@@ -285,7 +285,7 @@ Customizing your password will store it in your ~/.emacs file."
   :safe 'stringp)
 
 (defcustom sql-port 0
-  "Default port."
+  "Default port for connecting to a MySQL or Postgres server."
   :version "24.1"
   :type 'number
   :group 'SQL
@@ -613,30 +613,22 @@ settings.")
   '(:font-lock :sqli-program :sqli-options :sqli-login :statement))
 
 (defcustom sql-connection-alist nil
-  "An alist of connection parameters for interacting with a SQL
-  product.
-
+  "An alist of connection parameters for interacting with a SQL product.
 Each element of the alist is as follows:
 
   \(CONNECTION \(SQL-VARIABLE VALUE) ...)
 
 Where CONNECTION is a symbol identifying the connection, SQL-VARIABLE
 is the symbol name of a SQL mode variable, and VALUE is the value to
-be assigned to the variable.
-
-The most common SQL-VARIABLE settings associated with a connection
-are:
-
-  `sql-product'
-  `sql-user'
-  `sql-password'
-  `sql-port'
-  `sql-server'
-  `sql-database'
+be assigned to the variable.  The most common SQL-VARIABLE settings
+associated with a connection are: `sql-product', `sql-user',
+`sql-password', `sql-port', `sql-server', and `sql-database'.
 
 If a SQL-VARIABLE is part of the connection, it will not be
-prompted for during login."
-
+prompted for during login.  The command `sql-connect' starts a
+predefined SQLi session using the parameters from this list.
+Connections defined here appear in the submenu SQL->Start...  for
+making new SQLi sessions."
   :type `(alist :key-type (string :tag "Connection")
                 :value-type
                 (set
@@ -3647,7 +3639,9 @@ The list is maintained in SQL interactive buffers.")
       (read-from-minibuffer prompt tname))))
 
 (defun sql-list-all (&optional enhanced)
-  "List all database objects."
+  "List all database objects.
+With optional prefix argument ENHANCED, displays additional
+details or extends the listing to include other schemas objects."
   (interactive "P")
   (let ((sqlbuf (sql-find-sqli-buffer)))
     (unless sqlbuf
@@ -3659,7 +3653,9 @@ The list is maintained in SQL interactive buffers.")
       (set (make-local-variable 'sql-buffer) sqlbuf))))
 
 (defun sql-list-table (name &optional enhanced)
-  "List the details of a database table. "
+  "List the details of a database table named NAME.
+Displays the columns in the relation.  With optional prefix argument
+ENHANCED, displays additional details about each column."
   (interactive
    (list (sql-read-table-name "Table name: ")
          current-prefix-arg))