             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
