(8.1)COEN 171 - Control Structures

Control structure general issues Compound statements Selectors (conditional structures)

– single– two-way– multiway

Iteration– counter controlled– logical– intest– user-defined

Guarded commands

(8.2)Control Structure General Issues

Can consider control flow at several levels– within expressions

» associativity, operator precedence, order of evaluation

– between program units» procedures, coroutines, concurrency

– between statements» normal control flow is sequential

A control structure is a control statement and the statements whose execution it controls

To solve any programming problem, at minimum need (Bohm and Jacopini, 1966)– sequence– means of choosing between alternatives– means of repeating execution of statements

(8.3)Control Structure General Issues (cont.)

Much activity into control structure design in 1965 - 1975– single entry - exit for all structures preferable– unrestricted GOTOs are problematical

Overall design question– what control statements should a language have,

beyond selection and pretest logical loops? Control structure design trades off

– expressiveness (many control structures)– readability (few control structures)

(8.4)Compound Statements

Many (older) languages specify only single statements as targets of many actions

Compound statement is way to group many statements together so they are treated as one– begin end in most languages

» Algol 60 was first to use– { } in C, C++, Java

If the compound statement can also scope variables it’s referred to as a block– Most modern languages

Modern languages use syntax to avoid compound stmts– if <condition> Algol 68– then <statements>– else <statements>– fi

(8.5)Selector Statements

Allow execution of alternative statement sequences based on a test

Design issues– what is the form and type of the control expression?– what is the selectable segment form (single

statement, statement sequence, compound statement)?

– how is the meaning of selectors nested in then clauses of other selectors specified?

Single selector (simple conditional)– some languages (FORTRAN, BASIC) provide explicitly

» IF ( <Boolean expression> ) <statement>» bad because requires GOTOs to make a 2-way selector

– for that reason most make this a special case of

(8.6)Two-Way Selector

Also called 2-alternative conditional– if <condition> then <statement> else

<statement> “Dangling else” problem

– solve with semantics (Pascal)– forbid nesting unless embedded in compound

statement (ALGOL 60)– solve with reserved words to mark the end of each

if statement (Algol 68, Ada)» provides both flexibility and reliability

– Modula-2 follows last approach with same word used to end all statements» flexibility but reduced reliability

(8.7)Multiple Selector

Also called multi-alternative conditional– choose among 3 or more alternatives

Design issues– what is the form and type of the control expression?– what segments are selectable (single, compound,

sequential)?– is the construct encapsulated?– is execution flow through the structure restricted to

include just a single selectable segment?– what is done about unrepresented expression values?

Examples– FORTRAN arithmetic if

» IF ( <integer expression> ) labelneg, label0, labelpos» not encapsulated - needs GOTOs

(8.8)Multiple Selector (continued)

Examples (continued)– C switch

» switch (index) {» case 1:» case 3:odd += 1;» sumodd += index;» case 2:» case 4:even += 1;» sumeven += index;» default: printf (“error in

switch”); }» select statement based on value in index

• integer only

» straight line control flow after that• default always executes

» unless break executed to transfer to statement after switch

(8.9)Multiple Selector (continued)

Examples (continued)– case statements (implicit break in alternatives)

» case index is» when 1 | 3 => odd := odd + 1;» sumodd := sumodd + 1;» when 2 | 4 => even := even + 1;» sumeven := sumeven +

1;» when others => put (“error in case”);» end case;» selector type is any ordinal» Ada requires others clause» original Pascal left undefined what happens if no case

for index value» ISO Pascal says run-time error

(8.10)Multiple Selector (continued)

Examples (continued)– elsif (allows multiple tests like nested if, but easier

to read)» if COUNT < 10» then BAG1 := TRUE;» elsif COUNT < 100» then BAG2 := TRUE;» elsif COUNT < 1000» then BAG3 := TRUE;» else BAG4 := FALSE;» end if;

– how is this different than case/switch or nested If-Then-Else?» syntactically?» logically?» with respect to implementation?

(8.11)Iteration (loops)

Categorize by– how iteration is controlled

» logical loop» counter-controlled loop

– where control mechanism appears in loop» pretest

• before loop body

» intest • in middle of loop body

» posttest • after loop body

– logical direction of test» termination test ( repeat - until)

• stop if test true

» continuation test (while - do)• loop if test true

(8.12)Counter-controlled loops

