Chapter 6: Flow of Control

What's in Chapter 6?

Every procedural language provides statements for determining the flow of control within programs. Although declarations are a type of statement, in C the unqualified word statement usually refers to procedural statements rather than declarations. In this chapter we are concerned only with procedural 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.

Simple Statements

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;

with two semicolons, not three. Perhaps one good way to remember this is to think of statements that control other statements as "super" statements that "contain" ordinary (simple and compound) statements. Then remember that only simple statements are terminated. This implies, as stated above, that compound statements are not terminated with semicolons. Thus

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

is perfectly correct. Notice that each of the simple statements within the compound statement is terminated.

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, 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. In this example the local variable temp is only defined within the inner compound statement.

int main(void){ short n1,n2;
  n1=1; n2=2;
  { short temp;
    temp=n1; n1=n2; n2=temp; /* switch n1,n2 */
  }
  return 1;
}

Listing 6.1: Examples of a compound statements

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.

One important limitation in 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.

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 ) Statement1

or

if ( ExpressionList ) Statement1
else Statement2

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 Statement1 is executed and the Statement2 (if present) is skipped. If it is false (zero), then Statement1 is skipped and Statement2 (if present) is executed. In this first example, the function isGreater() is executed if G2 is larger than 100.

if(G2 > 100) isGreater();

A 3-wide median filter can be designed using if-else conditional statements.

short Median(short u1,short u2,short u3){ short result;
  if(u1>u2)
    if(u2>u3)    result=u2;   // u1>u2,u2>u3       u1>u2>u3
    else
       if(u1>u3) result=u3;   // u1>u2,u3>u2,u1>u3 u1>u3>u2
       else      result=u1;   // u1>u2,u3>u2,u3>u1 u3>u1>u2
  else
    if(u3>u2)    result=u2;   // u2>u1,u3>u2       u3>u2>u1
    else
       if(u1>u3) result=u1;   // u2>u1,u2>u3,u1>u3 u2>u1>u3
       else      result=u3;   // u2>u1,u2>u3,u3>u1 u2>u3>u1
  return(result):}

For more information on the design and analysis of digital filters,  see Chapter 5 of Embedded Systems: Real-Time Operating Systems for ARM Cortex M Microcontrollers by Jonathan W. Valvano

Complex conditional testing can be implemented using the relational and Boolean operators described in the last chapter.

if ((G2==G1)||(G4>G3)) True(); else False();

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?...}

where ExpressionList is a list of one or more expressions. Statement?... represents the statements to be selected for execution. They are selected by means of case and default prefixes--special labels that are used only within switch statements. These prefixes locate points to which control jumps depending on the value of ExpressionList. They are to the switch statement what ordinary labels are to the goto statement. They may occur only within the braces that delimit the body of a switch statement.

The case prefix has the form

case ConstantExpression :

and the default prefix has the form

default:

The terminating colons are required; they heighten the analogy to ordinary statement labels. Any expression involving only numeric and character constants and operators is valid in the case prefix.

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.

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;

Some examples may help clarify these ideas. Assume Port A is specified as an output, and bits 3,2,1,0 are connected to a stepper motor. The switch statement will first read Port A and the data with 0x0F (GPIO_PORTA_DATA_R&0x0F). If the result is 5, then PortA is set to 6 and control is passed to the end of the switch (because of the break). Similarly for the other 3 possibilities

#define GPIO_PORTA_DATA_R       (*((volatile unsigned long *)0x400043FC))
void step(void){ /* turn stepper motor one step */ 
   switch (GPIO_PORTA_DATA_R&0x0F) {
      case 0x05:
         GPIO_PORTA_DATA_R=0x06; // 6 follows 5;
         break;
      case 0x06:
         GPIO_PORTA_DATA_R=0x0A; // 10 follows 6;
         break;
      case 0x0A:
         GPIO_PORTA_DATA_R=0x09; // 9 follows 10;
         break;
      case 0x09:
         GPIO_PORTA_DATA_R=0x05; // 5 follows 9;
         break;
      default:
         PORTA=0x05; // start at 5
   }
}

For more information on stepper motors, see Section 8.8 of Embedded Systems: Introduction to ARM Cortex M Microcontrollers  or Section 6.5 of Embedded Systems: Real-Time Interfacing to ARM Cortex M Microcontrollers  by Jonathan W. Valvano..

This next example shows that the multiple tests can be performed for the same condition.

