Hello again...Let's get started...An example of the solution of the program presented in part 5 is below.

program part5;
  const
    income_tax = 0.15;    { set our 15% tax rate }
  type
    string20 = string[20];  { not needed, but good to demonstrate }
  var
    employee: string20;
    hours, rate: real;
    infile, outfile: text;
    grosspay, overtimepay, intax, netpay: real;

  procedure writeheaders;   { writes the headers on our report }
    begin
      writeln(outfile, 'The International Widget, Inc.':51);
      writeln(outfile, 'PayOut And Deductions Sheet':49);
      writeln(outfile);
      writeln(outfile, 'Employee', 'Hours':17, 'Rate':7, 'GrossPay':10,
                       'Overtime':10, 'IncomeTax':11, 'NetPay':9);
    end;

  function writeline(fillchar: char; strlength: integer):string;
  { handy function that fills a certain length of a string with a fixed
    character }
    var
      i: integer;
      str: string;
    begin
      str := '';
      for i := 1 to strlength do
        str := str + fillchar;
      writeline := str;
    end;

  procedure processrecord(hrs, rate: real;var gpay, opay, itax, npay: real);
    { does all of our required calculations for us }
     var
       rpay: real;
     begin
       if hrs > 40 then  { if overtime then }
         begin
           rpay := rate * 40;                { regular pay up to 40   }
           opay := (hrs - 40) * rate * 1.5;  { overtime rate after 40 }
         end
       else
         begin
           rpay := hrs * rate; { figure as normal }
           opay := 0;          { set overtime pay to 0, no overtime hours }
         end;
       gpay := opay + rpay;        { get our gross pay }
       itax := gpay * income_tax;  { get our deduction }
       npay := gpay - itax;        { actual pay to worker }
     end;

  begin
    assign(infile, 'WORKER.TXT');     { prepare input file  }
    reset(infile);
    assign(outfile, 'PAYOUT.TXT');    { prepare output file }
    rewrite(outfile);
    writeheaders;                         { write headers of report }
    writeln(outfile, writeline('=', 72));
    readln(infile, employee, hours, rate);
    while not eof(infile) do { while not end of file, read,process&write }
      begin
        writeln('Processing ', employee);
        processrecord(hours, rate, grosspay, overtimepay, intax, netpay);
        writeln(outfile, employee, hours:5:2, rate:7:2, grosspay:9:2,
                         overtimepay:10:2, intax:10:2, netpay:11:2);
        readln(infile, employee, hours, rate);
      end;
    writeln('Processing ', employee);
    processrecord(hours, rate, grosspay, overtimepay, intax, netpay);
    writeln(outfile, employee, hours:5:2, rate:7:2, grosspay:9:2,
                     overtimepay:10:2, intax:10:2, netpay:11:2);

    close(infile);
    close(outfile);    { close files }
  end.

For a lot of things, it is very useful to know exactly how things are done by the computer in programming. The array is one of them. An array is simply a group, or set of groups of like defined items. An example of such a thing is:

firstarray: array[1..3] of integer;

What we are doing is defining three integers that we want to indicate by numbers as 1(1st), 2(2nd), and 3(3rd) in the set of integers. Arrays are often used to correlate like items in a program to make them easier to process. Often it is with such data as this: Say we want to work with the high temperatures for each day of one month. It is correlated info, so it is a very good candidate for an array. The numbers between the [] are minimum..maximum index values for the array (to keep track of which part of the array we want). There are 31 days in a month(maximum), so we would store them as something like this:

temperatures: array[1..31] of integer;

We are defining the total number of integer units we want in the array. Which brings up the question: How is this stored in memory?

This rule is always helpful to remember when we work with arrays. It does point out logic rather readily of handling arrays. Now I will illustrate how to access items of the array. Keep in mind that array items can be read from the keyboard or text file, and written just like variables we have worked with before.

To read the 5th temperature in the array from the keyboard, we would use something like this: readln(temperatures[5]);

Note: in addressing an array, we can even use mathematical expressions...

If we wished to write out (one per line) to the screen, all the contents in the array, we would do something like this...keep in mind that array variables work exactly the same way as the variables have that we have been working with so far:

for i := 1 to 31 do
  writeln(i, temperatures[i]);

The indexes can be defined to be anything that was valid for use in the for loop, such as:

array1: array[1..10] of integer;
array2: array[-15..0] of real;
array3: array['a'..'z'] of char;

This naturally has limits, which you will find if you cross them (compiler warning). What the array is of can be any valid data type. Can we define an array of an array? Yes.

We can define infinitely, as our memory allows, the number of arrays of arrays we want to define. Say, for our temperature example, we wanted to define the limits of an array for the whole year. We know there are 12 months in the year, so we would need 12 occurences of the array we defined previously for the high temperatures for each day: A definition of this array would be:

temperatures: array[1..12] of array[1..31] of integer;

This is a very definable array that we could use to store all of our high temperatures for each day of the year.

Is there a shortcut, though? Yes, there is. You can use a comma in the first set of [] to define the limits of the 2nd array. Why? We see in the next paragraph. An example of a better definition of this array is:

temperatures: array[1..12, 1..31] of integer;

We see the parts of each array in the first one there...Remember above that I said computers store things linearly. It helps us when we know this in processing such a thing above. Actually, for double level, triple level, etc, tables, the 2nd array, 3rd array, etc is seen as minor units within the previous defined array. Say, we had this array:

array1: array[1..2, 1..2, 1..2] of char;

