This is Info file ../info/cc-mode.info, produced by Makeinfo-1.63 from
the input file cc-mode.texi.

   Copyright (C) 1995, 1996 Free Software Foundation, Inc.


File: cc-mode.info,  Node: File Styles,  Prev: Adding Styles,  Up: Styles

File Styles
-----------

   The Emacs manual describes how you can customize certain variables
on a per-file basis by including a "Local Variable" block at the end of
the file.  So far, you've only seen a functional interface to
`cc-mode', which is highly inconvenient for use in a Local Variable
block.  `cc-mode' provides two variables that make it easier for you to
customize your style on a per-file basis.

   The variable `c-file-style' can be set to a style name string.  When
the file is visited, `cc-mode' will automatically set the file's style
to this style using `c-set-style'.

   Another variable, `c-file-offsets', takes an association list
similar to what is allowed in `c-offsets-alist'.  When the file is
visited, `cc-mode' will automatically institute these offets using
`c-set-offset'.

   Note that file style settings (i.e. `c-file-style') are applied
before file offset settings (i.e. `c-file-offsets')(1).

   ---------- Footnotes ----------

   (1)  File styles are only supported since XEmacs 19.12 and Emacs
19.29.  They work via the standard Emacs hook variable
`hack-local-variables-hook'.


File: cc-mode.info,  Node: Advanced Customizations,  Prev: Styles,  Up: Customizing Indentation

Advanced Customizations
=======================

   For most users, `cc-mode' will support their coding styles with very
little need for more advanced customizations.  Usually, one of the
standard styles defined in `c-style-alist' will do the trick.  At most,
perhaps one of the syntactic symbol offsets will need to be tweaked
slightly, or maybe `c-basic-offset' will need to be changed.  However,
some styles require a more flexible framework for customization, and
one of the real strengths of `cc-mode' is that the syntactic analysis
model provides just such a framework. This allows you to implement
special indentation calculations for situations not handled by the mode
directly.

* Menu:

* Custom Indentation Functions::
* Custom Brace and Colon Hanging::
* Customizing Semi-colons and Commas::
* Other Special Indentations::


File: cc-mode.info,  Node: Custom Indentation Functions,  Next: Custom Brace and Colon Hanging,  Up: Advanced Customizations

Custom Indentation Functions
----------------------------

   One of the most common ways to customize `cc-mode' is by writing
"custom indentation functions" and associating them with specific
syntactic symbols (see *Note Syntactic Symbols::).  `cc-mode' itself
uses custom indentation functions to provide more sophisticated
indentation, for example when lining up C++ stream operator blocks:

     1: void main(int argc, char**)
     2: {
     3:   cout << "There were "
     4:     << argc
     5:     << "arguments passed to the program"
     6:     << endl;
     7: }

   In this example, lines 4 through 6 are assigned the `stream-op'
syntactic symbol.  Here, `stream-op' has an offset of `+', and with a
`c-basic-offset' of 2, you can see that lines 4 through 6 are simply
indented two spaces to the right of line 3.  But perhaps we'd like
`cc-mode' to be a little more intelligent so that it lines up all the
`<<' symbols in lines 3 through 6.  To do this, we have to write a
custom indentation function which finds the column of first stream
operator on the first line of the statement.  Here is the lisp code
(from the `cc-mode.el' source file) that implements this:

     (defun c-lineup-streamop (langelem)
       ;; lineup stream operators
       (save-excursion
         (let* ((relpos (cdr langelem))
                (curcol (progn (goto-char relpos)
                               (current-column))))
           (re-search-forward "<<\\|>>" (c-point 'eol) 'move)
           (goto-char (match-beginning 0))
           (- (current-column) curcol))))

Custom indent functions take a single argument, which is a syntactic
component cons cell (see *Note Syntactic Analysis::).  The function
returns an integer offset value that will be added to the running total
indentation for the line.  Note that what actually gets returned is the
difference between the column that the first stream operator is on, and
the column of the buffer relative position passed in the function's
argument.  Remember that `cc-mode' automatically adds in the column of
the component's relative buffer position and we don't want that value
added into the final total twice.

   Now, to associate the function `c-lineup-streamop' with the
`stream-op' syntactic symbol, we can add something like the following
to our `c++-mode-hook'(1):

     (c-set-offset 'stream-op 'c-lineup-streamop)

   Now the function looks like this after re-indenting (using `C-c
C-q'):

     1: void main(int argc, char**)
     2: {
     3:   cout << "There were "
     4:        << argc
     5:        << "arguments passed to the program"
     6:        << endl;
     7: }

   Custom indentation functions can be as simple or as complex as you
like, and any syntactic symbol that appears in `c-offsets-alist' can
have a custom indentation function associated with it.  `cc-mode' comes
with several standard custom indentation functions, not all of which are
used by the default styles.

   * `c-lineup-arglist' -- lines up function argument lines under the
     argument on the previous line.

   * `c-lineup-arglist-intro-after-paren' -- similar to
     `c-lineup-arglist', but works for argument lists that begin with an
     open parenthesis followed by a newline.

   * `c-lineup-arglist-close-under-paren' -- set your `arglist-close'
     syntactic symbol to this line-up function so that parentheses that
     close argument lists will line up under the parenthesis that
     opened the argument list.

   * `c-lineup-streamop' -- lines up C++ stream operators (e.g. `<<'
     and `>>').

   * `c-lineup-multi-inher' -- lines up multiple inheritance lines.

   * `c-lineup-C-comments' -- lines up C block comment continuation
     lines.

   * `c-lineup-comment' -- implements the old comment line up behavior
     specified by the variable `c-comment-only-line-offset'.

   * `c-lineup-runin-statements' -- lines up `statement's for coding
     standards which place the first statement in a block on the same
     line as the block opening brace.

   * `c-lineup-math' -- lines up math `statement-cont' lines under the
     previous line after the equals sign.

   * `c-lineup-ObjC-method-call' -- for Objective-C code, lines up
     selector arguments just after the message receiver.

   * `c-lineup-ObjC-method-args' -- for Objective-C code, lines up the
     colons that separate arguments by aligning colons vertically.

   * `c-lineup-ObjC-method-args-2' -- similar to
     `c-lineup-ObjC-method-args' but lines up the colon on the current
     line with the colon on the previous line.

   ---------- Footnotes ----------

   (1)  It probably makes more sense to add this to `c++-mode-hook'
than `c-mode-common-hook' since stream operators are only relevent for
C++.


File: cc-mode.info,  Node: Custom Brace and Colon Hanging,  Next: Customizing Semi-colons and Commas,  Prev: Custom Indentation Functions,  Up: Advanced Customizations

Custom Brace and Colon Hanging
------------------------------

   Syntactic symbols aren't the only place where you can customize
`cc-mode' with the lisp equivalent of callback functions.  Brace
"hanginess" can also be determined by custom functions associated with
syntactic symbols on the `c-hanging-braces-alist' variable.  Remember
that ACTION's are typically a list containing some combination of the
symbols `before' and `after' (see *Note Hanging Braces::).  However, an
ACTION can also be a function symbol which gets called when a brace
matching that syntactic symbol is typed.

   These ACTION functions are called with two arguments: the syntactic
symbol for the brace, and the buffer position at which the brace was
inserted.  The ACTION function is expected to return a list containing
some combination of `before' and `after'.  The function can also return
`nil'.  This return value has the normal brace hanging semantics.

   As an example, `cc-mode' itself uses this feature to dynamically
determine the hanginess of braces which close "do-while" constructs:

     void do_list( int count, char** atleast_one_string )
     {
         int i=0;
         do {
             handle_string( atleast_one_string[i] );
             i++;
         } while( i < count );
     }

   `cc-mode' assigns the `block-close' syntactic symbol to the brace
that closes the `do' construct, and normally we'd like the line that
follows a `block-close' brace to begin on a separate line.  However,
with "do-while" constructs, we want the `while' clause to follow the
closing brace.  To do this, we associate the `block-close' symbol with
the ACTION function `c-snug-do-while':

     (defun c-snug-do-while (syntax pos)
       "Dynamically calculate brace hanginess for do-while statements.
     Using this function, `while' clauses that end a `do-while' block will
     remain on the same line as the brace that closes that block.
     
     See `c-hanging-braces-alist' for how to utilize this function as an
     ACTION associated with `block-close' syntax."
       (save-excursion
         (let (langelem)
           (if (and (eq syntax 'block-close)
                    (setq langelem (assq 'block-close c-syntactic-context))
                    (progn (goto-char (cdr langelem))
                           (if (= (following-char) ?{)
                               (forward-sexp -1))
                           (looking-at "\\<do\\>[^_]")))
               '(before)
             '(before after)))))

   This function simply looks to see if the brace closes a "do-while"
clause and if so, returns the list `(before)' indicating that a newline
should be inserted before the brace, but not after it.  In all other
cases, it returns the list `(before after)' so that the brace appears
on a line by itself.

   During the call to the brace hanging ACTION function, the variable
`c-syntactic-context' is bound to the full syntactic analysis list.

   Note that for symmetry, colon hanginess should be customizable by
allowing function symbols as ACTIONs on the `c-hanging-colon-alist'
variable.  Since no use has actually been found for this feature, it
isn't currently implemented.


File: cc-mode.info,  Node: Customizing Semi-colons and Commas,  Next: Other Special Indentations,  Prev: Custom Brace and Colon Hanging,  Up: Advanced Customizations

Customizing Semi-colons and Commas
----------------------------------

   You can also customize the insertion of newlines after semi-colons
and commas, when the auto-newline minor mode is enabled (see *Note
Minor Modes::).  This is controlled by the variable
`c-hanging-semi&comma-criteria', which contains a list of functions
that are called in the order they appear.  Each function is called with
zero arguments, and is expected to return one of the following values:

   * non-`nil' -- A newline is inserted, and no more functions from the
     list are called.

   * `stop' -- No more functions from the list are called, but no
     newline is inserted.

   * `nil' -- No determination is made, and the next function in the
     list is called.

   If every function in the list is called without a determination being
made, then no newline is added. The default value for this variable is a
list containing a single function which inserts newlines only after
semi-colons which do not appear inside parenthesis lists (i.e. those
that separate `for'-clause statements).

   Here's an example of a criteria function that will prevent newlines
from being inserted after semicolons when there is a non-blank following
line.  Otherwise, it makes no determination:


     (defun my-semicolon-criteria ()
       (save-excursion
         (if (and (= last-command-char ?\;)
                  (zerop (forward-line 1))
                  (not (looking-at "^[ \t]*$")))
             'stop
           nil)))


File: cc-mode.info,  Node: Other Special Indentations,  Prev: Customizing Semi-colons and Commas,  Up: Advanced Customizations

Other Special Indentations
--------------------------

   In `gnu' style (see *Note Built-in Styles::), a minimum indentation
is imposed on lines with `label' or `case-label' syntax.  This minimum
indentation is controlled by the variable
`c-label-minimum-indentation'.  The default value for this variable is
1.

   One other customization variable is available in `cc-mode':
`c-special-indent-hook'.  This is a standard hook variable that is
called after every line is indented by `cc-mode'.  You can use it to do
any special indentation or line adjustments your style dictates, such
as adding extra indentation to constructors or destructor declarations
in a class definition, etc.  Note however, that you should not change
Point or Mark inside your `c-special-indent-hook' functions (i.e.
you'll probably want to wrap your function in a `save-excursion').

   Setting `c-special-indent-hook' in your style definition is handled
slightly differently than other variables.  In your style definition,
you should set the value for `c-special-indent-hook' to a function or
list of functions, which will be appended to `c-special-indent-hook'
using `add-hook'.  That way, the current setting for the buffer local
value of `c-special-indent-hook' won't be overridden.


File: cc-mode.info,  Node: Syntactic Symbols,  Next: Performance Issues,  Prev: Customizing Indentation,  Up: Top

Syntactic Symbols
*****************

   Here is a complete list of the recognized syntactic symbols as
described in the `c-offsets-alist' variable, along with a brief
description.  More detailed descriptions follow below.

   * `string' -- inside multi-line string

   * `c' -- inside a multi-line C style block comment

   * `defun-open' -- brace that opens a function definition

   * `defun-close' -- brace that closes a function definition

   * `defun-block-intro' -- the first line in a top-level defun

   * `class-open' -- brace that opens a class definition

   * `class-close' -- brace that closes a class definition

   * `inline-open' -- brace that opens an in-class inline method

   * `inline-close' -- brace that closes an in-class inline method

   * `ansi-funcdecl-cont' -- the nether region between an ANSI function
     declaration and the defun opening brace

   * `knr-argdecl-intro' -- first line of a K&R C argument declaration

   * `knr-argdecl' -- subsequent lines in a K&R C argument declaration

   * `topmost-intro' -- the first line in a topmost construct definition

   * `topmost-intro-cont' -- topmost definition continuation lines

   * `member-init-intro' -- first line in a member initialization list

   * `member-init-cont' -- subsequent member initialization list lines

   * `inher-intro' -- first line of a multiple inheritance list

   * `inher-cont' -- subsequent multiple inheritance lines

   * `block-open' -- statement block open brace

   * `block-close' -- statement block close brace

   * `brace-list-open' -- open brace of an enum or static array list

   * `brace-list-close' -- close brace of an enum or static array list

   * `brace-list-intro' -- first line in an enum or static array list

   * `brace-list-entry' -- subsequent lines in an enum or static array
     list

   * `statement' -- a C (or like) statement

   * `statement-cont' -- a continuation of a C (or like) statement

   * `statement-block-intro' -- the first line in a new statement block

   * `statement-case-intro' -- the first line in a case `block'

   * `statement-case-open' -- the first line in a case block starting
     with brace

   * `substatement' -- the first line after an if/while/for/do/else

   * `substatement-open' -- the brace that opens a substatement block

   * `case-label' -- a case or default label

   * `access-label' -- C++ private/protected/public access label

   * `label' -- any non-special C (or like) label

   * `do-while-closure' -- the `while' that ends a do/while construct

   * `else-clause' -- the `else' of an if/else construct

   * `comment-intro' -- a line containing only a comment introduction

   * `arglist-intro' -- the first line in an argument list

   * `arglist-cont' -- subsequent argument list lines when no arguments
     follow on the same line as the the arglist opening paren

   * `arglist-cont-nonempty' -- subsequent argument list lines when at
     least one argument follows on the same line as the arglist opening
     paren

   * `arglist-close' -- the solo close paren of an argument list

   * `stream-op' -- lines continuing a stream operator construct

   * `inclass' -- the construct is nested inside a class definition

   * `cpp-macro' -- the start of a cpp macro

   * `friend' -- a C++ friend declaration

   * `objc-method-intro' -- the first line of an Objective-C method
     definition

   * `objc-method-args-cont' -- lines continuing an Objective-C method
     definition

   * `objc-method-call-cont' -- lines continuing an Objective-C method
     call

   * `extern-lang-open' -- brace that opens an external language block

   * `extern-lang-close' -- brace that closes an external language block

   * `inextern-lang' -- analogous to `inclass' syntactic symbol

   Most syntactic symbol names follow a general naming convention.
When a line begins with an open or close brace, the syntactic symbol
will contain the suffix `-open' or `-close' respectively.

   Usually, a distinction is made between the first line that
introduces a construct and lines that continue a construct, and the
syntactic symbols that represent these lines will contain the suffix
`-intro' or `-cont' respectively.  As a sub-classification of this
scheme, a line which is the first of a particular brace block construct
will contain the suffix `-block-intro'.

   Let's look at some examples to understand how this works.  Remember
that you can check the syntax of any line by using `C-c C-s'.

       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: }

   Line 1 shows a `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
`topmost-intro-cont'.  Line 3 shows a `defun-open' since it is the
brace that opens a top-level function definition.  Line 9 is a
`defun-close' since it contains the brace that closes the top-level
function definition.  Line 4 is a `defun-block-intro', i.e. it is the
first line of a brace-block, which happens to be enclosed in a
top-level function definition.

   Lines 5, 6, and 7 are all given `statement' syntax since there isn't
much special about them.  Note however that line 8 is given
`statement-cont' syntax since it continues the statement begun on the
previous line.

   Here's another example, which illustrates some C++ class syntactic
symbols:

        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: }

   As in the previous example, line 1 has the `topmost-intro' syntax.
Here however, the brace that opens a C++ class definition on line 4 is
assigned the `class-open' syntax.  Note that in C++, classes, structs,
and unions are essentially equivalent syntactically (and are very
similar semantically), so replacing the `class' keyword in the example
above with `struct' or `union' would still result in a syntax of
`class-open' for line 4 (1).  Similarly, line 18 is assigned
`class-close' syntax.

   Line 2 introduces the inheritance list for the class so it is
assigned the `inher-intro' syntax, and line 3, which continues the
inheritance list is given `inher-cont' syntax.

   Hitting `C-c C-s' on line 5 shows the following analysis:


     `((inclass . 1) (access-label . 67))'

The primary syntactic symbol for this line is `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 `inclass'.  Similarly,
line 6 is given both `inclass' and `topmost-intro' syntax:


     `((inclass . 58) (topmost-intro . 60))'

   Line 7 introduces a C++ member initialization list and as such is
given `member-init-intro' syntax.  Note that in this case it is *not*
assigned `inclass' since this is not considered a top-level construct.
Lines 8 through 10 are all assigned `member-init-cont' since they
continue the member initialization list started on line 7.

   But the line 11's analysis is a bit more complicated:


     `((inclass . 1) (inline-open))'

   This line is assigned a syntax of both `inline-open' and `inclass'
because it opens an "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.  For example, if
the definition of the `Bass' constructor appeared outside the class
definition, line 11 would be given the `defun-open' syntax, even if the
keyword `inline' appeared before the method name, as in:

     class Bass
         : public Guitar,
           public Amplifiable
     {
     public:
         Bass();
     }
     
     inline
     Bass::Bass()
         : eString( new BassString( 0.105 )),
           aString( new BassString( 0.085 )),
           dString( new BassString( 0.065 )),
           gString( new BassString( 0.045 ))
     {
         eString.tune( 'E' );
         aString.tune( 'A' );
         dString.tune( 'D' );
         gString.tune( 'G' );
     }

   Returning to the previous example, line 16 is given `inline-close'
syntax, while line 12 is given `defun-block-open' syntax, and lines 13
through 15 are all given `statement' syntax.  Line 17 is interesting in
that it's syntactic analysis list contains three elements:


     `((friend) (inclass . 58) (topmost-intro . 380))'

   The `friend' syntactic symbol is a modifier that typically does not
have a relative buffer position.

   Here is another (totally contrived) example which illustrates how
syntax is assigned to various conditional constructs:

        1: void spam( int index )
        2: {
        3:     for( int i=0; i<index; i++ )
        4:     {
        5:         if( i == 10 )
        6:         {
        7:             do_something_special();
        8:         }
        9:         else
       10:             do_something( i );
       11:     }
       12:     do {
       13:         another_thing( i-- );
       14:     }
       15:     while( i > 0 );
       16: }

Only the lines that illustrate new syntactic symbols will be discussed.

   Line 4 has a brace which opens a conditional's substatement block.
It is thus assigned `substatement-open' syntax, and since line 5 is the
first line in the substatement block, it is assigned
`substatement-block-intro' syntax.  Lines 6 and 7 are assigned similar
syntax.  Line 8 contains the brace that closes the inner substatement
block.  It is given the syntax `block-close', as are lines 11 and 14.

   Line 9 is a little different -- since it contains the keyword `else'
matching the `if' statement introduced on line 5, it is given the
`else-clause' syntax.  Note also that line 10 is slightly different
too.  Because `else' is considered a conditional introducing keyword
(2), and because the following substatement is not a brace block, line
10 is assigned the `substatement' syntax.

   One other difference is seen on line 15.  The `while' construct that
closes a `do' conditional is given the special syntax
`do-while-closure' if it appears on a line by itself.  Note that if the
`while' appeared on the same line as the preceding close brace, that
line would have been assigned `block-close' syntax instead.

   Switch statements have their own set of syntactic symbols.  Here's an
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: }

   Here, lines 4, 7, and 10 are all assigned `case-label' syntax, while
lines 5 and 8 are assigned `statement-case-intro'.  Line 11 is treated
slightly differently since it contains a brace that opens a block -- it
is given `statement-case-open' syntax.

   There are a set of syntactic symbols that are used to recognize
constructs inside of brace lists.  A brace list is defined as an `enum'
or aggregate initializer list, such as might statically initialize an
array of structs.  For example:

       1: static char* ingredients[] =
       2: {
       3:     "Ham",
       4:     "Salt",
       5:     NULL
       6: }

   Following convention, line 2 in this example is assigned
`brace-list-open' syntax, and line 3 is assigned `brace-list-intro'
syntax.  Likewise, line 6 is assigned `brace-list-close' syntax.  Lines
4 and 5 however, are assigned `brace-list-entry' syntax, as would all
subsequent lines in this initializer list.

   External language definition blocks also have their own syntactic
symbols.  In this example:

        1: extern "C"
        2: {
        3:     int thing_one( int );
        4:     int thing_two( double );
        5: }

line 2 is given the `extern-lang-open' syntax while line 5 is given the
`extern-lang-close' syntax.  The analysis for line 3 yields:
`((inextern-lang) (topmost-intro . 14))', where `inextern-lang' is a
modifier similar in purpose to `inclass'.

   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:

        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: }

   Lines 5 and 12 are assigned `arglist-intro' syntax since they are
the first line following the open parenthesis, and lines 7 and 14 are
assigned `arglist-close' syntax since they contain the parenthesis that
closes the argument list.

   Lines that continue argument lists can be assigned one of two
syntactic symbols.  For example, Lines 2 and 17 are assigned
`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 *not empty* following the open parenthesis.  Contrast
this against lines 6 and 13 which are assigned `arglist-cont' syntax.
This is because the parenthesis that opens their argument lists is the
last character on that line (3).

   Note that there is no `arglist-open' syntax.  This is because any
parenthesis that opens an argument list, appearing on a separate line,
is assigned the `statement-cont' syntax instead.

   A few miscellaneous syntactic symbols that haven't been previously
covered are illustrated by this example:

        1: void Bass::play( int volume )
        2: const
        3: {
        4:     /* this line starts a multi-line
        5:      * comment.  This line should get `c' syntax */
        6:
        7:     char* a_long_multiline_string = "This line starts a multi-line \
        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: }

   The lines to note in this example include:

   * line 2, assigned the `ansi-funcdecl-cont' syntax;

   * line 4, assigned both `defun-block-intro' *and* `comment-intro'
     syntax (4);

   * line 5, assigned `c' syntax;

   * line 6 which, even though it contains nothing but whitespace, is
     assigned `defun-block-intro'.  Note that the appearance of the
     comment on lines 4 and 5 do not cause line 6 to be assigned
     `statement' syntax because comments are considered to be
     "syntactic whitespace", which are ignored when analyzing code;

   * line 8, assigned `string' syntax;

   * line 10, assigned `label' syntax;

   * line 11, assigned `block-open' syntax;

   * lines 12 and 14, assigned `cpp-macro' syntax;

   * line 17, assigned `stream-op' syntax (5).

   In Objective-C buffers, there are three additional syntactic symbols
assigned to various message calling constructs.  Here's an example
illustrating these:

       1: - (void)setDelegate:anObject
       2:           withStuff:stuff
       3: {
       4:     [delegate masterWillRebind:self
       5:               toDelegate:anObject
       6:               withExtraStuff:stuff];
       7: }

   Here, line 1 is assigned `objc-method-intro' syntax, and line 2 is
assigned `objc-method-args-cont' syntax.  Lines 5 and 6 are both
assigned `objc-method-call-cont' syntax.

   Two other syntactic symbols can appear in old style, non-prototyped C
code (6):

       1: int add_three_integers(a, b, c)
       2:      int a;
       3:      int b;
       4:      int c;
       5: {
       6:     return a + b + c;
       7: }

   Here, line 2 is the first line in an argument declaration list and
so is given the `knr-argdecl-intro' syntactic symbol.  Subsequent lines
(i.e. lines 3 and 4 in this example), are given `knr-argdecl' syntax.

   ---------- Footnotes ----------

   (1)  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 `class' is meaningless in C and
Objective-C.

   (2)  The list of conditional keywords are (in C, C++, Objective-C,
and Java): `for', `if', `do', `else', `while', and `switch'.  C++ and
Java have two additional conditional keywords: `try' and `catch'.  Java
also has the `finally' and `synchronized' keywords.

   (3)  The need for this somewhat confusing arrangement is that the
typical indentation desired for these lines is calculated differently.
This should be simplified in version 5 of `cc-mode', along with the
added distinction between argument lists in function declarations, and
argument lists in function calls.

   (4)  The `comment-intro' syntactic symbol is is another example of a
"modifier" since it always appears on a syntactic analysis list with
other symbols, and rarely has an associated relative buffer position.

   (5)  In C++ only.

   (6)  a.k.a. K&R C, or Kernighan & Ritchie C


File: cc-mode.info,  Node: Performance Issues,  Next: Frequently Asked Questions,  Prev: Syntactic Symbols,  Up: Top

Performance Issues
******************

   C and it's derivative languages are highly complex creatures.  Often,
ambiguous code situations arise that require `cc-mode' to scan large
portions of the buffer to determine syntactic context.  Such
pathological code(1) can cause `cc-mode' to perform fairly badly.  This
section identifies some of the coding styles to watch out for, and
suggests some workarounds that you can use to improve performance.

   Note that this is an area that will get a lot of attention in
`cc-mode' version 5.  The mode should end up being much faster, at the
expense of dropping Emacs 18 support, owing to the implementation of
syntactic analysis caching.

   Because `cc-mode' has to scan the buffer backwards from the current
insertion point, and because C's syntax is fairly difficult to parse in
the backwards direction, `cc-mode' often tries to find the nearest
position higher up in the buffer from which to begin a forward scan.
The farther this position is from the current insertion point, the
slower the mode gets.  Some coding styles can even force `cc-mode' to
scan from the beginning of the buffer!

   One of the simplest things you can do to reduce scan time, is make
sure any brace that opens a top-level block construct always appears in
the leftmost column.  This is actually an Emacs constraint, as embodied
in the `beginning-of-defun' function which `cc-mode' uses heavily.  If
you insist on hanging top-level open braces on the right side of the
line, then you should set the variable `defun-prompt-regexp' to
something reasonable (2), however that "something reasonable" is
difficult to define, so `cc-mode' doesn't do it for you.

   You will probably notice pathological behavior from `cc-mode' when
working in files containing large amounts of cpp macros.  This is
because `cc-mode' cannot quickly skip backwards over these lines.

   Previous versions of `cc-mode' had potential performance problems
when recognizing "K&R" style function argument declarations.  This was
because there are ambiguities in the C syntax when K&R style argument
lists are used (it is hard to distinguish them from top-level
declarations).  `cc-mode' has adopted BOCM's convention for limiting
the search: it assumes that argdecls are indented at least one space,
and that the function headers are not indented at all.  With current
versions of `cc-mode', `c-recognize-knr-p' is deprecated.

   You might want to investigate some of the speed-ups contained in the
file `cc-lobotomy.el', which is part of the canonical `cc-mode'
distribution.  As mentioned previous, `cc-mode' always trades accuracy
for speed, however it is recognized that sometimes you need speed and
can sacrifice some accuracy in indentation.  The file `cc-lobotomy.el'
contains hacks that will "dumb down" `cc-mode' in some specific ways,
making that trade-off of speed for accuracy.  I won't go into details
of its use here; you should read the comments at the top of the file,
and look at the variable `cc-lobotomy-pith-list' for details.

   ---------- Footnotes ----------

   (1)  such as the output of `lex(1)'!

   (2)  Note that this variable is only defined in Emacs 19.


File: cc-mode.info,  Node: Frequently Asked Questions,  Next: Getting the latest cc-mode release,  Prev: Performance Issues,  Up: Top

Frequently Asked Questions
**************************

     *Q.* *How do I re-indent the whole file?*

     *A.* Visit the file and hit `C-x h' to mark the whole buffer. Then
     hit `ESC C-\'.

     *Q.* *How do I re-indent the entire function?  `ESC C-x' doesn't
     work.*

     *A.* `ESC C-x' is reserved for future Emacs use.  To re-indent the
     entire function hit `C-c C-q'.

     *Q.* *How do I re-indent the current block?*

     *A.* First move to the brace which opens the block with `ESC C-u',
     then re-indent that expression with `ESC C-q'.

     *Q.* *Why doesn't the RET key indent the line to where the new
     text should go after inserting the newline?*

     *A.* Emacs' convention is that RET just adds a newline, and that
     LFD adds a newline and indents it.  You can make RET do this too
     by adding this to your `c-mode-common-hook' (see the sample
     `.emacs' file *Note Sample .emacs File::):

          (define-key c-mode-map "\C-m" 'newline-and-indent)

     This is a very common question. `:-)' If you want this to be the
     default behavior, don't lobby me, lobby RMS!

     *Q.* *I put `(c-set-offset 'substatement-open 0)' in my `.emacs'
     file but I get an error saying that `c-set-offset''s function
     definition is void.*

     *A.* This means that `cc-mode' wasn't loaded into your Emacs
     session by the time the `c-set-offset' call was reached, mostly
     likely because `cc-mode' is being autoloaded.  Instead of putting
     the `c-set-offset' line in your top-level `.emacs' file, put it in
     your `c-mode-common-hook', or simply add the following to the top
     of your `.emacs' file:

          (require 'cc-mode)

     See the sample `.emacs' file *Note Sample .emacs File:: for
     details.

     *Q.* *How do I make strings, comments, keywords, and other
     constructs appear in different colors, or in bold face, etc.?*

     *A.* "Syntax Colorization" is an Emacs 19 feature, controlled by
     `font-lock-mode'.  It is not part of `cc-mode'.

     *Q.* *I `setq' `c-basic-offset' to 4 in my `.emacs' file, but why
     does everything still get indented with only 2 spaces?*

     *A.* It's because `c-basic-offset' is now a "buffer local
     variable", meaning its value is unique to each buffer.  The
     prefered way to customize this is to change its value in a "mode
     hook" (most likely `c-mode-common-hook'.  Alternatively you can use
     `setq-default' to change its value globally.



File: cc-mode.info,  Node: Getting the latest cc-mode release,  Next: Sample .emacs File,  Prev: Frequently Asked Questions,  Up: Top

Getting the latest `cc-mode' release
************************************

   `cc-mode' is now distributed with both Emacs 19 and XEmacs 19, so
you would typically just use the version that comes with your Emacs.
These may be slightly out of date due to release schedule skew, so you
should always check the canonical site for the latest version.


         World Wide Web:
     
             `http://www.python.org/ftp/emacs/'
     
         Anonymous FTP:
     
             `ftp://ftp.python.org/pub/emacs/'

   There are many files under these directories; you can pick up the
entire distribution (named `cc-mode.tar.gz'; a gzip'd tar file), or any
of the individual files, including PostScript documentation.

   If you do not have anonymous ftp access, you can get the distribution
through an anonymous ftp-to-mail gateway, such as the one run by DEC at
`ftpmail@decwrl.dec.com'.  To get `cc-mode' via email, send the
following message in the body of your mail to that address:

     reply <a valid net address back to you>
     connect ftp.python.org
     binary
     uuencode
     chdir pub/emacs
     get cc-mode.tar.gz

or just send the message "help" for more information on ftpmail.
Response times will vary with the number of requests in the queue.  I am
in no way connected to this service, so I make no claims or guarantees
about its availability!


File: cc-mode.info,  Node: Sample .emacs File,  Next: Limitations and Known Bugs,  Prev: Getting the latest cc-mode release,  Up: Top

Sample `.emacs' file
********************

     ;; Here's a sample .emacs file that might help you along the way.  Just
     ;; copy this region and paste it into your .emacs file.  You may want to
     ;; change some of the actual values.
     
     (defconst my-c-style
       '((c-tab-always-indent           . t)
         (c-comment-only-line-offset    . 4)
         (c-hanging-braces-alist        . ((substatement-open after)
                                           (brace-list-open)))
         (c-hanging-colons-alist        . ((member-init-intro before)
                                           (inher-intro)
                                           (case-label after)
                                           (label after)
                                           (access-label after)))
         (c-cleanup-list                . (scope-operator
                                           empty-defun-braces
                                           defun-close-semi))
         (c-offsets-alist               . ((arglist-close     . c-lineup-arglist)
                                           (substatement-open . 0)
                                           (case-label        . 4)
                                           (block-open        . 0)
                                           (knr-argdecl-intro . -)))
         (c-echo-syntactic-information-p . t)
         )
       "My C Programming Style")
     
     ;; Customizations for all of c-mode, c++-mode, and objc-mode
     (defun my-c-mode-common-hook ()
       ;; add my personal style and set it for the current buffer
       (c-add-style "PERSONAL" my-c-style t)
       ;; offset customizations not in my-c-style
       (c-set-offset 'member-init-intro '++)
       ;; other customizations
       (setq tab-width 8
             ;; this will make sure spaces are used instead of tabs
             indent-tabs-mode nil)
       ;; we like auto-newline and hungry-delete
       (c-toggle-auto-hungry-state 1)
       ;; keybindings for all supported languages.  We can put these in
       ;; c-mode-map because c++-mode-map, objc-mode-map, and java-mode-map
       ;; inherit from it.
       (define-key c-mode-map "\C-m" 'newline-and-indent)
       )
     
     ;; the following only works in Emacs 19
     ;; Emacs 18ers can use (setq c-mode-common-hook 'my-c-mode-common-hook)
     (add-hook 'c-mode-common-hook 'my-c-mode-common-hook)


File: cc-mode.info,  Node: Limitations and Known Bugs,  Next: Mailing Lists and Submitting Bug Reports,  Prev: Sample .emacs File,  Up: Top

Limitations and Known Bugs
**************************

   * Multi-line macros are not handled properly.

   * Re-indenting large regions or expressions can be slow.

   * Use with Emacs 18 can be slow and annoying. You should seriously
     consider upgrading to Emacs 19.

   * There is still some weird behavior when filling C block comments.
     My suggestion is to check out separate fill packages such as
     `filladapt' or `adaptive-fill-mode'.  These can do a much better
     job of filling comment regions.

   * `c-indent-exp' has not been fully optimized.  It essentially
     equivalent to hitting `TAB' (`c-indent-command') on every line.
     Some information is cached from line to line, but such caching
     invariable causes inaccuracies in analysis in some bizarre
     situations.


File: cc-mode.info,  Node: Mailing Lists and Submitting Bug Reports,  Next: Concept Index,  Prev: Limitations and Known Bugs,  Up: Top

Mailing Lists and Submitting Bug Reports
****************************************

   To report bugs, use the `C-c C-b' (`c-submit-bug-report') command.
This provides vital information I need to reproduce your problem.  Make
sure you include a concise, but complete code example.  Please try to
boil your example down to just the essential code needed to reproduce
the problem, and include an exact recipe of steps needed to expose the
bug.  Be especially sure to include any code that appears *before* your
bug example, if you think it might affect my ability to reproduce it.

   Bug reports are now sent to the following email addresses:
`cc-mode-help@python.org' and `bug-gnu-emacs@prep.ai.mit.edu'; the
latter is mirrored on the Usenet newsgroup `gnu.emacs.bug'.  Other
questions and suggestions should be mailed to
`help-gnu-emacs@prep.ai.mit.edu' which is mirrored on `gnu.emacs.help'.

