Merge from mainline.

14 files changed, 1859 insertions, 1631 deletions

diff --git a/doc/emacs/ChangeLog b/doc/emacs/ChangeLog
index dc43450110f..dfdef6a0b05 100644
--- a/doc/emacs/ChangeLog
+++ b/doc/emacs/ChangeLog
@@ -1,3 +1,7 @@
+2011-03-06  Chong Yidong  <cyd@stupidchicken.com>
+
+        * search.texi (Isearch Yank): C-y now bound to isearch-yank-kill.
+
 2011-03-03  Drake Wilson  <drake@begriffli.ch>  (tiny change)
 
         * misc.texi (emacsclient Options): Add q/quiet.
diff --git a/doc/emacs/search.texi b/doc/emacs/search.texi
index e3c0445e189..9fdccc3218d 100644
--- a/doc/emacs/search.texi
+++ b/doc/emacs/search.texi
@@ -271,19 +271,24 @@ keybindings.  These keybindings are part of the keymap
 @node Isearch Yank
 @subsection Isearch Yanking
 
-  Within incremental search, you can use @kbd{C-w} and @kbd{C-y} to grab
-text from the buffer into the search string.  This makes it convenient
-to search for another occurrence of text at point.
+  Within incremental search, @kbd{C-y} (@code{isearch-yank-kill})
+copies text from the kill ring into the search string.  It uses the
+same text that @kbd{C-y}, outside of incremental search, would
+normally yank into the buffer.  @kbd{Mouse-2} in the echo area does
+the same.  @xref{Yanking}.
 
-  @kbd{C-w} copies the character or word after point and adds it to
-the search string, advancing point over it.  (The decision, whether to
-copy a character or a word, is heuristic.)
+  @kbd{C-w} (@code{isearch-yank-word-or-char}) grabs the next
+character or word at point, and adds it to the search string.  This is
+convenient for searching for another occurrence of the text at point.
+(The decision, whether to copy a character or a word, is heuristic.)
 
-  @kbd{C-y} is similar to @kbd{C-w} but copies all the rest of the
-current line into the search string.  If point is already at the end
-of a line, it grabs the entire next line.  If the search is currently
-case-insensitive, both @kbd{C-y} and @kbd{C-w} convert the text they
-copy to lower case, so that the search remains case-insensitive.
+  Similarly, @kbd{M-s C-e} (@code{isearch-yank-line}) grabs the rest
+of the current line, and adds it to the search string.  If point is
+already at the end of a line, it grabs the entire next line.
+
+  If the search is currently case-insensitive, both @kbd{C-w} and
+@kbd{M-s C-e} convert the text they copy to lower case, so that the
+search remains case-insensitive.
 
   @kbd{C-M-w} and @kbd{C-M-y} modify the search string by only one
 character at a time: @kbd{C-M-w} deletes the last character from the
@@ -293,10 +298,6 @@ after point into the search string is to enter the minibuffer by
 @kbd{M-e} and to type @kbd{C-f} at the end of the search string in the
 minibuffer.
 
-  The character @kbd{M-y} copies text from the kill ring into the
-search string.  It uses the same text that @kbd{C-y} would yank.
-@kbd{Mouse-2} in the echo area does the same.  @xref{Yanking}.
-
 @node Isearch Scroll
 @subsection Scrolling During Incremental Search
 
diff --git a/doc/lispref/ChangeLog b/doc/lispref/ChangeLog
index 7bb1919b837..32d13b57ffd 100644
--- a/doc/lispref/ChangeLog
+++ b/doc/lispref/ChangeLog
@@ -1,5 +1,20 @@
 2011-03-06  Chong Yidong  <cyd@stupidchicken.com>
 
+        * package.texi: Update index keywords.
+        (Package Archives): New node contents.  Document package-x.el.
+
+2011-03-06  Juanma Barranquero  <lekktu@gmail.com>
+
+        * makefile.w32-in (srcs): Add package.texi.
+
+2011-03-06  Chong Yidong  <cyd@stupidchicken.com>
+
+        * package.texi (Packaging, Packaging Basics, Simple Packages)
+        (Multi-file Packages): Expand and clarify.
+        (Package Archives): Temporary placeholder node.
+
+        * elisp.texi (Top): Update node listing.
+
         * Makefile.in (srcs): Add package.texi.
 
 2011-03-05  Chong Yidong  <cyd@stupidchicken.com>
diff --git a/doc/lispref/elisp.texi b/doc/lispref/elisp.texi
index cc3ceb8003c..fc066526614 100644
--- a/doc/lispref/elisp.texi
+++ b/doc/lispref/elisp.texi
@@ -1399,6 +1399,7 @@ Preparing Lisp code for distribution
 * Packaging Basics::        The basic concepts of Emacs Lisp packages.
 * Simple Packages::         How to package a single .el file.
 * Multi-file Packages::     How to package multiple files.
+* Package Archives::        Maintaining package archives.
 
 Starting Up Emacs
 
diff --git a/doc/lispref/makefile.w32-in b/doc/lispref/makefile.w32-in
index e0bcd21f2c0..d074dd22e24 100644
--- a/doc/lispref/makefile.w32-in
+++ b/doc/lispref/makefile.w32-in
@@ -87,6 +87,7 @@ srcs = \
   $(srcdir)/numbers.texi \
   $(srcdir)/objects.texi \
   $(srcdir)/os.texi \
+  $(srcdir)/package.texi \
   $(srcdir)/positions.texi \
   $(srcdir)/processes.texi \
   $(srcdir)/searching.texi \
diff --git a/doc/lispref/package.texi b/doc/lispref/package.texi
index 373e1e2b5c7..62fbc2a9a07 100644
--- a/doc/lispref/package.texi
+++ b/doc/lispref/package.texi
@@ -5,188 +5,232 @@
 @setfilename ../../info/package
 @node Packaging, Antinews, System Interface, Top
 @chapter Preparing Lisp code for distribution
-@cindex packaging
+@cindex package
+@cindex Lisp package
 
-  Emacs provides a standard way for Emacs Lisp code to be distributed
-to users.  This approach lets users easily download, install,
-uninstall, and upgrade Lisp code that they might want to use.
+  Emacs provides a standard way to distribute Emacs Lisp code to
+users.  A @dfn{package} is a collection of one or more files,
+formatted and bundled in such a way that users can easily download,
+install, uninstall, and upgrade it.
 
-  A @dfn{package} is simply one or more files, formatted and bundled
-in a particular way.  Typically a package includes primarily Emacs
-Lisp code, but it is possible to create other kinds of packages as
-well.
+  The following sections describe how to create a package, and how to
+put it in a @dfn{package archive} for others to download.
 
 @menu
 * Packaging Basics::        The basic concepts of Emacs Lisp packages.
 * Simple Packages::         How to package a single .el file.
 * Multi-file Packages::     How to package multiple files.
+* Package Archives::        Maintaining package archives.
 @end menu
 
 @node Packaging Basics
 @section Packaging Basics
-@cindex packaging basics
-
-  A package has a few attributes:
 @cindex package attributes
+@cindex package name
+@cindex package version
+@cindex dependencies
+@cindex package dependencies
+
+  A package is either a @dfn{simple package} or a @dfn{multi-file
+package}.  A simple package is stored in a package archive as a single
+Emacs Lisp file, while a multi-file package is stored as a tar file
+(containing multiple Lisp files, and possibly non-Lisp files such as a
+manual).
+
+  In ordinary usage, the difference between simple packages and
+multi-file packages is relatively unimportant; the Package Menu
+interface makes no distinction between them.  However, the procedure
+for creating them differs, as explained in the following sections.
+
+  Each package (whether simple or multi-file) has certain
+@dfn{attributes}:
 
 @table @asis
 @item Name
-A string, the name of the package.  This attribute is mandatory.  If
-it does not exist, the package cannot be installed by the package
-manager.
+A short word (e.g. @samp{auctex}).  This is usually also the symbol
+prefix used in the program (@pxref{Coding Conventions}).
 
 @item Version
-A version number, which is anything that can be parsed by
-@code{version-to-list}.  This attribute is mandatory.  If it does not
-exist, the package cannot be installed by the package manager.
+A version number, in a form that the function @code{version-to-list}
+understands (e.g. @samp{11.86}).  Each release of a package should be
+accompanied by an increase in the version number.
 
 @item Brief description
-This is shown to the user in the package menu buffer.  It is just a
-single line.  On a terminal with 80 characters per line, there are
-only 36 characters available in the package menu mode for showing the
-brief description, so it is best to keep it very brief.  If no brief
-name is given, an empty string is used.
+This is shown when the package is listed in the Package Menu.  It
+should occupy a single line, ideally in 36 characters or less.
 
 @item Long description
-This can be a @file{README} file or the like.  This is available to
-the user before the package is installed, via the package menu.  It
-should more fully describe the package and its capabilities, so a user
-can read it to decide whether he wants to install the package.  This
-attribute is optional.
+This is shown in the buffer created by @kbd{C-h P}
+(@code{describe-package}), following the package's brief description
+and installation status.  It normally spans multiple lines, and should
+fully describe the package and its capabilities.
 
 @item Dependencies
-This is a list of other packages and their minimal acceptable
-versions.  This is used both at download time (to make sure all the
-needed code is available) and at activation time (to ensure a package
-is only activated if all its dependencies have been successfully
-activated).  This attribute is optional.
-
-@item Manual
-A package can optionally include an Info manual.
+A list of other packages (possibly including minimal acceptable
+version numbers) on which this package depends.  The list may be
+empty, meaning this package has no dependencies.  Otherwise,
+installing this package also automatically installs its dependencies;
+if any dependency cannot be found, the package cannot be installed.
 @end table
 
-  Conceptually, a package goes through several state transitions (in
-reality some of these transitions are grouped together):
+@cindex content directory, package
+  Installing a package, either via the Package Menu, or via the
+command @code{package-install-file}, creates a subdirectory of
+@code{package-user-dir} named @file{@var{name}-@var{version}}, where
+@var{name} is the package's name and @var{version} its version
+(e.g. @file{~/.emacs.d/elpa/auctex-11.86/}).  We call this the
+package's @dfn{content directory}.  It is where Emacs puts the
+package's contents (the single Lisp file for a simple package, or the
+files extracted from a multi-file package).
+
+@cindex package autoloads
+  Emacs then searches every Lisp file in the content directory for
+autoload magic comments (@pxref{Autoload}).  These autoload
+definitions are saved to a file named @file{@var{name}-autoloads.el}
+in the content directory.  They are typically used to autoload the
+principal user commands defined in the package, but they can also
+perform other tasks, such as adding an element to
+@code{auto-mode-alist} (@pxref{Auto Major Mode}).  During this time,
+Emacs will also byte-compile the Lisp files.
+
+  After installation, and (by default) each time Emacs is started, the
+installed package is @dfn{activated}.  During activation, Emacs adds
+the package's content directory to @code{load-path}, and evaluates the
+autoload definitions in @file{@var{name}-autoloads.el}.
+
+  Note that a package typically does @emph{not} autoload every
+function and variable defined within it---only the handful of commands
+typically called to begin using the package.
 
-@table @asis
-@item Download
-Fetch the package from somewhere.
+@node Simple Packages
+@section Simple Packages
+@cindex single file package
+@cindex simple package
 
-@item Install
-Unpack the package, or write a @file{.el} file into the appropriate
-install directory.  This step also includes extracting autoloads and
-byte-compiling the Emacs Lisp code.
+  A simple package consists of a single Emacs Lisp source file.  The
+file must conform to the Emacs Lisp library header conventions
+(@pxref{Library Headers}).  The package's attributes are taken from
+the various headers, as illustrated by the following example:
 
-@item Activate
-Update @code{load-path} and @code{Info-directory-list} and evaluate
-the autoloads, so that the package is ready for the user to use.
-@end table
+@example
+@group
+;;; superfrobnicator.el --- Frobnicate and bifurcate flanges
 
-  It is best for users if packages do not do too much work at
-activation time.  The best approach is to have activation consist of
-some autoloads and little more.
+;; Copyright (C) 2011 Free Software Foundation, Inc.
+@end group
 
-@node Simple Packages
-@section Simple Packages
-@cindex single file packages
+;; Author: J. R. Hacker <jrh@@example.com>
+;; Version: 1.3
+;; Package-Requires: ((flange "1.0"))
+;; Keywords: frobnicate
 
-  The simplest package consists of a single Emacs Lisp source file.
-In this case, all the attributes of the package (@pxref{Packaging
-Basics}) are taken from this file.
+@dots{}
 
-  The package system expects this @file{.el} file to conform to the
-Emacs Lisp library header conventions.  @xref{Library Headers}.
+;;; Commentary:
 
-  The name of the package is the same as the base name of the
-@file{.el} file, as written in the first comment line.  For example,
-given the header line:
+;; This package provides a minor mode to frobnicate and/or
+;; bifurcate any flanges you desire.  To activate it, just type
+@dots{}
 
-@smallexample
-;;; superfrobnicator.el --- frobnicate and bifurcate flanges
-@end smallexample
+;;;###autoload
+(define-minor-mode superfrobnicator-mode
+@dots{}
+@end example
 
-the package name will be @samp{superfrobnicator}.
+  The name of the package is the same as the base name of the file, as
+written on the first line.  Here, it is @samp{superfrobnicator}.
 
-  The short description of the package is also taken from the first
-line of the file.
+  The brief description is also taken from the first line.  Here, it
+is @samp{Frobnicate and bifurcate flanges}.
 
-  If the file has a ``Commentary'' header, then it is used as the long
-description.
+  The version number comes from the @samp{Package-Version} header, if
+it exists, or from the @samp{Version} header otherwise.  One or the
+other @emph{must} be present.  Here, the version number is 1.3.
 
-  The version of the package comes either from the ``Package-Version''
-header, if it exists, or from the ``Version'' header.  A package is
-required to have a version number.  Each release of a package must be
-accompanied by an increase in the version number.
+  If the file has a @samp{;;; Commentary:} section, this section is
+used as the long description.  (When displaying the description, Emacs
+omits the @samp{;;; Commentary:} line, as well as the leading comment
+characters in the commentary itself.)
 
-  If the file has a ``Package-Requires'' header, then that is used as
-the package dependencies.  Otherwise, the package is assumed not to
-have any dependencies.
+  If the file has a @samp{Package-Requires} header, that is used as
+the package dependencies.  In the above example, the package depends
+on the @samp{flange} package, version 1.0 or higher.  @xref{Library
+Headers}, for a description of the @samp{Package-Requires} header.  If
+the header is omitted, the package has no dependencies.
 
-  A single-file package cannot have an Info manual.
+  The file ought to also contain one or more autoload magic comments,
+as explained in @ref{Packaging Basics}.  In the above example, a magic
+comment autoloads @code{superfrobnicator-mode}.
 
-  The file will be scanned for autoload cookies at install time.
-@xref{Autoload}.
+  @xref{Package Archives}, for a explanation of how to add a
+single-file package to a package archive.
 
 @node Multi-file Packages
 @section Multi-file Packages
-@cindex multi-file packages
-
-  A multi-file package is just a @file{.tar} file.  While less
-convenient to create than a single-file package, a multi-file package
-also offers more features: it can include an Info manual, multiple
-Emacs Lisp files, and also other data files needed by a package.
-
-  The contents of the @file{.tar} file must all appear beneath a
-single directory, named after the package and version.  Files can
-appear in subdirectories of this top-most directory, but Emacs Lisp
-code will only be found (and thus byte-compiled) at the top-most
-level.  Also, the @file{.tar} file is typically also given this same
-name.  For example, if you are distributing version 1.3 of the
-superfrobnicator, the package file would be named
-``superfrobnicator-1.3.tar'' and the contents would all appear in the
-directory @file{superfrobnicator-1.3} in that @file{.tar}.
-
-  The package must include a @file{-pkg.el} file, named after the
-package.  In our example above, this file would be called
-@file{superfrobnicator-pkg.el}.  This file must have a single form in
-it, a call to @code{define-package}.  The package dependencies and
-brief description are taken from this form.
+@cindex multi-file package
+
+  A multi-file package is less convenient to create than a single-file
+package, but it offers more features: it can include multiple Emacs
+Lisp files, an Info manual, and other file types (such as images).
+
+  Prior to installation, a multi-file package is stored in a package
+archive as a tar file.  The tar file must be named
+@file{@var{name}-@var{version}.tar}, where @var{name} is the package
+name and @var{version} is the version number.  Its contents, once
+extracted, must all appear in a directory named
+@file{@var{name}-@var{version}}, the @dfn{content directory}
+(@pxref{Packaging Basics}).  Files may also extract into
+subdirectories of the content directory.
+
+  One of the files in the content directory must be named
+@file{@var{name}-pkg.el}.  It must contain a single Lisp form,
+consisting of a call to the function @code{define-package}, described
+below.  This defines the package's version, brief description, and
+requirements.
+
+  For example, if we distribute version 1.3 of the superfrobnicator as
+a multi-file package, the tar file would be
+@file{superfrobnicator-1.3.tar}.  Its contents would extract into the
+directory @file{superfrobnicator-1.3}, and one of these would be the
+file @file{superfrobnicator-pkg.el}.
 
 @defun define-package name version &optional docstring requirements
-Define a package.  @var{name} is the name of the package, a string.
-@var{version} is the package's version, a string.  It must be in a
-form that can be understood by @code{version-to-list}.
-@var{docstring} is the short description of the package.
+This function defines a package.  @var{name} is the package name, a
+string.  @var{version} is the version, as a string of a form that can
+be understood by the function @code{version-to-list}.  @var{docstring}
+is the brief description.
+
 @var{requirements} is a list of required packages and their versions.
+Each element in this list should have the form @code{(@var{dep-name}
+@var{dep-version})}, where @var{dep-name} is a symbol whose name is
+the dependency's package name, and @var{dep-version} is the
+dependency's version (a string).
 @end defun
 
-  If a @file{README} file exists in the content directory, then it is
-used as the long description.
+  If the content directory contains a file named @file{README}, this
+file is used as the long description.
 
-  If the package has an Info manual, you should distribute the needed
-info files, plus a @file{dir} file made with @command{install-info}.
+  If the content directory contains a file named @file{dir}, this is
+assumed to be an Info directory file made with @command{install-info}.
 @xref{Invoking install-info, Invoking install-info, Invoking
-install-info, texinfo, Texinfo}.
+install-info, texinfo, Texinfo}.  The relevant Info files should also
+be present in the content directory.  In this case, Emacs will
+automatically add the content directory to @code{Info-directory-list}
+when the package is activated.
 
-  Do not include any @file{.elc} files in the package.  Those will be
-created at install time.  Note that there is no way to control the
-order in which files are byte-compiled; your package must be robust
-here.
+  Do not include any @file{.elc} files in the package.  Those are
+created when the package is installed.  Note that there is no way to
+control the order in which files are byte-compiled.
 
-  The installation process will scan all the @file{.el} files in the
-package for autoload cookies.  @xref{Autoload}.  They are extracted
-into a @file{-autoloads.el} file (e.g.,
-@file{superfrobnicator-autoloads.el}), so do not include a file of
-that name in your package.
+  Do not include any file named @file{@var{name}-autoloads.el}.  This
+file is reserved for the package's autoload definitions
+(@pxref{Packaging Basics}).  It is created automatically when the
+package is installed, by searching all the Lisp files in the package
+for autoload magic comments.
 
-  Any other files in the @file{.tar} file are simply unpacked when the
-package is installed.  This can be useful if your package needs
-auxiliary data files --- e.g., icons or sounds.
-
-  Emacs Lisp code installed via the package manager must take special
-care to be location-independent.  One easy way to do this is to make
-references to auxiliary data files relative to @var{load-file-name}.
-For example:
+  If the multi-file package contains auxiliary data files (such as
+images), the package's Lisp code can refer to these files via the
+variable @code{load-file-name} (@pxref{Loading}).  Here is an example:
 
 @smallexample
 (defconst superfrobnicator-base (file-name-directory load-file-name))
@@ -194,3 +238,82 @@ For example:
 (defun superfrobnicator-fetch-image (file)
   (expand-file-name file superfrobnicator-base))
 @end smallexample
