``````                   Turbo Pascal for DOS Beginning Tutorial
by Glenn Grotzinger
Part 5 -- Reading and Writing to Text Files.
All parts copyright 1995-96 (c) by Glenn Grotzinger

program part4; uses crt;

{ This program offers a menu-type system in order to convert a number
of seconds to hours, minutes, and seconds; and to convert a military
time to AM/PM time }

var
choice: integer;

{ This procedure shows the main menu. }
begin
writeln('1. Convert a number of seconds to hours, minutes, and',
' seconds.');
writeln('2. Convert a given military time to AM/PM time.');
writeln('3. Quit the program.');
writeln;
end;

procedure convseconds;
var
totalseconds: integer;
hours, minutes, seconds: integer;
temp: integer;
begin
clrscr;
write('Enter a total number of seconds: ');
writeln;
temp := totalseconds div 60;
seconds := totalseconds mod 60;
hours := temp div 60;
minutes := temp mod 60;
writeln;
writeln(totalseconds, ' seconds is ', hours, ' hours, ', minutes,
' minutes, ', seconds, ' seconds.');
writeln;
writeln('Press ENTER to continue:');
end;

procedure convmilitary;
{ Version 1.1.  Bug found and e-mailed to me.  It is appreciated. }
{ Involved the reporting of times from 0000 to 0059...Looks to }
{ be fixed now. (wrote this in a very dazed state -- post-surgery)}

var
hours, minutes: integer;
meridian: char;
begin
clrscr;
write('Enter a military time''s hours: ');
write('Enter a military time''s minutes: ');
if hours >= 12 then
begin
meridian := 'P';
hours := hours - 12;
end
else
meridian := 'A';
if hours = 0 then
hours := 12;
writeln;
write('It is ');
write(hours);
write(':');
if minutes < 10 then
write('0');
write(minutes);
writeln(' ', meridian, 'M.');
writeln;
writeln('Press ENTER to continue:');
end;

begin
choice := 10;
while choice <> 3 do
begin
clrscr;
case choice of
1: convseconds;
2: convmilitary;
end;
end;
end.
OK.  On to new stuff...

================
To address a file, we use the assign statement.  We use a text variable to
refer to the file, and a string to refer to the actual pathname and filename
of the file.

To open a file, we use a reset(<file variable>); statement to read it.

To write a new file, we use a rewrite(<file variable>); statement.

To close a file after we are done accessing it for read or write, we use
the close(<filevar>).

Special Identifiers
===================
There are functions defined in standard Pascal which aid us in processing
text files.  They are eof(<filevar>) and eoln(<filevar>).  They return
boolean values.  They are signals we can use in loops to aid us in finding
our way in text files.  EOF signals when we are at the end of a file.
EOLN signals when we are at the end of a line of text in a file.

NOTE: Keep in mind, we can have as many files defined as we need.  The only
limitation is that we can only have a maximum of the number of files defined
in the FILES= statement of the config.sys of the particular machine we are
on open at any one time.  It is always prudent to close files after you are
done with them.

Text file concepts and reading/writing to text files
====================================================
A sample program to illustrate all the items above.  We will be doing a
character by character read on an input file named DATA.TXT using eoln
and eof properly, and uppercasing the output of the file using the
standard upcase function. The output will be written to another output file
named UPCASED.TXT.

