home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Simtel MSDOS - Coast to Coast
/
simteldosarchivecoasttocoast2.iso
/
modula2
/
mod2txt.zip
/
CHAP4.TXT
< prev
next >
Wrap
Text File
|
1987-03-25
|
18KB
|
388 lines
Chapter 4 - Modula-2 Loops and Control Structures
Loops are some of the most important and most used
constructs in computer programming and in all parts of your
life. You use loops all the time for many things. Walking
is a repetition of putting one foot in front of the other
until you get where you are going. Eating a sandwich
involves a loop of eating, chewing, swallowing, etc. In
this chapter we will first cover all of the possible loops
you can define in Modula-2, then go on to the control
structures, the decision makers.
Load and display the program LOOPDEMO.MOD. This is a
rather large program compared to the ones we have seen so
far, but I felt it would be better to cover all of the loops
in one file than have you compile and run 4 different files.
REPEAT ... UNTIL LOOP
Ignoring the declaration part of the listing and going
straight to the program itself, we first come to the REPEAT
loop which does just what it says it will do. It will
repeat until it is told to stop. The REPEAT in line 16 and
the UNTIL go together, and everything between them will be
executed until the condition following the UNTIL becomes
TRUE. The condition can be any expression that will
evaluate to a BOOLEAN answer, TRUE or FALSE. It can even be
a composite expression with AND's, OR's, and NOT's like we
studied in the last chapter. It can be composed of any of
the simple types discussed so far as long as the terms are
all compatible and it evaluates to a BOOLEAN value. In this
case we have a very simple expression, "Index = 5". Since
"Index" is initialized to 0 and is incremented each time we
go through the loop, it will eventually reach a value of 5
and the loop will terminate, after which time the
expressions following it will be executed.
We are not quite finished with the REPEAT loop yet, we
will have more to say about it when we complete the WHILE
loop.
WHILE LOOP
The WHILE loop is very much like the REPEAT loop except
that the condition is tested at the beginning of the loop
and when the condition becomes FALSE, the loop is
terminated. Once again, the condition can be as complex as
desired but in this case it is the very simple "Index < 5".
When Index reaches 5, the loop is terminated and the
statements following the loop are executed.
The biggest difference between the REPEAT and the WHILE
loops is concerned with when the test is made. In the WHILE
Page 23
Chapter 4 - Modula-2 Loops and Control Structures
loop, the test is made at the beginning, so it is possible
that the statements inside the loop will not be executed
even once. In the REPEAT loop, the test is made at the end
of the loop, so the statements in the loop will always be
executed at least once. It is also good to keep in mind
that the REPEAT stops when its condition goes TRUE, and the
WHILE stops when its condition goes FALSE.
There is another loop that we can use in which we exit
from the center using any test we can devise. It will be
covered after we complete the FOR loop.
THE FOR LOOP
The FOR loop exists in one form or another in nearly
every programming language and you will use it repeatedly
because it is so useful. It uses the reserved words FOR,
TO, BY, DO, and END. It uses any simple variable type
except REAL, and counts loops depending on what counts you
put in for beginning and ending points. The first example
on line 31 says for the computer to start "Index" at 1 and
count to 5, going through the loop once for each value of
"Index". The count advances by 1 each time because nothing
else is specified and 1 is the default. The end of the loop
is specified by the reserved word END, and as many
statements as desired can be within the body of the loop.
The next loop starts in line 37 and this time counts
from 5 to 25 but incrementing by 4 each time because of the
"BY 4" part of the line. The loop will continue until the
second limit is going to be exceeded, at which time the loop
will stop. The beginning and ending limits can themselves
be some kind of a calculated value or a constant, the only
provision being that they must be of the same type as the
loop indexing variable. In fact they can be negative and
the increment value can be negative. This is illustrated in
the next loop that starts in line 48 where we count by -7
until we go from 5 to -35. No further explanation should be
required for this loop.
The next loop, starting in line 54, uses calculated
limits to determine its starting and ending points and it
uses the name "Where" for its incrementing value. The value
of "Where" is established in the definition part of this
program as a constant. It is simply used here and will be
explained in a future lesson when we get to it. "Where" is
a constant with a value of 11, and the incrementing value
must always be a constant.
The next two FOR loops use a CHAR type variable and
simply "count" from "A" to "Z", or backwards in the case of
Page 24
Chapter 4 - Modula-2 Loops and Control Structures
the second one.
Several things should be pointed out about the FOR loop
for you. The three values must agree in type, that is the
index, the starting point, and the ending point. The index
must not be changed by any logic within the loop or the
results will be unpredictable. The value of the index must
be assumed to be undefined after the loop terminates. You
may discover that it is predictable on your compiler, but it
may not be on some other compiler, and you may want to
transfer your program to another system someday.
THE INFINITE LOOP
The fourth and final loop is an infinite loop, it never
terminates by itself. It is up to you the programmer to see
to it that some means of terminating it is available, the
most usual is through use of the EXIT statement. Anyplace
in the loop you can set up some conditions for exiting based
on whatever you desire. Executing the EXIT procedure will
cause the program control to leave the loop and begin
executing the statements following the loop.
Now you have been exposed to the four loops available
in Modula-2, the REPEAT, WHILE, FOR, and LOOP. Spend some
time studying this program, then compile and run it to see
if it does what you expect it to do. Loops are very
important. You will do the vast majority of your logical
control in loops and IF statements.
WHAT IS AN IF STATEMENT?
Load the program IFDEMO.MOD and display it on your
monitor for an example of some IF statements. Ignoring the
header we notice that the program is composed of one big
loop in order to have some changing variables. Within the
loop are 3 IF statements, the most used conditional
statement in Modula-2.
The first IF statement is given in line 11. It simply
says "if the value of Index1 is less than 4, then" do
everything from the reserved word THEN to the reserved word
END which is associated with it. If the value of Index1 is
not less than 4, then all of these statements are ignored
and the next statement to be executed will be the one
following the reserved word END. In a nutshell, that is all
there is to the simple IF statement. Once again, the
condition can be any expression that will evaluate to a
BOOLEAN result, and it can be composed of any of the simple
types of data elements.
Page 25
Chapter 4 - Modula-2 Loops and Control Structures
THE "ELSE" CLAUSE
The second IF statement, beginning in line 17 has an
added feature, the ELSE clause. If the BOOLEAN expression
does not evaluate to TRUE, then instead of the expressions
following the THEN being executed, the group following the
ELSE will be. Thus, if it is TRUE, everything from the THEN
to the ELSE is executed, but if it is FALSE, everything from
the ELSE to the END is executed. The END statement is
therefore the terminator for the effect of the IF statement.
WHAT CAN GO IN THE IF STATEMENTS?
You may be wondering what is allowed to go into the
group of executable statements between the THEN and the ELSE
or some other place. The answer is, anything you want to
put there. You can put other IF statements, loops, input or
output statements, calculations, just about anything. If
you indent the statements properly, you will even be able to
read and understand what you put in there and why you put it
there. Of course, if you put a loop in there, for example,
you can put other constructs within the loop including other
IF statements, etc. Thus you can go as far as you desire in
building up a program.
THE ELSIF CLAUSE
The third and last kind of IF statement is given in the
third example starting on line 24. In this case, if the
expression within the IF statement is found to be FALSE, the
statements following the THEN are skipped and the next
construct is found, the ELSIF. If program control comes
here, it has a further expression to evaluate, which if
TRUE, will cause the statements immediately following its
THEN to be executed. If this expression is found to be
FALSE, the statements following the ELSE will be executed.
The net result is that, one and only one of the 3 groups of
instructions will be executed each time through the loop.
It is permissible to add as many ELSIF cases as desired to
this construct, leading to a "many way" branch. In
addition, the ELSE is entirely optional regardless of
whether or not the ELSIF's are used.
After studying this program, compile and run it and
compare the results with what you expected.
LOOP's IN IF's IN LOOP's
Load and display the next example program LOOPIF.MOD
for an example of some of the latest topics being combined.
This program makes nonsense data but is valuable because it
Page 26
Chapter 4 - Modula-2 Loops and Control Structures
is small enough to understand quickly to see how LOOP's and
IF's can be nested together. The entire program is a FOR
loop containing an IF statement. Each part of the IF
statement has a loop nested within it. There is no reason
why this process could not be continued if there were a need
to. Study this program then compile and run it.
FINALLY, A MEANINGFUL PROGRAM
Load and display the program named TEMPCONV.MOD for
your first look at a program that really does do something
useful. This is a program that generates a list of
temperatures in centigrade, converts the list to farenheit,
and displays the list along with a note in the table at the
freezing point and boiling point of water. You should have
no difficulty understanding this program, so the fine points
will be left up to you.
A few comments on good formatting is in order at this
point. Notice the temperature conversion program and how
well it is formatted. It is simple to follow the flow of
control, and the program itself needs no comments because of
the judicious choice of variable names. The block header at
the top of the page is a good example of how you should get
used to defining your programs. A simple block header of
that variety goes a long way toward making a program
maintainable and useful later. Take notice also of the way
the variables are each defined in a comment. A program as
simple as this probably doesn't need this much attention,
but it would be good for you to get into practice early. It
would be good for you to think of each of your programs as a
work of art and strive to make them look good.
After spending some time studying this program, compile
and run it to see what it does. Load and study the next
program named DUMBCONV.MOD to see if you can figure out what
it does. If you are really sharp, you will see that it is
the same program as the last one but without all of the
extra effort to put it into a neat, easy to follow format.
Compile and run this program and you will see that they both
do the same thing. They are identical as far as the
computer is concerned. But there is a world of difference
in the way they can be understood by a human being.
THE CASE STATEMENT
Load and display the program named CASEDEMO.MOD for an
example of the last decision making construct in Modula-2,
the CASE statement. A CASE statement is a "many-way" branch
based on some simple variable. In this program we have a
loop which sets the variable "Dummy" to the values from 1 to
Page 27
Chapter 4 - Modula-2 Loops and Control Structures
25 successively. Each time it comes to the CASE statement,
one of the branches is taken. The first branch is taken if
the value is from 1 to 5, the second branch is taken if the
value is from 6 to 9, the third is taken if it is either a
10 or 11, etc. Finally, if the value is not found in any of
the branches, the ELSE path is taken as would be the case of
a 12, a 13, or a few others. The important point is that
one and only one of the many paths are taken each time the
CASE construct is entered. The CASE variable can be any of
the simple types except for the REAL type. For each path,
as many statements can be executed as desired before the "|"
is put in to end that path. The CASE statement is a
powerful statement when you need it but you will not use it
nearly as often as you will use the IF statement and the
various loops.
PROGRAMMING EXERCISES
1. Write a program that will put your name on the monitor
10 times using a loop.
2. Write a program that lists the numbers from 1 to 12 on
the monitor and prints a special message beside the
number that represents the month of your birthday.
3. Write a program that calculates and lists the numbers
from 1 to 8 along with the factorial of each. This
will require use of a loop within a loop. A factorial
is the number obtained by multiplying each number less
than and up to the number in question. For example,
factorial 4 = 1 * 2 * 3 * 4. Use a CARDINAL type var-
iable for the result, then change it to an INTEGER to
see the difference in output due to the range of the
two different variable types. This is a good illustra-
tion of the fact that careful choice of variable type
is sometimes very important.
Page 28