+
+@node Package Archives
+@section Creating and Maintaining Package Archives
+@cindex package archive
+
+  Via the Package Menu, users may download packages from @dfn{package
+archives}.  Such archives are specified by the variable
+@code{package-archives}, whose default value contains a single entry:
+the archive hosted by the GNU project at @url{elpa.gnu.org}.  This
+section describes how to set up and maintain a package archive.
+
+@cindex base location, package archive
+@defopt package-archives
+The value of this variable is an alist of package archives recognized
+by the Emacs package manager.
+
+Each alist element corresponds to one archive, and should have the
+form @code{(@var{id} . @var{location})}, where @var{id} is the name of
+the archive (a string) and @var{location} is its @dfn{base location}
+(a string).
+
+If the base location starts with @samp{http:}, it is treated as a HTTP
+URL, and packages are downloaded from this archive via HTTP (as is the
+case for the default GNU archive).
+
+Otherwise, the base location should be a directory name.  In this
+case, Emacs retrieves packages from this archive via ordinary file
+access.  Such ``local'' archives are mainly useful for testing.
+@end defopt
+
+  A package archive is simply a directory in which the package files,
+and associated files, are stored.  If you want the archive to be
+reachable via HTTP, this directory must be accessible to a web server.
+How to accomplish this is beyond the scope of this manual.
+
+  A convenient way to set up and update a package archive is via the
+@code{package-x} library.  This is included with Emacs, but not loaded
+by default; type @kbd{M-x load-library @kbd{RET} package-x @kbd{RET}}
+to load it, or add @code{(require 'package-x)} to your init file.
+@xref{Lisp Libraries,, Lisp Libraries, emacs, The GNU Emacs Manual}.
+Once loaded, you can make use of the following:
+
+@defopt package-archive-upload-base
+The value of this variable is the base location of a package archive,
+as a directory name.  The commands in the @code{package-x} library
+will use this base location.
+
+The directory name should be absolute.  You may specify a remote name,
+such as @file{/ssh:foo@@example.com:/var/www/packages/}, if the
+package archive is on a different machine.  @xref{Remote Files,,
+Remote Files, emacs, The GNU Emacs Manual}.
+@end defopt
+
+@deffn Command package-upload-file filename
+This command prompts for @var{filename}, a file name, and uploads that
+file to @code{package-archive-upload-base}.  The file must be either a
+simple package (a @file{.el} file) or a multi-file package (a
+@file{.tar} file); otherwise, an error is raised.  The package
+attributes are automatically extracted, and the archive's contents
+list is updated with this information.
+
+If @code{package-archive-upload-base} does not specify a valid
+directory, the function prompts interactively for one.  If the
+directory does not exist, it is created.  The directory need not have
+any initial contents (i.e., you can use this command to populate an
+initially empty archive).
+@end deffn
+
+@deffn Command package-upload-buffer
+This command is similar to @code{package-upload-file}, but instead of
+prompting for a package file, it uploads the contents of the current
+buffer.  The current buffer must be visiting a simple package (a
+@file{.el} file) or a multi-file package (a @file{.tar} file);
+otherwise, an error is raised.
+@end deffn
+
+@noindent
+After you create an archive, remember that it is not accessible in the
+Package Menu interface unless it is in @code{package-archives}.
diff --git a/etc/NEWS b/etc/NEWS
index df9884e94b1..ac7fdcbab0c 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -247,6 +247,15 @@ replaced with Lisp commands `doc-file-to-man' and `doc-file-to-info'.
 
 * Editing Changes in Emacs 24.1
 
+** Search changes
+
++++
+*** C-y in Isearch is now bound to isearch-yank-kill, instead of
+isearch-yank-line.
+
++++
+*** M-s C-e in Isearch is now bound to isearch-yank-line.
+
 +++
 ** There is a new command `count-words-region', which does what you expect.
 
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index e34fde79543..6b7768fe93c 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,11 +1,40 @@
+2011-03-06  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * progmodes/gud.el (gdb-script-syntax-propertize-function):
+        Don't change the syntax of a \n that closes a comment (bug#8169).
+
+2011-03-06  Chong Yidong  <cyd@stupidchicken.com>
+
+        * emacs-lisp/package-x.el (package-archive-upload-base): Make it a
+        defcustom.
+        (package--update-file): Doc fix.  Accept relative file names.
+        (package--archive-contents-from-file): Remove the argument, since
+        it's necessarily always "archive-contents".
+        (package-maint-add-news-item): Pass relative file name args to
+        package--update-file.
+        (package-upload-buffer-internal): Prompt for a destination if
+        package-archive-upload-base is invalid.  Create the directory if
+        it does not exist.
+        (package-upload-buffer, package-upload-file): Doc fix.
+
+2011-03-06  Chong Yidong  <cyd@stupidchicken.com>
+
+        * isearch.el (isearch-mode-map): Bind C-y to isearch-yank-kill,
+        and move isearch-yank-line to M-s C-e (Bug#8183).
+
+2011-03-06  Alan Mackenzie  <acm@muc.de>
+
+        * progmodes/cc-engine.el (c-guess-basic-syntax): Reindent.
+        (c-guess-basic-syntax): Move CASE 19 to a different place,
+        correctly to process template-args-cont lines.
+
 2011-03-06  Jay Belanger  <jay.p.belanger@gmail.com>
 
         * calc/calc-ext.el (calc-init-extensions):
-        Rename calc-logunits-dblevel and calc-logunits-nplevel to
-        calc-dblevel and calc-nplevel, respectively.
-        Add keybindings for calc-spn, calc-midi and calc-freq.  Add
-        autoloads for calcFunc-spn, calcFunc-midi, calcFunc-freq,
-        calc-spn, calc-midi and calc-freq.
+        Rename calc-logunits-dblevel and calc-logunits-nplevel to calc-dblevel
+        and calc-nplevel, respectively.  Add keybindings for calc-spn,
+        calc-midi and calc-freq.  Add autoloads for calcFunc-spn,
+        calcFunc-midi, calcFunc-freq, calc-spn, calc-midi and calc-freq.
 
         * calc/calc-units.el (calc-dblevel): Rename from
         calc-logunits-dblevel.
diff --git a/lisp/emacs-lisp/package-x.el b/lisp/emacs-lisp/package-x.el
index 61f23abf0a7..4de95f65702 100644
--- a/lisp/emacs-lisp/package-x.el
+++ b/lisp/emacs-lisp/package-x.el
@@ -27,21 +27,41 @@
 
 ;;; Commentary:
 
-;; This file currently contains parts of the package system most
-;; people won't need, such as package uploading.
+;; This file currently contains parts of the package system that many
+;; won't need, such as package uploading.
+
+;; To upload to an archive, first set `package-archive-upload-base' to
+;; some desired directory.  For testing purposes, you can specify any
+;; directory you want, but if you want the archive to be accessible to
+;; others via http, this is typically a directory in the /var/www tree
+;; (possibly one on a remote machine, accessed via Tramp).
+
+;; Then call M-x package-upload-file, which prompts for a file to
+;; upload. Alternatively, M-x package-upload-buffer uploads the
+;; current buffer, if it's visiting a package file.
+
+;; Once a package is uploaded, users can access it via the Package
+;; Menu, by adding the archive to `package-archives'.
 
 ;;; Code:
 
 (require 'package)
 (defvar gnus-article-buffer)
 
-;; Note that this only works if you have the password, which you
-;; probably don't :-).
-(defvar package-archive-upload-base nil
-  "Base location for uploading to package archive.")
+(defcustom package-archive-upload-base "/path/to/archive"
+  "The base location of the archive to which packages are uploaded.
+This should be an absolute directory name.  If the archive is on
+another machine, you may specify a remote name in the usual way,
+e.g. \"/ssh:foo@example.com:/var/www/packages/\".
+See Info node `(emacs)Remote Files'.
+
+Unlike `package-archives', you can't specify a HTTP URL."
+  :type 'directory
+  :group 'package
+  :version "24.1")
 
 (defvar package-update-news-on-upload nil
-  "Whether package upload should also update NEWS and RSS feeds.")
+  "Whether uploading a package should also update NEWS and RSS feeds.")
 
 (defun package--encode (string)
   "Encode a string by replacing some characters with XML entities."
@@ -75,13 +95,18 @@
           title " - " (package--encode text)
           " </li>\n"))
 
-(defun package--update-file (file location text)
+(defun package--update-file (file tag text)
+  "Update the package archive file named FILE.
+FILE should be relative to `package-archive-upload-base'.
+TAG is a string that can be found within the file; TEXT is
+inserted after its first occurrence in the file."
+  (setq file (expand-file-name file package-archive-upload-base))
   (save-excursion
     (let ((old-buffer (find-buffer-visiting file)))
       (with-current-buffer (let ((find-file-visit-truename t))
                              (or old-buffer (find-file-noselect file)))
         (goto-char (point-min))
-        (search-forward location)
+        (search-forward tag)
         (forward-line)
         (insert text)
         (let ((file-precious-flag t))
@@ -105,30 +130,31 @@ Return the file contents, as a string, or nil if unsuccessful."
                 (buffer-substring-no-properties (point-min) (point-max)))
           (kill-buffer buffer))))))
 