// ASCII to decimal digit conversion
unsigned char convert(unsigned char letter){ unsigned char digit;  
   switch (letter) {
      case 'A':
      case 'B':
      case 'C':
      case 'D':
      case 'E':
      case 'F':
         digit=letter+10-'A';
         break;
      case 'a':
      case 'b':
      case 'c':
      case 'd':
      case 'e':
      case 'f':
         digit=letter+10-'a';
         break;
      default:
          digit=letter-'0';
   }
   return digit; }      

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 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. The other two merely provide an improved syntax and an execute-first feature. While statements have the form

while ( ExpressionList ) Statement

where ExpressionList is a list of one or more expressions and Statement is an simple or compound statement. If more than one expression is given, the right-most expression yields the value to be tested. First, ExpressionList is evaluated. If it yields true (non-zero), then Statement is executed and ExpressionList is evaluated again. As long as it yields true, Statement executes repeatedly. When it yields false, Statement is skipped, and control continues with whatever follows.

In the example

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

elements 0 through 4 of array[ ] are set to zero. First i is set to 5. Then as long as it is not zero, the assignment statement is executed. With each execution i is decremented before being used as a subscript.

It is common to use the while statement to implement busy-wait loops. For information on the UART see Section 8.2 of Embedded Systems: Introduction to ARM Cortex M Microcontrollers by Jonathan W. Valvano.

//------------UART_InChar------------
// Wait for new serial port input
// Input: none
// Output: ASCII code for key typed
unsigned char UART_InChar(void){
  while((UART1_FR_R&0x10) != 0);
  return((unsigned char)(UART1_DR_R&0xFF));
}
//------------UART_OutChar------------
// Output 8-bit to serial port
// Input: letter is an 8-bit ASCII character to be transferred
// Output: none
void UART_OutChar(char data){
  while((UART1_FR_R&0x20) != 0);
  UART1_DR_R = data;
}    

Continue and break statements are handy for use with the while statement (also helpful for the do and for loops). The continue statement has the form

continue;

It causes control to jump directly back to the top of the loop for the next evaluation of the controlling expression. If loop controlling statements are nested, then continue affects only the innermost surrounding statement. That is, the innermost loop statement containing the continue is the one that starts its next iteration.

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.

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:

The first ExpressionList is evaluated. This is done only once to initialize the control variable(s).

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.

The third ExpressionList is then evaluated to adjust the control variable(s) for the next pass, and the process goes back to step 2. E.g.,

for(J=100;J<1000;J++) { process();}

A five-element array is set to zero, could be written as

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

or a little more efficiently as

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

Any of the three expression lists may be omitted, but the semicolon separators must be kept. If the test expression is absent, the result is always true. Thus

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

will execute until the break is encountered.

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 ) ;

Statement is any simple or compound statement. The do statement executes in the following steps: first Statement is executed. 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.

As with the while and for statements, break and continue statements may be used. In this case, a continue causes control to proceed directly down to the while part of the statement for another test of ExpressionList. A break makes control exit to whatever follows the do statement.

I=100; do { process(); I--;} while (I>0);

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

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

or as

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

or as

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

The Return Statement

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? ;

ExpressionList? is an optional list of expressions. If present, the last expression determines the value to be returned by the function. If absent, the returned value is unpredictable.

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 5, 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

in which the ((UART1_FR_R&0x20) != 0) controls the execution of the null statement following. The null statement is just one way in which the C language follows a philosophy of attaching intuitive meanings to seemingly incomplete constructs. The idea is to make the language as general as possible by having the least number of disallowed constructs.

The Goto Statement

Goto statements break the sequential flow of execution by causing control to jump abruptly to designated points. They have the general form goto Name where Name is the name of a label which must appear in the same function. It must also be unique within the function.

short data[10];
void clear(void){ short n;
      n=1;
loop: data[n]=0;
      n++;
      if(n==10) goto done;
      goto loop;
done:
}

Listing 6.6: Examples of a goto statements

Notice that labels are terminated with a colon. This highlights the fact that they are not statements but statement prefixes which serve to label points in the logic as targets for goto statements. When control reaches a goto, it proceeds directly from there to the designated label. Both forward and backward references are allowed, but the range of the jump is limited to the body of the function containing the goto statement.

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.

Because they violate the structured programming criteria, goto statements should be used sparingly, if at all. Over reliance on them is a sure sign of sloppy thinking.

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 that 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.

Go to Chapter 7 on Pointers Return to Table of Contents