8

helmetpastoralSoftware and s/w Development

Dec 13, 2013 (3 years and 6 months ago)

65 views

Statement
-
Level Control Structures

Levels of Control Flow
, or execution sequence in a program



Within expressions



Among program units



Among program statements

Control Statements: Evolution



FORTRAN I control statements were based directly on IBM 704 hardware
. All were directly
related to machine language instructions.



Much research and argument in the 1960s about the issue



One important result: It was proven that all algorithms represented by flowcharts can
be coded with only two
-
way selection and pretest log
ical loops

(minimally required)

Control Structure



A
control structure

is a control statement and the
collection of
statements whose execution it
controls



Design question



Should a control structure
(selection and iteration)
have multiple entries?



The quest
ion is whether the execution of code segments (related to control statement)
begins with the 1
st

statement in the segment.



Multiple entries add little to the flexibility of a control structure, relative to the
decrease in readability caused by the increase
d complexity. Multiple entries are
possible only in languages that include
goto
s and statement labels.


Selection Statements



A
selection statement

provides the means of choosing between two or more paths of
execution

in a program.



Two general categories:



T
wo
-
way selectors



Multiple
-
way selectors

Two
-
Way Selection Statements



General form:


if control_expression



then clause



else clause



Design Issues:



What is the form and type of the control expression?



How are the
then

and
else

clauses specified?



How shoul
d the meaning of nested selectors be specified?



Control expressions are specified in parentheses if the
then

reserved word is not used to
introduce the then clause (like C
-
based languages)



In case using
then
, there is no need for the parentheses (like Ada)



In C89, which did not have a Boolean data type, arithmetic expressions were used as control
expressions.



In C99 and C++, either arithmetic or Boolean expressions can be used.



In Ada, Java, and C#, only Boolean expressions can be used for control expressio
ns.



In most new languages, the
then

and
else

clauses appear as either single statement or
compound statements.



One exception is Perl, all
then

and
else

clauses must be compound statements, even if they
contain single statement.



C
-
based, Perl, Java script,
and PHP, use braces to form compound statements.



Fortran 95, Ada, the
then

and
else

clauses are statement sequences. The last clause in a
selection construct in these languages is terminated with (
endif
).


Two
-
Way Selection: Example
s



FORTRAN:
IF

(boolean_
expr) statement



Problem: can select only a single statement; to select more, a
GOTO

must be used, as in the
following example


IF (.NOT. condition) GOTO 20



...


20 CONTINUE



Negative logic is bad for readability



This problem was s
olved in FORTRAN 77



Most later languages allow compounds for the selectable segment of their single
-
way
selectors

Two
-
Way Selection: Examples



ALGOL 60:


if
(boolean_expr)




then
statement (then clause)




else
statement (else clause)



The st
atements could be single or compound

Nesting Selectors



A problem arises when two
-
way selection constructs can be nested consider the following:



Java example



if (sum == 0)




if (count == 0)




result = 0;




el
se result = 1;



Which
if

gets the
else
?



This construct can be interpreted in two different ways, depending on whether the
else

clause
is matched with the first
then

clause or the second.



Java's static semantics rule:
else

matches with the nearest
if



To fo
rce an alternative semantics, compound statements may be used:



if (sum == 0) {




if (count == 0)




result = 0;



}






else result = 1;



The above solution is used in C, C
++, and C#



Perl requires that all then and else clauses to be compound

Multiple
-
Way Selection Statements



Allow the selection of one of any number of statements or statement groups



Design Issues:

1.

What is the form and type of the control expression?

The rang
e of possibilities is large,
because the number of possible statements is large. A two
-
ways selector needs an expression
with only two possible values.

2.

How are the selectable segments specified?

Single, compound, or statement sequence may be
selected.

3.

Is e
xecution flow through the structure restricted to include just a single selectable segment?

4.

What is done about unrepresented expression values?

Choice between disallow or do
nothing.

Multiple
-
Way Selection:
Examples



Early multiple selectors:



FORTRAN arithm
etic IF (a three
-
way selector)


IF (arithmetic expression) N1, N2, N3



Segments require
GOTO
s



Not encapsulated (selectable segments could be anywhere)

Multiple
-
Way Selection: Examples



Modern multiple selectors

(C, C++, Java)



C’s switch statement



switc
h (expression) {




case const_expr_1: stmt_1;









case const_expr_n: stmt_n;




[default: stmt_n+1]



}


Multiple
-
Way Selection: Examples



Design choices for C’s
switch
statement

1.

Control expression
and constant expressions
can be only an integer type

2.

S
electable segments can be statement sequences, blocks, or compound statements

3.