-(defun package--archive-contents-from-file (file)
-  "Parse the given archive-contents file."
-  (if (not (file-exists-p file))
-      ;; no existing archive-contents, possibly a new ELPA repo.
-      (list package-archive-version)
-    (let ((dont-kill (find-buffer-visiting file)))
-      (with-current-buffer (let ((find-file-visit-truename t))
-                             (find-file-noselect file))
-        (prog1
-            (package-read-from-string
-             (buffer-substring-no-properties (point-min) (point-max)))
-          (unless dont-kill
-            (kill-buffer (current-buffer))))))))
+(defun package--archive-contents-from-file ()
+  "Parse the archive-contents at `package-archive-upload-base'"
+  (let ((file (expand-file-name "archive-contents"
+                                package-archive-upload-base)))
+    (if (not (file-exists-p file))
+        ;; No existing archive-contents means a new archive.
+        (list package-archive-version)
+      (let ((dont-kill (find-buffer-visiting file)))
+        (with-current-buffer (let ((find-file-visit-truename t))
+                               (find-file-noselect file))
+          (prog1
+              (package-read-from-string
+               (buffer-substring-no-properties (point-min) (point-max)))
+            (unless dont-kill
+              (kill-buffer (current-buffer)))))))))
 
 (defun package-maint-add-news-item (title description archive-url)
-  "Add a news item to the ELPA web pages.
+  "Add a news item to the webpages associated with the package archive.
 TITLE is the title of the news item.
-DESCRIPTION is the text of the news item.
-You need administrative access to ELPA to use this."
+DESCRIPTION is the text of the news item."
   (interactive "sTitle: \nsText: ")
-  (package--update-file (concat package-archive-upload-base "elpa.rss")
+  (package--update-file "elpa.rss"
                         "<description>"
                         (package--make-rss-entry title description archive-url))
-  (package--update-file (concat package-archive-upload-base "news.html")
+  (package--update-file "news.html"
                         "New entries go here"
                         (package--make-html-entry title description)))
 
@@ -144,8 +170,8 @@ PKG-INFO is the package info, see `package-buffer-info'.
 EXTENSION is the file extension, a string.  It can be either
 \"el\" or \"tar\".
 
-The variable `package-archive-upload-base' specifies the upload
-destination.  If this is nil, signal an error.
+The upload destination is given by `package-archive-upload-base'.
+If its value is invalid, prompt for a directory.
 
 Optional arg ARCHIVE-URL is the URL of the destination archive.
 If it is non-nil, compute the new \"archive-contents\" file
@@ -156,85 +182,97 @@ addition, if `package-update-news-on-upload' is non-nil, call
 If ARCHIVE-URL is nil, compute the new \"archive-contents\" file
 from the \"archive-contents\" at `package-archive-upload-base',
 if it exists."
-  (unless package-archive-upload-base
-    (error "No destination specified in `package-archive-upload-base'"))
-  (save-excursion
-    (save-restriction
-      (let* ((file-type (cond
-                         ((equal extension "el") 'single)
-                         ((equal extension "tar") 'tar)
-                         (t (error "Unknown extension `%s'" extension))))
-             (file-name (aref pkg-info 0))
-             (pkg-name (intern file-name))
-             (requires (aref pkg-info 1))
-             (desc (if (string= (aref pkg-info 2) "")
-                       (read-string "Description of package: ")
-                     (aref pkg-info 2)))
-             (pkg-version (aref pkg-info 3))
-             (commentary (aref pkg-info 4))
-             (split-version (version-to-list pkg-version))
-             (pkg-buffer (current-buffer)))
-
-        ;; Get archive-contents from ARCHIVE-URL if it's non-nil, or
-        ;; from `package-archive-upload-base' otherwise.
-        (let ((contents (or (package--archive-contents-from-url archive-url)
-                            (package--archive-contents-from-file
-                             (concat package-archive-upload-base
-                                     "archive-contents"))))
-              (new-desc (vector split-version requires desc file-type)))
-          (if (> (car contents) package-archive-version)
-              (error "Unrecognized archive version %d" (car contents)))
-          (let ((elt (assq pkg-name (cdr contents))))
-            (if elt
-                (if (version-list-<= split-version
-                                     (package-desc-vers (cdr elt)))
-                    (error "New package has smaller version: %s" pkg-version)
-                  (setcdr elt new-desc))
-              (setq contents (cons (car contents)
-                                   (cons (cons pkg-name new-desc)
-                                         (cdr contents))))))
-
-          ;; Now CONTENTS is the updated archive contents.  Upload
-          ;; this and the package itself.  For now we assume ELPA is
-          ;; writable via file primitives.
-          (let ((print-level nil)
-                (print-length nil))
-            (write-region (concat (pp-to-string contents) "\n")
-                          nil
-                          (concat package-archive-upload-base
-                                  "archive-contents")))
-
-          ;; If there is a commentary section, write it.
-          (when commentary
-            (write-region commentary nil
-                          (concat package-archive-upload-base
-                                  (symbol-name pkg-name) "-readme.txt")))
-
-          (set-buffer pkg-buffer)
-          (write-region (point-min) (point-max)
-                        (concat package-archive-upload-base
-                                file-name "-" pkg-version
-                                "." extension)
-                        nil nil nil 'excl)
-
-          ;; Write a news entry.
-          (and package-update-news-on-upload
-               archive-url
-               (package--update-news (concat file-name "." extension)
-                                     pkg-version desc archive-url))
-
-          ;; special-case "package": write a second copy so that the
-          ;; installer can easily find the latest version.
-          (if (string= file-name "package")
-              (write-region (point-min) (point-max)
-                            (concat package-archive-upload-base
-                                    file-name "." extension)
-                            nil nil nil 'ask)))))))
+  (let ((package-archive-upload-base package-archive-upload-base))
+    ;; Check if `package-archive-upload-base' is valid.
+    (when (or (not (stringp package-archive-upload-base))
+              (eq package-archive-upload-base
+                  (car-safe
+                   (get 'package-archive-upload-base 'standard-value))))
+      (setq package-archive-upload-base
+            (read-directory-name
+             "Base directory for package archive: ")))
+    (unless (file-directory-p package-archive-upload-base)
+      (if (y-or-n-p (format "%s does not exist; create it? "
+                            package-archive-upload-base))
+          (make-directory package-archive-upload-base t)
+        (error "Aborted")))
+    (save-excursion
+      (save-restriction
+        (let* ((file-type (cond
+                           ((equal extension "el") 'single)
+                           ((equal extension "tar") 'tar)
+                           (t (error "Unknown extension `%s'" extension))))
+               (file-name (aref pkg-info 0))
+               (pkg-name (intern file-name))
+               (requires (aref pkg-info 1))
+               (desc (if (string= (aref pkg-info 2) "")
+                         (read-string "Description of package: ")
+                       (aref pkg-info 2)))
+               (pkg-version (aref pkg-info 3))
+               (commentary (aref pkg-info 4))
+               (split-version (version-to-list pkg-version))
+               (pkg-buffer (current-buffer)))
+
+          ;; Get archive-contents from ARCHIVE-URL if it's non-nil, or
+          ;; from `package-archive-upload-base' otherwise.
+          (let ((contents (or (package--archive-contents-from-url archive-url)
+                              (package--archive-contents-from-file)))
+                (new-desc (vector split-version requires desc file-type)))
+            (if (> (car contents) package-archive-version)
+                (error "Unrecognized archive version %d" (car contents)))
+            (let ((elt (assq pkg-name (cdr contents))))
+              (if elt
+                  (if (version-list-<= split-version
+                                       (package-desc-vers (cdr elt)))
+                      (error "New package has smaller version: %s" pkg-version)
+                    (setcdr elt new-desc))
+                (setq contents (cons (car contents)
+                                     (cons (cons pkg-name new-desc)
+                                           (cdr contents))))))
+
+            ;; Now CONTENTS is the updated archive contents.  Upload
+            ;; this and the package itself.  For now we assume ELPA is
+            ;; writable via file primitives.
+            (let ((print-level nil)
+                  (print-length nil))
+              (write-region (concat (pp-to-string contents) "\n")
+                            nil
+                            (expand-file-name "archive-contents"
+                                              package-archive-upload-base)))
+
+            ;; If there is a commentary section, write it.
+            (when commentary
+              (write-region commentary nil
+                            (expand-file-name
+                             (concat (symbol-name pkg-name) "-readme.txt")
+                             package-archive-upload-base)))
+
+            (set-buffer pkg-buffer)
+            (write-region (point-min) (point-max)
+                          (expand-file-name
+                           (concat file-name "-" pkg-version "." extension)
+                           package-archive-upload-base)
+                          nil nil nil 'excl)
+
+            ;; Write a news entry.
+            (and package-update-news-on-upload
+                 archive-url
+                 (package--update-news (concat file-name "." extension)
+                                       pkg-version desc archive-url))
+
+            ;; special-case "package": write a second copy so that the
+            ;; installer can easily find the latest version.
+            (if (string= file-name "package")
+                (write-region (point-min) (point-max)
+                              (expand-file-name
+                               (concat file-name "." extension)
+                               package-archive-upload-base)
+                              nil nil nil 'ask))))))))
 
 (defun package-upload-buffer ()
   "Upload the current buffer as a single-file Emacs Lisp package.
-The variable `package-archive-upload-base' specifies the upload
-destination."
+If `package-archive-upload-base' does not specify a valid upload
+destination, prompt for one."
   (interactive)
   (save-excursion
     (save-restriction
@@ -247,9 +285,8 @@ destination."
 Interactively, prompt for FILE.  The package is considered a
 single-file package if FILE ends in \".el\", and a multi-file
 package if FILE ends in \".tar\".
-
-The variable `package-archive-upload-base' specifies the upload
-destination."
+If `package-archive-upload-base' does not specify a valid upload
+destination, prompt for one."
   (interactive "fPackage file name: ")
   (with-temp-buffer
     (insert-file-contents-literally file)
diff --git a/lisp/isearch.el b/lisp/isearch.el
index 5aadac4a3b1..e13d9673514 100644
--- a/lisp/isearch.el
+++ b/lisp/isearch.el
@@ -464,7 +464,8 @@ This is like `describe-bindings', but displays only Isearch keys."
     (define-key map    "\C-w" 'isearch-yank-word-or-char)
     (define-key map "\M-\C-w" 'isearch-del-char)
     (define-key map "\M-\C-y" 'isearch-yank-char)
-    (define-key map    "\C-y" 'isearch-yank-line)
+    (define-key map    "\C-y" 'isearch-yank-kill)
+    (define-key map "\M-s\C-e" 'isearch-yank-line)
 
     (define-key map (char-to-string help-char) isearch-help-map)
     (define-key map [help] isearch-help-map)
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 654323e03e4..5ef12300195 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -8725,841 +8725,841 @@ comment at the start of cc-engine.el for more info."
 (defun c-guess-basic-syntax ()
   "Return the syntactic context of the current line."
   (save-excursion
-      (beginning-of-line)
-      (c-save-buffer-state
-          ((indent-point (point))
-           (case-fold-search nil)
-           ;; A whole ugly bunch of various temporary variables.  Have
-           ;; to declare them here since it's not possible to declare
-           ;; a variable with only the scope of a cond test and the
-           ;; following result clauses, and most of this function is a
-           ;; single gigantic cond. :P
-           literal char-before-ip before-ws-ip char-after-ip macro-start
-           in-macro-expr c-syntactic-context placeholder c-in-literal-cache
-           step-type tmpsymbol keyword injava-inher special-brace-list tmp-pos
-           containing-<
-           ;; The following record some positions for the containing
-           ;; declaration block if we're directly within one:
-           ;; `containing-decl-open' is the position of the open
-           ;; brace.  `containing-decl-start' is the start of the
-           ;; declaration.  `containing-decl-kwd' is the keyword
-           ;; symbol of the keyword that tells what kind of block it
-           ;; is.
-           containing-decl-open
-           containing-decl-start
-           containing-decl-kwd
-           ;; The open paren of the closest surrounding sexp or nil if
-           ;; there is none.
-           containing-sexp
-           ;; The position after the closest preceding brace sexp
-           ;; (nested sexps are ignored), or the position after
-           ;; `containing-sexp' if there is none, or (point-min) if
-           ;; `containing-sexp' is nil.
-           lim
-           ;; The paren state outside `containing-sexp', or at
-           ;; `indent-point' if `containing-sexp' is nil.
-           (paren-state (c-parse-state))
-           ;; There's always at most one syntactic element which got
-           ;; an anchor pos.  It's stored in syntactic-relpos.
-           syntactic-relpos
-           (c-stmt-delim-chars c-stmt-delim-chars))
-
-        ;; Check if we're directly inside an enclosing declaration
-        ;; level block.
-        (when (and (setq containing-sexp
-                         (c-most-enclosing-brace paren-state))
-                   (progn
-                     (goto-char containing-sexp)
-                     (eq (char-after) ?{))
-                   (setq placeholder
-                         (c-looking-at-decl-block
-                          (c-most-enclosing-brace paren-state
-                                                  containing-sexp)
-                          t)))
-          (setq containing-decl-open containing-sexp
-                containing-decl-start (point)
-                containing-sexp nil)
-          (goto-char placeholder)
-          (setq containing-decl-kwd (and (looking-at c-keywords-regexp)
-                                         (c-keyword-sym (match-string 1)))))
-
-        ;; Init some position variables.
-        (if c-state-cache
-            (progn
-              (setq containing-sexp (car paren-state)
-                    paren-state (cdr paren-state))
-              (if (consp containing-sexp)
-                  (progn
-                    (setq lim (cdr containing-sexp))
-                    (if (cdr c-state-cache)
-                        ;; Ignore balanced paren.  The next entry
-                        ;; can't be another one.
-                        (setq containing-sexp (car (cdr c-state-cache))
-                              paren-state (cdr paren-state))
-                      ;; If there is no surrounding open paren then
-                      ;; put the last balanced pair back on paren-state.
-                      (setq paren-state (cons containing-sexp paren-state)
-                            containing-sexp nil)))
-                (setq lim (1+ containing-sexp))))
-          (setq lim (point-min)))
-
-        ;; If we're in a parenthesis list then ',' delimits the
-        ;; "statements" rather than being an operator (with the
-        ;; exception of the "for" clause).  This difference is
-        ;; typically only noticeable when statements are used in macro
-        ;; arglists.
-        (when (and containing-sexp
-                   (eq (char-after containing-sexp) ?\())
-          (setq c-stmt-delim-chars c-stmt-delim-chars-with-comma))
-        ;; cache char before and after indent point, and move point to
-        ;; the most likely position to perform the majority of tests
-        (goto-char indent-point)
-        (c-backward-syntactic-ws lim)
-        (setq before-ws-ip (point)
-              char-before-ip (char-before))
-        (goto-char indent-point)
-        (skip-chars-forward " \t")
-        (setq char-after-ip (char-after))
-
-        ;; are we in a literal?
-        (setq literal (c-in-literal lim))
-
-        ;; now figure out syntactic qualities of the current line
-        (cond
+    (beginning-of-line)
+    (c-save-buffer-state
+        ((indent-point (point))
+         (case-fold-search nil)
+         ;; A whole ugly bunch of various temporary variables.  Have
+         ;; to declare them here since it's not possible to declare
+         ;; a variable with only the scope of a cond test and the
+         ;; following result clauses, and most of this function is a
+         ;; single gigantic cond. :P
+         literal char-before-ip before-ws-ip char-after-ip macro-start
+         in-macro-expr c-syntactic-context placeholder c-in-literal-cache
+         step-type tmpsymbol keyword injava-inher special-brace-list tmp-pos
+         containing-<
+         ;; The following record some positions for the containing
+         ;; declaration block if we're directly within one:
+         ;; `containing-decl-open' is the position of the open
+         ;; brace.  `containing-decl-start' is the start of the
+         ;; declaration.  `containing-decl-kwd' is the keyword
+         ;; symbol of the keyword that tells what kind of block it
+         ;; is.
+         containing-decl-open
+         containing-decl-start
+         containing-decl-kwd
+         ;; The open paren of the closest surrounding sexp or nil if
+         ;; there is none.
+         containing-sexp
+         ;; The position after the closest preceding brace sexp
+         ;; (nested sexps are ignored), or the position after
+         ;; `containing-sexp' if there is none, or (point-min) if
+         ;; `containing-sexp' is nil.
+         lim
+         ;; The paren state outside `containing-sexp', or at
+         ;; `indent-point' if `containing-sexp' is nil.
+         (paren-state (c-parse-state))
+         ;; There's always at most one syntactic element which got
+         ;; an anchor pos.  It's stored in syntactic-relpos.
+         syntactic-relpos
+         (c-stmt-delim-chars c-stmt-delim-chars))
+
+      ;; Check if we're directly inside an enclosing declaration
+      ;; level block.
+      (when (and (setq containing-sexp
+                       (c-most-enclosing-brace paren-state))
+                 (progn
+                   (goto-char containing-sexp)
+                   (eq (char-after) ?{))
+                 (setq placeholder
+                       (c-looking-at-decl-block
+                        (c-most-enclosing-brace paren-state
+                                                containing-sexp)
+                        t)))
+        (setq containing-decl-open containing-sexp
+              containing-decl-start (point)
+              containing-sexp nil)
+        (goto-char placeholder)
+        (setq containing-decl-kwd (and (looking-at c-keywords-regexp)
+                                       (c-keyword-sym (match-string 1)))))
+
+      ;; Init some position variables.
+      (if c-state-cache
+          (progn
+            (setq containing-sexp (car paren-state)
+                  paren-state (cdr paren-state))
+            (if (consp containing-sexp)
+                (progn
+                  (setq lim (cdr containing-sexp))
+                  (if (cdr c-state-cache)
+                      ;; Ignore balanced paren.  The next entry
+                      ;; can't be another one.
+                      (setq containing-sexp (car (cdr c-state-cache))
+                            paren-state (cdr paren-state))
+                    ;; If there is no surrounding open paren then
+                    ;; put the last balanced pair back on paren-state.
+                    (setq paren-state (cons containing-sexp paren-state)
+                          containing-sexp nil)))
+              (setq lim (1+ containing-sexp))))
+        (setq lim (point-min)))
+
+      ;; If we're in a parenthesis list then ',' delimits the
+      ;; "statements" rather than being an operator (with the
+      ;; exception of the "for" clause).  This difference is
+      ;; typically only noticeable when statements are used in macro
+      ;; arglists.
+      (when (and containing-sexp
+                 (eq (char-after containing-sexp) ?\())
+        (setq c-stmt-delim-chars c-stmt-delim-chars-with-comma))
+      ;; cache char before and after indent point, and move point to
+      ;; the most likely position to perform the majority of tests
+      (goto-char indent-point)
+      (c-backward-syntactic-ws lim)
+      (setq before-ws-ip (point)
+            char-before-ip (char-before))
+      (goto-char indent-point)
+      (skip-chars-forward " \t")
+      (setq char-after-ip (char-after))
+
+      ;; are we in a literal?
+      (setq literal (c-in-literal lim))
+
+      ;; now figure out syntactic qualities of the current line
+      (cond
 
-         ;; CASE 1: in a string.
-         ((eq literal 'string)
-          (c-add-syntax 'string (c-point 'bopl)))
-
-         ;; CASE 2: in a C or C++ style comment.
-         ((and (memq literal '(c c++))
-               ;; This is a kludge for XEmacs where we use
-               ;; `buffer-syntactic-context', which doesn't correctly
-               ;; recognize "\*/" to end a block comment.
-               ;; `parse-partial-sexp' which is used by
-               ;; `c-literal-limits' will however do that in most
-               ;; versions, which results in that we get nil from
-               ;; `c-literal-limits' even when `c-in-literal' claims
-               ;; we're inside a comment.
-               (setq placeholder (c-literal-limits lim)))
-          (c-add-syntax literal (car placeholder)))
-
-         ;; CASE 3: in a cpp preprocessor macro continuation.
-         ((and (save-excursion
-                 (when (c-beginning-of-macro)
-                   (setq macro-start (point))))
-               (/= macro-start (c-point 'boi))
-               (progn
-                 (setq tmpsymbol 'cpp-macro-cont)
-                 (or (not c-syntactic-indentation-in-macros)
-                     (save-excursion
-                       (goto-char macro-start)
-                       ;; If at the beginning of the body of a #define
-                       ;; directive then analyze as cpp-define-intro
-                       ;; only.  Go on with the syntactic analysis
-                       ;; otherwise.  in-macro-expr is set if we're in a
-                       ;; cpp expression, i.e. before the #define body
-                       ;; or anywhere in a non-#define directive.
-                       (if (c-forward-to-cpp-define-body)
-                           (let ((indent-boi (c-point 'boi indent-point)))
-                             (setq in-macro-expr (> (point) indent-boi)
-                                   tmpsymbol 'cpp-define-intro)
-                             (= (point) indent-boi))
-                         (setq in-macro-expr t)
-                         nil)))))
-          (c-add-syntax tmpsymbol macro-start)
-          (setq macro-start nil))
-
-         ;; CASE 11: an else clause?
-         ((looking-at "else\\>[^_]")
-          (c-beginning-of-statement-1 containing-sexp)
-          (c-add-stmt-syntax 'else-clause nil t
-                             containing-sexp paren-state))
+       ;; CASE 1: in a string.
+       ((eq literal 'string)
+        (c-add-syntax 'string (c-point 'bopl)))
+
+       ;; CASE 2: in a C or C++ style comment.
+       ((and (memq literal '(c c++))
+             ;; This is a kludge for XEmacs where we use
+             ;; `buffer-syntactic-context', which doesn't correctly
+             ;; recognize "\*/" to end a block comment.
+             ;; `parse-partial-sexp' which is used by
+             ;; `c-literal-limits' will however do that in most
+             ;; versions, which results in that we get nil from
+             ;; `c-literal-limits' even when `c-in-literal' claims
+             ;; we're inside a comment.
+             (setq placeholder (c-literal-limits lim)))
+        (c-add-syntax literal (car placeholder)))
+
+       ;; CASE 3: in a cpp preprocessor macro continuation.
+       ((and (save-excursion
+               (when (c-beginning-of-macro)
+                 (setq macro-start (point))))
+             (/= macro-start (c-point 'boi))
+             (progn
+               (setq tmpsymbol 'cpp-macro-cont)
+               (or (not c-syntactic-indentation-in-macros)
+                   (save-excursion
+                     (goto-char macro-start)
+                     ;; If at the beginning of the body of a #define
+                     ;; directive then analyze as cpp-define-intro
+                     ;; only.  Go on with the syntactic analysis
+                     ;; otherwise.  in-macro-expr is set if we're in a
+                     ;; cpp expression, i.e. before the #define body
+                     ;; or anywhere in a non-#define directive.
+                     (if (c-forward-to-cpp-define-body)
+                         (let ((indent-boi (c-point 'boi indent-point)))
+                           (setq in-macro-expr (> (point) indent-boi)
+                                 tmpsymbol 'cpp-define-intro)
+                           (= (point) indent-boi))
+                       (setq in-macro-expr t)
+                       nil)))))
+        (c-add-syntax tmpsymbol macro-start)
+        (setq macro-start nil))
+
+       ;; CASE 11: an else clause?
+       ((looking-at "else\\>[^_]")
+        (c-beginning-of-statement-1 containing-sexp)
+        (c-add-stmt-syntax 'else-clause nil t
+                           containing-sexp paren-state))
 
-         ;; CASE 12: while closure of a do/while construct?
-         ((and (looking-at "while\\>[^_]")
-               (save-excursion
-                 (prog1 (eq (c-beginning-of-statement-1 containing-sexp)
-                            'beginning)
-                   (setq placeholder (point)))))
-          (goto-char placeholder)
-          (c-add-stmt-syntax 'do-while-closure nil t
-                             containing-sexp paren-state))
+       ;; CASE 12: while closure of a do/while construct?
+       ((and (looking-at "while\\>[^_]")
+             (save-excursion
+               (prog1 (eq (c-beginning-of-statement-1 containing-sexp)
+                          'beginning)
+                 (setq placeholder (point)))))
+        (goto-char placeholder)
+        (c-add-stmt-syntax 'do-while-closure nil t
+                           containing-sexp paren-state))
 
-         ;; CASE 13: A catch or finally clause?  This case is simpler
-         ;; than if-else and do-while, because a block is required
-         ;; after every try, catch and finally.
-         ((save-excursion
-            (and (cond ((c-major-mode-is 'c++-mode)
-                        (looking-at "catch\\>[^_]"))
-                       ((c-major-mode-is 'java-mode)
-                        (looking-at "\\(catch\\|finally\\)\\>[^_]")))
-                 (and (c-safe (c-backward-syntactic-ws)
-                              (c-backward-sexp)
-                              t)
-                      (eq (char-after) ?{)
-                      (c-safe (c-backward-syntactic-ws)
-                              (c-backward-sexp)
-                              t)
-                      (if (eq (char-after) ?\()
-                          (c-safe (c-backward-sexp) t)
-                        t))
-                 (looking-at "\\(try\\|catch\\)\\>[^_]")
-                 (setq placeholder (point))))
-          (goto-char placeholder)
-          (c-add-stmt-syntax 'catch-clause nil t
-                             containing-sexp paren-state))
+       ;; CASE 13: A catch or finally clause?  This case is simpler
+       ;; than if-else and do-while, because a block is required
+       ;; after every try, catch and finally.
+       ((save-excursion
+          (and (cond ((c-major-mode-is 'c++-mode)
+                      (looking-at "catch\\>[^_]"))
+                     ((c-major-mode-is 'java-mode)
+                      (looking-at "\\(catch\\|finally\\)\\>[^_]")))
+               (and (c-safe (c-backward-syntactic-ws)
+                            (c-backward-sexp)
+                            t)
+                    (eq (char-after) ?{)
+                    (c-safe (c-backward-syntactic-ws)
+                            (c-backward-sexp)
+                            t)
+                    (if (eq (char-after) ?\()
+                        (c-safe (c-backward-sexp) t)
+                      t))
+               (looking-at "\\(try\\|catch\\)\\>[^_]")
+               (setq placeholder (point))))
+        (goto-char placeholder)
+        (c-add-stmt-syntax 'catch-clause nil t
+                           containing-sexp paren-state))
 
-         ;; CASE 18: A substatement we can recognize by keyword.
-         ((save-excursion
-            (and c-opt-block-stmt-key
-                 (not (eq char-before-ip ?\;))
-                 (not (c-at-vsemi-p before-ws-ip))
-                 (not (memq char-after-ip '(?\) ?\] ?,)))
-                 (or (not (eq char-before-ip ?}))
-                     (c-looking-at-inexpr-block-backward c-state-cache))
-                 (> (point)
-                    (progn
-                      ;; Ought to cache the result from the
-                      ;; c-beginning-of-statement-1 calls here.
+       ;; CASE 18: A substatement we can recognize by keyword.
+       ((save-excursion
+          (and c-opt-block-stmt-key
+               (not (eq char-before-ip ?\;))
+               (not (c-at-vsemi-p before-ws-ip))
+               (not (memq char-after-ip '(?\) ?\] ?,)))
+               (or (not (eq char-before-ip ?}))
+                   (c-looking-at-inexpr-block-backward c-state-cache))
+               (> (point)
+                  (progn
+                    ;; Ought to cache the result from the
+                    ;; c-beginning-of-statement-1 calls here.
+                    (setq placeholder (point))
+                    (while (eq (setq step-type
+                                     (c-beginning-of-statement-1 lim))
+                               'label))
+                    (if (eq step-type 'previous)
+                        (goto-char placeholder)
                       (setq placeholder (point))
-                      (while (eq (setq step-type
-                                       (c-beginning-of-statement-1 lim))
-                                 'label))
-                      (if (eq step-type 'previous)
-                          (goto-char placeholder)
-                        (setq placeholder (point))
-                        (if (and (eq step-type 'same)
-                                 (not (looking-at c-opt-block-stmt-key)))
-                            ;; Step up to the containing statement if we
-                            ;; stayed in the same one.
-                            (let (step)
-                              (while (eq
-                                      (setq step
-                                            (c-beginning-of-statement-1 lim))
-                                      'label))
-                              (if (eq step 'up)
-                                  (setq placeholder (point))
-                                ;; There was no containing statement afterall.
-                                (goto-char placeholder)))))
-                      placeholder))
-                 (if (looking-at c-block-stmt-2-key)
-                     ;; Require a parenthesis after these keywords.
-                     ;; Necessary to catch e.g. synchronized in Java,
-                     ;; which can be used both as statement and
-                     ;; modifier.
-                     (and (zerop (c-forward-token-2 1 nil))
-                          (eq (char-after) ?\())
-                   (looking-at c-opt-block-stmt-key))))
-
-          (if (eq step-type 'up)
-              ;; CASE 18A: Simple substatement.
-              (progn
-                (goto-char placeholder)
-                (cond
-                 ((eq char-after-ip ?{)
-                  (c-add-stmt-syntax 'substatement-open nil nil
-                                     containing-sexp paren-state))
-                 ((save-excursion
-                    (goto-char indent-point)
-                    (back-to-indentation)
-                    (c-forward-label))
-                  (c-add-stmt-syntax 'substatement-label nil nil
-                                     containing-sexp paren-state))
-                 (t
-                  (c-add-stmt-syntax 'substatement nil nil
-                                     containing-sexp paren-state))))
-
-            ;; CASE 18B: Some other substatement.  This is shared
-            ;; with case 10.
-            (c-guess-continued-construct indent-point
-                                         char-after-ip
-                                         placeholder
-                                         lim
-                                         paren-state)))
-
-         ;; CASE 14: A case or default label
-         ((looking-at c-label-kwds-regexp)
-          (if containing-sexp
-              (progn
-                (goto-char containing-sexp)
-                (setq lim (c-most-enclosing-brace c-state-cache
-                                                  containing-sexp))
-                (c-backward-to-block-anchor lim)
-                (c-add-stmt-syntax 'case-label nil t lim paren-state))
-            ;; Got a bogus label at the top level.  In lack of better
-            ;; alternatives, anchor it on (point-min).
-            (c-add-syntax 'case-label (point-min))))
-
-         ;; CASE 15: any other label
-         ((save-excursion
-            (back-to-indentation)
-            (and (not (looking-at c-syntactic-ws-start))
-                 (c-forward-label)))
-          (cond (containing-decl-open
-                 (setq placeholder (c-add-class-syntax 'inclass
-                                                       containing-decl-open
-                                                       containing-decl-start
-                                                       containing-decl-kwd
-                                                       paren-state))
-                 ;; Append access-label with the same anchor point as
-                 ;; inclass gets.
-                 (c-append-syntax 'access-label placeholder))
-
-                (containing-sexp
-                 (goto-char containing-sexp)
-                 (setq lim (c-most-enclosing-brace c-state-cache
-                                                   containing-sexp))
-                 (save-excursion
-                   (setq tmpsymbol
-                         (if (and (eq (c-beginning-of-statement-1 lim) 'up)
-                                  (looking-at "switch\\>[^_]"))
-                             ;; If the surrounding statement is a switch then
-                             ;; let's analyze all labels as switch labels, so
-                             ;; that they get lined up consistently.
-                             'case-label
-                           'label)))
-                 (c-backward-to-block-anchor lim)
-                 (c-add-stmt-syntax tmpsymbol nil t lim paren-state))
+                      (if (and (eq step-type 'same)
+                               (not (looking-at c-opt-block-stmt-key)))
+                          ;; Step up to the containing statement if we
+                          ;; stayed in the same one.
+                          (let (step)
+                            (while (eq
+                                    (setq step
+                                          (c-beginning-of-statement-1 lim))
+                                    'label))
+                            (if (eq step 'up)
+                                (setq placeholder (point))
+                              ;; There was no containing statement afterall.
+                              (goto-char placeholder)))))
+                    placeholder))
+               (if (looking-at c-block-stmt-2-key)
+                   ;; Require a parenthesis after these keywords.
+                   ;; Necessary to catch e.g. synchronized in Java,
+                   ;; which can be used both as statement and
+                   ;; modifier.
+                   (and (zerop (c-forward-token-2 1 nil))
+                        (eq (char-after) ?\())
+                 (looking-at c-opt-block-stmt-key))))
+
+        (if (eq step-type 'up)
+            ;; CASE 18A: Simple substatement.
+            (progn
+              (goto-char placeholder)
+              (cond
+               ((eq char-after-ip ?{)
+                (c-add-stmt-syntax 'substatement-open nil nil
+                                   containing-sexp paren-state))
+               ((save-excursion
+                  (goto-char indent-point)
+                  (back-to-indentation)
+                  (c-forward-label))
+                (c-add-stmt-syntax 'substatement-label nil nil
+                                   containing-sexp paren-state))
+               (t
+                (c-add-stmt-syntax 'substatement nil nil
+                                   containing-sexp paren-state))))
+
+          ;; CASE 18B: Some other substatement.  This is shared
+          ;; with case 10.
+          (c-guess-continued-construct indent-point
+                                       char-after-ip
+                                       placeholder
+                                       lim
+                                       paren-state)))
 
-                (t
-                 ;; A label on the top level.  Treat it as a class
-                 ;; context.  (point-min) is the closest we get to the
-                 ;; class open brace.
-                 (c-add-syntax 'access-label (point-min)))))
+       ;; CASE 14: A case or default label
+       ((looking-at c-label-kwds-regexp)
+        (if containing-sexp
+            (progn
+              (goto-char containing-sexp)
+              (setq lim (c-most-enclosing-brace c-state-cache
+                                                containing-sexp))
+              (c-backward-to-block-anchor lim)
+              (c-add-stmt-syntax 'case-label nil t lim paren-state))
+          ;; Got a bogus label at the top level.  In lack of better
+          ;; alternatives, anchor it on (point-min).
+          (c-add-syntax 'case-label (point-min))))
 
-         ;; CASE 4: In-expression statement.  C.f. cases 7B, 16A and
-         ;; 17E.
-         ((setq placeholder (c-looking-at-inexpr-block
-                             (c-safe-position containing-sexp paren-state)
-                             containing-sexp
-                             ;; Have to turn on the heuristics after
-                             ;; the point even though it doesn't work
-                             ;; very well.  C.f. test case class-16.pike.
-                             t))
-          (setq tmpsymbol (assq (car placeholder)
-                                '((inexpr-class . class-open)
-                                  (inexpr-statement . block-open))))
-          (if tmpsymbol
-              ;; It's a statement block or an anonymous class.
-              (setq tmpsymbol (cdr tmpsymbol))
-            ;; It's a Pike lambda.  Check whether we are between the
-            ;; lambda keyword and the argument list or at the defun
-            ;; opener.
-            (setq tmpsymbol (if (eq char-after-ip ?{)
-                                'inline-open
-                              'lambda-intro-cont)))
-          (goto-char (cdr placeholder))
+       ;; CASE 15: any other label
+       ((save-excursion
           (back-to-indentation)
-          (c-add-stmt-syntax tmpsymbol nil t
-                             (c-most-enclosing-brace c-state-cache (point))
-                             paren-state)
-          (unless (eq (point) (cdr placeholder))
-            (c-add-syntax (car placeholder))))
-
-         ;; CASE 5: Line is inside a declaration level block or at top level.
-         ((or containing-decl-open (null containing-sexp))
-          (cond
-
-           ;; CASE 5A: we are looking at a defun, brace list, class,
-           ;; or inline-inclass method opening brace
-           ((setq special-brace-list
-                  (or (and c-special-brace-lists
-                           (c-looking-at-special-brace-list))
-                      (eq char-after-ip ?{)))
-            (cond
+          (and (not (looking-at c-syntactic-ws-start))
+               (c-forward-label)))
+        (cond (containing-decl-open
+               (setq placeholder (c-add-class-syntax 'inclass
+                                                     containing-decl-open
+                                                     containing-decl-start
+                                                     containing-decl-kwd
+                                                     paren-state))
+               ;; Append access-label with the same anchor point as
+               ;; inclass gets.
+               (c-append-syntax 'access-label placeholder))
+
+              (containing-sexp
+               (goto-char containing-sexp)
+               (setq lim (c-most-enclosing-brace c-state-cache
+                                                 containing-sexp))
+               (save-excursion
+                 (setq tmpsymbol
+                       (if (and (eq (c-beginning-of-statement-1 lim) 'up)
+                                (looking-at "switch\\>[^_]"))
+                           ;; If the surrounding statement is a switch then
+                           ;; let's analyze all labels as switch labels, so
+                           ;; that they get lined up consistently.
+                           'case-label
+                         'label)))
+               (c-backward-to-block-anchor lim)
+               (c-add-stmt-syntax tmpsymbol nil t lim paren-state))
 
-             ;; CASE 5A.1: Non-class declaration block open.
-             ((save-excursion
-                (let (tmp)
-                  (and (eq char-after-ip ?{)
-                       (setq tmp (c-looking-at-decl-block containing-sexp t))
-                       (progn
-                         (setq placeholder (point))
-                         (goto-char tmp)
-                         (looking-at c-symbol-key))
-                       (c-keyword-member
-                        (c-keyword-sym (setq keyword (match-string 0)))
-                        'c-other-block-decl-kwds))))
-              (goto-char placeholder)
-              (c-add-stmt-syntax
-               (if (string-equal keyword "extern")
-                   ;; Special case for extern-lang-open.
-                   'extern-lang-open
-                 (intern (concat keyword "-open")))
-               nil t containing-sexp paren-state))
-
-             ;; CASE 5A.2: we are looking at a class opening brace
-             ((save-excursion
-                (goto-char indent-point)
-                (skip-chars-forward " \t")
-                (and (eq (char-after) ?{)
-                     (c-looking-at-decl-block containing-sexp t)
-                     (setq placeholder (point))))
-              (c-add-syntax 'class-open placeholder))
-
-             ;; CASE 5A.3: brace list open
-             ((save-excursion
-                (c-beginning-of-decl-1 lim)
-                (while (looking-at c-specifier-key)
-                  (goto-char (match-end 1))
-                  (c-forward-syntactic-ws indent-point))
-                (setq placeholder (c-point 'boi))
-                (or (consp special-brace-list)
-                    (and (or (save-excursion
-                               (goto-char indent-point)
-                               (setq tmpsymbol nil)
-                               (while (and (> (point) placeholder)
-                                           (zerop (c-backward-token-2 1 t))
-                                           (/= (char-after) ?=))
-                                 (and c-opt-inexpr-brace-list-key
-                                      (not tmpsymbol)
-                                      (looking-at c-opt-inexpr-brace-list-key)
-                                      (setq tmpsymbol 'topmost-intro-cont)))
-                               (eq (char-after) ?=))
-                             (looking-at c-brace-list-key))
-                         (save-excursion
-                           (while (and (< (point) indent-point)
-                                       (zerop (c-forward-token-2 1 t))
-                                       (not (memq (char-after) '(?\; ?\()))))
-                           (not (memq (char-after) '(?\; ?\()))
-                           ))))
-              (if (and (not c-auto-newline-analysis)
-                       (c-major-mode-is 'java-mode)
-                       (eq tmpsymbol 'topmost-intro-cont))
-                  ;; We're in Java and have found that the open brace
-                  ;; belongs to a "new Foo[]" initialization list,
-                  ;; which means the brace list is part of an
-                  ;; expression and not a top level definition.  We
-                  ;; therefore treat it as any topmost continuation
-                  ;; even though the semantically correct symbol still
-                  ;; is brace-list-open, on the same grounds as in
-                  ;; case B.2.
-                  (progn
-                    (c-beginning-of-statement-1 lim)
-                    (c-add-syntax 'topmost-intro-cont (c-point 'boi)))
-                (c-add-syntax 'brace-list-open placeholder)))
-
-             ;; CASE 5A.4: inline defun open
-             ((and containing-decl-open
-                   (not (c-keyword-member containing-decl-kwd
-                                          'c-other-block-decl-kwds)))
-              (c-add-syntax 'inline-open)
-              (c-add-class-syntax 'inclass
-                                  containing-decl-open
-                                  containing-decl-start
-                                  containing-decl-kwd
-                                  paren-state))
-
-             ;; CASE 5A.5: ordinary defun open
-             (t
-              (save-excursion
-                (c-beginning-of-decl-1 lim)
-                (while (looking-at c-specifier-key)
-                  (goto-char (match-end 1))
-                  (c-forward-syntactic-ws indent-point))
-                (c-add-syntax 'defun-open (c-point 'boi))
-                ;; Bogus to use bol here, but it's the legacy.  (Resolved,
-                ;; 2007-11-09)
-                ))))
-
-           ;; CASE 5B: After a function header but before the body (or
-           ;; the ending semicolon if there's no body).
-           ((save-excursion
-              (when (setq placeholder (c-just-after-func-arglist-p lim))
-                (setq tmp-pos (point))))
-            (cond
+              (t
+               ;; A label on the top level.  Treat it as a class
+               ;; context.  (point-min) is the closest we get to the
+               ;; class open brace.
+               (c-add-syntax 'access-label (point-min)))))
+
+       ;; CASE 4: In-expression statement.  C.f. cases 7B, 16A and
+       ;; 17E.
+       ((setq placeholder (c-looking-at-inexpr-block
+                           (c-safe-position containing-sexp paren-state)
+                           containing-sexp
+                           ;; Have to turn on the heuristics after
+                           ;; the point even though it doesn't work
+                           ;; very well.  C.f. test case class-16.pike.
+                           t))
+        (setq tmpsymbol (assq (car placeholder)
+                              '((inexpr-class . class-open)
+                                (inexpr-statement . block-open))))
+        (if tmpsymbol
+            ;; It's a statement block or an anonymous class.
+            (setq tmpsymbol (cdr tmpsymbol))
+          ;; It's a Pike lambda.  Check whether we are between the
+          ;; lambda keyword and the argument list or at the defun
+          ;; opener.
+          (setq tmpsymbol (if (eq char-after-ip ?{)
+                              'inline-open
+                            'lambda-intro-cont)))
+        (goto-char (cdr placeholder))
+        (back-to-indentation)
+        (c-add-stmt-syntax tmpsymbol nil t
+                           (c-most-enclosing-brace c-state-cache (point))
+                           paren-state)
+        (unless (eq (point) (cdr placeholder))
+          (c-add-syntax (car placeholder))))
 
-             ;; CASE 5B.1: Member init list.
-             ((eq (char-after tmp-pos) ?:)
-              (if (or (> tmp-pos indent-point)
-                      (= (c-point 'bosws) (1+ tmp-pos)))
-                  (progn
-                    ;; There is no preceding member init clause.
-                    ;; Indent relative to the beginning of indentation
-                    ;; for the topmost-intro line that contains the
-                    ;; prototype's open paren.
-                    (goto-char placeholder)
-                    (c-add-syntax 'member-init-intro (c-point 'boi)))
-                ;; Indent relative to the first member init clause.
-                (goto-char (1+ tmp-pos))
-                (c-forward-syntactic-ws)
-                (c-add-syntax 'member-init-cont (point))))
+       ;; CASE 5: Line is inside a declaration level block or at top level.
+       ((or containing-decl-open (null containing-sexp))
+        (cond
 
-             ;; CASE 5B.2: K&R arg decl intro
-             ((and c-recognize-knr-p
-                   (c-in-knr-argdecl lim))
-              (c-beginning-of-statement-1 lim)
-              (c-add-syntax 'knr-argdecl-intro (c-point 'boi))
-              (if containing-decl-open
-                  (c-add-class-syntax 'inclass
-                                      containing-decl-open
-                                      containing-decl-start
-                                      containing-decl-kwd
-                                      paren-state)))
-
-             ;; CASE 5B.4: Nether region after a C++ or Java func
-             ;; decl, which could include a `throws' declaration.
-             (t
-              (c-beginning-of-statement-1 lim)
-              (c-add-syntax 'func-decl-cont (c-point 'boi))
-              )))
+         ;; CASE 5A: we are looking at a defun, brace list, class,
+         ;; or inline-inclass method opening brace
+         ((setq special-brace-list
+                (or (and c-special-brace-lists
+                         (c-looking-at-special-brace-list))
+                    (eq char-after-ip ?{)))
+          (cond
 
-           ;; CASE 5C: inheritance line. could be first inheritance
-           ;; line, or continuation of a multiple inheritance
-           ((or (and (c-major-mode-is 'c++-mode)
+           ;; CASE 5A.1: Non-class declaration block open.
+           ((save-excursion
+              (let (tmp)
+                (and (eq char-after-ip ?{)
+                     (setq tmp (c-looking-at-decl-block containing-sexp t))
                      (progn
-                       (when (eq char-after-ip ?,)
-                         (skip-chars-forward " \t")
-                         (forward-char))
-                       (looking-at c-opt-postfix-decl-spec-key)))
-                (and (or (eq char-before-ip ?:)
-                         ;; watch out for scope operator
-                         (save-excursion
-                           (and (eq char-after-ip ?:)
-                                (c-safe (forward-char 1) t)
-                                (not (eq (char-after) ?:))
-                                )))
-                     (save-excursion
-                       (c-backward-syntactic-ws lim)
-                       (if (eq char-before-ip ?:)
-                           (progn
-                             (forward-char -1)
-                             (c-backward-syntactic-ws lim)))
-                       (back-to-indentation)
-                       (looking-at c-class-key)))
-                ;; for Java
-                (and (c-major-mode-is 'java-mode)
-                     (let ((fence (save-excursion
-                                    (c-beginning-of-statement-1 lim)
-                                    (point)))
-                           cont done)
-                       (save-excursion
-                         (while (not done)
-                           (cond ((looking-at c-opt-postfix-decl-spec-key)
-                                  (setq injava-inher (cons cont (point))
-                                        done t))
-                                 ((or (not (c-safe (c-forward-sexp -1) t))
-                                      (<= (point) fence))
-                                  (setq done t))
-                                 )
-                           (setq cont t)))
-                       injava-inher)
-                     (not (c-crosses-statement-barrier-p (cdr injava-inher)
-                                                         (point)))
-                     ))
-            (cond
-
-             ;; CASE 5C.1: non-hanging colon on an inher intro
-             ((eq char-after-ip ?:)
-              (c-beginning-of-statement-1 lim)
-              (c-add-syntax 'inher-intro (c-point 'boi))
-              ;; don't add inclass symbol since relative point already
-              ;; contains any class offset
-              )
+                       (setq placeholder (point))
+                       (goto-char tmp)
+                       (looking-at c-symbol-key))
+                     (c-keyword-member
+                      (c-keyword-sym (setq keyword (match-string 0)))
+                      'c-other-block-decl-kwds))))
+            (goto-char placeholder)
+            (c-add-stmt-syntax
+             (if (string-equal keyword "extern")
+                 ;; Special case for extern-lang-open.
+                 'extern-lang-open
+               (intern (concat keyword "-open")))
+             nil t containing-sexp paren-state))
 
-             ;; CASE 5C.2: hanging colon on an inher intro
-             ((eq char-before-ip ?:)
-              (c-beginning-of-statement-1 lim)
-              (c-add-syntax 'inher-intro (c-point 'boi))
-              (if containing-decl-open
-                  (c-add-class-syntax 'inclass
-                                      containing-decl-open
-                                      containing-decl-start
-                                      containing-decl-kwd
-                                      paren-state)))
-
-             ;; CASE 5C.3: in a Java implements/extends
-             (injava-inher
-              (let ((where (cdr injava-inher))
-                    (cont (car injava-inher)))
-                (goto-char where)
-                (cond ((looking-at "throws\\>[^_]")
-                       (c-add-syntax 'func-decl-cont
-                                     (progn (c-beginning-of-statement-1 lim)
-                                            (c-point 'boi))))
-                      (cont (c-add-syntax 'inher-cont where))
-                      (t (c-add-syntax 'inher-intro
-                                       (progn (goto-char (cdr injava-inher))
-                                              (c-beginning-of-statement-1 lim)
-                                              (point))))
-                      )))
-
-             ;; CASE 5C.4: a continued inheritance line
-             (t
-              (c-beginning-of-inheritance-list lim)
-              (c-add-syntax 'inher-cont (point))
-              ;; don't add inclass symbol since relative point already
-              ;; contains any class offset
-              )))
-
-           ;; CASE 5D: this could be a top-level initialization, a
-           ;; member init list continuation, or a template argument
-           ;; list continuation.
+           ;; CASE 5A.2: we are looking at a class opening brace
            ((save-excursion
-              ;; Note: We use the fact that lim is always after any
-              ;; preceding brace sexp.
-              (if c-recognize-<>-arglists
-                  (while (and
-                          (progn
-                            (c-syntactic-skip-backward "^;,=<>" lim t)
-                            (> (point) lim))
-                          (or
-                           (when c-overloadable-operators-regexp
-                             (when (setq placeholder (c-after-special-operator-id lim))
-                               (goto-char placeholder)
-                               t))
-                           (cond
-                            ((eq (char-before) ?>)
-                             (or (c-backward-<>-arglist nil lim)
-                                 (backward-char))
-                             t)
-                            ((eq (char-before) ?<)
-                             (backward-char)
-                             (if (save-excursion
-                                   (c-forward-<>-arglist nil))
-                                 (progn (forward-char)
-                                        nil)
-                               t))
-                            (t nil)))))
-                ;; NB: No c-after-special-operator-id stuff in this
-                ;; clause - we assume only C++ needs it.
-                (c-syntactic-skip-backward "^;,=" lim t))
-              (memq (char-before) '(?, ?= ?<)))
-            (cond
-
-             ;; CASE 5D.3: perhaps a template list continuation?
-             ((and (c-major-mode-is 'c++-mode)
-                   (save-excursion
-                     (save-restriction
-                       (c-with-syntax-table c++-template-syntax-table
-                         (goto-char indent-point)
-                         (setq placeholder (c-up-list-backward))
-                         (and placeholder
-                              (eq (char-after placeholder) ?<))))))
-              (c-with-syntax-table c++-template-syntax-table
-                (goto-char placeholder)
-                (c-beginning-of-statement-1 lim t)
-                (if (save-excursion
-                      (c-backward-syntactic-ws lim)
-                      (eq (char-before) ?<))
-                    ;; In a nested template arglist.
-                    (progn
-                      (goto-char placeholder)
-                      (c-syntactic-skip-backward "^,;" lim t)
-                      (c-forward-syntactic-ws))
-                  (back-to-indentation)))
-              ;; FIXME: Should use c-add-stmt-syntax, but it's not yet
-              ;; template aware.
-              (c-add-syntax 'template-args-cont (point) placeholder))
-
-             ;; CASE 5D.4: perhaps a multiple inheritance line?
-             ((and (c-major-mode-is 'c++-mode)
-                   (save-excursion
-                     (c-beginning-of-statement-1 lim)
-                     (setq placeholder (point))
-                     (if (looking-at "static\\>[^_]")
-                         (c-forward-token-2 1 nil indent-point))
-                     (and (looking-at c-class-key)
-                          (zerop (c-forward-token-2 2 nil indent-point))
-                          (if (eq (char-after) ?<)
-                              (c-with-syntax-table c++-template-syntax-table
-                                (zerop (c-forward-token-2 1 t indent-point)))
-                            t)
-                          (eq (char-after) ?:))))
-              (goto-char placeholder)
-              (c-add-syntax 'inher-cont (c-point 'boi)))
-
-             ;; CASE 5D.5: Continuation of the "expression part" of a
-             ;; top level construct.  Or, perhaps, an unrecognised construct.
-             (t
-              (while (and (setq placeholder (point))
-                          (eq (car (c-beginning-of-decl-1 containing-sexp))
-                              'same)
-                          (save-excursion
-                            (c-backward-syntactic-ws)
-                            (eq (char-before) ?}))
-                          (< (point) placeholder)))
-              (c-add-stmt-syntax
-               (cond
-                ((eq (point) placeholder) 'statement) ; unrecognised construct
-                   ;; A preceding comma at the top level means that a
-                   ;; new variable declaration starts here.  Use
-                   ;; topmost-intro-cont for it, for consistency with
-                   ;; the first variable declaration.  C.f. case 5N.
-                ((eq char-before-ip ?,) 'topmost-intro-cont)
-                (t 'statement-cont))
-               nil nil containing-sexp paren-state))
-             ))
-
-           ;; CASE 5F: Close of a non-class declaration level block.
-           ((and (eq char-after-ip ?})
-                 (c-keyword-member containing-decl-kwd
-                                   'c-other-block-decl-kwds))
-            ;; This is inconsistent: Should use `containing-decl-open'
-            ;; here if it's at boi, like in case 5J.
-            (goto-char containing-decl-start)
-            (c-add-stmt-syntax
-              (if (string-equal (symbol-name containing-decl-kwd) "extern")
-                  ;; Special case for compatibility with the
-                  ;; extern-lang syntactic symbols.
-                  'extern-lang-close
-                (intern (concat (symbol-name containing-decl-kwd)
-                                "-close")))
-              nil t
-              (c-most-enclosing-brace paren-state (point))
-              paren-state))
-
-           ;; CASE 5G: we are looking at the brace which closes the
-           ;; enclosing nested class decl
-           ((and containing-sexp
-                 (eq char-after-ip ?})
-                 (eq containing-decl-open containing-sexp))
-            (c-add-class-syntax 'class-close
+              (goto-char indent-point)
+              (skip-chars-forward " \t")
+              (and (eq (char-after) ?{)
+                   (c-looking-at-decl-block containing-sexp t)
+                   (setq placeholder (point))))
+            (c-add-syntax 'class-open placeholder))
+
+           ;; CASE 5A.3: brace list open
+           ((save-excursion
+              (c-beginning-of-decl-1 lim)
+              (while (looking-at c-specifier-key)
+                (goto-char (match-end 1))
+                (c-forward-syntactic-ws indent-point))
+              (setq placeholder (c-point 'boi))
+              (or (consp special-brace-list)
+                  (and (or (save-excursion
+                             (goto-char indent-point)
+                             (setq tmpsymbol nil)
+                             (while (and (> (point) placeholder)
+                                         (zerop (c-backward-token-2 1 t))
+                                         (/= (char-after) ?=))
+                               (and c-opt-inexpr-brace-list-key
+                                    (not tmpsymbol)
+                                    (looking-at c-opt-inexpr-brace-list-key)
+                                    (setq tmpsymbol 'topmost-intro-cont)))
+                             (eq (char-after) ?=))
+                           (looking-at c-brace-list-key))
+                       (save-excursion
+                         (while (and (< (point) indent-point)
+                                     (zerop (c-forward-token-2 1 t))
+                                     (not (memq (char-after) '(?\; ?\()))))
+                         (not (memq (char-after) '(?\; ?\()))
+                         ))))
+            (if (and (not c-auto-newline-analysis)
+                     (c-major-mode-is 'java-mode)
+                     (eq tmpsymbol 'topmost-intro-cont))
+                ;; We're in Java and have found that the open brace
+                ;; belongs to a "new Foo[]" initialization list,
+                ;; which means the brace list is part of an
+                ;; expression and not a top level definition.  We
+                ;; therefore treat it as any topmost continuation
+                ;; even though the semantically correct symbol still
+                ;; is brace-list-open, on the same grounds as in
+                ;; case B.2.
+                (progn
+                  (c-beginning-of-statement-1 lim)
+                  (c-add-syntax 'topmost-intro-cont (c-point 'boi)))
+              (c-add-syntax 'brace-list-open placeholder)))
+
+           ;; CASE 5A.4: inline defun open
+           ((and containing-decl-open
+                 (not (c-keyword-member containing-decl-kwd
+                                        'c-other-block-decl-kwds)))
+            (c-add-syntax 'inline-open)
+            (c-add-class-syntax 'inclass
                                 containing-decl-open
                                 containing-decl-start
                                 containing-decl-kwd
                                 paren-state))
 
-           ;; CASE 5H: we could be looking at subsequent knr-argdecls
+           ;; CASE 5A.5: ordinary defun open
+           (t
+            (save-excursion
+              (c-beginning-of-decl-1 lim)
+              (while (looking-at c-specifier-key)
+                (goto-char (match-end 1))
+                (c-forward-syntactic-ws indent-point))
+              (c-add-syntax 'defun-open (c-point 'boi))
+              ;; Bogus to use bol here, but it's the legacy.  (Resolved,
+              ;; 2007-11-09)
+              ))))
+
+         ;; CASE 5B: After a function header but before the body (or
+         ;; the ending semicolon if there's no body).
+         ((save-excursion
+            (when (setq placeholder (c-just-after-func-arglist-p lim))
+              (setq tmp-pos (point))))
+          (cond
+
+           ;; CASE 5B.1: Member init list.
+           ((eq (char-after tmp-pos) ?:)
+            (if (or (> tmp-pos indent-point)
+                    (= (c-point 'bosws) (1+ tmp-pos)))
+                (progn
+                  ;; There is no preceding member init clause.
+                  ;; Indent relative to the beginning of indentation
+                  ;; for the topmost-intro line that contains the
+                  ;; prototype's open paren.
+                  (goto-char placeholder)
+                  (c-add-syntax 'member-init-intro (c-point 'boi)))
+              ;; Indent relative to the first member init clause.
+              (goto-char (1+ tmp-pos))
+              (c-forward-syntactic-ws)
+              (c-add-syntax 'member-init-cont (point))))
+
+           ;; CASE 5B.2: K&R arg decl intro
            ((and c-recognize-knr-p
-                 (not containing-sexp)  ; can't be knr inside braces.
-                 (not (eq char-before-ip ?}))
-                 (save-excursion
-                   (setq placeholder (cdr (c-beginning-of-decl-1 lim)))
-                   (and placeholder
-                        ;; Do an extra check to avoid tripping up on
-                        ;; statements that occur in invalid contexts
-                        ;; (e.g. in macro bodies where we don't really
-                        ;; know the context of what we're looking at).
-                        (not (and c-opt-block-stmt-key
-                                  (looking-at c-opt-block-stmt-key)))))
-                 (< placeholder indent-point))
-            (goto-char placeholder)
-            (c-add-syntax 'knr-argdecl (point)))
-
-           ;; CASE 5I: ObjC method definition.
-           ((and c-opt-method-key
-                 (looking-at c-opt-method-key))
-            (c-beginning-of-statement-1 nil t)
-            (if (= (point) indent-point)
-                ;; Handle the case when it's the first (non-comment)
-                ;; thing in the buffer.  Can't look for a 'same return
-                ;; value from cbos1 since ObjC directives currently
-                ;; aren't recognized fully, so that we get 'same
-                ;; instead of 'previous if it moved over a preceding
-                ;; directive.
-                (goto-char (point-min)))
-            (c-add-syntax 'objc-method-intro (c-point 'boi)))
-
-           ;; CASE 5P: AWK pattern or function or continuation
-           ;; thereof.
-           ((c-major-mode-is 'awk-mode)
-            (setq placeholder (point))
-            (c-add-stmt-syntax
-             (if (and (eq (c-beginning-of-statement-1) 'same)
-                      (/= (point) placeholder))
-                 'topmost-intro-cont
-               'topmost-intro)
-             nil nil
-             containing-sexp paren-state))
-
-           ;; CASE 5N: At a variable declaration that follows a class
-           ;; definition or some other block declaration that doesn't
-           ;; end at the closing '}'.  C.f. case 5D.5.
-           ((progn
-              (c-backward-syntactic-ws lim)
-              (and (eq (char-before) ?})
+                 (c-in-knr-argdecl lim))
+            (c-beginning-of-statement-1 lim)
+            (c-add-syntax 'knr-argdecl-intro (c-point 'boi))
+            (if containing-decl-open
+                (c-add-class-syntax 'inclass
+                                    containing-decl-open
+                                    containing-decl-start
+                                    containing-decl-kwd
+                                    paren-state)))
+
+           ;; CASE 5B.4: Nether region after a C++ or Java func
+           ;; decl, which could include a `throws' declaration.
+           (t
+            (c-beginning-of-statement-1 lim)
+            (c-add-syntax 'func-decl-cont (c-point 'boi))
+            )))
+
+         ;; CASE 5C: inheritance line. could be first inheritance
+         ;; line, or continuation of a multiple inheritance
+         ((or (and (c-major-mode-is 'c++-mode)
+                   (progn
+                     (when (eq char-after-ip ?,)
+                       (skip-chars-forward " \t")
+                       (forward-char))
+                     (looking-at c-opt-postfix-decl-spec-key)))
+              (and (or (eq char-before-ip ?:)
+                       ;; watch out for scope operator
+                       (save-excursion
+                         (and (eq char-after-ip ?:)
+                              (c-safe (forward-char 1) t)
+                              (not (eq (char-after) ?:))
+                              )))
                    (save-excursion
-                     (let ((start (point)))
-                       (if (and c-state-cache
-                                (consp (car c-state-cache))
-                                (eq (cdar c-state-cache) (point)))
-                           ;; Speed up the backward search a bit.
-                           (goto-char (caar c-state-cache)))
-                       (c-beginning-of-decl-1 containing-sexp)
-                       (setq placeholder (point))
-                       (if (= start (point))
-                           ;; The '}' is unbalanced.
-                           nil
-                         (c-end-of-decl-1)
-                         (>= (point) indent-point))))))
-            (goto-char placeholder)
-            (c-add-stmt-syntax 'topmost-intro-cont nil nil
-                               containing-sexp paren-state))
+                     (c-backward-syntactic-ws lim)
+                     (if (eq char-before-ip ?:)
+                         (progn
+                           (forward-char -1)
+                           (c-backward-syntactic-ws lim)))
+                     (back-to-indentation)
+                     (looking-at c-class-key)))
+              ;; for Java
+              (and (c-major-mode-is 'java-mode)
+                   (let ((fence (save-excursion
+                                  (c-beginning-of-statement-1 lim)
+                                  (point)))
+                         cont done)
+                     (save-excursion
+                       (while (not done)
+                         (cond ((looking-at c-opt-postfix-decl-spec-key)
+                                (setq injava-inher (cons cont (point))
+                                      done t))
+                               ((or (not (c-safe (c-forward-sexp -1) t))
+                                    (<= (point) fence))
+                                (setq done t))
+                               )
+                         (setq cont t)))
+                     injava-inher)
+                   (not (c-crosses-statement-barrier-p (cdr injava-inher)
+                                                       (point)))
+                   ))
+          (cond
 
-           ;; NOTE: The point is at the end of the previous token here.
+           ;; CASE 5C.1: non-hanging colon on an inher intro
+           ((eq char-after-ip ?:)
+            (c-beginning-of-statement-1 lim)
+            (c-add-syntax 'inher-intro (c-point 'boi))
+            ;; don't add inclass symbol since relative point already
+            ;; contains any class offset
+            )
 
-           ;; CASE 5J: we are at the topmost level, make
-           ;; sure we skip back past any access specifiers
-           ((and
-             ;; A macro continuation line is never at top level.
-             (not (and macro-start
-                       (> indent-point macro-start)))
-             (save-excursion
-               (setq placeholder (point))
-               (or (memq char-before-ip '(?\; ?{ ?} nil))
-                   (c-at-vsemi-p before-ws-ip)
-                   (when (and (eq char-before-ip ?:)
-                              (eq (c-beginning-of-statement-1 lim)
-                                  'label))
-                     (c-backward-syntactic-ws lim)
-                     (setq placeholder (point)))
-                   (and (c-major-mode-is 'objc-mode)
-                        (catch 'not-in-directive
-                          (c-beginning-of-statement-1 lim)
-                          (setq placeholder (point))
-                          (while (and (c-forward-objc-directive)
-                                      (< (point) indent-point))
-                            (c-forward-syntactic-ws)
-                            (if (>= (point) indent-point)
-                                (throw 'not-in-directive t))
-                            (setq placeholder (point)))
-                          nil)))))
-            ;; For historic reasons we anchor at bol of the last
-            ;; line of the previous declaration.  That's clearly
-            ;; highly bogus and useless, and it makes our lives hard
-            ;; to remain compatible.  :P
-            (goto-char placeholder)
-            (c-add-syntax 'topmost-intro (c-point 'bol))
+           ;; CASE 5C.2: hanging colon on an inher intro
+           ((eq char-before-ip ?:)
+            (c-beginning-of-statement-1 lim)
+            (c-add-syntax 'inher-intro (c-point 'boi))
             (if containing-decl-open
-                (if (c-keyword-member containing-decl-kwd
-                                      'c-other-block-decl-kwds)
-                    (progn
-                      (goto-char (c-brace-anchor-point containing-decl-open))
-                      (c-add-stmt-syntax
-                       (if (string-equal (symbol-name containing-decl-kwd)
-                                         "extern")
-                           ;; Special case for compatibility with the
-                           ;; extern-lang syntactic symbols.
-                           'inextern-lang
-                         (intern (concat "in"
-                                         (symbol-name containing-decl-kwd))))
-                       nil t
-                       (c-most-enclosing-brace paren-state (point))
-                       paren-state))
-                  (c-add-class-syntax 'inclass
-                                      containing-decl-open
-                                      containing-decl-start
-                                      containing-decl-kwd
-                                      paren-state)))
-            (when (and c-syntactic-indentation-in-macros
-                       macro-start
-                       (/= macro-start (c-point 'boi indent-point)))
-              (c-add-syntax 'cpp-define-intro)
-              (setq macro-start nil)))
-
-           ;; CASE 5K: we are at an ObjC method definition
-           ;; continuation line.
-           ((and c-opt-method-key
+                (c-add-class-syntax 'inclass
+                                    containing-decl-open
+                                    containing-decl-start
+                                    containing-decl-kwd
+                                    paren-state)))
+
+           ;; CASE 5C.3: in a Java implements/extends
+           (injava-inher
+            (let ((where (cdr injava-inher))
+                  (cont (car injava-inher)))
+              (goto-char where)
+              (cond ((looking-at "throws\\>[^_]")
+                     (c-add-syntax 'func-decl-cont
+                                   (progn (c-beginning-of-statement-1 lim)
+                                          (c-point 'boi))))
+                    (cont (c-add-syntax 'inher-cont where))
+                    (t (c-add-syntax 'inher-intro
+                                     (progn (goto-char (cdr injava-inher))
+                                            (c-beginning-of-statement-1 lim)
+                                            (point))))
+                    )))
+
+           ;; CASE 5C.4: a continued inheritance line
+           (t
+            (c-beginning-of-inheritance-list lim)
+            (c-add-syntax 'inher-cont (point))
+            ;; don't add inclass symbol since relative point already
+            ;; contains any class offset
+            )))
+
+         ;; CASE 5D: this could be a top-level initialization, a
+         ;; member init list continuation, or a template argument
+         ;; list continuation.
+         ((save-excursion
+            ;; Note: We use the fact that lim is always after any
+            ;; preceding brace sexp.
+            (if c-recognize-<>-arglists
+                (while (and
+                        (progn
+                          (c-syntactic-skip-backward "^;,=<>" lim t)
+                          (> (point) lim))
+                        (or
+                         (when c-overloadable-operators-regexp
+                           (when (setq placeholder (c-after-special-operator-id lim))
+                             (goto-char placeholder)
+                             t))
+                         (cond
+                          ((eq (char-before) ?>)
+                           (or (c-backward-<>-arglist nil lim)
+                               (backward-char))
+                           t)
+                          ((eq (char-before) ?<)
+                           (backward-char)
+                           (if (save-excursion
+                                 (c-forward-<>-arglist nil))
+                               (progn (forward-char)
+                                      nil)
+                             t))
+                          (t nil)))))
+              ;; NB: No c-after-special-operator-id stuff in this
+              ;; clause - we assume only C++ needs it.
+              (c-syntactic-skip-backward "^;,=" lim t))
+            (memq (char-before) '(?, ?= ?<)))
+          (cond
+
+           ;; CASE 5D.3: perhaps a template list continuation?
+           ((and (c-major-mode-is 'c++-mode)
+                 (save-excursion
+                   (save-restriction
+                     (c-with-syntax-table c++-template-syntax-table
+                       (goto-char indent-point)
+                       (setq placeholder (c-up-list-backward))
+                       (and placeholder
+                            (eq (char-after placeholder) ?<))))))
+            (c-with-syntax-table c++-template-syntax-table
+              (goto-char placeholder)
+              (c-beginning-of-statement-1 lim t)
+              (if (save-excursion
+                    (c-backward-syntactic-ws lim)
+                    (eq (char-before) ?<))
+                  ;; In a nested template arglist.
+                  (progn
+                    (goto-char placeholder)
+                    (c-syntactic-skip-backward "^,;" lim t)
+                    (c-forward-syntactic-ws))
+                (back-to-indentation)))
+            ;; FIXME: Should use c-add-stmt-syntax, but it's not yet
+            ;; template aware.
+            (c-add-syntax 'template-args-cont (point) placeholder))
+
+           ;; CASE 5D.4: perhaps a multiple inheritance line?
+           ((and (c-major-mode-is 'c++-mode)
                  (save-excursion
                    (c-beginning-of-statement-1 lim)
-                   (beginning-of-line)
-                   (when (looking-at c-opt-method-key)
-                     (setq placeholder (point)))))
-            (c-add-syntax 'objc-method-args-cont placeholder))
+                   (setq placeholder (point))
+                   (if (looking-at "static\\>[^_]")
+                       (c-forward-token-2 1 nil indent-point))
+                   (and (looking-at c-class-key)
+                        (zerop (c-forward-token-2 2 nil indent-point))
+                        (if (eq (char-after) ?<)
+                            (c-with-syntax-table c++-template-syntax-table
+                              (zerop (c-forward-token-2 1 t indent-point)))
+                          t)
+                        (eq (char-after) ?:))))
+            (goto-char placeholder)
+            (c-add-syntax 'inher-cont (c-point 'boi)))
+
+           ;; CASE 5D.5: Continuation of the "expression part" of a
+           ;; top level construct.  Or, perhaps, an unrecognised construct.
+           (t
+            (while (and (setq placeholder (point))
+                        (eq (car (c-beginning-of-decl-1 containing-sexp))
+                            'same)
+                        (save-excursion
+                          (c-backward-syntactic-ws)
+                          (eq (char-before) ?}))
+                        (< (point) placeholder)))
+            (c-add-stmt-syntax
+             (cond
+              ((eq (point) placeholder) 'statement) ; unrecognised construct
+              ;; A preceding comma at the top level means that a
+              ;; new variable declaration starts here.  Use
+              ;; topmost-intro-cont for it, for consistency with
+              ;; the first variable declaration.  C.f. case 5N.
+              ((eq char-before-ip ?,) 'topmost-intro-cont)
+              (t 'statement-cont))
+             nil nil containing-sexp paren-state))
+           ))
+
+         ;; CASE 5F: Close of a non-class declaration level block.
+         ((and (eq char-after-ip ?})
+               (c-keyword-member containing-decl-kwd
+                                 'c-other-block-decl-kwds))
+          ;; This is inconsistent: Should use `containing-decl-open'
+          ;; here if it's at boi, like in case 5J.
+          (goto-char containing-decl-start)
+          (c-add-stmt-syntax
+           (if (string-equal (symbol-name containing-decl-kwd) "extern")
+               ;; Special case for compatibility with the
+               ;; extern-lang syntactic symbols.
+               'extern-lang-close
+             (intern (concat (symbol-name containing-decl-kwd)
+                             "-close")))
+           nil t
+           (c-most-enclosing-brace paren-state (point))
+           paren-state))
+
+         ;; CASE 5G: we are looking at the brace which closes the
+         ;; enclosing nested class decl
+         ((and containing-sexp
+               (eq char-after-ip ?})
+               (eq containing-decl-open containing-sexp))
+          (c-add-class-syntax 'class-close
+                              containing-decl-open
+                              containing-decl-start
+                              containing-decl-kwd
+                              paren-state))
+
+         ;; CASE 5H: we could be looking at subsequent knr-argdecls
+         ((and c-recognize-knr-p
+               (not containing-sexp)    ; can't be knr inside braces.
+               (not (eq char-before-ip ?}))
+               (save-excursion
+                 (setq placeholder (cdr (c-beginning-of-decl-1 lim)))
+                 (and placeholder
+                      ;; Do an extra check to avoid tripping up on
+                      ;; statements that occur in invalid contexts
+                      ;; (e.g. in macro bodies where we don't really
+                      ;; know the context of what we're looking at).
+                      (not (and c-opt-block-stmt-key
+                                (looking-at c-opt-block-stmt-key)))))
+               (< placeholder indent-point))
+          (goto-char placeholder)
+          (c-add-syntax 'knr-argdecl (point)))
+
+         ;; CASE 5I: ObjC method definition.
+         ((and c-opt-method-key
+               (looking-at c-opt-method-key))
+          (c-beginning-of-statement-1 nil t)
+          (if (= (point) indent-point)
+              ;; Handle the case when it's the first (non-comment)
+              ;; thing in the buffer.  Can't look for a 'same return
+              ;; value from cbos1 since ObjC directives currently
+              ;; aren't recognized fully, so that we get 'same
+              ;; instead of 'previous if it moved over a preceding
+              ;; directive.
+              (goto-char (point-min)))
+          (c-add-syntax 'objc-method-intro (c-point 'boi)))
+
+         ;; CASE 5P: AWK pattern or function or continuation
+         ;; thereof.
+         ((c-major-mode-is 'awk-mode)
+          (setq placeholder (point))
+          (c-add-stmt-syntax
+           (if (and (eq (c-beginning-of-statement-1) 'same)
+                    (/= (point) placeholder))
+               'topmost-intro-cont
+             'topmost-intro)
+           nil nil
+           containing-sexp paren-state))
+
+         ;; CASE 5N: At a variable declaration that follows a class
+         ;; definition or some other block declaration that doesn't
+         ;; end at the closing '}'.  C.f. case 5D.5.
+         ((progn
+            (c-backward-syntactic-ws lim)
+            (and (eq (char-before) ?})
+                 (save-excursion
+                   (let ((start (point)))
+                     (if (and c-state-cache
+                              (consp (car c-state-cache))
+                              (eq (cdar c-state-cache) (point)))
+                         ;; Speed up the backward search a bit.
+                         (goto-char (caar c-state-cache)))
+                     (c-beginning-of-decl-1 containing-sexp)
+                     (setq placeholder (point))
+                     (if (= start (point))
+                         ;; The '}' is unbalanced.
+                         nil
+                       (c-end-of-decl-1)
+                       (>= (point) indent-point))))))
+          (goto-char placeholder)
+          (c-add-stmt-syntax 'topmost-intro-cont nil nil
+                             containing-sexp paren-state))
+
+         ;; NOTE: The point is at the end of the previous token here.
+
+         ;; CASE 5J: we are at the topmost level, make
+         ;; sure we skip back past any access specifiers
+         ((and
+           ;; A macro continuation line is never at top level.
+           (not (and macro-start
+                     (> indent-point macro-start)))
+           (save-excursion
+             (setq placeholder (point))
+             (or (memq char-before-ip '(?\; ?{ ?} nil))
+                 (c-at-vsemi-p before-ws-ip)
+                 (when (and (eq char-before-ip ?:)
+                            (eq (c-beginning-of-statement-1 lim)
+                                'label))
+                   (c-backward-syntactic-ws lim)
+                   (setq placeholder (point)))
+                 (and (c-major-mode-is 'objc-mode)
+                      (catch 'not-in-directive
+                        (c-beginning-of-statement-1 lim)
+                        (setq placeholder (point))
+                        (while (and (c-forward-objc-directive)
+                                    (< (point) indent-point))
+                          (c-forward-syntactic-ws)
+                          (if (>= (point) indent-point)
+                              (throw 'not-in-directive t))
+                          (setq placeholder (point)))
+                        nil)))))
+          ;; For historic reasons we anchor at bol of the last
+          ;; line of the previous declaration.  That's clearly
+          ;; highly bogus and useless, and it makes our lives hard
+          ;; to remain compatible.  :P
+          (goto-char placeholder)
+          (c-add-syntax 'topmost-intro (c-point 'bol))
+          (if containing-decl-open
+              (if (c-keyword-member containing-decl-kwd
+                                    'c-other-block-decl-kwds)
+                  (progn
+                    (goto-char (c-brace-anchor-point containing-decl-open))
+                    (c-add-stmt-syntax
+                     (if (string-equal (symbol-name containing-decl-kwd)
+                                       "extern")
+                         ;; Special case for compatibility with the
+                         ;; extern-lang syntactic symbols.
+                         'inextern-lang
+                       (intern (concat "in"
+                                       (symbol-name containing-decl-kwd))))
+                     nil t
+                     (c-most-enclosing-brace paren-state (point))
+                     paren-state))
+                (c-add-class-syntax 'inclass
+                                    containing-decl-open
+                                    containing-decl-start
+                                    containing-decl-kwd
+                                    paren-state)))
+          (when (and c-syntactic-indentation-in-macros
+                     macro-start
+                     (/= macro-start (c-point 'boi indent-point)))
+            (c-add-syntax 'cpp-define-intro)
+            (setq macro-start nil)))
+
+         ;; CASE 5K: we are at an ObjC method definition
+         ;; continuation line.
+         ((and c-opt-method-key
+               (save-excursion
+                 (c-beginning-of-statement-1 lim)
+                 (beginning-of-line)
+                 (when (looking-at c-opt-method-key)
+                   (setq placeholder (point)))))
+          (c-add-syntax 'objc-method-args-cont placeholder))
 
-           ;; CASE 5L: we are at the first argument of a template
+         ;; CASE 5L: we are at the first argument of a template
          ;; arglist that begins on the previous line.
          ((and c-recognize-<>-arglists
                (eq (char-before) ?<)
@@ -9573,32 +9573,32 @@ comment at the start of cc-engine.el for more info."
           (c-beginning-of-statement-1 containing-sexp)
           (c-add-stmt-syntax 'statement nil t containing-sexp paren-state))
 
-     ;;CASE 5N: We are at a tompmost continuation line and the only
-     ;;preceding items are annotations.
+         ;;CASE 5N: We are at a tompmost continuation line and the only
+         ;;preceding items are annotations.
          ((and (c-major-mode-is 'java-mode)
                (setq placeholder (point))
-           (c-beginning-of-statement-1)
-           (progn
+               (c-beginning-of-statement-1)
+               (progn
                  (while (and (c-forward-annotation))
-               (c-forward-syntactic-ws))
-             t)
-           (prog1
-             (>= (point) placeholder)
-             (goto-char placeholder)))
-      (c-add-syntax 'annotation-top-cont (c-point 'boi)))
+                   (c-forward-syntactic-ws))
+                 t)
+               (prog1
+                   (>= (point) placeholder)
+                 (goto-char placeholder)))
+          (c-add-syntax 'annotation-top-cont (c-point 'boi)))
 
          ;; CASE 5M: we are at a topmost continuation line
          (t
           (c-beginning-of-statement-1 (c-safe-position (point) paren-state))
-            (when (c-major-mode-is 'objc-mode)
-              (setq placeholder (point))
-              (while (and (c-forward-objc-directive)
-                          (< (point) indent-point))
-                (c-forward-syntactic-ws)
-                (setq placeholder (point)))
-              (goto-char placeholder))
-            (c-add-syntax 'topmost-intro-cont (c-point 'boi)))
-           ))
+          (when (c-major-mode-is 'objc-mode)
+            (setq placeholder (point))
+            (while (and (c-forward-objc-directive)
+                        (< (point) indent-point))
+              (c-forward-syntactic-ws)
+              (setq placeholder (point)))
+            (goto-char placeholder))
+          (c-add-syntax 'topmost-intro-cont (c-point 'boi)))
+         ))
 
 
        ;; (CASE 6 has been removed.)
@@ -9614,576 +9614,576 @@ comment at the start of cc-engine.el for more info."
         (cond
 
          ;; CASE 7A: we are looking at the arglist closing paren.
-           ;; C.f. case 7F.
-           ((memq char-after-ip '(?\) ?\]))
-            (goto-char containing-sexp)
-            (setq placeholder (c-point 'boi))
-            (if (and (c-safe (backward-up-list 1) t)
-                     (>= (point) placeholder))
-                (progn
-                  (forward-char)
-                  (skip-chars-forward " \t"))
-              (goto-char placeholder))
-            (c-add-stmt-syntax 'arglist-close (list containing-sexp) t
+         ;; C.f. case 7F.
+         ((memq char-after-ip '(?\) ?\]))
+          (goto-char containing-sexp)
+          (setq placeholder (c-point 'boi))
+          (if (and (c-safe (backward-up-list 1) t)
+                   (>= (point) placeholder))
+              (progn
+                (forward-char)
+                (skip-chars-forward " \t"))
+            (goto-char placeholder))
+          (c-add-stmt-syntax 'arglist-close (list containing-sexp) t
                              (c-most-enclosing-brace paren-state (point))
                              paren-state))
 
-        ;; CASE 19: line is an expression, not a statement, and is directly
-        ;; contained by a template delimiter.   Most likely, we are in a
-        ;; template arglist within a statement.  This case is based on CASE
-        ;; 7.   At some point in the future, we may wish to create more
-        ;; syntactic symbols such as `template-intro',
-        ;; `template-cont-nonempty', etc., and distinguish between them as we
-        ;; do for `arglist-intro' etc. (2009-12-07).
-        ((and c-recognize-<>-arglists
-             (setq containing-< (c-up-list-backward indent-point containing-sexp))
-             (eq (char-after containing-<) ?\<))
-        (setq placeholder (c-point 'boi containing-<))
-        (goto-char containing-sexp)     ; Most nested Lbrace/Lparen (but not
-                                        ; '<') before indent-point.
-        (if (>= (point) placeholder)
-            (progn
-              (forward-char)
-              (skip-chars-forward " \t"))
-          (goto-char placeholder))
-        (c-add-stmt-syntax 'template-args-cont (list containing-<) t
-                           (c-most-enclosing-brace c-state-cache (point))
-                           paren-state))
-
          ;; CASE 7B: Looking at the opening brace of an
          ;; in-expression block or brace list.  C.f. cases 4, 16A
          ;; and 17E.
-           ((and (eq char-after-ip ?{)
-                 (progn
-                   (setq placeholder (c-inside-bracelist-p (point)
-                                                           paren-state))
-                   (if placeholder
-                       (setq tmpsymbol '(brace-list-open . inexpr-class))
-                     (setq tmpsymbol '(block-open . inexpr-statement)
-                           placeholder
-                           (cdr-safe (c-looking-at-inexpr-block
-                                      (c-safe-position containing-sexp
-                                                       paren-state)
-                                      containing-sexp)))
-                     ;; placeholder is nil if it's a block directly in
-                     ;; a function arglist.  That makes us skip out of
-                     ;; this case.
-                     )))
-            (goto-char placeholder)
-            (back-to-indentation)
-            (c-add-stmt-syntax (car tmpsymbol) nil t
-                               (c-most-enclosing-brace paren-state (point))
-                               paren-state)
-            (if (/= (point) placeholder)
-                (c-add-syntax (cdr tmpsymbol))))
+         ((and (eq char-after-ip ?{)
+               (progn
+                 (setq placeholder (c-inside-bracelist-p (point)
+                                                         paren-state))
+                 (if placeholder
+                     (setq tmpsymbol '(brace-list-open . inexpr-class))
+                   (setq tmpsymbol '(block-open . inexpr-statement)
+                         placeholder
+                         (cdr-safe (c-looking-at-inexpr-block
+                                    (c-safe-position containing-sexp
+                                                     paren-state)
+                                    containing-sexp)))
+                   ;; placeholder is nil if it's a block directly in
+                   ;; a function arglist.  That makes us skip out of
+                   ;; this case.
+                   )))
+          (goto-char placeholder)
+          (back-to-indentation)
+          (c-add-stmt-syntax (car tmpsymbol) nil t
+                             (c-most-enclosing-brace paren-state (point))
+                             paren-state)
+          (if (/= (point) placeholder)
+              (c-add-syntax (cdr tmpsymbol))))
+
+         ;; CASE 7C: we are looking at the first argument in an empty
+         ;; argument list. Use arglist-close if we're actually
+         ;; looking at a close paren or bracket.
+         ((memq char-before-ip '(?\( ?\[))
+          (goto-char containing-sexp)
+          (setq placeholder (c-point 'boi))
+          (if (and (c-safe (backward-up-list 1) t)
+                   (>= (point) placeholder))
+              (progn
+                (forward-char)
+                (skip-chars-forward " \t"))
+            (goto-char placeholder))
+          (c-add-stmt-syntax 'arglist-intro (list containing-sexp) t
+                             (c-most-enclosing-brace paren-state (point))
+                             paren-state))
 
-           ;; CASE 7C: we are looking at the first argument in an empty
-           ;; argument list. Use arglist-close if we're actually
-           ;; looking at a close paren or bracket.
-           ((memq char-before-ip '(?\( ?\[))
+         ;; CASE 7D: we are inside a conditional test clause. treat
+         ;; these things as statements
+         ((progn
             (goto-char containing-sexp)
-            (setq placeholder (c-point 'boi))
-            (if (and (c-safe (backward-up-list 1) t)
-                     (>= (point) placeholder))
-                (progn
-                  (forward-char)
-                  (skip-chars-forward " \t"))
-              (goto-char placeholder))
-            (c-add-stmt-syntax 'arglist-intro (list containing-sexp) t
-                               (c-most-enclosing-brace paren-state (point))
-                               paren-state))
+            (and (c-safe (c-forward-sexp -1) t)
+                 (looking-at "\\<for\\>[^_]")))
+          (goto-char (1+ containing-sexp))
+          (c-forward-syntactic-ws indent-point)
+          (if (eq char-before-ip ?\;)
+              (c-add-syntax 'statement (point))
+            (c-add-syntax 'statement-cont (point))
+            ))
+
+         ;; CASE 7E: maybe a continued ObjC method call. This is the
+         ;; case when we are inside a [] bracketed exp, and what
+         ;; precede the opening bracket is not an identifier.
+         ((and c-opt-method-key
+               (eq (char-after containing-sexp) ?\[)
+               (progn
+                 (goto-char (1- containing-sexp))
+                 (c-backward-syntactic-ws (c-point 'bod))
+                 (if (not (looking-at c-symbol-key))
+                     (c-add-syntax 'objc-method-call-cont containing-sexp))
+                 )))
 
-           ;; CASE 7D: we are inside a conditional test clause. treat
-           ;; these things as statements
-           ((progn
-              (goto-char containing-sexp)
-              (and (c-safe (c-forward-sexp -1) t)
-                   (looking-at "\\<for\\>[^_]")))
+         ;; CASE 7F: we are looking at an arglist continuation line,
+         ;; but the preceding argument is on the same line as the
+         ;; opening paren.  This case includes multi-line
+         ;; mathematical paren groupings, but we could be on a
+         ;; for-list continuation line.  C.f. case 7A.
+         ((progn
             (goto-char (1+ containing-sexp))
-            (c-forward-syntactic-ws indent-point)
-            (if (eq char-before-ip ?\;)
-                (c-add-syntax 'statement (point))
-              (c-add-syntax 'statement-cont (point))
-              ))
-
-           ;; CASE 7E: maybe a continued ObjC method call. This is the
-           ;; case when we are inside a [] bracketed exp, and what
-           ;; precede the opening bracket is not an identifier.
-           ((and c-opt-method-key
-                 (eq (char-after containing-sexp) ?\[)
-                 (progn
-                   (goto-char (1- containing-sexp))
-                   (c-backward-syntactic-ws (c-point 'bod))
-                   (if (not (looking-at c-symbol-key))
-                       (c-add-syntax 'objc-method-call-cont containing-sexp))
-                   )))
+            (< (save-excursion
+                 (c-forward-syntactic-ws)
+                 (point))
+               (c-point 'bonl)))
+          (goto-char containing-sexp)   ; paren opening the arglist
+          (setq placeholder (c-point 'boi))
+          (if (and (c-safe (backward-up-list 1) t)
+                   (>= (point) placeholder))
+              (progn
+                (forward-char)
+                (skip-chars-forward " \t"))
+            (goto-char placeholder))
+          (c-add-stmt-syntax 'arglist-cont-nonempty (list containing-sexp) t
+                             (c-most-enclosing-brace c-state-cache (point))
+                             paren-state))
 
-           ;; CASE 7F: we are looking at an arglist continuation line,
-           ;; but the preceding argument is on the same line as the
-           ;; opening paren.  This case includes multi-line
-           ;; mathematical paren groupings, but we could be on a
-           ;; for-list continuation line.  C.f. case 7A.
-           ((progn
-              (goto-char (1+ containing-sexp))
-              (< (save-excursion
-                   (c-forward-syntactic-ws)
-                   (point))
-                 (c-point 'bonl)))
-            (goto-char containing-sexp) ; paren opening the arglist
-            (setq placeholder (c-point 'boi))
-            (if (and (c-safe (backward-up-list 1) t)
-                     (>= (point) placeholder))
-                (progn
-                  (forward-char)
-                  (skip-chars-forward " \t"))
-              (goto-char placeholder))
-            (c-add-stmt-syntax 'arglist-cont-nonempty (list containing-sexp) t
-                               (c-most-enclosing-brace c-state-cache (point))
-                               paren-state))
+         ;; CASE 7G: we are looking at just a normal arglist
+         ;; continuation line
+         (t (c-forward-syntactic-ws indent-point)
+            (c-add-syntax 'arglist-cont (c-point 'boi)))
+         ))
 
-           ;; CASE 7G: we are looking at just a normal arglist
-           ;; continuation line
-           (t (c-forward-syntactic-ws indent-point)
-              (c-add-syntax 'arglist-cont (c-point 'boi)))
-           ))
+       ;; CASE 8: func-local multi-inheritance line
+       ((and (c-major-mode-is 'c++-mode)
+             (save-excursion
+               (goto-char indent-point)
+               (skip-chars-forward " \t")
+               (looking-at c-opt-postfix-decl-spec-key)))
+        (goto-char indent-point)
+        (skip-chars-forward " \t")
+        (cond
 
-         ;; CASE 8: func-local multi-inheritance line
-         ((and (c-major-mode-is 'c++-mode)
-               (save-excursion
-                 (goto-char indent-point)
-                 (skip-chars-forward " \t")
-                 (looking-at c-opt-postfix-decl-spec-key)))
-          (goto-char indent-point)
-          (skip-chars-forward " \t")
-          (cond
+         ;; CASE 8A: non-hanging colon on an inher intro
+         ((eq char-after-ip ?:)
+          (c-backward-syntactic-ws lim)
+          (c-add-syntax 'inher-intro (c-point 'boi)))
 
-           ;; CASE 8A: non-hanging colon on an inher intro
-           ((eq char-after-ip ?:)
-            (c-backward-syntactic-ws lim)
-            (c-add-syntax 'inher-intro (c-point 'boi)))
+         ;; CASE 8B: hanging colon on an inher intro
+         ((eq char-before-ip ?:)
+          (c-add-syntax 'inher-intro (c-point 'boi)))
 
-           ;; CASE 8B: hanging colon on an inher intro
-           ((eq char-before-ip ?:)
-            (c-add-syntax 'inher-intro (c-point 'boi)))
+         ;; CASE 8C: a continued inheritance line
+         (t
+          (c-beginning-of-inheritance-list lim)
+          (c-add-syntax 'inher-cont (point))
+          )))
+
+       ;; CASE 9: we are inside a brace-list
+       ((and (not (c-major-mode-is 'awk-mode)) ; Maybe this isn't needed (ACM, 2002/3/29)
+             (setq special-brace-list
+                   (or (and c-special-brace-lists ;;;; ALWAYS NIL FOR AWK!!
+                            (save-excursion
+                              (goto-char containing-sexp)
+                              (c-looking-at-special-brace-list)))
+                       (c-inside-bracelist-p containing-sexp paren-state))))
+        (cond
 
-           ;; CASE 8C: a continued inheritance line
-           (t
-            (c-beginning-of-inheritance-list lim)
-            (c-add-syntax 'inher-cont (point))
-            )))
+         ;; CASE 9A: In the middle of a special brace list opener.
+         ((and (consp special-brace-list)
+               (save-excursion
+                 (goto-char containing-sexp)
+                 (eq (char-after) ?\())
+               (eq char-after-ip (car (cdr special-brace-list))))
+          (goto-char (car (car special-brace-list)))
+          (skip-chars-backward " \t")
+          (if (and (bolp)
+                   (assoc 'statement-cont
+                          (setq placeholder (c-guess-basic-syntax))))
+              (setq c-syntactic-context placeholder)
+            (c-beginning-of-statement-1
+             (c-safe-position (1- containing-sexp) paren-state))
+            (c-forward-token-2 0)
+            (while (looking-at c-specifier-key)
+              (goto-char (match-end 1))
+              (c-forward-syntactic-ws))
+            (c-add-syntax 'brace-list-open (c-point 'boi))))
+
+         ;; CASE 9B: brace-list-close brace
+         ((if (consp special-brace-list)
+              ;; Check special brace list closer.
+              (progn
+                (goto-char (car (car special-brace-list)))
+                (save-excursion
+                  (goto-char indent-point)
+                  (back-to-indentation)
+                  (or
+                   ;; We were between the special close char and the `)'.
+                   (and (eq (char-after) ?\))
+                        (eq (1+ (point)) (cdr (car special-brace-list))))
+                   ;; We were before the special close char.
+                   (and (eq (char-after) (cdr (cdr special-brace-list)))
+                        (zerop (c-forward-token-2))
+                        (eq (1+ (point)) (cdr (car special-brace-list)))))))
+            ;; Normal brace list check.
+            (and (eq char-after-ip ?})
+                 (c-safe (goto-char (c-up-list-backward (point))) t)
+                 (= (point) containing-sexp)))
+          (if (eq (point) (c-point 'boi))
+              (c-add-syntax 'brace-list-close (point))
+            (setq lim (c-most-enclosing-brace c-state-cache (point)))
+            (c-beginning-of-statement-1 lim)
+            (c-add-stmt-syntax 'brace-list-close nil t lim paren-state)))
 
-         ;; CASE 9: we are inside a brace-list
-         ((and (not (c-major-mode-is 'awk-mode))  ; Maybe this isn't needed (ACM, 2002/3/29)
-               (setq special-brace-list
-                     (or (and c-special-brace-lists ;;;; ALWAYS NIL FOR AWK!!
-                              (save-excursion
-                                (goto-char containing-sexp)
-                                (c-looking-at-special-brace-list)))
-                         (c-inside-bracelist-p containing-sexp paren-state))))
+         (t
+          ;; Prepare for the rest of the cases below by going to the
+          ;; token following the opening brace
+          (if (consp special-brace-list)
+              (progn
+                (goto-char (car (car special-brace-list)))
+                (c-forward-token-2 1 nil indent-point))
+            (goto-char containing-sexp))
+          (forward-char)
+          (let ((start (point)))
+            (c-forward-syntactic-ws indent-point)
+            (goto-char (max start (c-point 'bol))))
+          (c-skip-ws-forward indent-point)
           (cond
 
-           ;; CASE 9A: In the middle of a special brace list opener.
-           ((and (consp special-brace-list)
-                 (save-excursion
-                   (goto-char containing-sexp)
-                   (eq (char-after) ?\())
-                 (eq char-after-ip (car (cdr special-brace-list))))
-            (goto-char (car (car special-brace-list)))
-            (skip-chars-backward " \t")
-            (if (and (bolp)
-                     (assoc 'statement-cont
-                            (setq placeholder (c-guess-basic-syntax))))
-                (setq c-syntactic-context placeholder)
-              (c-beginning-of-statement-1
-               (c-safe-position (1- containing-sexp) paren-state))
-              (c-forward-token-2 0)
-              (while (looking-at c-specifier-key)
-                (goto-char (match-end 1))
-                (c-forward-syntactic-ws))
-              (c-add-syntax 'brace-list-open (c-point 'boi))))
-
-           ;; CASE 9B: brace-list-close brace
-           ((if (consp special-brace-list)
-                ;; Check special brace list closer.
-                (progn
-                  (goto-char (car (car special-brace-list)))
-                  (save-excursion
-                    (goto-char indent-point)
-                    (back-to-indentation)
-                    (or
-                     ;; We were between the special close char and the `)'.
-                     (and (eq (char-after) ?\))
-                          (eq (1+ (point)) (cdr (car special-brace-list))))
-                     ;; We were before the special close char.
-                     (and (eq (char-after) (cdr (cdr special-brace-list)))
-                          (zerop (c-forward-token-2))
-                          (eq (1+ (point)) (cdr (car special-brace-list)))))))
-              ;; Normal brace list check.
-              (and (eq char-after-ip ?})
-                   (c-safe (goto-char (c-up-list-backward (point))) t)
-                   (= (point) containing-sexp)))
+           ;; CASE 9C: we're looking at the first line in a brace-list
+           ((= (point) indent-point)
+            (if (consp special-brace-list)
+                (goto-char (car (car special-brace-list)))
+              (goto-char containing-sexp))
             (if (eq (point) (c-point 'boi))
-                (c-add-syntax 'brace-list-close (point))
+                (c-add-syntax 'brace-list-intro (point))
               (setq lim (c-most-enclosing-brace c-state-cache (point)))
               (c-beginning-of-statement-1 lim)
-              (c-add-stmt-syntax 'brace-list-close nil t lim paren-state)))
+              (c-add-stmt-syntax 'brace-list-intro nil t lim paren-state)))
 
-           (t
-            ;; Prepare for the rest of the cases below by going to the
-            ;; token following the opening brace
-            (if (consp special-brace-list)
-                (progn
-                  (goto-char (car (car special-brace-list)))
-                  (c-forward-token-2 1 nil indent-point))
-              (goto-char containing-sexp))
-            (forward-char)
-            (let ((start (point)))
-              (c-forward-syntactic-ws indent-point)
-              (goto-char (max start (c-point 'bol))))
-            (c-skip-ws-forward indent-point)
-            (cond
+           ;; CASE 9D: this is just a later brace-list-entry or
+           ;; brace-entry-open
+           (t (if (or (eq char-after-ip ?{)
+                      (and c-special-brace-lists
+                           (save-excursion
+                             (goto-char indent-point)
+                             (c-forward-syntactic-ws (c-point 'eol))
+                             (c-looking-at-special-brace-list (point)))))
+                  (c-add-syntax 'brace-entry-open (point))
+                (c-add-syntax 'brace-list-entry (point))
+                ))
+           ))))
+
+       ;; CASE 10: A continued statement or top level construct.
+       ((and (not (memq char-before-ip '(?\; ?:)))
+             (not (c-at-vsemi-p before-ws-ip))
+             (or (not (eq char-before-ip ?}))
+                 (c-looking-at-inexpr-block-backward c-state-cache))
+             (> (point)
+                (save-excursion
+                  (c-beginning-of-statement-1 containing-sexp)
+                  (setq placeholder (point))))
+             (/= placeholder containing-sexp))
+        ;; This is shared with case 18.
+        (c-guess-continued-construct indent-point
+                                     char-after-ip
+                                     placeholder
+                                     containing-sexp
+                                     paren-state))
+
+       ;; CASE 16: block close brace, possibly closing the defun or
+       ;; the class
+       ((eq char-after-ip ?})
+        ;; From here on we have the next containing sexp in lim.
+        (setq lim (c-most-enclosing-brace paren-state))
+        (goto-char containing-sexp)
+        (cond
 
-             ;; CASE 9C: we're looking at the first line in a brace-list
-             ((= (point) indent-point)
-              (if (consp special-brace-list)
-                  (goto-char (car (car special-brace-list)))
-                (goto-char containing-sexp))
-              (if (eq (point) (c-point 'boi))
-                  (c-add-syntax 'brace-list-intro (point))
-                (setq lim (c-most-enclosing-brace c-state-cache (point)))
-                (c-beginning-of-statement-1 lim)
-                (c-add-stmt-syntax 'brace-list-intro nil t lim paren-state)))
-
-             ;; CASE 9D: this is just a later brace-list-entry or
-             ;; brace-entry-open
-             (t (if (or (eq char-after-ip ?{)
-                        (and c-special-brace-lists
-                             (save-excursion
-                               (goto-char indent-point)
-                               (c-forward-syntactic-ws (c-point 'eol))
-                               (c-looking-at-special-brace-list (point)))))
-                    (c-add-syntax 'brace-entry-open (point))
-                  (c-add-syntax 'brace-list-entry (point))
-                  ))
-             ))))
-
-         ;; CASE 10: A continued statement or top level construct.
-         ((and (not (memq char-before-ip '(?\; ?:)))
-               (not (c-at-vsemi-p before-ws-ip))
-               (or (not (eq char-before-ip ?}))
-                   (c-looking-at-inexpr-block-backward c-state-cache))
-               (> (point)
-                  (save-excursion
-                    (c-beginning-of-statement-1 containing-sexp)
-                    (setq placeholder (point))))
-               (/= placeholder containing-sexp))
-          ;; This is shared with case 18.
-          (c-guess-continued-construct indent-point
-                                       char-after-ip
-                                       placeholder
-                                       containing-sexp
-                                       paren-state))
-
-         ;; CASE 16: block close brace, possibly closing the defun or
-         ;; the class
-         ((eq char-after-ip ?})
-          ;; From here on we have the next containing sexp in lim.
-          (setq lim (c-most-enclosing-brace paren-state))
+         ;; CASE 16E: Closing a statement block?  This catches
+         ;; cases where it's preceded by a statement keyword,
+         ;; which works even when used in an "invalid" context,
+         ;; e.g. a macro argument.
+         ((c-after-conditional)
+          (c-backward-to-block-anchor lim)
+          (c-add-stmt-syntax 'block-close nil t lim paren-state))
+
+         ;; CASE 16A: closing a lambda defun or an in-expression
+         ;; block?  C.f. cases 4, 7B and 17E.
+         ((setq placeholder (c-looking-at-inexpr-block
+                             (c-safe-position containing-sexp paren-state)
+                             nil))
+          (setq tmpsymbol (if (eq (car placeholder) 'inlambda)
+                              'inline-close
+                            'block-close))
           (goto-char containing-sexp)
-            (cond
+          (back-to-indentation)
+          (if (= containing-sexp (point))
+              (c-add-syntax tmpsymbol (point))
+            (goto-char (cdr placeholder))
+            (back-to-indentation)
+            (c-add-stmt-syntax tmpsymbol nil t
+                               (c-most-enclosing-brace paren-state (point))
+                               paren-state)
+            (if (/= (point) (cdr placeholder))
+                (c-add-syntax (car placeholder)))))
 
-             ;; CASE 16E: Closing a statement block?  This catches
-             ;; cases where it's preceded by a statement keyword,
-             ;; which works even when used in an "invalid" context,
-             ;; e.g. a macro argument.
-             ((c-after-conditional)
-              (c-backward-to-block-anchor lim)
-              (c-add-stmt-syntax 'block-close nil t lim paren-state))
-
-             ;; CASE 16A: closing a lambda defun or an in-expression
-             ;; block?  C.f. cases 4, 7B and 17E.
-             ((setq placeholder (c-looking-at-inexpr-block
-                                 (c-safe-position containing-sexp paren-state)
-                                 nil))
-              (setq tmpsymbol (if (eq (car placeholder) 'inlambda)
-                                  'inline-close
-                                'block-close))
-              (goto-char containing-sexp)
-              (back-to-indentation)
-              (if (= containing-sexp (point))
-                  (c-add-syntax tmpsymbol (point))
-                (goto-char (cdr placeholder))
-                (back-to-indentation)
-                (c-add-stmt-syntax tmpsymbol nil t
-                                   (c-most-enclosing-brace paren-state (point))
-                                   paren-state)
-                (if (/= (point) (cdr placeholder))
-                    (c-add-syntax (car placeholder)))))
-
-             ;; CASE 16B: does this close an inline or a function in
-             ;; a non-class declaration level block?
-             ((save-excursion
-                (and lim
-                     (progn
-                       (goto-char lim)
-                       (c-looking-at-decl-block
-                        (c-most-enclosing-brace paren-state lim)
-                        nil))
-                     (setq placeholder (point))))
-              (c-backward-to-decl-anchor lim)
-              (back-to-indentation)
-              (if (save-excursion
-                    (goto-char placeholder)
-                    (looking-at c-other-decl-block-key))
-                  (c-add-syntax 'defun-close (point))
-                (c-add-syntax 'inline-close (point))))
-
-             ;; CASE 16F: Can be a defun-close of a function declared
-             ;; in a statement block, e.g. in Pike or when using gcc
-             ;; extensions, but watch out for macros followed by
-             ;; blocks.  Let it through to be handled below.
-             ;; C.f. cases B.3 and 17G.
-             ((save-excursion
-                (and (not (c-at-statement-start-p))
-                     (eq (c-beginning-of-statement-1 lim nil nil t) 'same)
-                     (setq placeholder (point))
-                     (let ((c-recognize-typeless-decls nil))
-                       ;; Turn off recognition of constructs that
-                       ;; lacks a type in this case, since that's more
-                       ;; likely to be a macro followed by a block.
-                       (c-forward-decl-or-cast-1 (c-point 'bosws) nil nil))))
-              (back-to-indentation)
-              (if (/= (point) containing-sexp)
-                  (goto-char placeholder))
-              (c-add-stmt-syntax 'defun-close nil t lim paren-state))
-
-             ;; CASE 16C: If there is an enclosing brace then this is
-             ;; a block close since defun closes inside declaration
-             ;; level blocks have been handled above.
-             (lim
-              ;; If the block is preceded by a case/switch label on
-              ;; the same line, we anchor at the first preceding label
-              ;; at boi.  The default handling in c-add-stmt-syntax
-              ;; really fixes it better, but we do like this to keep
-              ;; the indentation compatible with version 5.28 and
-              ;; earlier.  C.f. case 17H.
-              (while (and (/= (setq placeholder (point)) (c-point 'boi))
-                          (eq (c-beginning-of-statement-1 lim) 'label)))
-              (goto-char placeholder)
-              (if (looking-at c-label-kwds-regexp)
-                  (c-add-syntax 'block-close (point))
-                (goto-char containing-sexp)
-                ;; c-backward-to-block-anchor not necessary here; those
-                ;; situations are handled in case 16E above.
-                (c-add-stmt-syntax 'block-close nil t lim paren-state)))
-
-             ;; CASE 16D: Only top level defun close left.
-             (t
-              (goto-char containing-sexp)
-              (c-backward-to-decl-anchor lim)
-              (c-add-stmt-syntax 'defun-close nil nil
-                                 (c-most-enclosing-brace paren-state)
-                                 paren-state))
-             ))
+         ;; CASE 16B: does this close an inline or a function in
+         ;; a non-class declaration level block?
+         ((save-excursion
+            (and lim
+                 (progn
+                   (goto-char lim)
+                   (c-looking-at-decl-block
+                    (c-most-enclosing-brace paren-state lim)
+                    nil))
+                 (setq placeholder (point))))
+          (c-backward-to-decl-anchor lim)
+          (back-to-indentation)
+          (if (save-excursion
+                (goto-char placeholder)
+                (looking-at c-other-decl-block-key))
+              (c-add-syntax 'defun-close (point))
+            (c-add-syntax 'inline-close (point))))
+
+         ;; CASE 16F: Can be a defun-close of a function declared
+         ;; in a statement block, e.g. in Pike or when using gcc
+         ;; extensions, but watch out for macros followed by
+         ;; blocks.  Let it through to be handled below.
+         ;; C.f. cases B.3 and 17G.
+         ((save-excursion
+            (and (not (c-at-statement-start-p))
+                 (eq (c-beginning-of-statement-1 lim nil nil t) 'same)
+                 (setq placeholder (point))
+                 (let ((c-recognize-typeless-decls nil))
+                   ;; Turn off recognition of constructs that
+                   ;; lacks a type in this case, since that's more
+                   ;; likely to be a macro followed by a block.
+                   (c-forward-decl-or-cast-1 (c-point 'bosws) nil nil))))
+          (back-to-indentation)
+          (if (/= (point) containing-sexp)
+              (goto-char placeholder))
+          (c-add-stmt-syntax 'defun-close nil t lim paren-state))
+
+         ;; CASE 16C: If there is an enclosing brace then this is
+         ;; a block close since defun closes inside declaration
+         ;; level blocks have been handled above.
+         (lim
+          ;; If the block is preceded by a case/switch label on
+          ;; the same line, we anchor at the first preceding label
+          ;; at boi.  The default handling in c-add-stmt-syntax
+          ;; really fixes it better, but we do like this to keep
+          ;; the indentation compatible with version 5.28 and
+          ;; earlier.  C.f. case 17H.
+          (while (and (/= (setq placeholder (point)) (c-point 'boi))
+                      (eq (c-beginning-of-statement-1 lim) 'label)))
+          (goto-char placeholder)
+          (if (looking-at c-label-kwds-regexp)
+              (c-add-syntax 'block-close (point))
+            (goto-char containing-sexp)
+            ;; c-backward-to-block-anchor not necessary here; those
+            ;; situations are handled in case 16E above.
+            (c-add-stmt-syntax 'block-close nil t lim paren-state)))
 
-         ;; CASE 17: Statement or defun catchall.
+         ;; CASE 16D: Only top level defun close left.
          (t
-          (goto-char indent-point)
-          ;; Back up statements until we find one that starts at boi.
-          (while (let* ((prev-point (point))
-                        (last-step-type (c-beginning-of-statement-1
-                                         containing-sexp)))
-                   (if (= (point) prev-point)
-                       (progn
-                         (setq step-type (or step-type last-step-type))
-                         nil)
-                     (setq step-type last-step-type)
-                     (/= (point) (c-point 'boi)))))
-          (cond
+          (goto-char containing-sexp)
+          (c-backward-to-decl-anchor lim)
+          (c-add-stmt-syntax 'defun-close nil nil
+                             (c-most-enclosing-brace paren-state)
+                             paren-state))
+         ))
+
+       ;; CASE 19: line is an expression, not a statement, and is directly
+       ;; contained by a template delimiter.    Most likely, we are in a
+       ;; template arglist within a statement.  This case is based on CASE
+       ;; 7.    At some point in the future, we may wish to create more
+       ;; syntactic symbols such as `template-intro',
+       ;; `template-cont-nonempty', etc., and distinguish between them as we
+       ;; do for `arglist-intro' etc. (2009-12-07).
+       ((and c-recognize-<>-arglists
+             (setq containing-< (c-up-list-backward indent-point containing-sexp))
+             (eq (char-after containing-<) ?\<))
+        (setq placeholder (c-point 'boi containing-<))
+        (goto-char containing-sexp)     ; Most nested Lbrace/Lparen (but not
+                                        ; '<') before indent-point.
+        (if (>= (point) placeholder)
+            (progn
+              (forward-char)
+              (skip-chars-forward " \t"))
+          (goto-char placeholder))
+        (c-add-stmt-syntax 'template-args-cont (list containing-<) t
+                           (c-most-enclosing-brace c-state-cache (point))
+                           paren-state))
 
-           ;; CASE 17B: continued statement
-           ((and (eq step-type 'same)
-                 (/= (point) indent-point))
-            (c-add-stmt-syntax 'statement-cont nil nil
-                               containing-sexp paren-state))
-
-           ;; CASE 17A: After a case/default label?
-           ((progn
-              (while (and (eq step-type 'label)
-                          (not (looking-at c-label-kwds-regexp)))
-                (setq step-type
-                      (c-beginning-of-statement-1 containing-sexp)))
-              (eq step-type 'label))
-            (c-add-stmt-syntax (if (eq char-after-ip ?{)
-                                   'statement-case-open
-                                 'statement-case-intro)
-                               nil t containing-sexp paren-state))
-
-           ;; CASE 17D: any old statement
-           ((progn
-              (while (eq step-type 'label)
-                (setq step-type
-                      (c-beginning-of-statement-1 containing-sexp)))
-              (eq step-type 'previous))
-            (c-add-stmt-syntax 'statement nil t
-                               containing-sexp paren-state)
-            (if (eq char-after-ip ?{)
-                (c-add-syntax 'block-open)))
-
-           ;; CASE 17I: Inside a substatement block.
-           ((progn
-              ;; The following tests are all based on containing-sexp.
-              (goto-char containing-sexp)
-              ;; From here on we have the next containing sexp in lim.
-              (setq lim (c-most-enclosing-brace paren-state containing-sexp))
-              (c-after-conditional))
-            (c-backward-to-block-anchor lim)
-            (c-add-stmt-syntax 'statement-block-intro nil t
-                               lim paren-state)
-            (if (eq char-after-ip ?{)
-                (c-add-syntax 'block-open)))
-
-           ;; CASE 17E: first statement in an in-expression block.
-           ;; C.f. cases 4, 7B and 16A.
-           ((setq placeholder (c-looking-at-inexpr-block
-                               (c-safe-position containing-sexp paren-state)
-                               nil))
-            (setq tmpsymbol (if (eq (car placeholder) 'inlambda)
-                                'defun-block-intro
-                              'statement-block-intro))
-            (back-to-indentation)
-            (if (= containing-sexp (point))
-                (c-add-syntax tmpsymbol (point))
-              (goto-char (cdr placeholder))
-              (back-to-indentation)
-              (c-add-stmt-syntax tmpsymbol nil t
-                                 (c-most-enclosing-brace c-state-cache (point))
-                                 paren-state)
-              (if (/= (point) (cdr placeholder))
-                  (c-add-syntax (car placeholder))))
-            (if (eq char-after-ip ?{)
-                (c-add-syntax 'block-open)))
-
-           ;; CASE 17F: first statement in an inline, or first
-           ;; statement in a top-level defun. we can tell this is it
-           ;; if there are no enclosing braces that haven't been
-           ;; narrowed out by a class (i.e. don't use bod here).
-           ((save-excursion
-              (or (not (setq placeholder (c-most-enclosing-brace
-                                          paren-state)))
-                  (and (progn
-                         (goto-char placeholder)
-                         (eq (char-after) ?{))
-                       (c-looking-at-decl-block (c-most-enclosing-brace
-                                                 paren-state (point))
-                                                nil))))
-            (c-backward-to-decl-anchor lim)
-            (back-to-indentation)
-            (c-add-syntax 'defun-block-intro (point)))
+       ;; CASE 17: Statement or defun catchall.
+       (t
+        (goto-char indent-point)
+        ;; Back up statements until we find one that starts at boi.
+        (while (let* ((prev-point (point))
+                      (last-step-type (c-beginning-of-statement-1
+                                       containing-sexp)))
+                 (if (= (point) prev-point)
+                     (progn
+                       (setq step-type (or step-type last-step-type))
+                       nil)
+                   (setq step-type last-step-type)
+                   (/= (point) (c-point 'boi)))))
+        (cond
 
-           ;; CASE 17G: First statement in a function declared inside
-           ;; a normal block.  This can occur in Pike and with
-           ;; e.g. the gcc extensions, but watch out for macros
-           ;; followed by blocks.  C.f. cases B.3 and 16F.
-           ((save-excursion
-              (and (not (c-at-statement-start-p))
-                   (eq (c-beginning-of-statement-1 lim nil nil t) 'same)
-                   (setq placeholder (point))
-                   (let ((c-recognize-typeless-decls nil))
-                     ;; Turn off recognition of constructs that lacks
-                     ;; a type in this case, since that's more likely
-                     ;; to be a macro followed by a block.
-                     (c-forward-decl-or-cast-1 (c-point 'bosws) nil nil))))
+         ;; CASE 17B: continued statement
+         ((and (eq step-type 'same)
+               (/= (point) indent-point))
+          (c-add-stmt-syntax 'statement-cont nil nil
+                             containing-sexp paren-state))
+
+         ;; CASE 17A: After a case/default label?
+         ((progn
+            (while (and (eq step-type 'label)
+                        (not (looking-at c-label-kwds-regexp)))
+              (setq step-type
+                    (c-beginning-of-statement-1 containing-sexp)))
+            (eq step-type 'label))
+          (c-add-stmt-syntax (if (eq char-after-ip ?{)
+                                 'statement-case-open
+                               'statement-case-intro)
+                             nil t containing-sexp paren-state))
+
+         ;; CASE 17D: any old statement
+         ((progn
+            (while (eq step-type 'label)
+              (setq step-type
+                    (c-beginning-of-statement-1 containing-sexp)))
+            (eq step-type 'previous))
+          (c-add-stmt-syntax 'statement nil t
+                             containing-sexp paren-state)
+          (if (eq char-after-ip ?{)
+              (c-add-syntax 'block-open)))
+
+         ;; CASE 17I: Inside a substatement block.
+         ((progn
+            ;; The following tests are all based on containing-sexp.
+            (goto-char containing-sexp)
+            ;; From here on we have the next containing sexp in lim.
+            (setq lim (c-most-enclosing-brace paren-state containing-sexp))
+            (c-after-conditional))
+          (c-backward-to-block-anchor lim)
+          (c-add-stmt-syntax 'statement-block-intro nil t
+                             lim paren-state)
+          (if (eq char-after-ip ?{)
+              (c-add-syntax 'block-open)))
+
+         ;; CASE 17E: first statement in an in-expression block.
+         ;; C.f. cases 4, 7B and 16A.
+         ((setq placeholder (c-looking-at-inexpr-block
+                             (c-safe-position containing-sexp paren-state)
+                             nil))
+          (setq tmpsymbol (if (eq (car placeholder) 'inlambda)
+                              'defun-block-intro
+                            'statement-block-intro))
+          (back-to-indentation)
+          (if (= containing-sexp (point))
+              (c-add-syntax tmpsymbol (point))
+            (goto-char (cdr placeholder))
             (back-to-indentation)
-            (if (/= (point) containing-sexp)
-                (goto-char placeholder))
-            (c-add-stmt-syntax 'defun-block-intro nil t
-                               lim paren-state))
+            (c-add-stmt-syntax tmpsymbol nil t
+                               (c-most-enclosing-brace c-state-cache (point))
+                               paren-state)
+            (if (/= (point) (cdr placeholder))
+                (c-add-syntax (car placeholder))))
+          (if (eq char-after-ip ?{)
+              (c-add-syntax 'block-open)))
+
+         ;; CASE 17F: first statement in an inline, or first
+         ;; statement in a top-level defun. we can tell this is it
+         ;; if there are no enclosing braces that haven't been
+         ;; narrowed out by a class (i.e. don't use bod here).
+         ((save-excursion
+            (or (not (setq placeholder (c-most-enclosing-brace
+                                        paren-state)))
+                (and (progn
+                       (goto-char placeholder)
+                       (eq (char-after) ?{))
+                     (c-looking-at-decl-block (c-most-enclosing-brace
+                                               paren-state (point))
+                                              nil))))
+          (c-backward-to-decl-anchor lim)
+          (back-to-indentation)
+          (c-add-syntax 'defun-block-intro (point)))
 
-           ;; CASE 17H: First statement in a block.
-           (t
-            ;; If the block is preceded by a case/switch label on the
-            ;; same line, we anchor at the first preceding label at
-            ;; boi.  The default handling in c-add-stmt-syntax is
-            ;; really fixes it better, but we do like this to keep the
-            ;; indentation compatible with version 5.28 and earlier.
-            ;; C.f. case 16C.
-            (while (and (/= (setq placeholder (point)) (c-point 'boi))
-                        (eq (c-beginning-of-statement-1 lim) 'label)))
-            (goto-char placeholder)
-            (if (looking-at c-label-kwds-regexp)
-                (c-add-syntax 'statement-block-intro (point))
-              (goto-char containing-sexp)
-              ;; c-backward-to-block-anchor not necessary here; those
-              ;; situations are handled in case 17I above.
-              (c-add-stmt-syntax 'statement-block-intro nil t
-                                 lim paren-state))
-            (if (eq char-after-ip ?{)
-                (c-add-syntax 'block-open)))
-           ))
-         )
+         ;; CASE 17G: First statement in a function declared inside
+         ;; a normal block.  This can occur in Pike and with
+         ;; e.g. the gcc extensions, but watch out for macros
+         ;; followed by blocks.  C.f. cases B.3 and 16F.
+         ((save-excursion
+            (and (not (c-at-statement-start-p))
+                 (eq (c-beginning-of-statement-1 lim nil nil t) 'same)
+                 (setq placeholder (point))
+                 (let ((c-recognize-typeless-decls nil))
+                   ;; Turn off recognition of constructs that lacks
+                   ;; a type in this case, since that's more likely
+                   ;; to be a macro followed by a block.
+                   (c-forward-decl-or-cast-1 (c-point 'bosws) nil nil))))
+          (back-to-indentation)
+          (if (/= (point) containing-sexp)
+              (goto-char placeholder))
+          (c-add-stmt-syntax 'defun-block-intro nil t
+                             lim paren-state))
 
-        ;; now we need to look at any modifiers
-        (goto-char indent-point)
-        (skip-chars-forward " \t")
+         ;; CASE 17H: First statement in a block.
+         (t
+          ;; If the block is preceded by a case/switch label on the
+          ;; same line, we anchor at the first preceding label at
+          ;; boi.  The default handling in c-add-stmt-syntax is
+          ;; really fixes it better, but we do like this to keep the
+          ;; indentation compatible with version 5.28 and earlier.
+          ;; C.f. case 16C.
+          (while (and (/= (setq placeholder (point)) (c-point 'boi))
+                      (eq (c-beginning-of-statement-1 lim) 'label)))
+          (goto-char placeholder)
+          (if (looking-at c-label-kwds-regexp)
+              (c-add-syntax 'statement-block-intro (point))
+            (goto-char containing-sexp)
+            ;; c-backward-to-block-anchor not necessary here; those
+            ;; situations are handled in case 17I above.
+            (c-add-stmt-syntax 'statement-block-intro nil t
+                               lim paren-state))
+          (if (eq char-after-ip ?{)
+              (c-add-syntax 'block-open)))
+         ))
+       )
+
+      ;; now we need to look at any modifiers
+      (goto-char indent-point)
+      (skip-chars-forward " \t")
+
+      ;; are we looking at a comment only line?
+      (when (and (looking-at c-comment-start-regexp)
+                 (/= (c-forward-token-2 0 nil (c-point 'eol)) 0))
+        (c-append-syntax 'comment-intro))
+
+      ;; we might want to give additional offset to friends (in C++).
+      (when (and c-opt-friend-key
+                 (looking-at c-opt-friend-key))
+        (c-append-syntax 'friend))
+
+      ;; Set syntactic-relpos.
+      (let ((p c-syntactic-context))
+        (while (and p
+                    (if (integerp (c-langelem-pos (car p)))
+                        (progn
+                          (setq syntactic-relpos (c-langelem-pos (car p)))
+                          nil)
+                      t))
+          (setq p (cdr p))))
 
-        ;; are we looking at a comment only line?
-        (when (and (looking-at c-comment-start-regexp)
-                   (/= (c-forward-token-2 0 nil (c-point 'eol)) 0))
-          (c-append-syntax 'comment-intro))
-
-        ;; we might want to give additional offset to friends (in C++).
-        (when (and c-opt-friend-key
-                   (looking-at c-opt-friend-key))
-          (c-append-syntax 'friend))
-
-        ;; Set syntactic-relpos.
-        (let ((p c-syntactic-context))
-          (while (and p
-                      (if (integerp (c-langelem-pos (car p)))
-                          (progn
-                            (setq syntactic-relpos (c-langelem-pos (car p)))
-                            nil)
-                        t))
-            (setq p (cdr p))))
-
-        ;; Start of or a continuation of a preprocessor directive?
-        (if (and macro-start
-                 (eq macro-start (c-point 'boi))
-                 (not (and (c-major-mode-is 'pike-mode)
-                           (eq (char-after (1+ macro-start)) ?\"))))
-            (c-append-syntax 'cpp-macro)
-          (when (and c-syntactic-indentation-in-macros macro-start)
-            (if in-macro-expr
-                (when (or
-                       (< syntactic-relpos macro-start)
-                       (not (or
-                             (assq 'arglist-intro c-syntactic-context)
-                             (assq 'arglist-cont c-syntactic-context)
-                             (assq 'arglist-cont-nonempty c-syntactic-context)
-                             (assq 'arglist-close c-syntactic-context))))
-                  ;; If inside a cpp expression, i.e. anywhere in a
-                  ;; cpp directive except a #define body, we only let
-                  ;; through the syntactic analysis that is internal
-                  ;; in the expression.  That means the arglist
-                  ;; elements, if they are anchored inside the cpp
-                  ;; expression.
-                  (setq c-syntactic-context nil)
-                  (c-add-syntax 'cpp-macro-cont macro-start))
-              (when (and (eq macro-start syntactic-relpos)
-                         (not (assq 'cpp-define-intro c-syntactic-context))
-                         (save-excursion
-                           (goto-char macro-start)
-                           (or (not (c-forward-to-cpp-define-body))
-                               (<= (point) (c-point 'boi indent-point)))))
-                ;; Inside a #define body and the syntactic analysis is
-                ;; anchored on the start of the #define.  In this case
-                ;; we add cpp-define-intro to get the extra
-                ;; indentation of the #define body.
-                (c-add-syntax 'cpp-define-intro)))))
-
-        ;; return the syntax
-        c-syntactic-context)))
+      ;; Start of or a continuation of a preprocessor directive?
+      (if (and macro-start
+               (eq macro-start (c-point 'boi))
+               (not (and (c-major-mode-is 'pike-mode)
+                         (eq (char-after (1+ macro-start)) ?\"))))
+          (c-append-syntax 'cpp-macro)
+        (when (and c-syntactic-indentation-in-macros macro-start)
+          (if in-macro-expr
+              (when (or
+                     (< syntactic-relpos macro-start)
+                     (not (or
+                           (assq 'arglist-intro c-syntactic-context)
+                           (assq 'arglist-cont c-syntactic-context)
+                           (assq 'arglist-cont-nonempty c-syntactic-context)
+                           (assq 'arglist-close c-syntactic-context))))
+                ;; If inside a cpp expression, i.e. anywhere in a
+                ;; cpp directive except a #define body, we only let
+                ;; through the syntactic analysis that is internal
+                ;; in the expression.  That means the arglist
+                ;; elements, if they are anchored inside the cpp
+                ;; expression.
+                (setq c-syntactic-context nil)
+                (c-add-syntax 'cpp-macro-cont macro-start))
+            (when (and (eq macro-start syntactic-relpos)
+                       (not (assq 'cpp-define-intro c-syntactic-context))
+                       (save-excursion
+                         (goto-char macro-start)
+                         (or (not (c-forward-to-cpp-define-body))
+                             (<= (point) (c-point 'boi indent-point)))))
+              ;; Inside a #define body and the syntactic analysis is
+              ;; anchored on the start of the #define.  In this case
+              ;; we add cpp-define-intro to get the extra
+              ;; indentation of the #define body.
+              (c-add-syntax 'cpp-define-intro)))))
+
+      ;; return the syntax
+      c-syntactic-context)))
 
 
 ;; Indentation calculation.
diff --git a/lisp/progmodes/gud.el b/lisp/progmodes/gud.el
index 53918b903ee..47cbdf19ed2 100644
--- a/lisp/progmodes/gud.el
+++ b/lisp/progmodes/gud.el
@@ -3127,7 +3127,9 @@ class of the file (using s to separate nested class ids)."
    ("^document\\s-.*\\(\n\\)" (1 "< b"))
    ("^end\\(\\>\\)"
     (1 (ignore
-        (unless (eq (match-beginning 0) (point-min))
+        (when (and (> (match-beginning 0) (point-min))
+                   (eq 1 (nth 7 (save-excursion
+                                  (syntax-ppss (1- (match-beginning 0)))))))
           ;; We change the \n in front, which is more difficult, but results
           ;; in better highlighting.  If the doc is empty, the single \n is
           ;; both the beginning and the end of the docstring, which can't be
diff --git a/src/ChangeLog b/src/ChangeLog
index add827a9dc4..90722187e6c 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,4 +1,4 @@
-2011-03-06  Paul Eggert  <eggert@cs.ucla.edu>
+2011-03-07  Paul Eggert  <eggert@cs.ucla.edu>
 
         * xmenu.c (menu_highlight_callback): Now static.
         (set_frame_menubar): Remove unused local.
@@ -12,10 +12,18 @@
         (note_mouse_highlight): Mark variables that gcc -Wuninitialized
         does not deduce are never used uninitialized.
 
-        * lisp.h (IF_LINT): New macro, copied from ../lib-src/emacsclient.c
-        which in turn is copied from coreutils.
+        * lisp.h (IF_LINT): New macro, copied from ../lib-src/emacsclient.c.
+
+2011-03-06  Chong Yidong  <cyd@stupidchicken.com>
+
+        * xdisp.c (redisplay_window): Revert incorrect logic in 2011-03-06
+        change.
 
-        current_column: Now returns EMACS_INT, fixing some iftc.
+2011-03-06  Paul Eggert  <eggert@cs.ucla.edu>
+
+        current_column: Now returns EMACS_INT, fixing some iftc
+        that was introduced in the 2002-06-02 change "temporarily"; see
+        <http://lists.gnu.org/archive/html/emacs-devel/2002-06/msg00039.html>.
         * bytecode.c (Fbyte_code): Don't cast current_column () to int.
         * cmds.c (internal_self_insert): Likewise.
         * indent.c (Fcurrent_column): Likewise.
@@ -25,7 +33,6 @@
         to int.
         * xdisp.c (redisplay_internal, redisplay_window, decode_mode_spec):
         Likewise.
-
         * cmds.c (internal_self_insert): Declare locals to be EMACS_INT,
         not int or double, if they might contain a column number.
         * indent.c (current_column, Findent_to, indented_beyond_p):
diff --git a/src/xdisp.c b/src/xdisp.c
index f7f887f7850..858a0f74fb1 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -13697,6 +13697,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
   int buffer_unchanged_p = 0;
   int temp_scroll_step = 0;
   int count = SPECPDL_INDEX ();
+  int rc;
   int centering_position = -1;
   int last_line_misfit = 0;
   EMACS_INT beg_unchanged, end_unchanged;
@@ -14008,15 +14009,12 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
   /* Handle case where text has not changed, only point, and it has
      not moved off the frame, and we are not retrying after hscroll.
      (current_matrix_up_to_date_p is nonzero when retrying.)  */
-  if (current_matrix_up_to_date_p)
+  if (current_matrix_up_to_date_p
+      && (rc = try_cursor_movement (window, startp, &temp_scroll_step),
+          rc != CURSOR_MOVEMENT_CANNOT_BE_USED))
     {
-      int rc = try_cursor_movement (window, startp, &temp_scroll_step);
-
       switch (rc)
         {
-        case CURSOR_MOVEMENT_CANNOT_BE_USED:
-          break;
-
         case CURSOR_MOVEMENT_SUCCESS:
           used_current_matrix_p = 1;
           goto done;