program tutorial15;
var
infile, outfile: text;
inputchar: char;
begin
assign(infile, 'DATA.TXT'); { associate var infile with DATA.TXT }
reset(infile); { open DATA.TXT for read }
assign(outfile, 'UPCASED.TXT'); { assoc. var outfile with UPCASED.TXT }
rewrite(outfile); { open UPCASED.TXT for write }
while not eof(infile) do { while we're not at the EOF for infile }
begin
while not eoln(infile) do { while not EOLN for infile }
begin
write(outfile, upcase(inputchar)); { process and output }
end;
writeln(outfile);  { when end of line, advance both files down }
end;
close(infile);     { we're done with both of these files.  Close 'em }
close(outfile);    { time. }
end.

This program is primarily for illustration purposes of all the new concepts
we need to know in order to access files (there is a lot better way out
there of doing it).  As long as we remember what exactly is read and
considered as each type of variable (integer, char, string[limit], etc,
etc), we can read all sorts of data from a text file and write data back
out to a text file.  To illustrate:  If we have the following input file
as on disk...

14 23 34 53 32 Glenn Grotzinger
23 23 12 33 23 Clinton Sucks!

If we perform ONE read from a varied amount of different types from the
first position of the first line, we will see the following:

STRING[20]read: 14 23 34 53 32 Glenn
STRINGread: 14 23 34 53 32 Glenn Grotzinger

readln/writeln goes to the next line, whichever references what we are doing
to the text file.

We must keep these general rules in mind (I hope you played around with the

Another illustration to see usage of files.  It's the BETTER rewrite of
tutorial15.  We must also keep in mind that to read a text file, EOLN
is not necessarily required, but EOF is ALWAYS REQUIRED.  Improvements:
We can use a string and write a function to uppercase the whole string.
Plus, there's one little logic error above...Figure out why I do the
reads and writes different below and you'll have mastered the idea of
reading/writing files...(I intended to just demo the commands earlier,
this is a demo of how they should be used logically...)

program tutorial16;

var
inputstring: string;
infile, outfile: string;

function upstr(instring: string):string;
{ This function uppercases a whole string }
var
i: integer;
newstr: string;
begin
newstr := '';
for i := 1 to length(instring) do
newstr := newstr + upcase(instring[i]);
{ we can piece strings together using +.  Keep it in mind }
end;

begin
assign(infile, 'DATA.TXT');
reset(infile);
assign(outfile, 'UPCASED.TXT');
rewrite(outfile);
while not eof(infile) do
begin
writeln(outfile, upstr(inputstring));
end;
writeln(outfile, upstr(inputstring));
close(infile);
close(outfile);
end.

Remember to play with the logic in accessing text files.  And in reading and
writing files, BE SURE YOU USE FILES THAT YOU CAN STAND TO LOSE IF YOU ARE
NOT COMPLETELY COMFORTABLE WITH PROGRAMMING FOR FILE ACCESS.  IF A FILE
BY A NAME YOU USE FOR A PROGRAM ALREADY EXISTS ON THE DRIVE, AND YOU REWRITE
IT, IT WILL BE COMPLETELY LOST!  THIS MEANS ANY UNDELETE PROGRAM WILL *NOT*
BE ABLE TO RECOVER THE FILE!!!!!!!!!!!   I will cover in a later part
how to find out whether files exist on the drive as well as other commands
and functions used in Pascal to perform DOS-like functions (delete files,
make directories, remove directories, and so forth).

Printer Output
==============
The printer can basically be treated as a write-only file (you only
rewrite it, not reset it).  To use the printer?  Use the unit printer, like
you did the unit crt or wincrt before then write to a text file variable
named lst....Printer defines everything you need to write to the printer.
Printer assumes LPT1, so if your printer is on something else, you can
define the text file variable to be the port address for the printer....

program tutorial17; uses printer;
var
str: string;
infile: text;
begin
assign(infile, 'PRINTME.TXT');
reset(infile);
while not eof(infile) do
begin
writeln(lst, str);
end;
writeln(lst, str);
writeln('File sent to printer on LPT1..');
end.

Practice Programming Problem Notes
==================================
Probably ALL programs I pose on these in the future will involve
at least ONE data file off of disk.  If it is a binary one that I have
created for express purpose of these problems, I will be attaching it to
the tutorial message as a binary file attachment.  If its a text file,
I will probably ask you to create it, giving you the format.  If you have
been doing source code, you should be able to use a text file editor.

Practice Programming Problem #5
===============================
Write a program in Pascal and entirely Pascal which will conduct
a worker-pay recording.  Be sure the program is modular and uses functions
and procedures to the best benefit, as well as efficiently coded (be sure
you are using format codes!).  We will be reading worker names and data
from a file in the current directory with the program named WORKER.TXT.
Format of input and output files will be covered later.  What we will be
doing is figuring out how much to pay each of these employees in our data
file.  Points to keep in mind:

1) Gross pay is hourly rate * hours-worked for hours worked below 40.
2) 40 hours of time is full-time pay, beyond 40 hours is time and a half.
Therefore, we must pay them 1/2 more than we normally would at the
hourly computed rate for any hours above 40 from point 1.
3) Income Taxes are 15% of computed gross pay (before taxes, etc).
4) We must indicate all of these deductions by computations in the output.
5) We may have 1 employee, we may have 10,000.  We need to give the
user some indication as to what we are doing (all we will see is
a blank prompt otherwise.) so they won't think our program has hung
or crashed.  Write a message such as "Processing <employee name>" to
the screen for each employee.

Write a report of what our deductions are from each person's salary, and
what we are paying each employee to a file named PAYOUT.TXT.

Format of WORKER.TXT (I recommend you type this in *EXACTLY* and use it)
--------------------
Glenn Grotzinger    44.25  7.34
Joe Schmoe          65.32  4.35
Jim Nabors          40.00  10.01
Sheila Roberts      32.12  6.25
Kathy York          23.21  11.10
--------------------

(the area between all the --- is the WORKER.TXT to use.... -- another note:
be sure there aren't any blank lines at the bottom of the file -- those
cause problems...)
First thing on each line is employee name (max of 20 chars).
Second thing is total hours worked.
Third thing is pay rate.

Format of PAYOUT.TXT
--------------------
The International Widget, Inc.
PayOut And Deductions Sheet

Employee              Hours  Rate  GrossPay  Overtime  IncomeTax  NetPay
========================================================================
Glenn Grotzinger      34.25  7.34   345.23     32.34     15.34    305.23
...

--------------------
(The numbers should be correct, and the file should appear sort of like
this, but with more entries (equivalent to the number of entries in the
WORKER.TXT file.  This is only a sample illustration.)

Note:  In any program, you should always make accounts for changes in the
number of lines of text in an input file.  Use EOF.  Do not use a
defined set loop.  Also, as a tip, to get the output the way you want it
to look, it doesn't hurt to type it out as a sample, so you know how to
space it when you go into the programming part of it.

Next Time
=========
We will discuss arrays and their usage.  If there is a difficulty in inter-
preting data files for text files, tell me, and I will probably attach them
as binaries in the future.  Please send all comments, inquiries, etc, etc
to ggrotz@2sprint.net.  P.S.  Sorry this one ain't too fun...Couldn't think
of anything better to get you the practice in using text files...

``````

[Back to TUTOR SWAG index]  [Back to Main SWAG index]  [Original]