regards

All the best,
  Tim

Var
  F:Text
  Data1:Array[1..2]of String;
  Data2:Array[1..2]of Integer;

Procedure SaveData;
Begin
  Assign(F,'test.dat');
  Rewrite(F);
  Write(F,Data1[1]);
  Write(F,Data1[2]);
  Write(F,Data2[1]);
  Write(F,Data2[2]);
  Close(F);
End;

More efficient would be comma delimited files - depending upon the content of
your strings. A more flexible approach would be creating your own text tokens
to signal what the data on the rest of the line will be. Eg:

Read (InFile,TokenChar); (* READ FIRST LETTER OF LINE *)
CASE TokenChar OF
 'N': BEGIN (* READ A NUMBER *)
        READLN (InFile,NumberData[NumberIndex]);
        Inc(NumberIndex);
        END;
 'S': BEGIN (* READ A STRING *)
        READLN (InFile,StringData[StringIndex]);
        Inc(StringIndex);
        END;
 ELSE Writeln ('ReadData Token error line ', StringIndex+NumberIndex,
                      ' "',TokenChar,'"');
END; (* CASE *)

On Mon Nov 23, remove wrote:

Since the file on disk need not be people readable, you may as
well read and write the data as formatted in the computer.
Rather than use read/write, use blockread/blockwrite.

These two procedures work on files of type FILE!

var
   db     : file;

You can read/write any amount of data up to 64KB. You open/close
them the usual way (see the manual).

procedure
   dbload;
var
   readlen    : word;
begin
   assign(db, 'c:\...');
   reset(db);

   blockread(db, array1, sizeof(array1), readlen);
   blockread(db, array2, sizeof(array2), readlen);
   ...
   close(db);
end;

procedure
   dbsave;
var
   writelen    : word;
begin
   assign(db, 'c:\...');
   rewrite(db);

   blockwrite(db, array1, sizeof(array1), writelen);
   blockwrite(db, array2, sizeof(array2), writelen);
   ...
   close(db);
end;

Of course, you should check all return codes (reset, rewrite,
...) and check that the readlen equals the size of the array.

This is enough provided the things in the database are simple
arrays.

If you are using protected mode, you may have to copy the data
to a real mode buffer first.

BTW, one thing you should do is begin the database with a
version field, a word or perhaps a short string, that identifies
the version of the database. The first time it might contain
'MyDBV0.01'. Each time you change the DB format (it will
happen), you change this field value.

The dbsave routine writes the new DB identification and the new
data. The dbload routine reads the DB identification, and based
on what it finds, it either converts an earlier DB format to
the new format or reads the new format.

Where the data is stored in lists in RAM rather than arrays, you
can either read/write one list element at a time, or collect
many list entries into a buffer. The latter is much faster,
since IO operations are quite slow. Collecting 1000 20 byte list
entries into a 20KB buffer and then doing a single write can
speed up the database load/save by a factor of 100.

var
  StringArray : array[1..3] of String;
  IntegerArray : array[1..3] of Integer;
  I : Byte;
  F : Text;

  procedure ShowArray;
    {-Draw the array on the screen}
  var
    I : Byte;
  begin
    for I := 1 to 3 do
      Write(IntegerArray[I], ': ', StringArray[I], ', ');
    WriteLn;
  end;

begin
  {-Fill in some data}
  StringArray[1] := 'Save';
  StringArray[2] := 'into';
  StringArray[3] := 'files';
  for I := 1 to 3 do
    IntegerArray[I] := I;

  ShowArray;

  {-Save it to a file}
  Assign(F, 'TEST.DAT');
  Rewrite(F);
  for I := 1 to 3 do begin
    WriteLn(F, StringArray[I]);
    WriteLn(F, IntegerArray[I]);
  end;
  Close(F);

  {-Make the array empty}
  FillChar(StringArray, SizeOf(StringArray), 0);
  FillChar(IntegerArray, SizeOf(IntegerArray), 0);

  ShowArray;

  {-Read the data back from the file}
  Reset(F);
  for I := 1 to 3 do begin
    ReadLn(F, StringArray[I]);
    ReadLn(F, IntegerArray[I]);
  end;
  Close(F);

  ShowArray;
end.