+@item brace-else-brace
+Clean up @samp{@} else @{} constructs by placing the entire construct on
+a single line. Clean up occurs when the open brace after the
+@samp{else} is typed. So for example, this:
+
+@example
+@group
+void spam(int i)
+@{
+ if( i==7 ) @{
+ dosomething();
+ @}
+ else
+ @{
+@end group
+@end example
+
+@noindent
+appears like this after the last open brace is typed:
+
+@example
+@group
+void spam(int i)
+@{
+ if( i==7 ) @{
+ dosomething();
+ @} else @{
+@end group
+@end example
+
+@item brace-elseif-brace
+Similar to the @code{brace-else-brace} clean-up, but this cleans up
+@samp{@} else if (...) @{} constructs. For example:
+
+@example
+@group
+void spam(int i)
+@{
+ if( i==7 ) @{
+ dosomething();
+ @}
+ else if( i==3 )
+ @{
+@end group
+@end example
+
+@noindent
+appears like this after the last open parenthesis is typed:
+
+@example
+@group
+void spam(int i)
+@{
+ if( i==7 ) @{
+ dosomething();
+ @} else if(
+@end group
+@end example
+
+@noindent
+and like this after the last open brace is typed:
+
+@example
+@group
+void spam(int i)
+@{
+ if( i==7 ) @{
+ dosomething();
+ @} else if( i==3 ) @{
+@end group
+@end example
+
+@item brace-catch-brace
+Analogous to @code{brace-elseif-brace}, but cleans up @samp{@} catch
+(...) @{} in C++ and Java mode.
+
+@item empty-defun-braces
+Clean up braces following a top-level function or class definition that
+contains no body. Clean up occurs when the closing brace is typed.
+Thus the following:
+
+@example
+@group
+class Spam
+@{
+@}
+@end group
+@end example
+
+@noindent
+is transformed into this when the close brace is typed:
+
+@example
+@group
+class Spam
+@{@}
+@end group
+@end example
+
+@item defun-close-semi
+Clean up the terminating semicolon on top-level function or class
+definitions when they follow a close brace. Clean up occurs when the
+semicolon is typed. So for example, the following:
+
+@example
+@group
+class Spam
+@{
+...
+@}
+;
+@end group
+@end example
+
+@noindent
+is transformed into this when the semicolon is typed:
+
+@example
+@group
+class Spam
+@{
+...
+@};
+@end group
+@end example
+
+@item list-close-comma
+Clean up commas following braces in array and aggregate initializers.
+Clean up occurs when the comma is typed. The space before the comma
+is zapped just like the space before the semicolon in
+@code{defun-close-semi}.
+
+@item scope-operator
+Clean up double colons which might designate a C++ scope operator split
+across multiple lines@footnote{Certain C++ constructs introduce
+ambiguous situations, so @code{scope-operator} clean-ups might not
+always be correct. This usually only occurs when scoped identifiers
+appear in switch label tags.}. Clean up occurs when the second colon is
+typed. You will always want @code{scope-operator} in the
+@code{c-cleanup-list} when you are editing C++ code.
+
+@item one-liner-defun
+Clean up a single line of code enclosed by defun braces by removing
+the whitespace before and after the code. The clean-up happens when
+the closing brace is typed. If the variable
+@code{c-max-one-liner-length} is set, the cleanup is only done if the
+resulting line would be no longer than the value of that variable.
+
+For example, consider this AWK code:
+
+@example
+@group
+BEGIN @{
+ FS = "\t" # use <TAB> as a field separator
+@}
+@end group
+@end example
+
+@noindent
+It gets compacted to the following when the closing brace is typed:
+
+@example
+@group
+BEGIN @{FS = "\t"@} # use <TAB> as a field separator
+@end group
+@end example
+
+@defopt c-max-one-liner-length
+@vindex max-one-liner-length (c-)
+The maximum length of the resulting line for which the clean-up
+@code{one-liner-defun} will be triggered. This length is that of the entire
+line, including any leading whitespace and any trailing comment. Its
+default value is 80. If the value is zero or @code{nil}, no limit
+applies.
+@end defopt
+@end table
+
+The following clean-ups are always active when they occur on
+@code{c-cleanup-list}, regardless of whether Electric minor mode or
+Auto-newline minor mode are enabled:
+
+@table @code
+@item space-before-funcall
+Insert a space between the function name and the opening parenthesis
+of a function call. This produces function calls in the style
+mandated by the GNU coding standards, e.g. @samp{signal@w{ }(SIGINT,
+SIG_IGN)} and @samp{abort@w{ }()}. Clean up occurs when the opening
+parenthesis is typed. This clean-up should never be active in AWK
+Mode, since such a space is syntactically invalid for user defined
+functions.
+
+@item compact-empty-funcall
+Clean up any space between the function name and the opening parenthesis
+of a function call that has no arguments. This is typically used
+together with @code{space-before-funcall} if you prefer the GNU function
+call style for functions with arguments but think it looks ugly when
+it's only an empty parenthesis pair. I.e. you will get @samp{signal
+(SIGINT, SIG_IGN)}, but @samp{abort()}. Clean up occurs when the
+closing parenthesis is typed.
+
+@item comment-close-slash
+When inside a block comment, terminate the comment when you type a slash
+at the beginning of a line (i.e. immediately after the comment prefix).
+This clean-up removes whitespace preceding the slash and if needed,
+inserts a star to complete the token @samp{*/}. Type @kbd{C-q /} in this
+situation if you just want a literal @samp{/} inserted.
+@end table
+
+
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+@node Indentation Engine Basics, Customizing Indentation, Clean-ups, Top
+@comment node-name, next, previous, up
+@chapter Indentation Engine Basics
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+This chapter will briefly cover how @ccmode{} indents lines of code.
+It is helpful to understand the indentation model being used so that
+you will know how to customize @ccmode{} for your personal coding
+style. All the details are in @ref{Customizing Indentation}.
+
+@ccmode{} has an indentation engine that provides a flexible and
+general mechanism for customizing indentation. When @ccmode{} indents
+a line of code, it separates its calculations into two steps:
+
+@enumerate
+@item
+@cindex syntactic symbol
+@cindex anchor position
+It analyzes the line to determine its @dfn{syntactic symbol(s)} (the
+kind of language construct it's looking at) and its @dfn{anchor
+position} (the position earlier in the file that @ccmode{} will indent
+the line relative to). The anchor position might be the location of
+an opening brace in the previous line, for example. @xref{Syntactic
+Analysis}.
+@item
+@cindex offsets
+@cindex indentation offset specifications
+It looks up the syntactic symbol(s) in the configuration to get the
+corresponding @dfn{offset(s)}. The symbol @code{+}, which means
+``indent this line one more level'' is a typical offset. @ccmode{}
+then applies these offset(s) to the anchor position, giving the
+indentation for the line. The different sorts of offsets are
+described in @ref{c-offsets-alist}.
+@end enumerate
+
+In exceptional circumstances, the syntax directed indentation
+described here may be a nuisance rather than a help. You can disable
+it by setting @code{c-syntactic-indentation} to @code{nil}. (To set
+the variable interactively, @ref{Minor Modes}).
+
+@defopt c-syntactic-indentation
+@vindex syntactic-indentation (c-)
+When this is non-@code{nil} (which it is by default), the indentation
+of code is done according to its syntactic structure. When it's
+@code{nil}, every line is just indented to the same level as the
+previous one, and @kbd{TAB} (@code{c-indent-command}) adjusts the
+indentation in steps of @code{c-basic-offset}. The current style
+(@pxref{Config Basics}) then has no effect on indentation, nor do any
+of the variables associated with indentation, not even
+@code{c-special-indent-hook}.
+@end defopt
+
+@menu
+* Syntactic Analysis::
+* Syntactic Symbols::
+* Indentation Calculation::
+@end menu
+
+
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+@node Syntactic Analysis, Syntactic Symbols, Indentation Engine Basics, Indentation Engine Basics
+@comment node-name, next, previous, up
+@section Syntactic Analysis
+@cindex syntactic analysis
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+@cindex syntactic element
+@cindex syntactic context
+The first thing @ccmode{} does when indenting a line of code, is to
+analyze the line, determining the @dfn{syntactic context} of the
+(first) construct on that line. It's a list of @dfn{syntactic
+elements}, where each syntactic element in turn is a list@footnote{In
+@ccmode 5.28 and earlier, a syntactic element was a dotted pair; the
+cons was the syntactic symbol and the cdr was the anchor position.
+For compatibility's sake, the parameter passed to a line-up function
+still has this dotted pair form (@pxref{Custom Line-Up}).} Here is a
+brief and typical example:
+
+@example
+((defun-block-intro 1959))
+@end example
+
+@cindex syntactic symbol
+@noindent
+The first thing inside each syntactic element is always a
+@dfn{syntactic symbol}. It describes the kind of construct that was
+recognized, e.g. @code{statement}, @code{substatement},
+@code{class-open}, @code{class-close}, etc. @xref{Syntactic Symbols},
+for a complete list of currently recognized syntactic symbols and
+their semantics. The remaining entries are various data associated
+with the recognized construct - there might be zero or more.
+
+@cindex anchor position
+Conceptually, a line of code is always indented relative to some
+position higher up in the buffer (typically the indentation of the
+previous line). That position is the @dfn{anchor position} in the
+syntactic element. If there is an entry after the syntactic symbol in
+the syntactic element list then it's either nil or that anchor position.
+
+Here is an example. Suppose we had the following code as the only thing
+in a C++ buffer @footnote{The line numbers in this and future examples
+don't actually appear in the buffer, of course!}:
+
+@example
+ 1: void swap( int& a, int& b )
+ 2: @{
+ 3: int tmp = a;
+ 4: a = b;
+ 5: b = tmp;
+ 6: @}
+@end example
+
+@noindent
+We can use @kbd{C-c C-s} (@code{c-show-syntactic-information}) to
+report what the syntactic analysis is for the current line:
+
+@table @asis
+@item @kbd{C-c C-s} (@code{c-show-syntactic-information})
+@kindex C-c C-s
+@findex c-show-syntactic-information
+@findex show-syntactic-information (c-)
+This command calculates the syntactic analysis of the current line and
+displays it in the minibuffer. The command also highlights the anchor
+position(s).
+@end table
+
+ Running this command on line 4 of this example, we'd see in the echo
+area@footnote{With a universal argument (i.e. @kbd{C-u C-c C-s}) the
+analysis is inserted into the buffer as a comment on the current
+line.}:
+
+@example
+((statement 35))
+@end example
+
+@noindent
+and the @samp{i} of @code{int} on line 3 would be highlighted. This
+tells us that the line is a statement and it is indented relative to
+buffer position 35, the highlighted position. If you were to move
+point to line 3 and hit @kbd{C-c C-s}, you would see:
+
+@example
+((defun-block-intro 29))
+@end example
+
+@noindent
+This indicates that the @samp{int} line is the first statement in a top
+level function block, and is indented relative to buffer position 29,
+which is the brace just after the function header.
+
+Here's another example:
+
+@example
+ 1: int add( int val, int incr, int doit )
+ 2: @{
+ 3: if( doit )
+ 4: @{
+ 5: return( val + incr );
+ 6: @}
+ 7: return( val );
+ 8: @}
+@end example
+
+@noindent
+Hitting @kbd{C-c C-s} on line 4 gives us:
+
+@example
+((substatement-open 46))
+@end example
+
+@cindex substatement
+@cindex substatement block
+@noindent
+which tells us that this is a brace that @emph{opens} a substatement
+block. @footnote{A @dfn{substatement} is the line after a
+conditional statement, such as @code{if}, @code{else}, @code{while},
+@code{do}, @code{switch}, etc. A @dfn{substatement
+block} is a brace block following one of these conditional statements.}
+
+@cindex comment-only line
+Syntactic contexts can contain more than one element, and syntactic
+elements need not have anchor positions. The most common example of
+this is a @dfn{comment-only line}:
+
+@example
+ 1: void draw_list( List<Drawables>& drawables )
+ 2: @{
+ 3: // call the virtual draw() method on each element in list
+ 4: for( int i=0; i < drawables.count(), ++i )
+ 5: @{
+ 6: drawables[i].draw();
+ 7: @}
+ 8: @}
+@end example
+
+@noindent
+Hitting @kbd{C-c C-s} on line 3 of this example gives:
+
+@example
+((comment-intro) (defun-block-intro 46))
+@end example
+
+@noindent
+and you can see that the syntactic context contains two syntactic
+elements. Notice that the first element, @samp{(comment-intro)}, has no
+anchor position.
+
+
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+@node Syntactic Symbols, Indentation Calculation, Syntactic Analysis, Indentation Engine Basics
+@comment node-name, next, previous, up
+@section Syntactic Symbols
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+@cindex syntactic symbols, brief list
+@vindex c-offsets-alist
+@vindex offsets-alist (c-)
+This section is a complete list of the syntactic symbols which appear
+in the @code{c-offsets-alist} style variable, along with brief
+descriptions. The previous section (@pxref{Syntactic Analysis})
+states what syntactic symbols are and how the indentation engine uses
+them.
+
+More detailed descriptions of these symbols, together with snippets of
+source code to which they apply, appear in the examples in the
+subsections below. Note that, in the interests of brevity, the anchor
+position associated with most syntactic symbols is @emph{not}
+specified. In cases of doubt, type @kbd{C-c C-s} on a pertinent
+line---this highlights the anchor position.
+
+@ssindex -open symbols
+@ssindex -close symbols
+@ssindex -block-intro symbols
+The syntactic symbols which indicate brace constructs follow a general
+naming convention. When a line begins with an open or close brace,
+its syntactic symbol will contain the suffix @code{-open} or
+@code{-close} respectively. The first line within the brace block
+construct will contain the suffix @code{-block-intro}.
+
+@ssindex -intro symbols
+@ssindex -cont symbols
+In constructs which can span several lines, a distinction is usually
+made between the first line that introduces the construct and the
+lines that continue it. The syntactic symbols that indicate these
+lines will contain the suffixes @code{-intro} or @code{-cont}
+respectively.
+
+The best way to understand how all this works is by looking at some
+examples. Remember that you can see the syntax of any source code
+line by using @kbd{C-c C-s}.
+
+@table @code
+@item string
+Inside a multiline string. @ref{Literal Symbols}.
+@item c
+Inside a multiline C style block comment. @ref{Literal Symbols}.
+@item defun-open
+Brace that opens a top-level function definition. @ref{Function
+Symbols}.
+@item defun-close
+Brace that closes a top-level function definition. @ref{Function
+Symbols}.
+@item defun-block-intro
+The first line in a top-level defun. @ref{Function Symbols}.
+@item class-open
+Brace that opens a class definition. @ref{Class Symbols}.
+@item class-close
+Brace that closes a class definition. @ref{Class Symbols}.
+@item inline-open
+Brace that opens an in-class inline method. @ref{Class Symbols}.
+@item inline-close
+Brace that closes an in-class inline method. @ref{Class Symbols}.
+@item func-decl-cont
+The region between a function definition's argument list and the
+function opening brace (excluding K&R argument declarations). In C,
+you cannot put anything but whitespace and comments in this region,
+however in C++ and Java, @code{throws} declarations and other things
+can appear here. @ref{Literal Symbols}. @c @emph{FIXME!!! Can it not
+@c go somewhere better?}
+@item knr-argdecl-intro
+First line of a K&R C argument declaration. @ref{K&R Symbols}.
+@item knr-argdecl
+Subsequent lines in a K&R C argument declaration. @ref{K&R Symbols}.
+@item topmost-intro
+The first line in a ``topmost'' definition. @ref{Function Symbols}.
+@item topmost-intro-cont
+Topmost definition continuation lines. This is only used in the parts
+that aren't covered by other symbols such as @code{func-decl-cont} and
+@code{knr-argdecl}. @ref{Function Symbols}.
+@item member-init-intro
+First line in a member initialization list. @ref{Class Symbols}.
+@item member-init-cont
+Subsequent member initialization list lines. @ref{Class Symbols}.
+@item inher-intro
+First line of a multiple inheritance list. @ref{Class Symbols}.
+@item inher-cont
+Subsequent multiple inheritance lines. @ref{Class Symbols}.
+@item block-open
+Statement block open brace. @ref{Literal Symbols}.
+@item block-close
+Statement block close brace. @ref{Conditional Construct Symbols}.
+@item brace-list-open
+Open brace of an enum or static array list. @ref{Brace List Symbols}.
+@item brace-list-close
+Close brace of an enum or static array list. @ref{Brace List Symbols}.
+@item brace-list-intro
+First line in an enum or static array list. @ref{Brace List Symbols}.
+@item brace-list-entry
+Subsequent lines in an enum or static array list. @ref{Brace List
+Symbols}.
+@item brace-entry-open
+Subsequent lines in an enum or static array list where the line begins
+with an open brace. @ref{Brace List Symbols}.
+@item statement
+A statement. @ref{Function Symbols}.
+@item statement-cont
+A continuation of a statement. @ref{Function Symbols}.
+@item statement-block-intro
+The first line in a new statement block. @ref{Conditional Construct
+Symbols}.
+@item statement-case-intro
+The first line in a case block. @ref{Switch Statement Symbols}.
+@item statement-case-open
+The first line in a case block that starts with a brace. @ref{Switch
+Statement Symbols}.
+@item substatement
+The first line after a conditional or loop construct.
+@ref{Conditional Construct Symbols}.
+@item substatement-open
+The brace that opens a substatement block. @ref{Conditional Construct
+Symbols}.
+@item substatement-label
+The first line after a conditional or loop construct if it's a label.
+@ref{Conditional Construct Symbols}.
+@item case-label
+A label in a @code{switch} block. @ref{Switch Statement Symbols}.
+@item access-label
+C++ access control label. @ref{Class Symbols}.
+@item label
+Any other label. @ref{Literal Symbols}.
+@item do-while-closure
+The @code{while} line that ends a @code{do}-@code{while} construct.
+@ref{Conditional Construct Symbols}.
+@item else-clause
+The @code{else} line of an @code{if}-@code{else} construct.
+@ref{Conditional Construct Symbols}.
+@item catch-clause
+The @code{catch} or @code{finally} (in Java) line of a
+@code{try}-@code{catch} construct. @ref{Conditional Construct
+Symbols}.
+@item comment-intro
+A line containing only a comment introduction. @ref{Literal Symbols}.
+@item arglist-intro
+The first line in an argument list. @ref{Paren List Symbols}.
+@item arglist-cont
+Subsequent argument list lines when no arguments follow on the same
+line as the arglist opening paren. @ref{Paren List Symbols}.
+@item arglist-cont-nonempty
+Subsequent argument list lines when at least one argument follows on
+the same line as the arglist opening paren. @ref{Paren List Symbols}.
+@item arglist-close
+The solo close paren of an argument list. @ref{Paren List Symbols}.
+@item stream-op
+Lines continuing a stream operator (C++ only). @ref{Literal
+Symbols}. @c @emph{FIXME!!! Can this not be moved somewhere better?}
+@item inclass
+The line is nested inside a class definition. @ref{Class Symbols}.
+@item cpp-macro
+The start of a preprocessor macro definition. @ref{Literal Symbols}.
+@item cpp-define-intro
+The first line inside a multiline preprocessor macro if
+@code{c-syntactic-indentation-in-macros} is set. @ref{Multiline Macro
+Symbols}.
+@item cpp-macro-cont
+All lines inside multiline preprocessor macros if
+@code{c-syntactic-indentation-in-macros} is @code{nil}.
+@ref{Multiline Macro Symbols}.
+@item friend
+A C++ friend declaration. @ref{Class Symbols}.
+@item objc-method-intro
+The first line of an Objective-C method definition. @ref{Objective-C
+Method Symbols}.
+@item objc-method-args-cont
+Lines continuing an Objective-C method definition. @ref{Objective-C
+Method Symbols}.
+@item objc-method-call-cont
+Lines continuing an Objective-C method call. @ref{Objective-C Method
+Symbols}.
+@item extern-lang-open
+Brace that opens an @code{extern} block (e.g. @code{extern "C"
+@{...@}}). @ref{External Scope Symbols}.
+@item extern-lang-close
+Brace that closes an @code{extern} block. @ref{External Scope
+Symbols}.
+@item inextern-lang
+Analogous to @code{inclass} syntactic symbol, but used inside
+@code{extern} blocks. @ref{External Scope Symbols}.
+@item namespace-open
+@itemx namespace-close
+@itemx innamespace
+These are analogous to the three @code{extern-lang} symbols above, but
+are returned for C++ namespace blocks. @ref{External Scope Symbols}.
+@item module-open
+@itemx module-close
+@itemx inmodule
+Analogous to the above, but for CORBA IDL @code{module} blocks.
+@ref{External Scope Symbols}.
+@item composition-open
+@itemx composition-close
+@itemx incomposition
+Analogous to the above, but for CORBA CIDL @code{composition} blocks.
+@ref{External Scope Symbols}.
+@item template-args-cont
+C++ template argument list continuations. @ref{Class Symbols}.
+@item inlambda
+Analogous to @code{inclass} syntactic symbol, but used inside lambda
+(i.e. anonymous) functions. Only used in Pike mode. @ref{Statement
+Block Symbols}.
+@item lambda-intro-cont
+Lines continuing the header of a lambda function, i.e. between the
+@code{lambda} keyword and the function body. Only used in Pike mode.
+@ref{Statement Block Symbols}.
+@item inexpr-statement
+A statement block inside an expression. The gcc C and C++ extension
+for this is recognized. It's also used for the special functions that
+take a statement block as an argument in Pike. @ref{Statement Block
+Symbols}.
+@item inexpr-class
+A class definition inside an expression. This is used for anonymous
+classes in Java. It's also used for anonymous array initializers in
+Java. @ref{Anonymous Class Symbol}.
+@end table
+
+@menu
+* Function Symbols::
+* Class Symbols::
+* Conditional Construct Symbols::
+* Switch Statement Symbols::
+* Brace List Symbols::
+* External Scope Symbols::
+* Paren List Symbols::
+* Literal Symbols::
+* Multiline Macro Symbols::
+* Objective-C Method Symbols::
+* Anonymous Class Symbol::
+* Statement Block Symbols::
+* K&R Symbols::
+@end menu
+
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+@node Function Symbols, Class Symbols, Syntactic Symbols, Syntactic Symbols
+@comment node-name, next, previous, up
+@subsection Function Symbols
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+This example shows a typical function declaration.
+
+@example
+ 1: void
+ 2: swap( int& a, int& b )
+ 3: @{
+ 4: int tmp = a;
+ 5: a = b;
+ 6: b = tmp;
+ 7: int ignored =
+ 8: a + b;
+ 9: @}
+@end example
+
+@ssindex topmost-intro
+@ssindex topmost-intro-cont
+@ssindex defun-open
+@ssindex defun-close
+@ssindex defun-block-intro
+Line 1 shows a @code{topmost-intro} since it is the first line that
+introduces a top-level construct. Line 2 is a continuation of the
+top-level construct introduction so it has the syntax
+@code{topmost-intro-cont}. Line 3 shows a @code{defun-open} since it is
+the brace that opens a top-level function definition. Line 9 is the
+corresponding
+@code{defun-close} since it contains the brace that closes the top-level
+function definition. Line 4 is a @code{defun-block-intro}, i.e. it is
+the first line of a brace-block, enclosed in a
+top-level function definition.
+
+@ssindex statement
+@ssindex statement-cont
+Lines 5, 6, and 7 are all given @code{statement} syntax since there
+isn't much special about them. Note however that line 8 is given
+@code{statement-cont} syntax since it continues the statement begun
+on the previous line.
+
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+@node Class Symbols, Conditional Construct Symbols, Function Symbols, Syntactic Symbols
+@comment node-name, next, previous, up
+@subsection Class related Symbols
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+Here's an example which illustrates some C++ class syntactic symbols:
+
+@example
+ 1: class Bass
+ 2: : public Guitar,
+ 3: public Amplifiable
+ 4: @{
+ 5: public:
+ 6: Bass()
+ 7: : eString( new BassString( 0.105 )),
+ 8: aString( new BassString( 0.085 )),
+ 9: dString( new BassString( 0.065 )),
+10: gString( new BassString( 0.045 ))
+11: @{
+12: eString.tune( 'E' );
+13: aString.tune( 'A' );
+14: dString.tune( 'D' );
+15: gString.tune( 'G' );
+16: @}
+17: friend class Luthier;
+18: @};
+@end example
+
+@ssindex class-open
+@ssindex class-close
+As in the previous example, line 1 has the @code{topmost-intro} syntax.
+Here however, the brace that opens a C++ class definition on line 4 is
+assigned the @code{class-open} syntax. Note that in C++, classes,
+structs, and unions are essentially equivalent syntactically (and are
+very similar semantically), so replacing the @code{class} keyword in the
+example above with @code{struct} or @code{union} would still result in a
+syntax of @code{class-open} for line 4 @footnote{This is the case even
+for C and Objective-C. For consistency, structs in all supported
+languages are syntactically equivalent to classes. Note however that
+the keyword @code{class} is meaningless in C and Objective-C.}.
+Similarly, line 18 is assigned @code{class-close} syntax.
+
+@ssindex inher-intro
+@ssindex inher-cont
+Line 2 introduces the inheritance list for the class so it is assigned
+the @code{inher-intro} syntax, and line 3, which continues the
+inheritance list is given @code{inher-cont} syntax.
+
+@ssindex access-label
+@ssindex inclass
+Hitting @kbd{C-c C-s} on line 5 shows the following analysis:
+
+@example
+((inclass 58) (access-label 58))
+@end example
+
+@noindent
+The primary syntactic symbol for this line is @code{access-label} as
+this a label keyword that specifies access protection in C++. However,
+because this line is also a top-level construct inside a class
+definition, the analysis actually shows two syntactic symbols. The
+other syntactic symbol assigned to this line is @code{inclass}.
+Similarly, line 6 is given both @code{inclass} and @code{topmost-intro}
+syntax:
+
+@example
+((inclass 58) (topmost-intro 60))
+@end example
+
+@ssindex member-init-intro
+@ssindex member-init-cont
+Line 7 introduces a C++ member initialization list and as such is given
+@code{member-init-intro} syntax. Note that in this case it is
+@emph{not} assigned @code{inclass} since this is not considered a
+top-level construct. Lines 8 through 10 are all assigned
+@code{member-init-cont} since they continue the member initialization
+list started on line 7.
+
+@cindex in-class inline methods
+@ssindex inline-open
+@ssindex inline-close
+Line 11's analysis is a bit more complicated:
+
+@example
+((inclass 58) (inline-open))
+@end example
+
+This line is assigned a syntax of both @code{inline-open} and
+@code{inclass} because it opens an @dfn{in-class} C++ inline method
+definition. This is distinct from, but related to, the C++ notion of an
+inline function in that its definition occurs inside an enclosing class
+definition, which in C++ implies that the function should be inlined.
+However, if the definition of the @code{Bass} constructor appeared
+outside the class definition, the construct would be given the
+@code{defun-open} syntax, even if the keyword @code{inline} appeared
+before the method name, as in:
+
+@example
+ 1: class Bass
+ 2: : public Guitar,
+ 3: public Amplifiable
+ 4: @{
+ 5: public:
+ 6: Bass();
+ 7: @};
+ 8:
+ 9: inline
+10: Bass::Bass()
+11: : eString( new BassString( 0.105 )),
+12: aString( new BassString( 0.085 )),
+13: dString( new BassString( 0.065 )),
+14: gString( new BassString( 0.045 ))
+15: @{
+16: eString.tune( 'E' );
+17: aString.tune( 'A' );
+18: dString.tune( 'D' );
+19: gString.tune( 'G' );
+20: @}
+@end example
+
+@ssindex friend
+Returning to the previous example, line 16 is given @code{inline-close}
+syntax, while line 12 is given @code{defun-block-open} syntax, and lines
+13 through 15 are all given @code{statement} syntax. Line 17 is
+interesting in that its syntactic analysis list contains three
+elements:
+
+@example
+((inclass 58) (topmost-intro 380) (friend))
+@end example
+
+The @code{friend} and @code{inline-open} syntactic symbols are
+modifiers that do not have anchor positions.
+
+@ssindex template-args-cont
+Template definitions introduce yet another syntactic symbol:
+
+@example
+ 1: ThingManager <int,
+ 2: Framework::Callback *,
+ 3: Mutex> framework_callbacks;
+@end example
+
+Here, line 1 is analyzed as a @code{topmost-intro}, but lines 2 and 3
+are both analyzed as @code{template-args-cont} lines.
+
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+@node Conditional Construct Symbols, Switch Statement Symbols, Class Symbols, Syntactic Symbols
+@comment node-name, next, previous, up
+@subsection Conditional Construct Symbols
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+Here is a (totally contrived) example which illustrates how syntax is
+assigned to various conditional constructs:
+
+@example
+ 1: void spam( int index )
+ 2: @{
+ 3: for( int i=0; i<index; i++ )
+ 4: @{
+ 5: if( i == 10 )
+ 6: do_something_special();
+ 7: else
+ 8: silly_label:
+ 9: do_something( i );
+10: @}
+11: do @{
+12: another_thing( i-- );
+13: @}
+14: while( i > 0 );
+15: @}
+@end example
+
+Only the lines that illustrate new syntactic symbols will be discussed.
+
+@ssindex substatement-open
+@ssindex statement-block-intro
+@ssindex block-close
+Line 4 has a brace which opens a conditional's substatement block. It
+is thus assigned @code{substatement-open} syntax, and since line 5 is
+the first line in the substatement block, it is assigned
+@code{statement-block-intro} syntax. Line 10 contains the brace
+that closes the inner substatement block, and is therefore given the
+syntax @code{block-close}@footnote{@code{block-open} is used only for
+``free-standing'' blocks, and is somewhat rare (@pxref{Literal
+Symbols} for an example.)}. Line 13 is treated the same way.
+
+@ssindex substatement
+Lines 6 and 9 are also substatements of conditionals, but since they
+don't start blocks they are given @code{substatement} syntax
+instead of @code{substatement-open}.
+
+@ssindex substatement-label
+Line 8 contains a label, which is normally given @code{label} syntax.
+This one is however a bit special since it's between a conditional and
+its substatement. It's analyzed as @code{substatement-label} to let you
+handle this rather odd case differently from normal labels.
+
+@ssindex else-clause
+@ssindex catch-clause
+Line 7 start with an @code{else} that matches the @code{if} statement on
+line 5. It is therefore given the @code{else-clause} syntax and is
+anchored on the matching @code{if}. The @code{try}-@code{catch}
+constructs in C++ and Java are treated this way too, except that
+@code{catch} and (in Java) @code{finally}, are marked with
+@code{catch-clause}.
+
+@ssindex do-while-closure
+The @code{while} construct on line 14 that closes a @code{do}
+conditional is given the special syntax @code{do-while-closure} if it
+appears on a line by itself. Note that if the @code{while} appeared on
+the same line as the preceding close brace, that line would still have
+@code{block-close} syntax.
+
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+@node Switch Statement Symbols, Brace List Symbols, Conditional Construct Symbols, Syntactic Symbols
+@comment node-name, next, previous, up
+@subsection Switch Statement Symbols
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+Switch statements have their own set of syntactic symbols. Here's an
+example:
+
+@example
+ 1: void spam( enum Ingredient i )
+ 2: @{
+ 3: switch( i ) @{
+ 4: case Ham:
+ 5: be_a_pig();
+ 6: break;
+ 7: case Salt:
+ 8: drink_some_water();
+ 9: break;
+10: default:
+11: @{
+12: what_is_it();
+13: break;
+14: @}
+15: @}
+14: @}
+@end example
+
+@ssindex case-label
+@ssindex statement-case-intro
+@ssindex statement-case-open
+Here, lines 4, 7, and 10 are all assigned @code{case-label} syntax,
+while lines 5 and 8 are assigned @code{statement-case-intro}. Line 11
+is treated slightly differently since it contains a brace that opens a
+block --- it is given @code{statement-case-open} syntax.
+
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+@node Brace List Symbols, External Scope Symbols, Switch Statement Symbols, Syntactic Symbols
+@comment node-name, next, previous, up
+@subsection Brace List Symbols
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+@cindex brace lists
+There are a set of syntactic symbols that are used to recognize
+constructs inside of brace lists. A brace list is defined as an
+@code{enum} or aggregate initializer list, such as might statically
+initialize an array of structs. The three special aggregate constructs
+in Pike, @code{(@{ @})}, @code{([ ])} and @code{(< >)}, are treated as
+brace lists too. An example:
+
+@example
+ 1: static char* ingredients[] =
+ 2: @{
+ 3: "Ham",
+ 4: "Salt",
+ 5: NULL
+ 6: @};
+@end example
+
+@ssindex brace-list-open
+@ssindex brace-list-intro
+@ssindex brace-list-close
+@ssindex brace-list-entry
+Following convention, line 2 in this example is assigned
+@code{brace-list-open} syntax, and line 3 is assigned
+@code{brace-list-intro} syntax. Likewise, line 6 is assigned
+@code{brace-list-close} syntax. Lines 4 and 5 however, are assigned
+@code{brace-list-entry} syntax, as would all subsequent lines in this
+initializer list.
+
+@ssindex brace-entry-open
+Your static initializer might be initializing nested structures, for
+example:
+
+@example
+ 1: struct intpairs[] =
+ 2: @{
+ 3: @{ 1, 2 @},
+ 4: @{
+ 5: 3,
+ 6: 4
+ 7: @}
+ 8: @{ 1,
+ 9: 2 @},
+10: @{ 3, 4 @}
+11: @};
+@end example
+
+Here, you've already seen the analysis of lines 1, 2, 3, and 11. On
+line 4, things get interesting; this line is assigned
+@code{brace-entry-open} syntactic symbol because it's a bracelist entry
+line that starts with an open brace. Lines 5 and 6 (and line 9) are
+pretty standard, and line 7 is a @code{brace-list-close} as you'd
+expect. Once again, line 8 is assigned as @code{brace-entry-open} as is
+line 10.
+
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+@node External Scope Symbols, Paren List Symbols, Brace List Symbols, Syntactic Symbols
+@comment node-name, next, previous, up
+@subsection External Scope Symbols
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+External language definition blocks also have their own syntactic
+symbols. In this example:
+
+@example
+ 1: extern "C"
+ 2: @{
+ 3: int thing_one( int );
+ 4: int thing_two( double );
+ 5: @}
+@end example
+
+@ssindex extern-lang-open
+@ssindex extern-lang-close
+@ssindex inextern-lang
+@ssindex inclass
+@noindent
+line 2 is given the @code{extern-lang-open} syntax, while line 5 is given
+the @code{extern-lang-close} syntax. The analysis for line 3 yields:
+
+@example
+((inextern-lang) (topmost-intro 14))
+@end example
+
+@noindent
+where @code{inextern-lang} is a modifier similar in purpose to
+@code{inclass}.
+
+There are various other top level blocks like @code{extern}, and they
+are all treated in the same way except that the symbols are named after
+the keyword that introduces the block. E.g. C++ namespace blocks get
+the three symbols @code{namespace-open}, @code{namespace-close} and
+@code{innamespace}. The currently recognized top level blocks are:
+
+@table @asis
+@item @code{extern-lang-open}, @code{extern-lang-close}, @code{inextern-lang}
+@code{extern} blocks in C and C++.@footnote{These should logically be
+named @code{extern-open}, @code{extern-close} and @code{inextern}, but
+that isn't the case for historical reasons.}
+
+@item @code{namespace-open}, @code{namespace-close}, @code{innamespace}
+@ssindex namespace-open
+@ssindex namespace-close
+@ssindex innamespace
+@code{namespace} blocks in C++.
+
+@item @code{module-open}, @code{module-close}, @code{inmodule}
+@ssindex module-open
+@ssindex module-close
+@ssindex inmodule
+@code{module} blocks in CORBA IDL.
+
+@item @code{composition-open}, @code{composition-close}, @code{incomposition}
+@ssindex composition-open
+@ssindex composition-close
+@ssindex incomposition
+@code{composition} blocks in CORBA CIDL.
+@end table
+
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+@node Paren List Symbols, Literal Symbols, External Scope Symbols, Syntactic Symbols
+@comment node-name, next, previous, up
+@subsection Parenthesis (Argument) List Symbols
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+A number of syntactic symbols are associated with parenthesis lists,
+a.k.a argument lists, as found in function declarations and function
+calls. This example illustrates these:
+
+@example
+ 1: void a_function( int line1,
+ 2: int line2 );
+ 3:
+ 4: void a_longer_function(
+ 5: int line1,
+ 6: int line2
+ 7: );
+ 8:
+ 9: void call_them( int line1, int line2 )
+10: @{
+11: a_function(
+12: line1,
+13: line2
+14: );
+15:
+16: a_longer_function( line1,
+17: line2 );
+18: @}
+@end example
+
+@ssindex arglist-intro
+@ssindex arglist-close
+Lines 5 and 12 are assigned @code{arglist-intro} syntax since they are
+the first line following the open parenthesis, and lines 7 and 14 are
+assigned @code{arglist-close} syntax since they contain the parenthesis
+that closes the argument list.
+
+@ssindex arglist-cont-nonempty
+@ssindex arglist-cont
+Lines that continue argument lists can be assigned one of two syntactic
+symbols. For example, Lines 2 and 17
+are assigned @code{arglist-cont-nonempty} syntax. What this means
+is that they continue an argument list, but that the line containing the
+parenthesis that opens the list is @emph{not empty} following the open
+parenthesis. Contrast this against lines 6 and 13 which are assigned
+@code{arglist-cont} syntax. This is because the parenthesis that opens
+their argument lists is the last character on that line.
+
+Syntactic elements with @code{arglist-intro},
+@code{arglist-cont-nonempty}, and @code{arglist-close} contain two
+buffer positions: the anchor position (the beginning of the
+declaration or statement) and the position of the open parenthesis.
+The latter position can be used in a line-up function (@pxref{Line-Up
+Functions}).
+
+Note that there is no @code{arglist-open} syntax. This is because any
+parenthesis that opens an argument list, appearing on a separate line,
+is assigned the @code{statement-cont} syntax instead.
+
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+@node Literal Symbols, Multiline Macro Symbols, Paren List Symbols, Syntactic Symbols
+@comment node-name, next, previous, up
+@subsection Comment String Label and Macro Symbols
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+A few miscellaneous syntactic symbols that haven't been previously
+covered are illustrated by this C++ example:
+
+@example
+ 1: void Bass::play( int volume )
+ 2: const
+ 3: @{
+ 4: /* this line starts a multiline
+ 5: * comment. This line should get `c' syntax */
+ 6:
+ 7: char* a_multiline_string = "This line starts a multiline \
+ 8: string. This line should get `string' syntax.";
+ 9:
+10: note:
+11: @{
+12: #ifdef LOCK
+13: Lock acquire();
+14: #endif // LOCK
+15: slap_pop();
+16: cout << "I played "
+17: << "a note\n";
+18: @}
+19: @}
+@end example
+
+The lines to note in this example include:
+
+@itemize @bullet
+@item
+@ssindex func-decl-cont
+Line 2 is assigned the @code{func-decl-cont} syntax.
+
+@item
+@ssindex comment-intro
+Line 4 is assigned both @code{defun-block-intro} @emph{and}
+@code{comment-intro} syntax. A syntactic element with
+@code{comment-intro} has no anchor point --- It is always accompanied
+by another syntactic element which does have one.
+
+@item
+@ssindex c
+Line 5 is assigned @code{c} syntax.
+
+@item
+@cindex syntactic whitespace
+Line 6 which, even though it contains nothing but whitespace, is
+assigned @code{defun-block-intro}. Note that the appearance of the
+comment on lines 4 and 5 do not cause line 6 to be assigned
+@code{statement} syntax because comments are considered to be
+@dfn{syntactic whitespace}, which are ignored when analyzing
+code.
+
+@item
+@ssindex string
+Line 8 is assigned @code{string} syntax.
+
+@item
+@ssindex label
+Line 10 is assigned @code{label} syntax.
+
+@item
+@ssindex block-open
+Line 11 is assigned @code{block-open} as well as @code{statement}
+syntax. A @code{block-open} syntactic element doesn't have an anchor
+position, since it always appears with another syntactic element which
+does have one.
+
+@item
+@ssindex cpp-macro
+Lines 12 and 14 are assigned @code{cpp-macro} syntax in addition to the
+normal syntactic symbols (@code{statement-block-intro} and
+@code{statement}, respectively). Normally @code{cpp-macro} is
+configured to cancel out the normal syntactic context to make all
+preprocessor directives stick to the first column, but that's easily
+changed if you want preprocessor directives to be indented like the rest
+of the code. Like @code{comment-intro}, a syntactic element with
+@code{cpp-macro} doesn't contain an anchor position.
+
+@item
+@ssindex stream-op
+Line 17 is assigned @code{stream-op} syntax.
+@end itemize
+
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+@node Multiline Macro Symbols, Objective-C Method Symbols, Literal Symbols, Syntactic Symbols
+@comment node-name, next, previous, up
+@subsection Multiline Macro Symbols
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+@cindex multiline macros
+@cindex syntactic whitespace
+@ssindex cpp-define-intro
+@ssindex cpp-macro-cont
+Multiline preprocessor macro definitions are normally handled just like
+other code, i.e. the lines inside them are indented according to the
+syntactic analysis of the preceding lines inside the macro. The first
+line inside a macro definition (i.e. the line after the starting line of
+the cpp directive itself) gets @code{cpp-define-intro}. In this example:
+
+@example
+ 1: #define LIST_LOOP(cons, listp) \
+ 2: for (cons = listp; !NILP (cons); cons = XCDR (cons)) \
+ 3: if (!CONSP (cons)) \
+ 4: signal_error ("Invalid list format", listp); \
+ 5: else
+@end example
+
+@noindent
+line 1 is given the syntactic symbol @code{cpp-macro}. The first line
+of a cpp directive is always given that symbol. Line 2 is given
+@code{cpp-define-intro}, so that you can give the macro body as a whole
+some extra indentation. Lines 3 through 5 are then analyzed as normal
+code, i.e. @code{substatement} on lines 3 and 4, and @code{else-clause}
+on line 5.
+
+The syntactic analysis inside macros can be turned off with
+@code{c-syntactic-indentation-in-macros} (@pxref{Custom Macros}). In
+that case, lines 2 through 5 would all be given @code{cpp-macro-cont}
+with an anchor position pointing to the @code{#} which starts the cpp
+directive@footnote{This is how @ccmode{} 5.28 and earlier analyzed
+macros.}.
+
+@xref{Custom Macros}, for more info about the treatment of macros.
+
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+@node Objective-C Method Symbols, Anonymous Class Symbol, Multiline Macro Symbols, Syntactic Symbols
+@comment node-name, next, previous, up
+@subsection Objective-C Method Symbols
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+In Objective-C buffers, there are three additional syntactic symbols
+assigned to various message calling constructs. Here's an example
+illustrating these:
+
+@example
+ 1: - (void)setDelegate:anObject
+ 2: withStuff:stuff
+ 3: @{
+ 4: [delegate masterWillRebind:self
+ 5: toDelegate:anObject
+ 6: withExtraStuff:stuff];
+ 7: @}
+@end example
+
+@ssindex objc-method-intro
+@ssindex objc-method-args-cont
+@ssindex objc-method-call-cont
+Here, line 1 is assigned @code{objc-method-intro} syntax, and line 2 is
+assigned @code{objc-method-args-cont} syntax. Lines 5 and 6 are both
+assigned @code{objc-method-call-cont} syntax.
+
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+@node Anonymous Class Symbol, Statement Block Symbols, Objective-C Method Symbols, Syntactic Symbols
+@comment node-name, next, previous, up
+@subsection Anonymous Class Symbol (Java)
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+Java has a concept of anonymous classes which can look something like
+this:
+
+@example
+ 1: public void watch(Observable o) @{
+ 2: o.addObserver(new Observer() @{
+ 3: public void update(Observable o, Object arg) @{
+ 4: history.addElement(arg);
+ 5: @}
+ 6: @});
+ 7: @}
+@end example
+
+@ssindex inexpr-class
+The brace following the @code{new} operator opens the anonymous class.
+Lines 3 and 6 are assigned the @code{inexpr-class} syntax, besides the
+@code{inclass} symbol used in normal classes. Thus, the class will be
+indented just like a normal class, with the added indentation given to
+@code{inexpr-class}. An @code{inexpr-class} syntactic element doesn't
+have an anchor position.
+
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+@node Statement Block Symbols, K&R Symbols, Anonymous Class Symbol, Syntactic Symbols
+@comment node-name, next, previous, up
+@subsection Statement Block Symbols
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+There are a few occasions where a statement block might be used inside
+an expression. One is in C or C++ code using the gcc extension for
+this, e.g:
+
+@example
+ 1: int res = (@{
+ 2: int y = foo (); int z;
+ 3: if (y > 0) z = y; else z = - y;
+ 4: z;
+ 5: @});
+@end example
+
+@ssindex inexpr-statement
+Lines 2 and 5 get the @code{inexpr-statement} syntax, besides the
+symbols they'd get in a normal block. Therefore, the indentation put on
+@code{inexpr-statement} is added to the normal statement block
+indentation. An @code{inexpr-statement} syntactic element doesn't
+contain an anchor position.
+
+In Pike code, there are a few other situations where blocks occur inside
+statements, as illustrated here:
+
+@example
+ 1: array itgob()
+ 2: @{
+ 3: string s = map (backtrace()[-2][3..],
+ 4: lambda
+ 5: (mixed arg)
+ 6: @{
+ 7: return sprintf ("%t", arg);
+ 8: @}) * ", " + "\n";
+ 9: return catch @{
+10: write (s + "\n");
+11: @};
+12: @}
+@end example
+
+@ssindex inlambda
+@ssindex lambda-intro-cont
+Lines 4 through 8 contain a lambda function, which @ccmode{} recognizes
+by the @code{lambda} keyword. If the function argument list is put
+on a line of its own, as in line 5, it gets the @code{lambda-intro-cont}
+syntax. The function body is handled as an inline method body, with the
+addition of the @code{inlambda} syntactic symbol. This means that line
+6 gets @code{inlambda} and @code{inline-open}, and line 8 gets
+@code{inline-close}@footnote{You might wonder why it doesn't get
+@code{inlambda} too. It's because the closing brace is relative to the
+opening brace, which stands on its own line in this example. If the
+opening brace was hanging on the previous line, then the closing brace
+would get the @code{inlambda} syntax too to be indented correctly.}.
+
+@ssindex inexpr-statement
+On line 9, @code{catch} is a special function taking a statement block
+as its argument. The block is handled as an in-expression statement
+with the @code{inexpr-statement} syntax, just like the gcc extended C
+example above. The other similar special function, @code{gauge}, is
+handled like this too.
+
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+@node K&R Symbols, , Statement Block Symbols, Syntactic Symbols
+@comment node-name, next, previous, up
+@subsection K&R Symbols
+@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+@ssindex knr-argdecl-intro
+@ssindex knr-argdecl
+Two other syntactic symbols can appear in old style, non-prototyped C
+code @footnote{a.k.a. K&R C, or Kernighan & Ritchie C}: