Click above to get retro games delivered to your door ever month!

                       Overview


   Variable Length Fields

   FlexFile is a very focused dual purpose tool kit for Clipper
   programmers.  Its first and main purpose is to provide a
   complete replacement for Clipper's memo-fields with a more
   powerful and more efficient Variable Length Field engine.  We
   are certain that it will relieve you of the confinement
   imposed by Clipper's memo-fields, but also, we believe it may
   change the way you think about your data base structures in
   general.

   FlexFile was designed to be immediately familiar to the
   Clipper programmer. To accomplish this goal, many of the
   function names can only be distinguished from their Clipper
   counterpart by a V_ prefix.  For example, V_USE() opens a DBV
   file in the currently V_SELECT()ed work area.

   The similarities extend into the structural use of FlexFile's
   Variable Length Fields (VLF) as well.  FlexFile's version of a
   memo-field (which we will refer to as a pointer-field) is a
   six byte character type field in a DBF file. FlexFile uses
   this pointer-field to store a pointer to variable length data
   in a .DBV file (FlexFile's version of a .DBT file).  These
   similarities allow any Clipper REPLACE syntax which works on
   memo-fields to remain almost unchanged when used with
   FlexFile.  This claim carries in network environments as well.

   The benefits and use of FlexFile's Variable Length Fields are
   discussed in detail in the Reference "Variable Length Fields".
   Pay special attention to the section on FlexFile's extended
   features.



   Arrays

   FlexFile's strongly typed arrays provide a utility which defy
   the products name.  Instead of being flexible, these arrays
   are purposefully rigid.  The utility of these arrays is
   twofold.  First and foremost, they use far less space than
   their Clipper counterpart.  For example, any Clipper array of
   1,000 elements would require a minimum of 14,000 bytes from
   Clipper's free pool of memory.  A FlexFile array of 1,000
   integers, on the other hand, would require only 2,000 bytes
   from Clipper's free pool of memory.

   Typically, large strongly typed arrays are used for scientific
   or statistical matrixes.  For this reason, FlexFile provides a
   host of functions which globally manipulate or query these
   large arrays.