Small Memory Footprint (SFileTbl.c)
===================================

Since 16 bit DOS programs have a limited memory space, the file lists
could not be expected to fully fit within memory so I used a simple
buffering method as follows:

Each file table uses a single 64000 byte buffer (this is enough less
than 64K that any DOS C compiler should be able to allocate it). When
adding files to the table, the file info entries are added from the
bottom to the top, and the position in the buffer (a file table entry
is variable length) are kept in an index that builds from the top
of the buffer down.
  When the two sides meet, the result is sorted using a simple shell
sort and flushed to disk. An entry is added to another table which
contains the offset into the temporary file of the start of this table,
and the number of entries in it, and the maximum entry length. This continues
until no more files need to be added.
  Assuming a maximum path length of 260 bytes, plus overhead fills
the structure to around 300 bytes (including the index entry), 213
entries will fit between flushes. In reality, the average path is rarely
greater than 70 or so characters, giving closer to 640 entries per
buffer.
  When all is complete, the original 64,000 byte buffer is divied up into
chunks, each the length of the maximum entry length of a given table
(say 16 sub-tables each with a maximum entry length of 100 bytes, subtable
one gets a buffer at position 0, subtable 2 at positition 100, subtable
3 at position 200, etc).
  The entries are then read back on demand (fileTableGetFirst(...), 
fileTableGetNext(...)) using a simple merge operation.

Note that to simplifiy the code, each subtable only gets a single buffer
during the read. This generally leaves quite a bit of wasted space in the
64,000 byte buffer, but such is life. I leave disk caching up to the operating
system. If no cache is being run, the ``process'' and ``postProcess'' phases
will require an enormous amount of time. I leave it as an excerciase to anyone
who really wants to to allow each subtable to maintain multiple buffers
to improve performance.
