Merge from emacs-24; up to 2012-12-14T15:22:24Z!monnier@iro.umontreal.ca

8 files changed, 263 insertions, 221 deletions

diff --git a/doc/misc/ChangeLog b/doc/misc/ChangeLog
index d4dde056461..05f53257fa8 100644
--- a/doc/misc/ChangeLog
+++ b/doc/misc/ChangeLog
@@ -1,3 +1,23 @@
+2013-02-07  Glenn Morris  <rgm@gnu.org>
+
+        * cl.texi (Equality Predicates): Mention memql.
+
+2013-02-07  Eric Ludlam  <zappo@gnu.org>
+
+        * doc/misc/ede.texi (Creating a project): Make ede-new doc less
+        specific, and only about items it supports, indicating that there
+        might be more.  Remove refs to simple project and direct automake
+        from ede new.
+        (Simple projects): Re-write to not talk about ede-simple-project
+        which is deprecated, and instead use the term to mean projects
+        that don't do much management, just project wrapping.  Add
+        ede-generic-project link.
+        (ede-generic-project): New node (bug#11441).
+
+2013-02-07  Glenn Morris  <rgm@gnu.org>
+
+        * cl.texi (Equality Predicates): Fix eq/eql pedantry.
+
 2013-02-01  Glenn Morris  <rgm@gnu.org>
 
         * calc.texi (Help Commands): Update calc-view-news description.
diff --git a/doc/misc/cl.texi b/doc/misc/cl.texi
index c3657415078..8da6032d728 100644
--- a/doc/misc/cl.texi
+++ b/doc/misc/cl.texi
@@ -817,8 +817,9 @@ not compare strings against vectors of integers.
 Also note that the Common Lisp functions @code{member} and @code{assoc}
 use @code{eql} to compare elements, whereas Emacs Lisp follows the
 MacLisp tradition and uses @code{equal} for these two functions.
-In Emacs, use @code{memq} (or @code{cl-member}) and @code{assq} (or
-@code{cl-assoc}) to get functions which use @code{eql} for comparisons.
+The functions @code{cl-member} and @code{cl-assoc} use @code{eql},
+as in Common Lisp.  The standard Emacs Lisp functions @code{memq} and
+@code{assq} use @code{eq}, and the standard @code{memql} uses @code{eql}.
 
 @node Control Structure
 @chapter Control Structure
diff --git a/doc/misc/ede.texi b/doc/misc/ede.texi
index cadd815025c..ddee7e6b5d5 100644
--- a/doc/misc/ede.texi
+++ b/doc/misc/ede.texi
@@ -450,9 +450,11 @@ ede-new}, or click on the @samp{Create Project} item in the
 
 The @command{ede-new} command prompts for the type of project you
 would like to create.  Each project type has its own benefits or
-language specific enhancements.  @ede{} supports four different
-project types: @samp{Make}, @samp{Automake}, @samp{direct Automake},
-and @samp{Simple}.
+language specific enhancements.  Not all projects that @ede{} supports
+also allow creating a new project.  Projects such as @code{emacs}
+or @code{linux} are designed to recognize existing projects only.
+Project types such as @samp{Make} and @samp{Automake} do support
+creating new project types with @command{ede-new}.
 
 @itemize
 @item
@@ -468,21 +470,6 @@ Unlike a @samp{Make} project, this project autogenerates a
 @file{Makefile.am} file.  @ede{} handles the Automake bootstrapping
 routines, which import and maintain a @file{configure.am} script and
 other required files.
-
-@item
-For the @samp{direct Automake} project type, @ede{} reads directly
-from the Automake files.
-
-You cannot create direct Automake projects with the @command{ede-new}
-command.  Instead, when you visit a project with existing Automake
-files, @ede{} automatically detects them.
-
-@item
-The @samp{Simple} project type provides light-weight constructs for
-identifying a project root and looking up files.  If you already have
-a non-@ede{} project infrastructure, you can use a @samp{Simple}
-project to provide other Emacs packages, such as Semantic, with some
-information about the project.  @xref{Simple projects}.
 @end itemize
 
 A subproject is merely a project in a subdirectory of another project.
@@ -795,24 +782,19 @@ able to find your SDK and compile your programs.
 @node Simple projects
 @section Simple Projects
 
