b) Make your variables smaller - use singles instead of doubles or
extended reals.

c) Store infrequently referenced data arrays as records in disk
files.

d) Shrink the buffers on text files.

etc. etc.  Mostly use the heap.

A simple string takes up 256 bytes (255 for the contents, 1 for the
length counter).  This is 1/4 of a Kilobyte, which means that your
data segment can only contain 256 of these {*word*81}s....

Now usually a string needn't contain more than about 80 characters (a
full screen's width in text mode). So, wherever possible, replace  

"VAR a:String"  with "VAR a:String[80]" and you'll save HUNDREDS of
bytes per string.

Next, try to move all variables that you DON'T NEED GLOBALLY  into
your procedures. Make them local! These variables are not inside your
data segment, but on the stack, and available ONLYonly inside the
procedure where they were declared, and they are destroyed as soon as
you leave the procedure.

So instead of:

VAR s:array[1..1000] of char;

procedure test;
begin
s[1]:='t';
end;

Use:

procedure test;
VAR s:array[1..1000] of char;
begin
s[1]:='t';
end;

These tips are the easiest way to save memory, without resorting to
pointer variables on the heap. If you want to find out how much data
memory your program needs, use [C]ompile [I]nfo in Borland Pascal
after you compiled your program.

Hope this helps,
Arthur Hoornweg.

Type
  PMyArray=^TMyArray;
  TMyArray=Array[1..399] Of Long;

Var
  MyPtr : PMyArray;

Begin
  New(MyPtr);
  MyPtr^[1] := 45345;
  Writeln('I just stored ', MyPtr^[1], ' on the heap.');
End.

Also, put any strings you want to use in a text file, one per line.  Then,
when you initialize your program, read this text file into a structure
similar to the one above.  When you want to write a string, refer to the
string by varible name and array index (e.g., MyString^[234] would contain
line 234 of the text file).

If you do this, however, bear in mind that using New() on a String type
will always allocate 256 bytes.  If you want to allocate fewer bytes per
string, create a pointer to a string and an array of pointers to strings.
Then, create a procedure to assign a string value to one of these
pointers:

(Suppose the following line is the contents of your string file:)
This is a string on the heap.

Program HeapStr;

Type
  PMyString=^String;
  PMyArray=^TMyArray;
  TMyArray=Array[1..500] Of PMyString;

Procedure AssignString(sp : PMyString; sv : String);
Begin
  GetMem(sp, Length(sv)+1);
  sp^ := sv;
End;

Var
  MyPtr : PMyArray;
  F : Text;
  Tmp : String;
  i : Word;

Begin
  Assign(F,'STRINGS.TXT');
  Reset(F);
  New(MyPtr);
  i := 0;
  While Not EOF(F) Do Begin
    Inc(i);
    ReadLn(F, Tmp);
    AssignString(MyPtr^[i],Tmp);
  End;
  Close(F);
  WriteLn(MyPtr^[1]);
End.

This program would output:

-----------------------------------------------
Mike Chapin
Powder River
mcha...@vcn.com
http://www.vcn.com/server/netizens/mchapin/first.html
Gillette, WY