CHAPTER 10:

STATEMENTS

In the C language, statements can be written only within the body of a function; more specifically, only within compound statements. The normal flow of control among statements is sequential, proceeding from one statement to the next. However, as we shall see, most of the statements in C are designed to alter this sequential flow so that algorithms of arbitrary complexity can be implemented. This is done with statements that control whether or not other statements execute and, if so, how many times. Furthermore, the ability to write compound statements permits the writing a sequence of statements wherever a single, possibly controlled, statement is allowed. These two features provide the necessary generality to implement any algorithm, and to do it in a structured way.

The C language uses semicolons as statement terminators. A semicolon follows every simple (non-compound) statement, even the last one in a sequence.

When one statement controls other statements, a terminator is applied only to the controlled statements. Thus we would write

		if(x > 5) x = 0; else ++x; 

		while(x < 5) {func(); ++x;}

Null Statements

The simplest C statement is the null statement. It has no text, just a semicolon terminator. As its name implies, it does exactly nothing. Why have a statement that serves no purpose? Well, as it turns out, statements that do nothing can serve a purpose. As we saw in Chapter 9, expressions in C can do work beyond that of simply yielding a value. In fact, in C programs, all of the work is accomplished by expressions; this includes assignments and calls to functions that invoke operating system services such as input/output operations. It follows that anything can be done at any point in the syntax that calls for an expression. Take, for example, the statement

		while(...) ;

Compound Statements

The terms compound statement and block both refer to a collection of statements that are enclosed in braces to form a single unit. Compound statements have the form

		{ObjectDeclaration?... Statement?... }

ObjectDeclaration?... is an optional set of local declarations. If present, Small C requires that they precede the statements; in other words, they must be written at the head of the block. Statement?... is a series of zero or more simple or compound statements. Notice that there is not a semicolon at the end of a block; the closing brace suffices to delimit the end.

The power of compound statements derives from the fact that one may be placed anywhere the syntax calls for a statement. Thus any statement that controls other statements is able to control units of logic of any complexity.

When control passes into a compound statement, two things happen. First, space is reserved on the stack for the storage of local variables that are declared at the head of the block. Then the executable statements are processed.

When control leaves a compound statement, the stack is restored to its original condition. For more on local declarations, see Chapters 4-6.

One important limitation in Small C is that a block containing local declarations must be entered through its leading brace. This is because bypassing the head of a block effectively skips the logic that reserves space for local objects. Since the goto and switch statements (below) could violate this rule, Small C mutually excludes from any function goto statements and declarations at levels below the function body, and it disallows declarations within switch statements. Full C has no such restrictions, however. As it turns out, these restrictions are seldom encountered, since most people declare all of their locals at the head of function bodies, and it is fairly unusual to see locals declared in blocks within switch statements.

Expression Statements

The C language is unusual in its provision for expression statements--expressions which the compiler accepts as complete statements. We saw in Chapter 8 that this generalization leads to the elimination of procedures as a distinct class of subroutine and the elimination of special call statements for invoking them. This feature and the provision of assignment operators also leads to the elimination of a special assignment statement.

The value produced by an expression statement is not used under normal conditions. In fact, some compilers optimize such values into oblivion. But Small C goes ahead and produces them in its primary register and then ignores them. It is possible, however, to utilize these values by inserting assembly language code after the expression statement. See Chapter 11 for details.

As we noted above, the work in C programs is really done by expressions. Function calls, assignments, increments, and decrements are all performed during expression evaluation. That being the case, it follows that C must provide for the normal sequential evaluation of expressions; it must support expression statements.

Some examples of valid expression statements are:

		func();
		++i;
		i = 15, j = 16, k = 17;
		x += func(x, y = 12) * 100;  

Goto statements break the sequential flow of execution by causing control to jump abruptly to designated points. They have the general form

		goto Name ;

		Name :

As we observed above, goto statements, cannot be used in functions which declare locals in blocks which are subordinate to the outermost block of the function.

Goto statements should be used sparingly, if at all. Over reliance on them is a sure sign of sloppy thinking. Strictly speaking, they are never absolutely necessary. In fact the original Small C compiler did not even support goto statements. But situations do occasionally arise in which a goto can save the writing of redundant statements. To keep the meaning of your logic clear, you should try to limit the distance between goto statements and their target labels. It also helps to write labels so they stand out from their surrounding code; for instance, placing a blank line above a label helps.

The If Statement

If statements provide a non-iterative choice between alternate paths based on specified conditions. They have either of two forms

		if ( ExpressionList ) Statement

		if ( ExpressionList ) Statement 

ExpressionList is a list of one or more expressions and Statement is any simple or compound statement. First, ExpressionList is evaluated and tested. If more than one expression is given, they are evaluated from left to right and the right-most expression is tested. If the result is true (non-zero), then the first (or only) statement is executed and the one following the keyword else (if present) is skipped. If it is false (zero), the first statement is skipped and the second (if present) is executed. For example, the statement

		if (ch) {
			putchar(ch);
			++i;
			}
		else return (i);