-There is a wide array of Simple projects.  The root for simple
-projects is the class @code{ede-simple-project}.  This handles the
-infrastructure of storing a .ede file if needed.
-
-The class @code{ede-simple-project} is designed to be subclassed.
-Then key @ede{} methods can be overridden to provide a quick wrapper
-over any project.
+There is a wide array of simple projects.  In this case a simple
+project is one that detects, or is directed to identify a directory as
+belonging to a project, but doesn't provide many features of a typical
+@ede{} project.  Having the project however allows tools such as
+@semantic{} to find sources and perform project level completions.
 
-A second project type is @code{ede-cpp-root}.  This project type is
-designed to be created for a directory hierarchy full of C/C++ code.
-It can be configured with minimal lisp knowledge to do header file
-lookup for @semantic{}, improving code completion performance.
 
 @menu
 * ede-cpp-root::                This project marks the root of a C/C++ code project.
 * ede-java-root::               This project marks the root of a Java project.
 * ede-emacs::                   A project for working with Emacs.
 * ede-linux::                   A project for working with Linux kernels.
+* ede-generic-project::         A project type for wrapping build systems with EDE.
 * Custom Locate::               Customizing how to locate files in a simple project
 @end menu
 
@@ -1045,7 +1027,7 @@ tree, and enables EDE project mode for it.
 It pre-populates the C Preprocessor symbol map for correct parsing,
 and has an optimized include file identification function.
 
-@node ede-linux, Custom Locate, ede-emacs, Simple projects
+@node ede-linux, ede-generic-project, ede-emacs, Simple projects
 @subsection ede-linux
 
 The @code{ede-linux} project will automatically identify a Linux
@@ -1054,7 +1036,60 @@ Kernel source tree, and enable EDE project mode for it.
 It pre-populates the C Preprocessor symbol map for reasonable parsing,
 and has an optimized include file identification function.
 