Any number of segments can be executed in one execution of the construct (there is
no implicit branch at the end of selectable segments)

4.

default
clause is for unrepresented value
s (if there is no

default
, the whole statement
does nothing)

-

Example:


}
index);

,
n"

%d
index

switch,
in

Error
printf("

:
default

index;
sumeven



1;
even

:
4

case

:
2

case

index;
sumodd



1;
odd

:
3

case
:
1

case

{

(index)

switch










-

This code

prints the error message on every execution, in addition to the execution of the rest
cases.

-

To separate these segments, an explicit branch mus
t be included (break statement).

-

The reliability problem arises when the mistaken absence of a break statement in a segment
allows control to incorrectly flow to the next segment. The C
switch

designer traded a decrease
in
reliability for an increase in fl
exibility.

-

C#
switch

statement has a static semantics rules disallows the implicit execution of more than
one segment.

-

The rule is that every selectable segment must end with an explicit unconditional branch
statement: either a
break
, which transfers contr
ol out of the
switch
, or a
goto
, which can
transfer control to one of the selectable segments.

-

Ex:


}
);
n"

switch
in

Error
iteLine("
Console.Wr

:
default

;
positive

:
1

case

break;


;
zero

:
0

case

break;


;

negative

:
1
-

case

{
(value)

switch







Multiple
-
Way Selection: Examples



The Ada case statement


case expression is



when choice list => stmt_sequence;







when ch
oice list => stmt_sequence;



when others => stmt_sequence;]


end case;



Where the expression is of ordinal type and the
when others

clause is optional.



The choice lists of Ada
case

statements are pften single literals, but they can also be
subranges, such
as 10..15



They can also use
OR

operators
( )

to create lists of literal
s.
10 15 20



whenothers

used for unrepresented values.



The values in the choice lists must be mutually exclusive. i.e. a constant may not appear in
more than one choice list.



More reliab
le than C’s switch (once a stmt_sequence execution is completed, control is
passed to the first statement after the case statement
. C, C++, and Java do not have implicit
exits after the selectable segments.

Multiple
-
Way Selection Using if



In many situation
s a
switch
or
case

construct is inadequate for multiple selection. Ex, when
selections must be made on the basis of a Boolean expression rather than some ordinal type,
nested two
-
way selectors can be used to simulate a multiple selector.



Multiple Selectors

can appear as direct extensions to two
-
way selectors, using else
-
if clauses,
for example in Ada:


if ...




then ...


elsif ...



then ...


elsif ...



then ...



else ...


end if



Consider the following Ada selector construct:


endif;
True;
:
Bag3

then

1000
count

elsif
True;
:
Bag2

then

100
count

elsif
True;
:
Bag1

then

10
count

if









This example is not easily simulated with a case statement, because each selectable statement
is chosen on the basis of a Boolean expression. Therefore. The
elsif

construct is not
redundant form of
case
.


Iterative Statements



An iterativ
e statement is one that causes a statement or collection of statements to be
executed zero, one, or more times.
An iterative construct is often called loop.



The repeated execution of a statement or compound statement is accomplished either by
iteration or
recursion



General design issues for iteration control statements:

1. How is iteration controlled?

2. Where is the control mechanism in the loop?




The primary possibility for iteration control are logical, counting, or a combination of the
two.



The main ch
oices for the location of the control mechanism are the top or the bottom of the
loop. A third option allows the user to decide where to put the control.



The body of the loop is the collection of statements whose execution is controlled by the
iteration st
atement.



Pretest means that the test for loop copletion occurs before the loop body is executed, while
posttest means it occurs after the loop body is executed.

Counter
-
Controlled Loops



A counting iterative statement has a loop variable, and a means of spe
cifying the
initial

and
terminal
, and
stepsize

values

(loop parameters)



Design Issues:

1.

What are the type and scope of the loop variable?

Integer, enumeration, character and
floating
-
pointtypes.

2.

What is the value of the loop variable at loop termination?

3.

Sh
ould it be legal for the loop variable or loop parameters to be changed in the loop
body, and if so, does the change affect loop control?

4.

Should the loop parameters be evaluated only once, or once for every iteration?

Iterative Statements: Examples



FORTR
AN 90 syntax


DO

label var = start, finish [, stepsize]



Stepsize can be any value but zero
, where it is absent, considered 1.



The label is that of the last statement in the loop body.



Parameters can be expressions



Design choices:

1. Loop variable must be
I
NTEGER

2. Loop variable always has its last value

3. The loop variable cannot be changed in the loop, but the parameters can; because they are
evaluated only once, it does not affect loop control
, because the value of evaluation is used to
compute an itera
tion count, which then has the number of times the loop is to be executed. The loop
is controlled by the iteration count
, not the loop parameters. The iteration count is an internal
variable that is inaccessible to the user code.

4. Loop parameters are eva
luated only once

5. Do constructs can be entered only through the
Do

statement, making the statement a single
-
entry
structure.

Example:

contine

10
....

10

1,
count

10

Do


Iterative Statements: Examples



FORTRAN 95 : a second form:


[name:] DO variable = initial, term
inal [,stepsize]





END DO [name]




Loop variable must be an
INTEGER

Example:

Do

End

10

1,
count

Do


Iterative Statements



Pascal’s for statement

for

variable := initial (
to
|
downto
) final
do

statement



Design choices:

1.

Loop variable must be
an ordinal type of usual scope

2.

After normal termination, loop variable is undefined

3.

The loop variable cannot be changed in the loop; the loop parameters can be changed,
but they are evaluated just once, so it does not affect loop control

4.

Just once

Iterativ
e Statements: Examples



Ada


for var in [reverse] discrete_range loop ...


end loop



A discrete range is a sub
-
range of an integer or enumeration type

(such as 1..10 or
Monday..Friday)



The
reverse

reserved word, when present, indicates that the

values of the discrete range are
assigned to the loop variable in revere order.



Stepsize is always one (next element of the discrete range).



Scope of the loop variable is the range of the loop



Loop variable is implicitly
declared at the
for

statement and
implicitly
undeclared

after loop
termination
. Example:

loop

end
count;
sum
:
sum
loop

1..10

in

count

for
1.35;
:
Float
:
count







The Float variable
count

is unaffected by the
for loop
. Upon loop termination, the variable
count

is still Float type with the value of 1.35. also, the Float
-
type variable
count

is hidden
from the code in the body of the loop, being masked by the loop counter
count
, which is
implicitly declared to be the type of the descrete range, Integer.



The Ada loop variable cannot be assigned a value in the loop body. Variables used to speci
fy
the discrete range can be changed in the loop, but because the range is evaluated only once,
these changes do not affect loop control.



It is not legal to branch into the Ada for loop body.

Iterative Statements: Examples



C’s for statement

for

([expr_1] ;

[expr_2] ; [expr_3])
loop body



Lop body can be a single statement, a compound statement, or a null statement.



The 1
st

expression is for initialization and is evaluated only once, when the
for

statement
execution begins.



The 2
nd

expression is the loop cont
rol and is evaluated before each execution of the loop
body.



In C, a zero value means false, and all non zero values mean true. So, if the value of 2
nd

expression is zero, the
for

is terminated.



In C99, the expression could be a Boolean type, which can sto
re only the

values 0 or 1.



The last expression in the
for

is executed after each execution of the loop body, which is used
to increment the lop counter.

...

)
count

10;
count

1.
(count

for







All of the expressions of C’s
for

are optional. An absent of 2
nd

expression is
considered true,
considered infinite loop.



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



There

is no explicit loop variable



Everything can be changed in the loop

(i.e. variables appeared in loop parameter expression
can be changed in the loop body).



The first expression is evaluated once, but the other two are evaluated with each iteration



It is le
gal to branch into a C
for

loop body.



C’s
for

is more flexible than the counting loop statements of Fortran and Ada, because each
of the expressions can comprise multiple statements, which in turn allow multiple loop
variables that can be of any type.

Ex:

body.

loop

a

have

not

does


2.5);
count2*

count2,
count1
m
su
100.0;
cpount2

&
&

10
count1


1.0;
count2

0,
(count1

for










Iterative Statements: Examples



C++ differs from C in two ways:

1.

The control expression can also be Boolean

2.

The initial expression can include variable definitions (scope is from the definition to
the end of the loop body)


{...}

)
count

len;
count

0;
count

(int

for







Java and C#

1.

Differs from C++ in that the control expression must be Boolean


Iterative Statements: Logically
-
Controlled Loops



Repetition control is based on a Boolean



Logically controlled loops are more general than counter
-
controlled
loops> every counting
loop can be built with a logical loop, but the reverse is not true.



It is legal in both C and C++ to branch into while and do loop bodies
.



C89 version uses arithmetic expression for control.



C99 and C++ may be either arithmetic or Boo
lean.



Design issues:



Sould the control be p
re
-
test or post
-
test?



Should the logically controlled loop be a special case of the counting loop statement ?
expression rather than a counter



The C
-
based languages include both pre
-
test and post
-
test logically co
ntrol loops that are not
special forms of their counter
-
controlled iterative statements.



General forms:


while (ctrl_expr)


d
o



loop body




loop body







while (ctrl_expr)


Iterative Statements: Logically
-
Controlled Loops: Exam
ples



Pascal has separate pre
-
test and post
-
test logical loop statements (
while
-
do

and
repeat
-
until
)



C and C++ also have both



Java is like C, except the control expression must be Boolean (and the body can only be
entered at the beginning
--

Java has no
got
o

Iterative Statements: Logically
-
Controlled Loops: Examples



Ada has a pretest version, but no post
-
test



FORTRAN 77 and 90 have neither



Perl has two pre
-
test logical loops,
while

and
until
. The
until

is similar to
while
, but uses the
inverse of the value o
f the control expression.

Iterative Statements: User
-
Located Loop Control Mechanisms



Sometimes it is convenient for the programmers to decide a location for loop control (other
than top or bottom of the loop)



Simple design for single loops (e.g., break)



De
sign issues for nested loops

1.

Should the conditional be part of the exit?

2.

Should control be transferable out of more than one loop?

Iterative Statements: User
-
Located Loop Control Mechanisms
break

and
continue



C , C++, and Java:
break

statement



Unconditiona
l

unlabeled exits
; for any loop or
switch
; one level only
(last in Perl).



Java and C# have a labeled break statement: control transfers to the label



Example of nested loop in Java, in which there is a
break

out of the outer loop from the
nested loop.

}


outerLoop;

break



1000.0)
(sum

if



ol];
mat[row][c
sum


{


)
col

numCol;
col

0;
(col

for


)
row

numRows;
row
0;
(row

for

:
outerLoop














C, C++ include an unlabeled control statement
:
continue

statement; it skips the remainder of
this iteration, but does not exit the loop



Ex:


}
value;
sum

continue;

0)
(value

if

lue);
getnext(va

{
1000)
(sum

while







A negative value causes the assignment statement to be skipped.



On th
e other hand, in:


}
value;
sum
break;

0)
(value

if

lue);
getnext(va

{
1000)
(sum

while







A negative value terminates the loop.



Java and Perl have statements similar to continue, except that they can
include

labels that
specify which loop is to be continued.



The motivation for user
-
located loop exits

is to fulfill a need for
goto

statement through
highly restricted branch statement.



The target of a
goto

can be many places above and below the
goto

itself. While the
target of
user
-
located loops

exits must be below the
exit

and follow the end of a compou
nd statement.


Iterative Statements: Iteration Based on Data Structures

(Iteration controlled by a data
structure)



Rather than counter or Boolean expression control the iterations, these loops are controlled
by the n
umber
of
elements in a data structure
.



Perl, Java Script, PHP, Java, and C# have such statements.



Control mechanism is a call to an
iterator

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



C's
for

can be used to build a user
-
defined iterator:


for (p=root; p==NULL; traverse(p)){

}



In this statement, traverse is the iterator.



C#’s foreach statement iterates on the elements of arrays and other collections:




String[] strList = {“Bob”, “Carol”, “Ted”};


foreach (String name in strList)



Con
sole.WriteLine (“Name: {0}”, name);




The notation {0} indicates the position in the string to be displayed

Unconditional Branching



Transfers execution control to a specified place in the program



Represented one of the most heated debates in 1960’s and 1970
’s



Well
-
known mechanism: goto statement



Major concern: Readability



Some languages do not support goto statement (e.g., Module
-
2 and Java)



C# offers goto statement (can be used in switch statements)



Loop exit statements are restricted and somewhat camouflag
ed goto’s

Guarded Commands



Suggested by Dijkstra



Purpose: to support a new programming methodology that supported verification
(correctness) during development



Basis for two linguistic mechanisms for concurrent programming (in CSP and Ada)



Basic Idea: if t
he order of evaluation is not important, the program should not specify one

Selection Guarded Command



Form

if <Boolean exp>
-
> <statement>

[] <Boolean exp>
-
> <statement>


...

[] <Boolean exp>
-
> <statement>

fi



Semantics: when construct is reached,



Eval
uate all Boolean expressions



If more than one are true, choose one non
-
deterministically



If none are true, it is a runtime error

Selection Guarded Command: Illustrated



Loop Guarded Command



Form

do <Boolean>
-
> <statement>

[] <
Boolean>
-
> <statement>


...

[] <Boolean>
-
> <statement>

od



Semantics: for each iteration



Evaluate all Boolean expressions



If more than one are true, choose one non
-
deterministically; then start loop again



If none are true, exit loop

Loop Guarded Command:
Illustrated




Guarded Commands: Rationale



Connection between control statements and program verification is intimate



Verification is impossible with goto statements



Verification is possible with only selection and logical prete
st loops



Verification is relatively simple with only guarded commands