Go to the first, previous, next, last section, table of contents.

# New Indentation Engine

`cc-mode` has a new indentation engine, providing a simplified, yet flexible and general mechanism for customizing indentation. It breaks indentation calculation into two steps. First for the line of code being indented, `cc-mode` analyzes what kind of language construct it's looking at, then it applies user defined offsets to the current line based on this analysis.

This section will briefly cover how indentation is calculated in `cc-mode`. It is important to understand the indentation model being used so that you will know how to customize `cc-mode` for your personal coding style.

- Syntactic Analysis
- Indentation Calculation

## Syntactic Analysis

The first thing `cc-mode` does when indenting a line of code, is to analyze the line, determining the syntactic component list of the construct on that line. A syntactic component consists of a pair of information (in lisp parlance, a cons cell), where the first part is a syntactic symbol, and the second part is a relative buffer position. Syntactic symbols describe elements of C code (2), e.g. `statement`, `substatement`, `class-open`, `class-close`, etc. See section Syntactic Symbols, for a complete list of currently recognized syntactic symbols and their semantics. The variable `c-offsets-alist` also contains the list of currently supported syntactic symbols.

Conceptually, a line of C code is always indented relative to the indentation of some line higher up in the buffer. This is represented by the relative buffer position in the syntactic component.

It might help to see an example. Suppose we had the following code as the only thing in a `c++-mode` buffer (3):

      1: void swap( int& a, int& b )
      2: {
      3:     int tmp = a;
      4:     a = b;
      5:     b = tmp;
      6: }

We can use the command `C-c C-s` (`c-show-syntactic-information`) to simply report what the syntactic analysis is for the current line. Running this command on line 4 this example, we'd see in the echo area:

    ((statement . 35))

This tells us that the line is a statement and it is indented relative to buffer position 35, which happens to be the ``i'` in `int` on line 3. If you were to move point to line 3 and hit `C-c C-s`, you would see:

    ((defun-block-intro . 29))

This indicates that the ``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:

      1: int add( int val, int incr, int doit )
      2: {
      3:     if( doit )
      4:         {
      5:             return( val + incr );
      6:         }
      7:     return( val );
      8: }

Hitting `C-c C-s` on line 4 gives us:

    ((substatement-open . 46))

which tells us that this is a brace that opens a substatement block. (4)

Syntactic component lists can contain more than one component, and individual syntactic components need not have relative buffer positions. The most common example of this is a line that contains a comment only line.

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

Hitting `C-c C-s` on line 3 of example 3 gives us:

    ((comment-intro) (defun-block-intro . 46))

so you can see that the syntactic component list contains two syntactic components. Also notice that the first component, ``(comment-intro)'` has no relative buffer position.

## Indentation Calculation

Indentation for the current line is calculated using the syntactic component list derived in step 1 above (see section Syntactic Analysis). Each component contributes to the final total indentation of the line in two ways.

First, the syntactic symbols are looked up in the `c-offsets-alist` variable, which is an association list of syntactic symbols and the offsets to apply for those symbols. These offsets are added to the running total.

Second, if the component has a relative buffer position, `cc-mode` adds the column number of that position to the running total. By adding up the offsets and columns for every syntactic component on the list, the final total indentation for the current line is computed.

Let's use our two code examples above to see how this works. Here is our first example again:

        1: void swap( int& a, int& b )
        2: {
        3:     int tmp = a;
        4:     a = b;
        5:     b = tmp;
        6: }

Let's say point is on line 3 and we hit the `TAB` key to re-indent the line. Remember that the syntactic component list for that line is:

    ((defun-block-intro . 29))

`cc-mode` looks up `defun-block-intro` in the `c-offsets-alist` variable. Let's say it finds the value ``4'`; it adds this to the running total (initialized to zero), yielding a running total indentation of 4 spaces.

Next `cc-mode` goes to buffer position 29 and asks for the current column. Since the brace at buffer position 29 is in column zero, it adds ``0'` to the running total. Since there is only one syntactic component on the list for this line, indentation calculation is complete, and the total indentation for the line is 4 spaces.

Here's another example:

        1: int add( int val, int incr, int doit )
        2: {
        3:     if( doit )
        4:         {
        5:             return( val + incr );
        6:         }
        7:     return( val );
        8: }

If we were to hit `TAB` on line 4 in the above example, the same basic process is performed, despite the differences in the syntactic component list. Remember that the list for this line is:

    ((substatement-open . 46))

Here, `cc-mode` first looks up the `substatement-open` symbol in `c-offsets-alist`. Let's say it finds the value ``4'`. This yields a running total of 4. `cc-mode` then goes to buffer position 46, which is the ``i'` in `if` on line 3. This character is in the fourth column on that line so adding this to the running total yields an indentation for the line of 8 spaces.

Simple, huh?

Actually, the mode usually just does The Right Thing without you having to think about it in this much detail. But when customizing indentation, it's helpful to understand the general indentation model being used.

To help you configure `cc-mode`, you can set the variable `c-echo-syntactic-information-p` to non-`nil` so that the syntactic component list and calculated offset will always be echoed in the minibuffer when you hit `TAB`.

Go to the first, previous, next, last section, table of contents.