``````                  Turbo Pascal for DOS Beginning Tutorial
by Glenn Grotzinger
Part 4 -- Writing Procedures and Functions
all parts copyright 1995-96 (c) by Glenn Grotzinger.

Hello, again, and lets get started...

An example of a solution of last week's programming problem:

program part3;

{ This program enables a user to play a guessing game.
Range: 1-100     Guesses: 6 }

var
choice: char;
randnum, number_given, attempts: integer;

begin
randomize; { start random # generator }
while upcase(choice) <> 'N' do   { while we want to play }
begin
randnum := random(100) + 1;  { generate random number for game }
attempts := 6; { set initial number of attempts }
number_given := 1000; { stuff number_given so while kicks in }
writeln('I''m thinking of a number between 1 and 100.  What is it?');
while (attempts > 0) and (number_given <> randnum) do
{ while we still have attempts to guess }
begin
if number_given = randnum then
writeln('Congratulations!  You got the number right!')
else
begin
attempts := attempts - 1;
if attempts = 0 then
writeln('Sorry, you ran out of choices. ',
' The number I was thinking of is ',
randnum, '.')
else
if number_given > randnum then
writeln('It''s lower.  (', attempts,
' guesses remaining)')
else
writeln('It''s higher. (', attempts,
' guesses remaining)');
end;
end;
writeln;
writeln('Do you want to play again? (Y/N)');
end;
end.
If there are any questions or difficulties, write ggrotz@2sprint.net.

On to the new stuff...

PROCEDURE writing
=================
This is a way a lot of things work in Pascal.  For example, the
write command is a procedure.  We say the procedure name, then a list of
parameters which describe what we want to write.  Write is defined in
Pascal itself, but we can write our own procedures to do things.  Before
the main part of the program, and after our variable declarations, we
place our procedures.  Procedures are essentially whole separate programs
which perform small tasks in a bigger program. Here is a short example of
what I mean:

program tutorial11;

var
one, two: integer;
final: integer;

begin
end;

begin
writeln('Type two numbers in (space after each number) to add.');
writeln('The answer is ', final, '.');
end.

The procedure enables us to perform more modular, understandable, and
easier to debug programs.  We always code logical parts of the program
together in procedures and functions (will be discussed later).  This
example is pretty simplistic, as we include only one statement in a
procedure (generally a waste of time), which could easily be in the body
of the program.  We can use one statement procedures in more logical things,
such as conversions of one set of unit to another.  We describe the parts
of the procedure declaration above, and the calling of the procedure.

We can define a series of statements as long as they are the same type, and
we don't want to keep them without the use of the VAR section of the
procedure.  We don't care about, and don't modify first, and second, so we
place them in there without the var.  We modify the variable used as
answer, so we MUST have the VAR before it in order to have the variable
survive in a modified state by calling the procedure.  Play around with
what happens in tutorial11 when you remove the var from in front of the
third statement.  When we call the procedure, we use variables which match
and make sense to what we want each variable we want. we use one, and two
for the numbers to add, because our procedure is designed
to add those first two numbers.  Then we put final in the last one, because
that is our final answer.  We can SAFELY use the same variable names for
the procedure and the globals, but it is a good idea not to, as it will not
always be possible to correlate our items in that way.  We should always
have a goal to write procedures/functions with ability to drop them into
another program where all the parameters are passed to it.  We can easily
drop the procedure written above into any other program that needs a similar
function.  It is possible to have a parameterless procedure as well, if it
is predicted as required.  Say...In a multi-function menu system or something
that does a set thing (clrscr is an example).

NOTE: It is always good to keep your old code when you write and use
parameter passing in your procedures and functions, so you can easily
re-use your code and save time in having to rewrite old code.

FUNCTION writing
================
Function declarations are exactly like procedures, except that functions
have the capability to return a value.  We see in the example, below, which
is a rewrite of tutorial11.

program tutorial12;
var
one, two: integer;
final: integer;

var
begin
{we can also do addtwonumbers := first + second;}
end;

begin
writeln('Type two numbers in (space after each number) to add.');
writeln('The answer is ', final, '.');
end.

In the function, we see we MUST define the final answer to the value of
the function.  The end part :integer; defines the return value of the
function.  The way to set up a function should be evident from this example.

SETS
====
It's possible in an IF/WHILE/REPEAT to set up a test on a group of statements.
For example:
IF character in ['a'..'z'] then
{ if character is in the lowercase alphabet }
IF character in ['1','2','3','5']
{ if character is 1, 2, 3, or 5 }
IF number in [0..23] then
{ if number is between 0 and 23 }

TYPE and CONST statements.
==========================
It's possible to type-delineate variables.  Such as for example, we may want
to limit a string from it's standard 255 characters (if we say just string),
to say 10 characters (string[10]), we can not use something like that in
a procedure or function (we will see the types used a lot).  Therefore, we
use the type section to redefine this so we can use them in procedures/
functions.

It's also possible to set constants in a pascal program.  Say, if we want
to set up a constant tax rate, we just define it in a constant section.

We see this in an example:

program tutorial13;
const
tax_rate = 0.14; {14% tax rate}
type
string[15] = string15;
{ string[15] redefined so we can use it in a procedure/function,
though we will not have procedures or functions here. }
var
total_pay: real;
your_name: string15;
{if we make type dec, we must carry it across.  This variable is
a string with a limit of 15 characters. }
begin
writeln('Who are you? (15 char. max)');
writeln('How much did you earn this paycheck?');
writeln('Assuming, you have a ', tax_rate * 100 :0:0, '% income tax ',
'rate, you will have to pay \$', total_pay * tax_rate :0:2,
' in income tax this paycheck.');
end.

The use of tax_rate is a prime reason that we would want to define a
constant.  Instead of using that number everywhere we needed it, we used
the reference of tax_rate.  Why?  If the income tax ever changed in this
example, we would not need to go through the whole program and change that
number.  All we need to do is change that reference.

Clearing the screen
===================
This will be the first example of a command that we must call a unit for
to get.  The unit you call (as I did in tutorial1) would be CRT for TP/DOS,
and WINCRT for TP/WIN.  You use the statement clrscr; for this.  This
program example clears the screen.

program tutorial14; uses crt;
begin
clrscr;
writeln('I cleared the screen for you.');
end.

Final Note
-=========
You should lay out your programs in logical units using functions and
procedures, making them parameter passing if possible, and logical.
The best may be (especially for programs that do multiple things which
are unrelated on code level) to not parameter pass.  Whatever works
functionally is the best, and if you can't figure out a way to parameter
pass to the procedure or function....

Programming Practice Problem Notes
==================================
This is the first program, that I would expect you to write using
functions and procedures.  All programs you should write in the future
should strive to use parameter-passed procedures.  The reasons are many-
fold for this, which I stated before.  Be sure you do this.  This program
should not be any more difficult than any of the previous programming
problems I gave.  All I expect this one to be is an exercise for you to
learn in using procedures and functions.  If you want more practice beyond
this problem in writing things using procedures and parameters, I suggest
you recode the programming problem out of part 2.  If you can get it more
easier understood to look at, and using parameter-passed procedures for the
logical parts of it, and make it work right, then you got it.

Practice Programming Problem #4
===============================
Write a program in pascal and entirely Pascal which will present
a simple menu driven system (readable, and by pages -- use clrscr in the
appropriate spots) which will enable the user by choice to do the following,
as indicated by sample output for the menu.

======================
1. Convert a number of seconds to hours, minutes, and seconds.
2. Convert a given military time to AM/PM time.
3. Quit the program.

sample output for option 1
==========================
Please enter a number of seconds: 3600

3600 seconds is 1 hour, 0 minutes, and 0 seconds.

Press ENTER to continue:

sample output for option 2
==========================
Enter a military time's hours: 14
Enter a miltiary time's seconds: 00

It is 2:00 PM.

Press ENTER to continue:
================

Notes: 1. there are 60 seconds in a minute, 60 minutes in an hour.
2. "military time" is 24-hr time.  For example, 16:00 would be
4 P.M.
3. The program must continue to function in the menu system until
the user wishes to quit.
4. Remember to ask the user for appropriate data that you need.
5. Be sure to pause the screen to enable the user to see the results
of their query.  You may accomplish this by just calling readln;.
It will call the computer to wait until the user presses a key.
6. Be SURE your program is easily understood.

The solution to this program will be presented in the next part.  Good luck!

Next time
=========
Next time, we will discuss the usage of text files for reading in
data and writing out results. We really are moving along with the concepts