for I := 1 to 207 step N do– I is iteration control variable (ICV) or loop variable– 1, 207, N are loop parameters– all pretest loops except FORTRANs before 77

ICV design issues– legal types for ICV

» typically discrete» FORTRAN IV integer only» FORTRAN 77, 90 also allow real and double

– can ICV be modified inside the loop » usually no

– scope (Ada scopes ICV to just the loop)– value at termination

» undefined (Pascal, FORTRAN IV)» last value assigned (most)» unbound (Ada)

(8.13)Counter-controlled loops (continued)

Effect of loop parameter changes– none (most languages)

» calculate trip count from parameter values before loop execution

– affect loop (Algol 60, PL/I, COBOL)» Pascal Algol 60» for I := 1 to N do for I := 1 step 1 until N do» N := N + 1; N := N + 1;» { doubles N} { infinite loop if N >1 at

start}

(8.14)General Loops

Combine counting and other forms of loop control– great flexibility– can be confusing

Algol 60– for var := <list_of_stuff> do statement where

<list_of_stuff> is» list of expressions» expression step expression until expression» expression while boolean_expression

for index := 1 step 2 until 50, 60, 70, 80, index + 1 until 100 do

(index = 1, 3, 5, 7, ..., 49, 60, 70, 80, 81, 82, ..., 100)

(8.15)General Loops (continued)

Algol 60 (continued)– ICV can’t be changed inside loop– paramters can and affect loop behavior

» evaluated each time through C

– for ([expr_1] ; [expr_2] ; [expr_3]) statement» the expressions can be whole statements, or even

statement sequences, with the statements separated by commas

» the value of a multiple-statement expression is the value of the last statement in the expression

» if the second expression is absent, it is an infinite loop

– for (sum = 0.0, count = 0; count <= 10 && sum < 1000.0; sum = sum + count++)

– everything can be changed inside the loop» and affects loop behavior

– most flexible loop statement

(8.16)Intest Loops

Provide controlled goto mechanism with destination limited to statement following loop– C break, Modula-2 exit– FORTRAN 90 exit [ < loopname > ]

» exit multiple levels of loop

– Ada exit [ < loopname > ] [ when < condition > ]

Also have statements that transfer to the control mechanism at the end of the loop– C continue– FORTRAN 90 cycle [ < loopname > ]

Usually used for dealing with exceptional conditions in loop (exit if encounter something which will cause errors in rest of loop)

(8.17)User-Defined Iteration Control

Use order and number of elements of some data structure to control iteration– also called iterator– control mechanism is a call to a user-defined

function that returns the next element in some chosen order, if there is one; else exit loop

Examples– COMMON LISP (DOLIST L) function

» executes body once for each top level element in the list

– C's for can be used to build a user-defined iterator» assume p is a pointer to a linked list» for (p=hdr; p; p=next(p)) { ... }

(8.18)Unconditional Branching

Problem is readability– so some languages don’t allow them– Modula-2, CLU, Euclid

Label forms – unsigned int constants

» Pascal (with colon)» FORTRAN (no colon)

– identifiers with colons» ALGOL 60, C, PL/I

– identifiers in << ... >>» Ada

– variables as labels» PL/I » can be assigned values and passed as parameters» highly flexible, but make program impossible to read

and difficult to implement

(8.19)Guarded Commands

All of the previous control structures can be implemented with if-then-elses and gotos

Dijkstra proposed two non-deterministic control structures in 1975 that can’t be implemented that way

selector– if < Boolean expr > <statement

sequence>– [] < Boolean expr > < statement sequence

>– fi– semantics:

» evaluate all guards; true guards are open» non-deterministically select one open guard and

execute stmts» if no guards true, run time error

guard

if x >= y max := x

[] y >= x max := y

fi

(8.20)Guarded Commands (continued)

Iteration– do < Boolean expr > < statement

sequence >– [] < Boolean expr > < statement

sequence >– od– semantics:

» evaluate guards» execute statements for one open guard» repeat until no guards are open

do q1 > q2 swap (q1, q2)

[] q2 > q3 swap (q2, q3)

[] q3 > q4 swap (q3, q4)

od

(8.21)Guarded Commands (continued)

Good models for concurrency Connection between control statements and

program verification is intimate– verification is impossible with gotos– verification is possible with only selection and

logical pretest loops– verification is relatively simple with only guarded

commands Never implemented in a real language, but

similar syntax in ADA concurrency statements