-@node Custom Locate,  , ede-linux, Simple projects
+@node ede-generic-project, Custom Locate, ede-linux, Simple projects
+@subsection ede-generic-project
+
+The @code{ede-generic-project} is a project system that makes it easy
+to wrap up different kinds of build systems as an EDE project.
+Projects such as @ref{ede-emacs} require coding skills to create.
+Generic projects also require writing Emacs Lisp code, but the
+requirements are minimal.  You can then use
+@command{customize-project} to configure build commands, includes, and
+other options for that project.  The configuration is saved in
+@file{EDEConfig.el}.
+
+Generic projects are disabled by default because they have the
+potential to interfere with other projects.  To use the generic
+project sytem to start detecting projects, you need to enable it.
+
+@deffn Command ede-enable-generic-projects
+Enable generic project loaders.
+
+This enables generic loaders for projects that are detected using
+either a @file{Makefile}, @file{SConstruct}, or @file{CMakeLists}.
+
+You do not need to use this command if you create your own generic
+project type.
+@end deffn
+
+If you want to create your own generic project loader, you need to
+define your own project and target classes, and create an autoloader.
+The example for Makefiles looks like this:
+
+@example
+;;; MAKEFILE
+
+(defclass ede-generic-makefile-project (ede-generic-project)
+  ((buildfile :initform "Makefile")
+   )
+  "Generic Project for makefiles.")
+
+(defmethod ede-generic-setup-configuration ((proj ede-generic-makefile-project) config)
+  "Setup a configuration for Make."
+  (oset config build-command "make -k")
+  (oset config debug-command "gdb ")
+  )
+
+(ede-generic-new-autoloader "generic-makefile" "Make"
+                            "Makefile" 'ede-generic-makefile-project)
+@end example
+
+This example project will detect any directory with the file
+@file{Makefile} in it as belonging to this project type.
+Customization of the project will allow you to make build and debug
+commands more precise.
+
+@node Custom Locate,  , ede-generic-project, Simple projects
 @subsection Custom Locate
 
 The various simple project styles all have one major drawback, which
@@ -1062,8 +1097,6 @@ is that the files in the project are not completely known to EDE@.
 When the EDE API is used to try and file files by some reference name
 in the project, then that could fail.
 
-@@TODO - Add ID Utils and CScope examples
-
 @ede{} can therefore use some external locate commands, such as the unix
 ``locate'' command, or ``GNU Global''.
 
@@ -1093,6 +1126,11 @@ You can add your own locate tool but subclassing from
 methods.  See the code in @file{ede-locate.el} for GNU Global as a
 simple example.
 
+@@TODO - Add ID Utils and CScope examples
+
+More on idutils and cscope is in the CEDET manual, and they each have
+their own section.
+
 @node Extending EDE, GNU Free Documentation License, Miscellaneous commands, Top
 @chapter Extending @ede{}
 
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index f87bdddacda..ef97f6a8816 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,22 @@
+2013-02-07  Alan Mackenzie  <acm@muc.de>
+
+        Fix bug in state cache mechanism.  Remove 'BOD "strategy".  Refactor.
+        * progmodes/cc-engine.el (c-get-fallback-scan-pos): Remove.
+        (c-parse-state-get-strategy): Don't return 'BOD any more.
+        (c-append-lower-brace-pair-to-state-cache):
+        Extra parameter HERE instead of narrowing.
+        Widen to top of buffer before searching backwards for a brace pair.
+        (c-state-push-any-brace-pair): Add HERE parameter to function call.
+        (c-append-to-state-cache): Extra parameter HERE in place of narrowing.
+        Narrow to parameter HERE, in place of being called narrowed.
+        (c-remove-stale-state-cache): Extra parameter HERE in place of
+        narrowing.  Check there's an open brace in the cache before
+        searching for its match.
+        (c-invalidate-state-cache-1): Add HERE parameter to function call.
+        (c-parse-state-1): Don't narrow here for 'forward strategy,
+        instead passing extra parameter HERE to several functions.
+        Remove 'BOD strategy.
+
 2013-02-06  Nicolas Richard <theonewiththeevillook@yahoo.fr>  (tiny change)
 
         * emacs-lisp/package.el (describe-package-1): Tell what archive is
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index 7cb278f2a6f..56ec2ed50c8 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,8 @@
+2013-02-07  Gábor Vida  <gabor.v.vida@ericsson.com>  (tiny change)
+
+        * auth-source.el (auth-source-format-prompt): Don't get confused by
+        any "\" in replacement text.  (Bug#13637)
+
 2013-01-30  Christopher Schmidt  <christopher@ch.ristopher.com>
 
         * gnus-int.el (gnus-backend-trace-elapsed): New variable.
diff --git a/lisp/gnus/auth-source.el b/lisp/gnus/auth-source.el
index ac16200adb2..e94904bf175 100644
--- a/lisp/gnus/auth-source.el
+++ b/lisp/gnus/auth-source.el
@@ -913,7 +913,7 @@ while \(:host t) would find all host entries."
       (when (and c v)
         (setq prompt (replace-regexp-in-string (format "%%%c" c)
                                                (format "%s" v)
-                                               prompt)))))
+                                               prompt nil t)))))
   prompt)
 
 (defun auth-source-ensure-strings (values)
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index d4e4d6de483..977bc755e32 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -2477,20 +2477,6 @@ comment at the start of cc-engine.el for more info."
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Defuns which analyze the buffer, yet don't change `c-state-cache'.
-(defun c-get-fallback-scan-pos (here)
-  ;; Return a start position for building `c-state-cache' from
-  ;; scratch.  This will be at the top level, 2 defuns back.
-  (save-excursion
-    ;; Go back 2 bods, but ignore any bogus positions returned by
-    ;; beginning-of-defun (i.e. open paren in column zero).
-    (goto-char here)
-    (let ((cnt 2))
-      (while (not (or (bobp) (zerop cnt)))
-        (c-beginning-of-defun-1)        ; Pure elisp BOD.
-        (if (eq (char-after) ?\{)
-            (setq cnt (1- cnt)))))
-    (point)))
-
 (defun c-state-balance-parens-backwards (here- here+ top)
   ;; Return the position of the opening paren/brace/bracket before HERE- which
   ;; matches the outermost close p/b/b between HERE+ and TOP.  Except when
@@ -2548,47 +2534,23 @@ comment at the start of cc-engine.el for more info."
   ;; o - ('forward START-POINT) - scan forward from START-POINT,
   ;;     which is not less than the highest position in `c-state-cache' below here.
   ;; o - ('backward nil) - scan backwards (from HERE).
-  ;; o - ('BOD START-POINT) - scan forwards from START-POINT, which is at the
-  ;;   top level.
   ;; o - ('IN-LIT nil) - point is inside the literal containing point-min.
   (let ((cache-pos (c-get-cache-scan-pos here)) ; highest position below HERE in cache (or 1)
-        BOD-pos             ; position of 2nd BOD before HERE.
-        strategy            ; 'forward, 'backward, 'BOD, or 'IN-LIT.
-        start-point
-        how-far)                        ; putative scanning distance.
+        strategy            ; 'forward, 'backward, or 'IN-LIT.
+        start-point)
     (setq good-pos (or good-pos (c-state-get-min-scan-pos)))
     (cond
      ((< here (c-state-get-min-scan-pos))
-      (setq strategy 'IN-LIT
-            start-point nil
-            cache-pos nil
-            how-far 0))
+      (setq strategy 'IN-LIT))
      ((<= good-pos here)
       (setq strategy 'forward
-            start-point (max good-pos cache-pos)
-            how-far (- here start-point)))
+            start-point (max good-pos cache-pos)))
      ((< (- good-pos here) (- here cache-pos)) ; FIXME!!! ; apply some sort of weighting.
-      (setq strategy 'backward
-            how-far (- good-pos here)))
+      (setq strategy 'backward))
      (t
       (setq strategy 'forward
-              how-far (- here cache-pos)
-              start-point cache-pos)))
-
-    ;; Might we be better off starting from the top level, two defuns back,
-    ;; instead?  This heuristic no longer works well in C++, where
-    ;; declarations inside namespace brace blocks are frequently placed at
-    ;; column zero.
-    (when (and (not (c-major-mode-is 'c++-mode))
-               (> how-far c-state-cache-too-far))
-      (setq BOD-pos (c-get-fallback-scan-pos here)) ; somewhat EXPENSIVE!!!
-      (if (< (- here BOD-pos) how-far)
-          (setq strategy 'BOD
-                start-point BOD-pos)))
-
-    (list
-     strategy
-     (and (memq strategy '(forward BOD)) start-point))))
+            start-point cache-pos)))
+    (list strategy (and (eq strategy 'forward) start-point))))
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2630,7 +2592,7 @@ comment at the start of cc-engine.el for more info."
 
   (setq c-state-point-min (point-min)))
 
-(defun c-append-lower-brace-pair-to-state-cache (from &optional upper-lim)
+(defun c-append-lower-brace-pair-to-state-cache (from here &optional upper-lim)
   ;; If there is a brace pair preceding FROM in the buffer, at the same level
   ;; of nesting (not necessarily immediately preceding), push a cons onto
   ;; `c-state-cache' to represent it.  FROM must not be inside a literal.  If
@@ -2654,8 +2616,7 @@ comment at the start of cc-engine.el for more info."
   ;; reduce the time wasted in repeated fruitless searches in brace deserts.
   (save-excursion
     (save-restriction
-      (let* ((here (point-max))
-             new-cons
+      (let* (new-cons
              (cache-pos (c-state-cache-top-lparen)) ; might be nil.
              (macro-start-or-from
               (progn (goto-char from)
@@ -2690,7 +2651,6 @@ comment at the start of cc-engine.el for more info."
                 ;; search bound, even though the algorithm below would skip
                 ;; over the new paren pair.
                 (cache-lim (and cache-pos (< cache-pos from) cache-pos)))
-            (widen)
             (narrow-to-region
                 (cond
                  ((and desert-lim cache-lim)
@@ -2698,7 +2658,9 @@ comment at the start of cc-engine.el for more info."
                  (desert-lim)
                  (cache-lim)
                  ((point-min)))
-                (point-max)))
+                ;; The top limit is EOB to ensure that `bra' is inside the
+                ;; accessible part of the buffer at the next scan operation.
+                (1+ (buffer-size))))
 
           ;; In the next pair of nested loops, the inner one moves back past a
           ;; pair of (mis-)matching parens or brackets; the outer one moves
@@ -2765,25 +2727,24 @@ comment at the start of cc-engine.el for more info."
                       (if (consp (car c-state-cache))
                           (cdr c-state-cache)
                         c-state-cache)))
-        ;; N.B.  This defsubst codes one method for the simple, normal case,
+        ;; N.B.  This defsubst codes one method for the simple, normal case,
         ;; and a more sophisticated, slower way for the general case.  Don't
         ;; eliminate this defsubst - it's a speed optimization.
-        (c-append-lower-brace-pair-to-state-cache (1- bra+1)))))
+        (c-append-lower-brace-pair-to-state-cache (1- bra+1) (point-max)))))
 
-(defun c-append-to-state-cache (from)
-  ;; Scan the buffer from FROM to (point-max), adding elements into
-  ;; `c-state-cache' for braces etc.  Return a candidate for
-  ;; `c-state-cache-good-pos'.
+(defun c-append-to-state-cache (from here)
+  ;; Scan the buffer from FROM to HERE, adding elements into `c-state-cache'
+  ;; for braces etc.  Return a candidate for `c-state-cache-good-pos'.
   ;;
   ;; FROM must be after the latest brace/paren/bracket in `c-state-cache', if
   ;; any.  Typically, it is immediately after it.  It must not be inside a
   ;; literal.
-  (let ((here-bol (c-point 'bol (point-max)))
+  (let ((here-bol (c-point 'bol here))
         (macro-start-or-here
-         (save-excursion (goto-char (point-max))
+         (save-excursion (goto-char here)
                          (if (c-beginning-of-macro)
                              (point)
-                           (point-max))))
+                           here)))
         pa+1                  ; pos just after an opening PAren (or brace).
         (ren+1 from)          ; usually a pos just after an closing paREN etc.
                               ; Is actually the pos. to scan for a (/{/[ from,
@@ -2796,75 +2757,77 @@ comment at the start of cc-engine.el for more info."
         mstart)               ; start of a macro.
 
     (save-excursion
-      ;; Each time round the following loop, we enter a successively deeper
-      ;; level of brace/paren nesting.  (Except sometimes we "continue at
-      ;; the existing level".)  `pa+1' is a pos inside an opening
-      ;; brace/paren/bracket, usually just after it.
-      (while
-          (progn
-            ;; Each time round the next loop moves forward over an opening then
-            ;; a closing brace/bracket/paren.  This loop is white hot, so it
-            ;; plays ugly tricks to go fast.  DON'T PUT ANYTHING INTO THIS
-            ;; LOOP WHICH ISN'T ABSOLUTELY NECESSARY!!!  It terminates when a
-            ;; call of `scan-lists' signals an error, which happens when there
-            ;; are no more b/b/p's to scan.
-            (c-safe
-              (while t
-                (setq pa+1 (scan-lists ren+1 1 -1) ; Into (/{/[; might signal
-                      paren+1s (cons pa+1 paren+1s))
-                (setq ren+1 (scan-lists pa+1 1 1)) ; Out of )/}/]; might signal
-                (if (and (eq (char-before pa+1) ?{)) ; Check for a macro later.
-                    (setq bra+1 pa+1))
-                (setcar paren+1s ren+1)))
-
-            (if (and pa+1 (> pa+1 ren+1))
-                ;; We've just entered a deeper nesting level.
-                (progn
-                  ;; Insert the brace pair (if present) and the single open
-                  ;; paren/brace/bracket into `c-state-cache' It cannot be
-                  ;; inside a macro, except one around point, because of what
-                  ;; `c-neutralize-syntax-in-CPP' has done.
-                  (c-state-push-any-brace-pair bra+1 macro-start-or-here)
-                  ;; Insert the opening brace/bracket/paren position.
-                  (setq c-state-cache (cons (1- pa+1) c-state-cache))
-                  ;; Clear admin stuff for the next more nested part of the scan.
-                  (setq ren+1 pa+1  pa+1 nil  bra+1 nil  bra+1s nil)
-                  t)                    ; Carry on the loop
-
-              ;; All open p/b/b's at this nesting level, if any, have probably
-              ;; been closed by matching/mismatching ones.  We're probably
-              ;; finished - we just need to check for having found an
-              ;; unmatched )/}/], which we ignore.  Such a )/}/] can't be in a
-              ;; macro, due the action of `c-neutralize-syntax-in-CPP'.
-              (c-safe (setq ren+1 (scan-lists ren+1 1 1)))))) ; acts as loop control.
-
-      ;; Record the final, innermost, brace-pair if there is one.
-      (c-state-push-any-brace-pair bra+1 macro-start-or-here)
-
-      ;; Determine a good pos
-      (while (and (setq paren+1 (car paren+1s))
-                  (> (if (> paren+1 macro-start-or-here)
-                         paren+1
-                       (goto-char paren+1)
-                       (setq mstart (and (c-beginning-of-macro)
-                                         (point)))
-                       (or mstart paren+1))
-                     here-bol))
-        (setq paren+1s (cdr paren+1s)))
-      (cond
-       ((and paren+1 mstart)
-        (min paren+1 mstart))
-       (paren+1)
-       (t from)))))
+      (save-restriction
+        (narrow-to-region (point-min) here)
+        ;; Each time round the following loop, we enter a successively deeper
+        ;; level of brace/paren nesting.  (Except sometimes we "continue at
+        ;; the existing level".)  `pa+1' is a pos inside an opening
+        ;; brace/paren/bracket, usually just after it.
+        (while
+            (progn
+              ;; Each time round the next loop moves forward over an opening then
+              ;; a closing brace/bracket/paren.  This loop is white hot, so it
+              ;; plays ugly tricks to go fast.  DON'T PUT ANYTHING INTO THIS
+              ;; LOOP WHICH ISN'T ABSOLUTELY NECESSARY!!!  It terminates when a
+              ;; call of `scan-lists' signals an error, which happens when there
+              ;; are no more b/b/p's to scan.
+              (c-safe
+                (while t
+                  (setq pa+1 (scan-lists ren+1 1 -1) ; Into (/{/[; might signal
+                        paren+1s (cons pa+1 paren+1s))
+                  (setq ren+1 (scan-lists pa+1 1 1)) ; Out of )/}/]; might signal
+                  (if (and (eq (char-before pa+1) ?{)) ; Check for a macro later.
+                      (setq bra+1 pa+1))
+                  (setcar paren+1s ren+1)))
+
+              (if (and pa+1 (> pa+1 ren+1))
+                  ;; We've just entered a deeper nesting level.
+                  (progn
+                    ;; Insert the brace pair (if present) and the single open
+                    ;; paren/brace/bracket into `c-state-cache' It cannot be
+                    ;; inside a macro, except one around point, because of what
+                    ;; `c-neutralize-syntax-in-CPP' has done.
+                    (c-state-push-any-brace-pair bra+1 macro-start-or-here)
+                    ;; Insert the opening brace/bracket/paren position.
+                    (setq c-state-cache (cons (1- pa+1) c-state-cache))
+                    ;; Clear admin stuff for the next more nested part of the scan.
+                    (setq ren+1 pa+1  pa+1 nil  bra+1 nil  bra+1s nil)
+                    t)                  ; Carry on the loop
+
+                ;; All open p/b/b's at this nesting level, if any, have probably
+                ;; been closed by matching/mismatching ones.  We're probably
+                ;; finished - we just need to check for having found an
+                ;; unmatched )/}/], which we ignore.  Such a )/}/] can't be in a
+                ;; macro, due the action of `c-neutralize-syntax-in-CPP'.
+                (c-safe (setq ren+1 (scan-lists ren+1 1 1)))))) ; acts as loop control.
+
+        ;; Record the final, innermost, brace-pair if there is one.
+        (c-state-push-any-brace-pair bra+1 macro-start-or-here)
+
+        ;; Determine a good pos
+        (while (and (setq paren+1 (car paren+1s))
+                    (> (if (> paren+1 macro-start-or-here)
+                           paren+1
+                         (goto-char paren+1)
+                         (setq mstart (and (c-beginning-of-macro)
+                                           (point)))
+                         (or mstart paren+1))
+                       here-bol))
+          (setq paren+1s (cdr paren+1s)))
+        (cond
+         ((and paren+1 mstart)
+          (min paren+1 mstart))
+         (paren+1)
+         (t from))))))
 