The Switch Statement

Switch statements provide a non-iterative choice between any number of paths based on specified conditions. They compare an expression to a set of constant values. Selected statements are then executed depending on which value, if any, matches the expression. Switch statements have the form

		switch ( ExpressionList ) { Statement?...}

The case prefix has the form

		case ConstantExpression : 

		default: 

After evaluating ExpressionList, a search is made for the first matching case prefix. Control then goes directly to that point and proceeds normally from there. Other case prefixes and the default prefix have no effect once a case has been selected; control flows through them just as though they were not even there. If no matching case is found, control goes to the default prefix, if there is one. In the absence of a default prefix, the entire compound statement is ignored and control resumes with whatever follows the switch statement. Only one default prefix may be used with each switch. Full C compilers reject multiple case prefixes with the same value; however, Small C accepts them but effectively sees only the first one.

If it is not desirable to have control proceed from the selected prefix all the way to the end of the switch block, break statements may be used to exit the block. Break statements have the form

		break; 

		switch (ch) {
			case 'Y':
			case 'y': cptr = "yes";
				 break;
			case 'N':
			case 'n': cptr = "no";
				 break;
			default: cptr = "error";
			}

The statement

		switch (i) {
			default: putchar ('a');
			case 2: putchar ('b');
			case 3: putchar ('c');
			}

The body of the switch is not a normal compound statement since local declarations are not allowed in it or in subordinate blocks. This restriction enforces the Small C rule that a block containing declarations must be entered through its leading brace.

The While Statement

The while statement is one of three statements that determine the repeated execution of a controlled statement. This statement alone is sufficient for all loop control needs. In fact it was the only such statement supported by the original Small C compiler. The other two merely provide an improved syntax and an execute-first feature. While statements have the form

		while ( ExpressionList ) Statement

In the example

		i = 5;
		while (i) array[--i] = 0;

It is common to see while statements where the statement being controlled is null and all of the work is done in the expression being tested. In the statement

		while (*dest++ = *sour++) ;

Two other statements are handy for use with the while (or any loop controlling) statement when it controls a compound statement. The continue statement has the form

		continue; 

The break statement (described earlier) may also be used to break out of loops. It causes control to pass on to whatever follows the loop controlling statement. If while (or any loop or switch) statements are nested, then break affects only the innermost statement containing the break. That is, it exits only one level of nesting.

It is not uncommon to see while statements such as

		while (1) {
			...
			if(...) break;
			...
			}

The For Statement

The for statement also controls loops. It is really just an embellished while in which the three operations normally performed on loop-control variables (initialize, test, and modify) are brought together syntactically. It has the form

		for ( ExpressionList? ;
			ExpressionList? ;
			ExpressionList? ) Statement

For statements are performed in the following steps:

1. The first ExpressionList is evaluated. This is done only once to initialize the control variable(s).
2. The second ExpressionList is evaluated to determine whether or not to perform Statement. If more than one expression is given, the right-most expression yields the value to be tested. If it yields false (zero), control passes on to whatever follows the for statement. But, if it yields true (non-zero), Statement executes.
3. The third ExpressionList is then evaluated to adjust the control variable(s) for the next pass, and the process goes back to step 2.

		for (i = 4; i >= 0; --i) array[i] = 0; 

		for (i = 5; i; array[--i] = 0) ; 

		for (;;) {...break;...} 

As with the while statement, break and continue statements may be used with equivalent effects. A break statement makes control jump directly to whatever follows the for statement. And a continue skips whatever remains in the controlled block so that the third ExpressionList is evaluated, after which the second one is evaluated and tested. In other words, a continue has the same effect as transferring control directly to the end of the block controlled by the for.

The Do Statement

The do statement is the third loop controlling statement in C. It is really just an execute-first while statement. It has the form

		do Statement while ( ExpressionList ) ;

1. Statement is executed.
2. Then, ExpressionList is evaluated and tested. If more than one expression is given, the right most expression yields the value to be tested. If it yields true (non-zero), control goes back to step 1; otherwise, it goes on to whatever follows.

The example of the five-element array could be written as

		i = 4;
		do {array[i] = 0; --i;} while (i >= 0); 

		i = 4;
		do array[i--] = 0; while (i >= 0); 

		i = 5;
		do array[--i] = 0; while (i); 

The return statement is used within a function to return control to the caller. Return statements are not always required since reaching the end of a function always implies a return. But they are required when it becomes necessary to return from interior points within a function or when a useful value is to be returned to the caller. Return statements have the form

		return ExpressionList? ; 

Missing Statements

It may be surprising that nothing was said about input/output, program control, or memory management statements. The reason is that such statements do not exist in the C language proper.

In the interest of portability these services have been relegated to a set of standard functions in the run-time library. Since they depend so heavily on the run-time environment, removing them from the language eliminates a major source of compatibility problems. Each implementation of C has its own library of standard functions which perform these operations. Since different compilers have libraries that are pretty much functionally equivalent, programs have very few problems when they are compiled by different compilers. Chapter 12 describes the standard functions of the Small C compiler.