                  Chapter 6 - Arrays, Types, and Constants


             Load  the program named ARRAYS.MOD and we will go right
        to our first example of an array.  An array is simply a list
        made up of several of the same type of element.   Notice the
        VAR  definition  in the sample program and specifically  the
        variable  named  "Automobiles".   The  reserved  word  ARRAY
        followed  by  the square brackets with a  range  of  numbers
        contained  within them is the proper way to define an  array
        of,  in this case, CARDINAL type variables.  This defines 12
        different CARDINAL type variables,  each of which is capable
        of  storing  one CARDINAL number.   The names of the  twelve
        variables are given by Automobiles[1],  Automobiles[2],  ...
        Automobiles[12].  The variable name is "Automobiles" and the
        array  subscripts  are  the  numbers  1  through  12.    The
        variables  are  true  CARDINAL type  variables  and  can  be
        assigned  values,  or they can be used in calculations or in
        nearly  anyplace  in a program where it is legal  to  use  a
        CARDINAL type variable.  One place they cannot be used is as
        the  index  for a FOR loop since a simple variable  type  is
        required there.

                           WHAT GOOD ARE ARRAYS?

             Notice lines 10 through 12 of the  program.   In  these
        lines,  each of the 12 variables is assigned a value.   When
        "Index"  is 1,  then "Automobiles[1]" is assigned  11,  then
        when "Index" is 2, "Automobiles[2]" is assigned 12, etc.

             If  the  12  variables  were  defined  as  12  separate
        variables of whatever names we chose for them,  we could not
        assign  them values in a loop but would have to assign  each
        one  independently.   In  this instance,  we are  generating
        nonsense  data  but in a real program,  this loop  could  be
        reading  in  a series of data from a file such as  would  be
        done with a database.   The advantage of the array should be
        very clear, especially if we were to change the array limits
        to several thousand elements.

             The  statement in line 13 assigns a value to one of the
        elements  at random to illustrate the method.   Notice  that
        the 7th element of the array named "Automobiles" is assigned
        the value of 54.   The address of this data is therefore the
        variable  name  "Automobiles[7]" and the data  contained  in
        that  address is 54.   We have therefore assigned values  to
        the 12 variables by a nonsensical but known scheme,  and now
        we can use the 12 variables in any way that is legal  within
        Modula-2.

             The  next loop causes the 12 values to be displayed  on
        the  monitor  in  a neat orderly fashion.   In  line  20  we
        display  the index of the variable in question,  and in line
        22,  we display the actual variable.   Keep in mind that the


                                Page 37









                  Chapter 6 - Arrays, Types, and Constants


        index  could have been INTEGER and still be used to  display
        an array of type CARDINAL provided we defined "Index" as  an
        integer and always used it as such.   Spend enough time with
        this  program  so that you thoroughly  understand  it,  then
        compile and run it.

                      WHAT ABOUT AN ILLEGAL SUBSCRIPT?

             Modula-2  does  very strong "type checking"  and  limit
        checking.   If,  in the above program, you tried to assign a
        value to "Automobiles[13]",  which doesn't exist, a run time
        error would be generated and the program would cease.   This
        is one of the advantages of Modula-2 over some of the  older
        programming  languages.   Some compilers have the ability to
        enable or disable this feature.

                        MULTIPLY DIMENSIONED ARRAYS

             Load  the  file named ARRAYS2.MOD for an example  of  a
        program with two-dimensional arrays.   In this program,  the
        VAR  section contains the "Checkerboard" variable  which  is
        defined  as an 8 element ARRAY in which each element is an 8
        element ARRAY, therefore being an 8 by 8 square ARRAY.  Each
        element  is capable of storing one CARDINAL  type  variable.
        The variable "Value" is defined the same way except that the
        method of definition is slightly different.  The two methods
        result in the same type and number of variables.

             In  lines  11 through 16 we have two nested FOR  loops.
        The  outer loop causes "Index" to count from 1 to 8 and  for
        each value of "Index",  the variable "Count" counts  through
        the values 1 to 8 also.   The net result is that we evaluate
        the  assignments  in lines 13 and 14 once for each  possible
        combination of "Index" and "Count".   For each  combination,
        we assign some nonsense data to "Checkerboard" then use  the
        result  of that calculation to assign some nonsense data  to
        the variable "Value".  The purpose here is to illustrate the
        method  of using the double subscripted variables.   Next we
        display  the  entire matrix of  "Checkerboard".   The  loops
        cause  8  values  to be displayed on one line  so  that  the
        entire  matrix  is displayed on only 8  lines.   You  should
        study this logic because you will find output sequences like
        this to be very valuable.

                        CHANGING A FEW OF THE VALUES

             In line 27 and following we change a few of the  values
        at random for illustrative purposes.   Since "Value[3,6]" is
        assigned  the  value  of 3,  it can be used as  one  of  the
        subscripts  of the next line and in fact it is.   This would
        be  a   rather  sloppy programming style but it  is  a  good


                                Page 38









                  Chapter 6 - Arrays, Types, and Constants


        illustration  of what can be done.   Finally using the  same
        technique as that for "Checkerboard",  the "Value" matrix is
        displayed.

                      HOW MANY SUBSCRIPTS CAN BE USED?

             There is no limit as to how many subscripts can be used
        in Modula-2 by definition, but there is a practical limit of
        somewhere in the range of 3 or 4.   If you use too many, you
        will  very quickly get confused and lose control of what the
        program  is supposed to be doing.   I have never  seen  more
        than 3 subscripts used in any programming language, and very
        few instances of more than two.   Let the problem definition
        be your guide.

             This program was pretty straightforward, and it is time
        for you to compile and run it.

                            THE TYPE DECLARATION

             Load  the program named TYPES.MOD for a new topic  that
        you will use often,  especially in large programs.   At  the
        top  of  the listing we have a group of  TYPE  declarations.
        The  first line defines "ArrayDef" as a new TYPE  definition
        that  can  be used in the same way you would use INTEGER  or
        any of the other simple type definitions.   In line 12,  the
        variable  named  "Stuff" is defined as a  variable  of  type
        "ArrayDef", and since "ArrayDef" is a 14 element ARRAY, then
        "Stuff" is a 14 element array of INTEGER.   It seems like we
        didn't  save anything and in fact we added a few  keystrokes
        to the program in order to do this.   If you look at line 13
        you  will see that we have also defined "Stuff2" as the same
        type of array.   We have,  in fact, defined them to be "type
        compatible" which will be very important when we get to  the
        program itself.

             Continuing  down  the  list of  TYPE  declarations,  we
        define a TYPE with 28 characters,  then a TYPE with 60  real
        variables,  and another with 6 BOOLEAN variables.   The next
        TYPE  consists  of 12 variables of TYPE "DogFood"  which  is
        itself a TYPE of 6 BOOLEANS,  resulting in a TYPE consisting
        of  6  times 12 = 72 BOOLEANS.   It is possible to  continue
        building up TYPE definitions like this indefinitely,  and as
        you build up applications,  you will find yourself  building
        up  rather  complex  TYPE declarations and  having  a  clear
        picture  of how they go together because it is your solution
        to  a problem.   The last TYPE to be defined is  that  named
        "Boat"  which has exactly the same size and  characteristics
        as  "Airplane".   We  will  see  shortly  that  there  is  a
        difference in these two definitions.



                                Page 39









                  Chapter 6 - Arrays, Types, and Constants



                         HOW DO WE USE ALL OF THIS?

             In  the VAR part of the definition part of the program,
        we declare some variables,  two simple types and some of the
        types we defined above.  In the program part, we assign some
        values  to the 72 variables making up the  "Puppies"  matrix
        and the 72 variables making up the "Kitties" matrix.  All of
        the  elements of "Stuff" are then assigned nonsense  values.
        The  really interesting statement comes in line 30 where  we
        say  "Stuff2 := Stuff;".   In this simple statement,  all 14
        values   stored   in   "Stuff"  are  copied  into   the   14
        corresponding  elements  of "Stuff2" without using  a  loop.
        This  is  possible  because  the  two  variables  are   TYPE
        compatible,  they  have  the same TYPE definition.   If  you
        study the definitions above,  you will see that "Stuff3"  is
        of  the same number and range of elements and is composed of
        the same type of elements,  namely INTEGER,  as "Stuff"  but
        they  are not TYPE compatible because were not defined  with
        the  same TYPE definition statement.   In like manner,  even
        though "Puppies" and "Kitties" are identical in  type,  they
        are not TYPE compatible.

             You  have the ability,  through careful  assignment  of
        variables, to avoid certain kinds of programming errors.  If
        certain variables should never be assigned to each other,  a
        careful  selection  of types can prevent  it.   Suppose  for
        example  that  you have a program working with  peaches  and
        books.   You would never want to copy a matrix of peaches to
        one defining books,  it just wouldn't make sense.  Those two
        matrices  should be defined with different type declarations
        even though they may be identical in size.

             Compile  and  run  this program,  even though  it  will
        result in no output, then move the comment delimiter in line
        31 to a position following the assignment statement and  see
        if it does give you a TYPE incompatibility error.

                            DEFINING A CONSTANT

             Load the program named CONSTANT.MOD for a definition of
        the constant as used in Modula-2.   We will finally keep the
        promise made when we studied LOOPDEMO in chapter 4.  The new
        reserved  word CONST is used to define a constant for use in
        the program.  The constant "MaxSize" can be used anywhere in
        the program that it is desired to use the number 12, because
        they are in fact identical.  Two additional CONST values are
        defined  for  illustrative  purposes  only.    In  the  TYPE
        declaration  section we use the constant "MaxSize" to define
        two types, then use them to define several variables.



                                Page 40









                  Chapter 6 - Arrays, Types, and Constants


             In  the  program there is one FOR loop using  the  same
        constant "MaxSize" as the upper limit.   It doesn't seem  to
        be  too  useful yet,  but suppose your boss came to you  and
        said  to  change the program so that it  handled  142  cases
        instead  of 12.   The way the program is written,  you would
        only  have to change the value of the  constant,  recompile,
        and  you  would  be done.   If you had used  the  number  12
        everywhere,  you would have to replace every 12 with the new
        number,  142, being careful not to change the one in line 21
        which is a different kind of 12.   Of course even that would
        not  be  too difficult in such a simple program,  but  in  a
        program  with 5000 lines of code,  one simple  change  could
        take a week.

             Compile and run this program.


                       THE OPEN ARRAY IN A PROCEDURE

             Load and display the program named ARAYPASS.MOD for  an
        example  of  a  program  with  arrays  being  passed  to   a
        procedure.   Notice  how the procedures are formatted.   The
        rows  of  asterisks make them really stand out and  easy  to
        find.    You  will  develop  your  own  personal  style   of
        formatting  in  a way that is clear and easy to  follow  for
        you.

             The two procedures in this program are identical except
        for  the  way the arrays are passed to them.   In the  first
        procedure named "AddNumbers", the variable named "Donkey" is
        passed  the array by using the same type which was  used  to
        define  one  of the arrays.   The procedure merely adds  the
        values  of the elements of the array passed to it and writes
        the result out to the monitor.  The way it is written, it is
        only  capable of adding arrays that are indexed from  10  to
        15.  Any other array will cause a "type incompatible" error.
        This is simply called passing an array to the procedure.

             The  second  procedure  named "GenAddNumbers"  has  its
        input array defined as an "ARRAY OF CARDINAL" with no limits
        stated.   This procedure can add all of the variables in any
        CARDINAL  array  regardless of the range of its  subscripts.
        The  lower subscript will always be defined as  zero  within
        this type of procedure, and the upper limit of the array can
        be  found with the predefined procedure "HIGH".   It is used
        as shown in the example.   The first time this procedure  is
        called  in the main program,  it is called with the variable
        "SizeOne".   In  the  procedure,  the array  subscripts  for
        "Donkey"  will  be 0 through 5.   When  the  variable  named
        "SizeTwo" is the array sent to the procedure,  then "Donkey"
        will  have  the limits of 0 and 218.   The second  procedure


                                Page 41









                  Chapter 6 - Arrays, Types, and Constants


        definition method is therefore more general.  This is called
        passing an "open array" to the procedure.

                          WHICH ONE SHOULD I USE?

             There  will be times when you wish to use  the  general
        case  for  passing a parameter,  the "open array".   A  good
        example  is the procedure named "WriteString" that  we  have
        been  using in this tutorial.   It would be a bit cumbersome
        if  we were only allowed to pass a 10 character string to it
        each time.   Since it can accept a string of any length,  it
        is evidently defined with an "ARRAY OF CHAR" in its  header.
        (We  will  see  in  a later  chapter  that  this  particular
        procedure  is  exactly that,  a procedure that  someone  has
        thoughtfully programmed for you.   You only need to tell the
        system where it can be found using the IMPORT statement.)

             There  will  likewise be times when you will desire  to
        use  the  more specific method of definition.   If  you  are
        using  a  lot of arrays and have a specific  operation  that
        needs  to  be done to only a few arrays that have  a  common
        definition,  you  would  be wise to use  this  method.   The
        computer  could  then  tell  you if you  tried  to  use  the
        procedure on an array that it was not intended for.  This is
        making  wise  use  of the type  checking  available  in  the
        computer.

                          HANDLING STRINGS IN MODULA-2

             Load  the last file for this chapter,  STRINGEX.MOD for
        an  example of using strings in Modula-2.   This program  is
        the  first program to deviate from the standard  library  as
        defined by Niklaus Wirth.   When he defined the language, he
        suggested   several   library  procedures  that  should   be
        available  in  every  Modula-2 compiler  and  most  compiler
        writers  have followed his suggestions  quite  closely.   He
        failed  to define a standard library for the string handling
        procedures.   There  is  therefore  some  freedom  for  each
        compiler  writer to define the string handling  routines  in
        any way he pleases.   Most however, have followed at least a
        resemblance  to a standard,  so the procedure calls are very
        similar from compiler to compiler.   It may be necessary for
        you  to modify this file to suit your  particular  compiler.
        The COMPILER.DOC file on your distribution disk has comments
        for modifications needed for several compilers, but if yours
        is  not listed,  it will be up to you to make  the  required
        modifications to the source file.

             A  complete description of the libraries and what  they
        are will be given in chapter 8.



                                Page 42









                  Chapter 6 - Arrays, Types, and Constants


                     BACK TO THE PROGRAM ON YOUR DISPLAY

             The  first thing that is different here is the addition
        of another IMPORT statement in line 10,  this one  importing
        procedures  from the module named "Strings".   This  is  the
        module containing the procedures which we will need in  this
        program.  A string is an array of type CHAR, each element of
        the  array being capable of storing one character.   Thus an
        array of CHAR type elements is capable of storing a word,  a
        sentence, a paragraph, or even a whole chapter, depending on
        how big the array is.   Using the example on your screen, we
        will learn how to manipulate text data.

             One  additional feature of the example program will  be
        found on line 24.   In this line the "WriteString" procedure
        is used in a way we have not used as yet.  Instead of having
        an  expression  in  quotes,  it has the name of  a  variable
        within its parentheses.  It will display whatever characters
        are stored in the string named "stuff" defined by the "ARRAY
        OF CHAR".   So if we learn how to get a string of characters
        stored  in  a  variable of type  "string",  we  can  display
        anything on the monitor that we can generate internal to the
        computer.

             According to the definition of Modula-2, a string is an
        ARRAY  OF CHAR with a 0 as a terminator.   We will get  more
        familiar with strings as we continue our study.

                         SOME NEW STRING PROCEDURES

             The first line of the program itself, line 34, contains
        a  string  assignment.   In this case,  we are  telling  the
        system to copy the constant "ABCDEFGHIJKL" into the variable
        named  "Horse".   The array into which you are copying  must
        begin  at  index  0 in order for this to  work  because  all
        character  constants are,  by definition,  started at  zero.
        The  variable  "Horse",  which  only contains  room  for  12
        characters  will only receive the first 12 characters of the
        constant.   The procedure "Display" is called with Horse  as
        the   variable   and  the  variable  is  displayed   between
        parentheses  for  clarity  of  understanding,   and  the  12
        characters  of  the variable are displayed  in  their  ASCII
        equivalent.  When you finally run this program, compare some
        of  the values to the ASCII table that is included with  the
        DOS documentation that came with your computer.

             In  line  37 of the program,  the constant  "12345"  is
        assigned  to  the variable "Cow".   In the  next  line,  the
        variable "Cow" is assigned to the variable "Horse",  and the
        display procedure is called again.   This time, the variable
        "Cow" is shorter than the destination,  so the system has to


                                Page 43









                  Chapter 6 - Arrays, Types, and Constants


        compensate  for the difference.   After it transfers  the  5
        characters to "Horse",  it will place a 0 (zero) in the next
        position to indicate the end of the string.   The definition
        of  the  string still has 12 places,  but there are  only  5
        places  of interest,  so the system will consider all places
        past the 5th as undefined.  This time the system only prints
        out  5  characters  in the procedure.   The  list  of  ASCII
        equivalents shows that the other values are still there, the
        output  routine simply stopped when it came to the 0 in  the
        sixth position.

             Note  that  the Assign statement may be  different  for
        different compilers because it is not a part of the Modula-2
        definition by Niclaus Wirth.

                               CONCATENATION

             Concatenation is simply putting two strings together to
        make up one bigger string.   Beginning in line 41,  two  new
        string  variables are defined,  "S1" and "S2",  then the two
        new variables are concatenated together and assigned to  our
        old  favorite variable named "Horse".   The variable "Horse"
        should  now contain the silly expression  "NeatThings",  and
        when you run the program,  you will find that it  does.   It
        also  has  a 0 in character position 11 now to indicate  the
        end  of the string.   Line 47 concatenates "Horse" to  "Cow"
        and stores the result in "Horse",  but since the  expression
        is  now too long,  part of it will get truncated and  simply
        thrown away.  Finally, "Cow" is concatenated to "Horse", and
        the result stored back into "Horse".  This has the effect of
        shifting  the prior contents of "Horse" right and adding the
        characters stored in "Cow" to the beginning.   Line 45 is an
        example  of  a string assignment.   This  is  only  possible
        because they are of the same TYPE.  The variable "Cow" has a
        different  TYPE so can't be assigned to either of these  two
        variables.   Note  that  the TYPE does not have to start  at
        zero for this to work.

             Note  that  even though "Horse" was the  only  variable
        used  in the calls to "Display",  any of the  other  strings
        could have been used also.   This is the topic of the fourth
        programming exercise below.

             Compile  and run the program and see if it really  does
        do all that it should do as described above, keeping in mind
        that  you  may have to modify the file to  accommodate  your
        particular compiler.


        PROGRAMMING EXERCISES



                                Page 44









                  Chapter 6 - Arrays, Types, and Constants


        1.   Write a program to store the CARDINAL values 201 to 212
             in an array then display them on the monitor.

        2.   Write  a  program to store a 10 by 10 array  containing
             the products of the indices, therefore a multiplication
             table.  Display the matrix on the monitor.

        3.   Modify the program in 2 above to include a constant  so
             that  by simply changing the constant,  the size of the
             matrix and the range of the table will be changed.

        4.   Modify  the program named STRINGEX.MOD to include calls
             to  "Display" with each of the string variables at  the
             end of the program.







































                                Page 45
