c - STATEMENTS AND CONTROL FLOW

[nixawk]

This section describes how to organize statements into logical
thoughts and how to format various kinds of statements. The
general principles for writing clear statements are as follows:

• Use blank lines to organize statements into paragraphs and
  to separate logically related statements.

• Limit the complexity of statements, breaking a complex
  statement into several simple statements if it makes the
  code clearer to read.

• Indent to show the logical structure of your code.

[nixawk]

Statement Placement

It is recommended that you use explicit comparison even if the comparison value
will never change. For example, this statement:

if (!(bufsize % sizeof(int)))

should be written instead as

if ((bufsize % sizeof(int)) == 0)

to reflect the numeric (not boolean) nature of the test.

[nixawk]

Braces

Compound statements, also known as blocks, are lists of statements enclosed in
braces. The brace style we recommend is the Braces-Stand-Alone method. Place
braces on separate lines and align them. This style, which is used throughout this
document, allows for easier pairing of the braces and costs only one vertical space.

Example: Braces-Stand-Alone method

for (i = 0, j = strlen(s)-1; i < j; i++, j--)
{
    c = s[i];
    s[i] = s[j];
    s[j] = c;
}

Although C does not require braces around single statements, there are times when
braces help improve the readability of the code. Nested conditionals and loops can
often benefit from the addition of braces, especially when a conditional expression is
long and complex.

The following examples show the same code with and without braces. We encourage
the use of braces to improve readability. Use your own judgment when deciding
whether or not to use braces, remembering that what is clear to you may not be
obvious to others who read your code.

Example: braces improve readability

for (dp = &values[0]; dp < top_value; dp++)
{
    if (dp->d_value == arg_value
     && (dp->d_flag & arg_flag) != 0)
    {
        return (dp);
    }
}
return (NULL);

Example: no braces

for (dp = &values[0]; dp < top_value; dp++)
    if (dp->d_value == arg_value
     && (dp->d_flag & arg_flag) != 0)
        return (dp);
return (NULL);

• If the span of a block is large (more than about 40 lines) or there are several
  nested blocks, comment closing braces to indicate what part of the process
  they delimit:

for (sy = sytable; sy != NULL; sy = sy->sy_link)
{
    if (sy->sy_flag == DEFINED)
    {
        ...
    } /* if defined */
    else
    {
        ...
    } /* if undefined */
}     /* for all symbols */

• If a for or while statement has a dummy body, the semicolon should go on the
  next line. It is good practice to add a comment stating that the dummy body is
  deliberate

/* Locate end of string */
for (char_p = string; *char_p != EOS; char_p++)
    ; /* do nothing */

• Always put a space between reserved words and their opening parentheses.

• Always put parentheses around the objects of sizeof and return.

[nixawk]

Selection Control Statements

This section discusses the recommended formatting for selection control statements.
Examples are given to show how to format single statements as well as blocks of
statements.

If

• Indent single statements one level:

if (expression)
    one_statement;

• Indent a block of statements one level using braces:

if (expression)
{
    statement_1;
    ...
    statement_n;
}

If Else

• If else statements that have only simple statements in both the if and else
  sections do not require braces but should be indented one level:

if (expression)
    statement
else
    statement

• If else statements that have a compound statement in either the if or else
  section require braces and should be indented one level using braces:

if (expression)
    one_statement;
else
{
    statement_1;
    ...
    statement_n;
}

Else If

For readability, use the following format for else if statements:

if (expression)
    statement[s]
else if (expression)
    statement[s]
else
    statement[s]

Nested If Statements

If If If

Use nested if statements if there are alternative actions (i.e., there is an action in the
else clause), or if an action completed by a successful evaluation of the condition has
to be undone. Do not use nested if statements when only the if clause contains
actions.

Example: good nesting

status = delta_create((Callback)NULL, &delta);
if ( status == NDB_OK )
{
    if ((status = delta_record_condition(...)) == NDB_OK &&
        (status = delta_field_condition(...)) == NDB_OK &&
        (status=delta_field_condition(...)) == NDB_OK )

      status = delta_commit(delta, ...);

  (void)ndb_destroy_delta( delta);
}

Example: inappropriate nesting

status = delta_create((Callback)NULL, &delta);
if (status == NDB_OK)
{
    status = delta_record_condition( delta, ...);
    if (status == NDB_OK )
    {
        status = delta_field_condition(delta, ...);
        if (status == NDB_OK )
        {
            status = delta_field_condition( ...);
            if (status == NDB_OK )
                status = delta_commit(delta, ...);
        }
    }
    (VOID)ndb_destroy_delta(delta);
}
return(status);

If If Else

Because the else part of an if else statement is optional, omitting the “else” from a
nested if sequence can result in ambiguity. Therefore, always use braces to avoid
confusion and to make certain that the code compiles the way you intended. In the
following example, the same code is shown both with and without braces. The first
example will produce the results desired. The second example will not produce the
results desired because the “else” will be paired with the second “if” instead of the
first.

Example: braces produce desired result

if (n > 0)
{
    for (i = 0; i < n; i++)
    {
        if (s[i] > 0)
        {
            printf("...");
            return(i);
        }
    }
}
else /* CORRECT -- braces force proper association */
    printf("error - n is zero\n");

Example: absence of braces produces undesired result

if (n > 0)
    for (i = 0; i < n; i++)
        if (s[i] > 0)
        {
            printf("...");
            return(i);
        }
        else /* WRONG -- the compiler will match to closest */
                /* else-less if */
           printf("error - n is zero\n");

Switch

For readability, use the following format for switch statements:

switch (expression)
{
    case aaa:
        statement[s]
        break;
    case bbb: /* fall through */
    case ccc:
        statement[s]
        break;
    default:
        statement[s]
        break;
}

Note that the fall-through feature of the C switch statement should be commented for
future maintenance.

All switch statements should have a default case, which may be merely a “fatal error”
exit. The default case should be last and does not require a break, but it is a good idea
to put one there anyway for consistency.

[nixawk]

Iteration Control Statements

This section discusses the recommended formatting for iteration control statements.
Examples are given to show how to format single statements as well as blocks of
statements.

While

For one statement, use the following format:

while (expression)
    one_statement;

For a block of statements, use:

while (expression)
{
    statement_1;
    ...
    statement_n;
}

For

Use the following formats:

for (expression)
    one_statement;

for (expression)
{
    statement_1;
    ...
    statement_n;
}

If a for loop will not fit on one line, split it among three lines rather than two:

for (curr = *listp, trail = listp;
    curr != NULL;
    trail = &(curr->next), curr = curr->next)
{
    statement_1;
    ...
    statement_n;
}

Do While

For readability, use the following format:

do
{
    statement_1;
    statement_2;
    statement_3;
}
while (expression)