It would be set up in linear memory like this:

array1    char   char    char  char        char   char  char   char
        [1,1,1] [1,1,2] [1,2,1] [1,2,2] [2,1,1] [2,1,2] [2,2,1] [2,2,2]
           array1[1,1]  array[1,2]        array1[2,1]  array1[2,2]
                  array1[1]                       array1[2]

for i := 1 to 12 do
  begin
    for j := 1 to 31 do
      write(temperatures[i, j], ' ');
    writeln;
  end;

It can be done. It's done like this:

const
  months: array[1..12] of string[3] = ('Jan', 'Feb', 'Mar', 'Apr', 'May',
          'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec');

These are two functions we can use to work with the ASCII table. They are system functions.

Ord(char) gives us an integer that represents the character we put in the ()'s. Chr(integer) gives us a character which corresponds to the ASCII code number that is given in integer.

A type called boolean exists. It can either be set to true or false.

As a final note, defining arrays, if you play around with doing that and using them (I hope you do..:-), you may get an error from the compiler that your data structure as defined is too large. The reason is that Pascal defaults to operating and compiling your programs like they were going to work on an 8088 class machine. The maximum addressable memory there is 64KB. If that happens, it means you have too many variables defined. There is a way to get around this, which will be covered in a future part of this tutorial. Don't give up on this, and remember: Experimentation is the best tool for learning how this stuff works...

Once upon a time, a friend of yours did you a really big favor. Now they want you to repay that favor. They are in college and doing a statistical study on the average number of times that each letter of the alphabet is used. To accomplish that, to your unfortunate ears, your friend wants you to sit down with a sheet of paper and a book and start tallying letters on a table that's written on that sheet of paper. You know this is very time consuming and there is probably a better way. You realize that with your programming knowledge that you have and several text files that you have on your hard drive that you can make a program that will accomplish the task much faster. They asked you to count through a 200 page book originally, so you decide that documentation of some shareware (5 text files) that you have are counted and summarized will do sufficiently for what your friend intends.

Write a program in Pascal and entirely Pascal that will read no more than 10 text file names from a file named FILES.TXT (you can create it, one filename (full path) per line, be sure you can find them on your drive (I recommend to get them as a whole to be no less than 200KB in size (all files combined), and as large as you want them to be as a whole -- I am only stating a good set of minimums -- the no more than 10 part is a good required part of the program to do.). For each and every file in this list, count the number of times each letter is used (whether the letter is uppercased or lowercased is irrelevant Notes and Hints:

1. We want counts for EACH file with EACH letter to be printed out.
2. Hint: Use an array to store the data for your numbers counted.
3. Total number of letters encountered DO NOT include numbers, wierd characters, etc, etc. If you are foreign to the U.S. and have other characters in your alphabet than A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q, R,S,T,U,V,W,X,Y, and Z and their lowercased cousins, program this utility using your alphabet.
4. Hint: Remember to take totals, we need data from ALL of our samples to be used.
5. Hint: We don't need 52 IF statements or a large case statement. Look at the ASCII table and see why I say this.
6. The program specifications say that FILES.TXT should not have more than 10 files. If it does, just design your program to stop at file #10 and write an error message at the end of the output.
7. As with the last program, we need to write action indications to the screen so we know the program is running and has not crashed.
8. If you see negative numbers for sums, or screwy numbers, remember to initialize any arrays you may be adding things to. Also, if you see the negative numbers, integer type overflowed (Integer max: 32000). If this happens, define all integers associated with that area to longint (Integer max: 2 billion).

Sample of FILES.TXT (It should look like this, just be sure the files you list are on your drive and are TEXT files, and not word processor files)

c:\mouse\readme.txt
c:\4dos\4dos.doc
d:\pastutr\pascal1.txt
c:\config.sys
d:\ezycom\ezy1.prn

Sample of FRNDDATA.TXT:

                        Alphabetical Count Data
                        for c:\mouse\readme.txt

Letter             Count                    Letter              Count
  A                 12                        N                   6
  B                 10                        O                   7
  C                  4                        P                   2
  D                 92                        Q                   2
  E                 20                        R                   4
  F                 32                        S                   2
  G                 23                        T                   3
  H                  2                        U                   4
  I                  2                        V                   2
  J                 34                        W                   2
  K                 21                        X                   4
  L                123                        Y                   5
  M              12341                        Z                   2

(repeat above for rest of files in FILES.TXT)

5 files processed.
15232 letters encountered.

                        Alphabetic Count Data
                           for all files

(repeat a letter count system like we did for each file we did)

We will cover the use of records, and a few other nice commands, plus a little mathematics. Inevitably, in the sciences, math is used somewhere. We're getting to the point of needing that. I've tried to show partial code to do things now that we're getting farther. If people are having problems integrating the code into a program to see how it works (if you do, maybe you should work on the previous parts?), tell me and I'll go back to posting complete programs. With reference to mathematics, if you do not know how to convert number bases, ask a parent or your favorite mathematics professor. :-)

After that, we will have most of the basics covered. That does not mean I will quit. This is, my guess, about 2 parts away from the halfway point (don't quote me on that:-). Anyway, there's lots more to cover, and a few special topics coming up. To illustrate, the tutorial after the records tutorial will involve the use of DOS compatible commands, in other words those things you do in DOS (the first special topic) -- we're gonna go over how to do those things in Pascal.

Please send any comments, questions, requests for help with the sample programs (you SHOULD be doing them as you get each of these parts) to [email protected].