Oakland CPM Archive/oakcpm.iso/sigm/vol148/student2.pas

Pascal/Delphi Source File | 1984-04-29 | 21.5 KB | 848 lines

PROGRAM Student;

{---------------------------------------------------------------}
{ PROGRAM TITLE:    STUDENT    version 2.0            }
{ WRITTEN BY:        Raymond E. Penley            }
{ DATE WRITTEN:        Dec 18, 1982                }
{                                }
{ INPUT/OUTPUT FILES:           *** ACCESS METHOD ***    }
{   STUDENT.NDX - Misc data        <sequential>        }
{   STUDENT.DAT - Name & Address    <direct (random)>    }
{   STUDENT.GDS    - Grade data        <sequential>        }
{                                }
{ COMMANDS:                            }
{  New student    - Adds a new entry if file not filled.        }
{  Find        - Searches & displays a student            }
{  Change    - Allows changes on address/grades        }
{  List        - Displays data for all students        }
{  Quit        - Terminate program/close all files        }
{                                }
{ SUMMARY:                            }
{ Writes a name & address file and a grade file on all students.}
{ Also a file of misc. data; # of rcds on file and date file    }
{ was last updated.                        }
{                                }
{ 01/29/83 -- EXTENSIVE ERROR CORRECTING ADDED:            }
{ 04/02/83 -- added vlength() by D. Cortesi            }
{                                }
{ NOTES:                            }
{  utility procedures from the Pascal/Z User's Group        }
{  Library diskette.                        }
{---------------------------------------------------------------}


CONST
  MaxStudents = 200; { determines maximum # of data records in file }
  enter = 'ENTER NEW DATA OR PRESS RETURN TO KEEP PRESENT DATA';
  escape = 27;        { ASCII escape character }

TYPE

   {-------------------------------------------------------------}
   { create a binary search tree in memory to hold our index     }
   {-------------------------------------------------------------}

   link = ^ip;            { pointer to the binary tree }
   ip = RECORD            { the binary tree record }
      item : integer;    { KEY FIELD. student's id number      }
      rcd  : integer;    {            data file record pointer      }
      left,right: link    {            pointers to left/right nodes }
    END;

  byte        = 0..255;
  charset    = SET OF CHAR;
  strng2    = string 2;
  strng5    = string 5;
  strng20    = string 20;
  strng        = string 20;


  {-------------------------------------------------------------}
  { sturec - identifies the data to be stored for each student    }
  {-------------------------------------------------------------}

  sturec  = RECORD              { field, type, length        }
           id    : integer;    { id,     n,  5     <KEY FIELD>    }
           name,        { name,   c, 20            }
           street,        { street, c, 20            }
           city   : strng20;{ city,   c, 20            }
           state  : strng2;    { state,  c,  2            }
           zipcode: strng5    { zipcode,c,  5            }
        END;
  { total number of bytes = 77 per record.
    72 bytes + 1 for each string }


  {-------------------------------------------------------------}
  { Allow for ten grades and the student ID. Please note that    }
  { this may be changed to suit your particular requirements.    }
  { NOTE: the enumerated type has been setup such that        }
  {       ORD(exam1) = 1.                    }
  {-------------------------------------------------------------}

  gradetype = ( id,    { id field is link between all data files }
        exam1,    { 1st exam grade              }
        exam2,    { 2nd exam grade              }
        exam3,    { 3rd exam grade              }
        exam4,    { 4th exam grade              }
        exam5,    { 5th exam grade              }
        exam6,    { 6th exam grade              }
        exam7,    { 7th exam grade              }
        quiz1,    { quiz 1                   }
        quiz2,    { quiz 2                   }
        final);    { final grade                   }

  {-------------------------------------------------------------}
  gradestore    = array [gradetype] of integer;

  {-------------------------------------------------------------}
  StuGds    = array [1..MaxStudents] of gradestore;

  {-------------------------------------------------------------}
  FTYPE        = FILE OF StuRec;

  string0    = string 0;
  string255    = string 255;

VAR
  bell        : char;        { console bell }
  command    : char;        { command character }
  console    : TEXT;        { direct output to console }
  date        : packed array [1..8] of char; { date of last update }
  g        : gradetype;
  Grades    : StuGds;
  ioresult    : boolean;
  listhead    : link;
  more        : boolean;    { done processing flag }
  R        : integer;    { record pointer }
  rof        : integer;    { total Records On File }
  stucount    : integer;    { # of students in class }
  Student    : StuRec;    { A single student }
  StuFile    : FTYPE;    { name & address file }
  taken        : integer;    { # of tests taken thus far }
  updated    : boolean;    { flag for updated items }

{$R-}{ range checking OFF }

{-----------------------------------------------}
{         GENERAL PURPOSE UTILITIES             }
{-----------------------------------------------}

{$iPRIMS.PZ }


{ pause - allows prgm to stop until ready to continue }

PROCEDURE pause;
VAR    ch : char;
BEGIN
   writeln;
   write ('Press any key to continue ');
   keyin(ch); writeln
END{ pause };


{ ClearScreen - simple routine to clear the console device }

PROCEDURE ClearScreen;
VAR    i: 1..25;
BEGIN
   FOR i:=1 TO 25 DO writeln
END{ ClearScreen };


{ Q - prints a text message and accepts only the characters    }
{ passed via goodchars. Returns the result in uppercase.    }
{                                }
{ Q ( 'Enter "A", "B", or "C" -> ', ['A','B','C'], command );    }
{                                }
{ REQUIRES:                            }
{    procedure keyin();external;                }
{    function toupper():char;external;            }

PROCEDURE Q ( message: string255; goodchars: charset; VAR ch: char );
CONST    bell = 7;        { ASCII bell char }
VAR    tch: char;        { temp char       }
BEGIN
   write( message );
   REPEAT
     keyin(tch);
     ch := toupper(tch);
     IF ch IN goodchars
    THEN
       writeln (tch)
    ELSE
       write (chr(bell))
   UNTIL ch in goodchars
END{ Q };


{ readint - input of an integer value between lower..upper.    }
{    returns integer value and true if valid integer        }
{    else returns a zero value and false.            }
{ REQUIRES:                            }
{    function ivalue():integer;                }
{    function vlength():integer;external;            }

FUNCTION readint ( VAR i: integer; lower,upper: integer ): boolean;
VAR    answer: strng20;
BEGIN
      readint := true;
      readln(answer);
      IF vlength(answer) > 0 THEN BEGIN
     i := ivalue(answer,1);
     IF (i < lower) OR (upper < i ) THEN {do it again}
        readint := false;
      END
END{ readint };


{-----------------------------------------------}
{        PROGRAM SPECIFIC UTILITIES             }
{-----------------------------------------------}

{ gde - converts an integer to the enumerated type gradetype }

FUNCTION gde ( exam: integer ): gradetype;
BEGIN
     CASE exam OF
    0: gde := id;
    1: gde := exam1;
    2: gde := exam2;
    3: gde := exam3;
    4: gde := exam4;
    5: gde := exam5;
    6: gde := exam6;
    7: gde := exam7;
    8: gde := quiz1;
    9: gde := quiz2;
       10: gde := final
     END
END{ gde };

{$R+}{ RANGE CHECKING ON }


{ insert - adds a node to the binary search tree, preserving the ordering }

PROCEDURE insert( VAR node: link; ident, R: integer );
BEGIN
  IF node=nil THEN BEGIN
     new(node);        { create a new storage location }
     WITH node^ DO BEGIN
        left := nil;
        right := nil;
        item := ident;    { store the student's id }
        rcd := R    { store the location record pointer }
     END{with}
  END
  ELSE
     WITH node^ DO
        IF ident<item THEN
           insert ( left,ident,R )
        ELSE IF ident>item THEN
           insert ( right,ident,R )
        ELSE
       { DUPLICATE ENTRY }{ not handled }
END{ insert };


{ search - returns a pointer to a node in the tree containing }
{  the given data, or nil if there is no such node.          }

FUNCTION search ( node: link; ident: integer ): link;
BEGIN
  IF node=nil THEN
     search := nil
  ELSE
     WITH node^ DO
        IF ident<item THEN
           search := search(left,ident)
        ELSE IF ident>item THEN
           search := search(right,ident)
        ELSE
           search := node
END{ search };



PROCEDURE ListRange ( VAR first, last: integer );
{ RETURNS:                               }
{   one value        -first = last                   }
{   all values        -first = lower bound, last = highest bound }
{   a range of values    -first/last = entered values           }
{ ENTER with first = lower bound; last = uppermost bound.       }
VAR
    tch: char;
    t1,t2: integer;
BEGIN
  t1 := first;
  t2 := last;
  writeln;
  Q( 'ENTER LIST RANGE: A(ll, O(ne, R(ange ->', ['A','O','R'], tch );
  CASE tch of
     'A':
    BEGIN
      first := t1;
      last := t2
    END
     'O':
    REPEAT
      write ( 'WHICH ONE? '); readln(first);
      last := first;
    UNTIL (first<=t2) or (first>=t1);
     'R':
    REPEAT
       write ( 'Enter lower bound ->'); readln(first);
       write ( 'Enter upper bound ->'); readln(last)
    UNTIL first <= last
  end{CASE}
END{ ListRange };



{ fread - reads the address file and sets the global record pointer }

PROCEDURE fread ( VAR StuFile: FTYPE; VAR node: link );
BEGIN
   R := node^.rcd;        { returns the record pointer. }
   read ( StuFile:R, student )    { read student record R. }
END{ fread };



PROCEDURE ChangeAddress ( VAR student: sturec; VAR goodstatus: boolean );
LABEL
   1;    { early exit }
CONST
   ok = true;
VAR
   answer: strng20;
   i     : integer;
   node  : link;
   valid : boolean;

    PROCEDURE disp ( message, value: string255 );
    BEGIN
       writeln;
       IF vlength(value) > 0 THEN BEGIN
          writeln ( message, value );
          write ( ' ':19 )
       END
       ELSE
          write ( message );
    END{ disp };

BEGIN {ChangeAddress}
   goodstatus := ok;
   IF command = 'C' THEN BEGIN
      writeln;
      writeln ( enter )
   END;
   writeln;writeln;
   WITH student DO BEGIN
    IF id=0
       THEN
          setlength ( answer,0 )
       ELSE
          STR ( id,answer );

        { NOTE:
        do not allow ID to be changed after initial input }
    IF command = 'N' THEN BEGIN { adding New records }
       REPEAT
          disp ( 'ID Number      ... ', answer )
       UNTIL readint ( id,1,9999 );

       node := search ( listhead,id );    { id already on file? }
       IF node<>nil THEN BEGIN { already on file }
          fread ( StuFile, node );    { read record for display }
          ClearScreen;
          writeln ( bell, id, ' already on file!');
          goodstatus := not ok;
          {EXIT}goto 1
       END
    END{IF command='N'...}
    ELSE
       writeln ( 'ID Number      ... ', answer );

    disp ( 'Name           ... ', name ); readln(answer);
    IF vlength(answer)>0 THEN
       name := answer;

    disp ( 'Street Address ... ', street ); readln(answer);
    IF vlength(answer)>0 THEN
       street := answer;

    disp ( 'City           ... ', city ); readln(answer);
    IF vlength(answer)>0 THEN
       city := answer;

    disp ( 'State          ... ', state ); readln(answer);
    IF vlength(answer)>0 THEN BEGIN
       state[1] := toupper ( answer[1] );
       state[2] := toupper ( answer[2] );
       setlength ( state,2 )
    END;

    REPEAT
       valid := true;
       disp ( 'Zip code       ... ', zipcode ); readln(answer);
       IF vlength(answer)>0 THEN BEGIN
          zipcode := '     ';        { insure no garbage in answer }
          IF isdigit(answer[1]) THEN { good chance is digit }
             FOR i:=1 TO 5 DO
            zipcode[i] := answer[i]
          ELSE BEGIN
         write(bell); valid := false
          END
       END
    UNTIL valid;
   END;
   updated := true;
1:{early exit}
END{ ChangeAddress };



PROCEDURE ChangeGrades ( VAR student: sturec );
{NOTE:
    record pointer must be set before entry to ChangeGrades() }
CONST
   low = 0;    { lowest grade acceptable }
   high = 110;    { highest grade acceptable <wow!>}
VAR
   answer    : strng20;
   first,last    : gradetype;
   lower,upper    : integer;
BEGIN
   lower := 1;
   upper := taken;
   ListRange ( lower,upper );
   first := gde(lower);
   last := gde(upper);
   writeln;
   writeln ( enter );
   writeln;writeln;
   writeln ( 'STUDENT: ', student.name );
   writeln;
   FOR g:=first TO last DO BEGIN
      REPEAT
     write ( ord(g):3, grades[R,g]:6, ' ?' )
      UNTIL readint ( grades[R,g],low,high )
   END{FOR g}
END{ ChangeGrades };



PROCEDURE display ( VAR output: TEXT; VAR student: sturec );
{NOTE:
    record pointer must be set before entry to display() }
CONST
   width = 35;
BEGIN
   writeln ( output );
   writeln ( output );
   WITH student DO BEGIN
    writeln ( output, 'STUDENT ID: ', id:1 );
    writeln ( output, name, ' ':width-vlength(name), street );
    writeln ( output, ' ':width, city, ', ', state, ' ', zipcode );
    writeln ( output, 'GRADES');
    writeln ( output, ' < first half year >< second half year >');
    FOR g:=exam1 TO gde(taken) DO
       write ( output, grades[R,g]:4 );
    writeln ( output );
    writeln ( output );
    writeln ( output )
   END
END{ display };



PROCEDURE MODIFY;
VAR
    node       : link;
    ch       : char;
    goodstatus : boolean;
BEGIN
   IF command='N' THEN { arrived here from ADD }
      command := 'C'   { ... switch to CHANGE. }
   ELSE BEGIN
      writeln;
      REPEAT
     write ('Enter student id number ... ')
      UNTIL readint ( student.id,1,9999 )
   END;

   node := search ( listhead,student.id );
   IF node<>nil THEN BEGIN
      fread ( StuFile, node );
      CASE command of
    'C':
       BEGIN {CHANGE}
          writeln;
          Q( 'Do you wish to change A(ddress, or G(rades? <escape=quit> ',
            [chr(escape),'A','G'], ch );
          if ord(ch)<>escape then begin
             CASE ch of
            'A':
               ChangeAddress ( student,goodstatus );
            'G':
               ChangeGrades ( student )
             END{CASE};
             display ( console,student );
             if ch='A' THEN { update address file }
            write ( StuFile:R, student )
          end
       END{ CHANGE };
    'F':
       BEGIN {FIND}
          display ( console,student )
       END{ FIND }
      END{CASE}
   END
   ELSE
      writeln ( bell, student.id:1,' not on file!')
END{ MODIFY };



PROCEDURE ADD;
VAR
    goodstatus: boolean;
BEGIN
   IF rof >= MaxStudents THEN
      writeln ( 'Sorry can''t add file is full.' )
   ELSE BEGIN { OK to add more records }
      R := rof + 1;        { temp set record pointer }
      WITH student DO BEGIN { initialize all fields to zero }
     id := 0;
     setlength ( name,0 );
     setlength ( street,0 );
     setlength ( city,0 );
     setlength ( state,0 );
     setlength ( zipcode,0 )
      END;
      writeln;
      writeln ( 'RECORD #', R:1 );
      ChangeAddress ( student,goodstatus );
      display ( console, student );

      IF goodstatus THEN BEGIN
     grades[R,id] := student.id;    { update grades matrix }
     insert ( listhead,student.id,R );
     write ( StuFile:R, student );    { update address file }
     updated := true;        { flag we updated the file }
     rof := R;            { increment records on file }
     stucount := rof;        { and student count         }
     { move right into edit mode...change address/grades }
     MODIFY
      END{IF goodstatus then...};
      pause
   END{ELSE}
END{ ADD };



{ list - lists ALL records on file }

PROCEDURE LIST;
VAR
    output : TEXT;

    { printlist - writes the entire tree recursively }
    PROCEDURE PrintList ( node: link );
    LABEL    1;
    BEGIN
       IF node<>nil THEN
          WITH node^ DO BEGIN
             PrintList (left);
         fread ( StuFile, node ); { read address file }
         display ( output, student );
         { test the keyboard and abort on any keypress }
         IF conchar<>0 THEN BEGIN {ABORT}
            writeln;writeln(chr(7);'ABORTED');goto 1
         END;
         IF command<>'P' THEN pause;
             PrintList ( right )
          END{with};
    1:{abort}
    END{ PrintList };

BEGIN
   writeln;
   Q('Output to C(onsole or P(rinter? <escape=quit> ',
        [chr(escape),'C','P'], command );
   IF ord(command)=escape THEN
      {all done}
   ELSE BEGIN
      CASE command OF
     'P': { direct output to the list device }
        REWRITE( 'LST:',output );
     'C': { direct output to the console device }
          REWRITE( 'CON:',output )
      end{CASE};
      PrintList(listhead)
   END
END{ LIST }{ CLOSE(output); };



{ report - generates totals and prints a formatted report on each student }

PROCEDURE report;
LABEL
    1; {abort}
CONST
    fw = 6;
TYPE
    atype = (avg,total);
VAR
    a,rr     : integer;
    aborted     : boolean;
    accum     : array [avg..total,gradetype] of integer;
    first,g,
    last     : gradetype;
    output     : TEXT;


   PROCEDURE PrintClass ( node: link );
   LABEL
     2; {abort}
   BEGIN
      IF node<>nil THEN
         WITH node^ DO BEGIN
            PrintClass (left);
        R := rcd;
        rr := rr + 1;
        { output line consists of: line #, student id #, grades }
        write ( output, rr:3, grades[R,id]:5, '  ' );
        a := 0;                   { "a" = grade accumulator }
        FOR g:=first TO last DO BEGIN
           write ( output,grades[R,g]:fw );
               a := a + grades[R,g];
           accum[total,g] := accum[total,g] + grades[R,g]
        END{FOR g};
        { print the rounded average of this student's grades }
        writeln (output, '  ', round(a/taken):fw );

        { test the keyboard and abort on any keypress }
        IF conchar<>0 THEN BEGIN {ABORT}
           aborted := true;
           writeln;writeln(chr(7);'ABORTED');goto 2
        END;
            PrintClass ( right )
         END{with};
   2:{abort}
   END{ PrintClass };

BEGIN{ report }
   writeln;
   Q('Output to C(onsole or P(rinter? <escape=quit> ',
        [chr(escape),'C','P'], command );
   IF ord(command)=escape THEN
      goto 1; {all done}
   CASE command OF
      'P': { direct output to the list device }
         REWRITE( 'LST:',output );
      'C': { direct output to the console device }
         REWRITE( 'CON:',output )
   END{CASE};

   first := exam1;    { first = 1st exam grade, last = last exam taken }
   last := gde(taken);

{REPORT LINE 1}
   writeln ( output );
   write(output,' STUDENT  ');
   FOR g:=first TO last DO
      IF ord(g)=1
     then write(output,' EXAMS')
     else write(output,'      ');
   writeln(output,'  AVERAGE');

{REPORT LINE 2}
   write ( output,'========  ' );
   FOR g:=first TO last DO BEGIN
      write( output,ord(g):fw );
      accum[total,g] := 0    { zero total accumulator }
   END;
   writeln ( output,'  =======' );

{REPORT LINE 3...n}
   rr := 0;
   aborted := false;
   PrintClass(listhead);
   if aborted then goto 1;
   write ( output,'          ' );{ 10 spaces }
   FOR g:=first TO last DO BEGIN
    { compute the average for all the student's grades }
    accum[avg,g] := accum[total,g] DIV stucount;
    { underline each column }
    write(output,'   ---');
   END;
   writeln (output);

{REPORT SUMMATION LINE...}
   writeln ( ' CLASS' );
   write   ( ' AVERAGE: ');
   FOR g:=first TO last DO
      write ( output,accum[avg,g]:fw );
   writeln ( output );
   writeln ( output );
1:{abort}
END{ report }{ CLOSE(output); };



PROCEDURE STATS;
VAR
    answer    : strng20;
    valid    : boolean;
BEGIN
   writeln;
   writeln ( 'MAX STUDENTS ALLOWED ... ', MaxStudents:3 );
   writeln ( 'NUMBER OF STUDENTS ..... ', stucount:3 );
   REPEAT
    write  ('NUMBER OF TESTS ........ ', taken:3,' ?' );
    readln ( answer );
    IF vlength(answer)>0 THEN
       taken := ivalue( answer,1 );
    valid := (taken>=0)
   UNTIL valid
END{ STATS };



PROCEDURE fclose;
VAR
    StuGrades: FILE OF gradestore;    { grade data on each student }
    StuNdx   : TEXT;        { index file }
BEGIN
   { OPEN 'STUDENT.NDX' for WRITE assign StuNdx }
   rewrite('STUDENT.NDX',StuNdx);
   writeln ( StuNdx, rof );
   writeln ( StuNdx, date );
   writeln ( StuNdx, stucount ); { # of students in class }
   writeln ( StuNdx, taken );    { # of tests taken thus far }

   { OPEN 'STUDENT.GDS' for WRITE assign StuGrades }
   rewrite('STUDENT.GDS',StuGrades);
   FOR R:=1 TO rof DO
      write ( StuGrades, grades[R] )
END{ fclose }{ CLOSE(StuNdx); CLOSE(StuGrades); };



PROCEDURE Initialize;
VAR
    i,rr    : integer;
    ch    : char;
    StuGrades: FILE OF gradestore;    { grade data on each student }
    StuNdx   : TEXT;        { index file }
BEGIN
   ClearScreen;
   writeln ( ' ':32, 'STUDENT SYSTEM');
   writeln;
   writeln;
   bell := chr(7);
   listhead := nil;    { make the list empty }
   updated := false;    { say file has not been updated }

   { insure that all cells in grades matrix are 0 }
   FOR g:=id TO final DO
      grades[1,g] := 0;
   FOR rr:=2 TO MaxStudents DO
      grades[rr] := grades[1];

   { OPEN 'CON:' for WRITE assign console }        {open files=1}
   rewrite('CON:',console);

   { OPEN 'STUDENT.NDX' for READ assign StuNdx }    {open files=2}
   reset('STUDENT.NDX',StuNdx);

   IF eof(StuNdx) THEN BEGIN {create all files}
    writeln ( 'Please standby while I create data files ...' );
       { OPEN 'STUDENT.NDX' for WRITE assign StuNdx }    {open files=2}
    rewrite('STUDENT.NDX',StuNdx);
       { OPEN 'STUDENT.DAT' for WRITE assign StuFile }    {open files=3}
       rewrite('STUDENT.DAT',StuFile);
       { OPEN 'STUDENT.GDS' for WRITE assign StuGrades }    {open files=4}
       rewrite('STUDENT.GDS',StuGrades);

    rof := 0;
    stucount := 0;
    taken := 10;    { setup to 10 then can lower at any time }
    date := 'MM/DD/YY'
   END
   ELSE BEGIN { finish opening files and read record count }
       { OPEN 'STUDENT.DAT' for READ assign StuFile }    {open files=3}
    reset('STUDENT.DAT',StuFile);
       { OPEN 'STUDENT.GDS' for READ assign StuGrades }    {open files=4}
    reset('STUDENT.GDS',StuGrades);

    readln ( StuNdx, rof );
    readln ( StuNdx, date );
    readln ( StuNdx, stucount );    { # of students in class }
    readln ( StuNdx, taken );    { # of tests taken thus far }
    writeln;
    FOR rr:=1 TO rof DO BEGIN
       write( chr(13), 'RECORD #', rr:1 );
       read ( StuGrades, grades[rr] );
       read ( StuFile:rr,student );    { create the B-tree in memory }
       insert ( listhead,student.id,rr ){ INDEX ON student.id         }
    END;
    writeln
   END;

   IF rof>0 THEN BEGIN
      writeln;
      writeln ( 'There are ',rof:1,' records on file as of ', date )
   END;
   writeln;
   write ( 'ENTER TODAY''S DATE <MM/DD/YY>  ->');
   keyin(ch);
   if ord(ch)=13 then
      {accept date given}
   else begin
      date[1] := ch;
      write(ch);
      FOR i:=2 TO 8 DO BEGIN
         IF (i=3) or (i=6)
        THEN ch := '/'
        ELSE keyin(ch);
          write(ch);
          date[i] := ch
      END;
   end;
   writeln
END{ Initialize }{ CLOSE(StuNdx); CLOSE(StuGrades); };        {open files=2}



BEGIN    (*** MAIN PROGRAM ***)
   Initialize;
   more := true;
   WHILE more DO BEGIN
    writeln;
    Q('N(ew student, F(ind, C(hange, R(eport, L(ist, S(tats, Q(uit ...?',
        ['N','C','F','R','L','S','Q'], command );
    CASE command of
       'N':
          ADD;
       'C','F':
          MODIFY;
       'R':
          report;
       'L':
          LIST;
       'S':
          STATS;
       'Q':
          more := false
    end{CASE}
   END{while};
   IF updated THEN fclose
END.