-(defun c-remove-stale-state-cache (start-point pps-point)
+(defun c-remove-stale-state-cache (start-point here pps-point)
   ;; Remove stale entries from the `c-cache-state', i.e. those which will
-  ;; not be in it when it is amended for position (point-max).
-  ;; Additionally, the "outermost" open-brace entry before (point-max)
-  ;; will be converted to a cons if the matching close-brace is scanned.
+  ;; not be in it when it is amended for position HERE.  Additionally, the
+  ;; "outermost" open-brace entry before HERE will be converted to a cons if
+  ;; the matching close-brace is scanned.
   ;;
   ;; START-POINT is a "maximal" "safe position" - there must be no open
-  ;; parens/braces/brackets between START-POINT and (point-max).
+  ;; parens/braces/brackets between START-POINT and HERE.
   ;;
   ;; As a second thing, calculate the result of parse-partial-sexp at
   ;; PPS-POINT, w.r.t. START-POINT.  The motivation here is that
@@ -2881,23 +2844,23 @@ comment at the start of cc-engine.el for more info."
   ;;   last element to be removed from `c-state-cache', when that elt is a
   ;;   cons, otherwise nil.
   ;; o - PPS-STATE is the parse-partial-sexp state at PPS-POINT.
-  (save-restriction
-    (narrow-to-region 1 (point-max))
-    (save-excursion
-      (let* ((in-macro-start   ; start of macro containing (point-max) or nil.
+  (save-excursion
+    (save-restriction
+      (narrow-to-region 1 (point-max))
+      (let* ((in-macro-start   ; start of macro containing HERE or nil.
               (save-excursion
-                (goto-char (point-max))
+                (goto-char here)
                 (and (c-beginning-of-macro)
                      (point))))
              (start-point-actual-macro-start ; Start of macro containing
                                              ; start-point or nil
-              (and (< start-point (point-max))
+              (and (< start-point here)
                    (save-excursion
                      (goto-char start-point)
                      (and (c-beginning-of-macro)
                           (point)))))
              (start-point-actual-macro-end ; End of this macro, (maybe
-                                        ; (point-max)), or nil.
+                                        ; HERE), or nil.
               (and start-point-actual-macro-start
                    (save-excursion
                      (goto-char start-point-actual-macro-start)
@@ -2909,14 +2872,14 @@ comment at the start of cc-engine.el for more info."
              scan-back-pos
              pair-beg pps-point-state target-depth)
 
-        ;; Remove entries beyond (point-max).  Also remove any entries inside
-        ;; a macro, unless (point-max) is in the same macro.
+        ;; Remove entries beyond HERE.  Also remove any entries inside
+        ;; a macro, unless HERE is in the same macro.
         (setq upper-lim
               (if (or (null c-state-old-cpp-beg)
-                      (and (> (point-max) c-state-old-cpp-beg)
-                           (< (point-max) c-state-old-cpp-end)))
-                  (point-max)
-                (min (point-max) c-state-old-cpp-beg)))
+                      (and (> here c-state-old-cpp-beg)
+                           (< here c-state-old-cpp-end)))
+                  here
+                (min here c-state-old-cpp-beg)))
         (while (and c-state-cache (>= (c-state-cache-top-lparen) upper-lim))
           (setq scan-back-pos (car-safe (car c-state-cache)))
           (setq c-state-cache (cdr c-state-cache)))
@@ -2934,7 +2897,7 @@ comment at the start of cc-engine.el for more info."
         ;; time round; the corresponding elements in `c-state-cache' are
         ;; removed.  `pos' is just after the brace-pair or the open paren at
         ;; (car c-state-cache).  There can be no open parens/braces/brackets
-        ;; between `start-point'/`start-point-actual-macro-start' and (point-max),
+        ;; between `start-point'/`start-point-actual-macro-start' and HERE,
         ;; due to the interface spec to this function.
         (setq pos (if (and start-point-actual-macro-end
                            (not (eq start-point-actual-macro-start
@@ -2944,7 +2907,9 @@ comment at the start of cc-engine.el for more info."
                     start-point))
         (goto-char pos)
         (while (and c-state-cache
-                    (< (point) (point-max)))
+                    (or (numberp (car c-state-cache)) ; Have we a { at all? 
+                        (cdr c-state-cache))
+                    (< (point) here))
           (cond
            ((null pps-state)            ; first time through
             (setq target-depth -1))
@@ -2956,7 +2921,7 @@ comment at the start of cc-engine.el for more info."
           ;; Scan!
           (setq pps-state
                 (parse-partial-sexp
-                 (point) (if (< (point) pps-point) pps-point (point-max))
+                 (point) (if (< (point) pps-point) pps-point here)
                  target-depth
                  nil pps-state))
 
@@ -3209,7 +3174,7 @@ comment at the start of cc-engine.el for more info."
       ;; Do we need to add in an earlier brace pair, having lopped one off?
       (if (and dropped-cons
                (< too-high-pa (+ here c-state-cache-too-far)))
-          (c-append-lower-brace-pair-to-state-cache too-high-pa here-bol))
+          (c-append-lower-brace-pair-to-state-cache too-high-pa here here-bol))
       (setq c-state-cache-good-pos (or (c-state-cache-after-top-paren)
                                        (c-state-get-min-scan-pos)))))
 
@@ -3285,47 +3250,39 @@ comment at the start of cc-engine.el for more info."
           strategy (car res)
           start-point (cadr res))
 
-    (when (eq strategy 'BOD)
-      (setq c-state-cache nil
-            c-state-cache-good-pos start-point))
-
     ;; SCAN!
-    (save-restriction
-      (cond
-       ((memq strategy '(forward BOD))
-        (narrow-to-region (point-min) here)
-        (setq res (c-remove-stale-state-cache start-point here-bopl))
-        (setq cache-pos (car res)
-              scan-backward-pos (cadr res)
-              bopl-state (car (cddr res))) ; will be nil if (< here-bopl
+    (cond
+     ((eq strategy 'forward)
+      (setq res (c-remove-stale-state-cache start-point here here-bopl))
+      (setq cache-pos (car res)
+            scan-backward-pos (cadr res)
+            bopl-state (car (cddr res))) ; will be nil if (< here-bopl
                                         ; start-point)
-        (if scan-backward-pos
-            (c-append-lower-brace-pair-to-state-cache scan-backward-pos))
-        (setq good-pos
-              (c-append-to-state-cache cache-pos))
-        (setq c-state-cache-good-pos
-              (if (and bopl-state
-                       (< good-pos (- here c-state-cache-too-far)))
-                  (c-state-cache-non-literal-place here-bopl bopl-state)
-                good-pos)))
-
-       ((eq strategy 'backward)
-        (setq res (c-remove-stale-state-cache-backwards here)
-              good-pos (car res)
-              scan-backward-pos (cadr res)
-              scan-forward-p (car (cddr res)))
-        (if scan-backward-pos
-            (c-append-lower-brace-pair-to-state-cache
-             scan-backward-pos))
-        (setq c-state-cache-good-pos
-              (if scan-forward-p
-                  (progn (narrow-to-region (point-min) here)
-                         (c-append-to-state-cache good-pos))
-                good-pos)))
-
-       (t ; (eq strategy 'IN-LIT)
-        (setq c-state-cache nil
-              c-state-cache-good-pos nil)))))
+      (if scan-backward-pos
+          (c-append-lower-brace-pair-to-state-cache scan-backward-pos here))
+      (setq good-pos
+            (c-append-to-state-cache cache-pos here))
+      (setq c-state-cache-good-pos
+            (if (and bopl-state
+                     (< good-pos (- here c-state-cache-too-far)))
+                (c-state-cache-non-literal-place here-bopl bopl-state)
+              good-pos)))
+
+     ((eq strategy 'backward)
+      (setq res (c-remove-stale-state-cache-backwards here)
+            good-pos (car res)
+            scan-backward-pos (cadr res)
+            scan-forward-p (car (cddr res)))
+      (if scan-backward-pos
+          (c-append-lower-brace-pair-to-state-cache scan-backward-pos here))
+      (setq c-state-cache-good-pos
+            (if scan-forward-p
+                (c-append-to-state-cache good-pos here)
+              good-pos)))
+
+     (t                                 ; (eq strategy 'IN-LIT)
+      (setq c-state-cache nil
+            c-state-cache-good-pos nil))))
 
   c-state-cache)
 
diff --git a/nt/INSTALL b/nt/INSTALL
index 487e5ec0bf8..0c4b50f0c28 100644
--- a/nt/INSTALL
+++ b/nt/INSTALL
@@ -110,12 +110,14 @@
   WinZip is known to create some subtle and hard to debug problems,
   such as converting files to DOS CR-LF format, not creating empty
   directories, etc.  We suggest to use djtarnt.exe from the GNU FTP
-  site.
+  site.  For modern formats, such as .tar.xz, we suggest bsdtar.exe
+  from the libarchive package; its precompiled Windows binaries are
+  available from this site:
+
+    http://sourceforge.net/projects/ezwinports/files/
 
-  In addition to this file, you should also read INSTALL.BZR in the
-  parent directory, and make sure that you have a version of
-  "touch.exe" in your path, and that it will create files that do not
-  yet exist.
+  In addition to this file, if you build a development snapshot, you
+  should also read INSTALL.BZR in the parent directory.
 
 * Supported development environments