                   Welcome to Turbo C ++
                   ---------------------

This README file contains important information about Turbo C++.
For the latest information about Turbo C++, the accompanying
programs, and the manuals, read this file in its entirety.


TABLE OF CONTENTS
-----------------
1.  How to Get Help
2.  Installation
3.  Features
4.  Important Information
5.  Testing Your Expanded Memory
6.  Corrections to the Documents
7.  TCTOUR
8.  Files on the Disks


 1. HOW TO GET HELP
-------------------

  If you have any problems, please read this file, the
  HELPME!.DOC file, and the Turbo C++ manuals first. If you still
  have a question and need assistance, help is available from
  the following sources:

  1. Type GO BPROGB on the CompuServe bulletin board system for
     instant access to the Borland forums with their libraries of
     technical information and answers to common questions.

     If you are not a member of CompuServe, see the enclosed special
     offer, and write for full details on how to receive a free
     IntroPak containing a $15 credit toward your first month's on-
     line charges.

  2. Check with your local software dealer or users' group.

  3. Write to us at the following address:

     Borland International
     Turbo C Technical Support
     1800 Green Hills Road
     P.O. Box 660001
     Scotts Valley, CA  95066-0001

     Please remember to include your serial number or we will be
     unable to process your letter.

  4. If you have an urgent problem that cannot wait and you have sent
     in the license agreement that came with the package, you may
     call the Borland Technical Support Department at (408) 438-5300.
     Please have the following information ready before calling:

     a. Product name and serial number on your original distribution
        disk.  Please have your serial number ready or we will be
        unable to process your call.

     b. Product version number. The version number for Turbo C++
        can be displayed by pressing Alt-Space/A.

     c. Computer brand, model, and the brands and model numbers of
        any additional hardware.

     d. Operating system and version number. (The version number can
        be determined by typing VER at the MSDOS prompt.)

     e. Contents of your AUTOEXEC.BAT file.

     f. Contents of your CONFIG.SYS file.


2. INSTALLATION
---------------

  You MUST use the INSTALL program to install Turbo C++.
  The files on the distribution disks are all archived and
  have to be properly assembled.  You cannot do this by
  hand!

  To start the installation, change your current drive to the one
  that has the install program on it and type INSTALL.  You will
  be given instructions in a box at the bottom of the screen for
  each prompt. For example, if you will be installing from drive
  A:, type:

    A:
    INSTALL

  You should read the rest of this README file to get further
  information about this release before you do the installation.

3. FEATURES
-----------

  - C++!  Turbo C++ offers you the full power of C++ programming,
    implementing the entire C++ 2.0 language as defined by the AT&T
    specification.  To help you get started, we're also including
    C++ class libraries.

  - ANSI C!  A 100% implementation of the ANSI C standard.

  - Borland's new Programmer's Platform. The Programmer's Platform
    is a new generation user interface; it goes beyond the old
    integrated environment (IDE) to provide access to the full range of
    programs and tools on your computer. It includes:

    -- mouse support

    -- multiple overlapping windows

    -- a multi-file editor

    -- user-configurable menu entries to run other programs
      without leaving Turbo C++

  - VROOMM (overlay manager): VROOMM lets you overlay your code
    without complexity. You select the code segments for
    overlaying; VROOMM takes care of the rest, doing the work
    needed to fit your code into 640K.

  - An online tour of the new Programmer's Platform.

  - Online hypertext help, with copy-and-paste program examples
    for practically every function.

  - Many indispensable library functions, including heap checking
    functions and a complete set of complex and BCD math functions.

4. IMPORTANT INFORMATION
------------------------

  C++ STREAM I/O

  The standard libraries have all the functions needed for
  the IOSTREAM libraries defined in the AT&T 2.0 spec.  If
  you have code that uses the STREAM libraries from the 1.0
  spec, you must link with the appropriate OLDSTRMx.LIB
  file, where 'x' is replaced by the letter for the
  appropriate memory model:

    oldstrms.lib -- small model
    oldstrmc.lib -- compact model
    oldstrmm.lib -- medium model
    oldstrml.lib -- large model
    oldstrmh.lib -- huge model

  EXAMPLE PROGRAMS

  When you are running any example programs that come with
  .PRJ files, if you didn't use the standard directories when
  you installed Turbo C++ you will have to change the .PRJ file
  to reflect your actual directory setup.  Do this from inside
  TC with Alt-O/D.

  Included in this release is source code to the GREP2MSG and
  TASM2MSG filter programs (in EXAMPLES), which give an example of
  how to write your own custom filter programs to use with the
  Transfer Menu (see page 64 of the User's Guide).

  COMPILER AVAILABLE MEMORY

  To achieve better capacity and flexibility, Turbo C++ uses VROOMM,
  which means that the reported "available memory" number (both with
  the standalone compiler and in the integrated development environment)
  reflects the actual amount of RAM available to VROOMM for the entire
  compiler. What this means is that even when the reported available
  memory approaches or is equal to zero, much larger files can still
  be compiled at the expense of compilation speed. In the Programmer's
  Platform, when memory available for VROOMM reaches zero, the compile
  box will show "Swapping ...." as the amount of available memory; the
  standalone compiler will merely report "Available memory 0" in this case.



  OVERLAYS AND ASSEMBLY LANGUAGE

  Just as all "C" modules to be linked into an overlaid executable must
  be compiled with the -Y compiler switch, all assembly language modules
  need to be assembled with the -O TASM switch. If an assembly file is
  the result of a TCC compilation, TCC automatically passes -O to the
  assembler whenever -Y is used. Modules written entirely in assembly
  language must be assembled with the -O switch (using TASM version 2.0
  or newer) if they are to be linked into an overlaid executable. Failure
  to follow these rules may result in the overlaid program failing
  unpredictably when run.

  IMPORTANT NOTES

  - If you use inline assembler in C++, TASM 1.0 may not be able
    to assemble the generated code.  If you run into this problem,
    you will need to update to version 2.0 of TASM.

  - Functions that return structures now take a hidden
    parameter that contains the address where the returned
    structure is to be placed.  If you are writing assembler
    code to link with C code you must be sure to allow for
    this extra parameter.

  - When debugging mouse application the Options|Debugging|Display
    Swapping option should be set to "Always" for best results.

  - When running under DOS versions 2.0 or 2.1, you should not rename
    TC, TCC, or TLINK.  They need to know their names to be able to
    load their overlays.

  - TEMC will not allow a macro to contain multiple commands that return
    exit codes.

  - C++ programs that use either of the stream libraries will not link
    correctly if you compile with the -K command-line switch (default
    char is unsigned) or with the corresponding option in the Programmer's
    Platform ( Alt-Options/Compiler/Code Generation/Unsigned characters).

  - Example 2 for the signal() function in the Reference Guide uses
    an extension to signal() that is not supported in C++, so the
    example will not compile as a C++ program.

  - If you have selected Save Desktop in the Turbo C++ Programmer's
    Platform, everything that you put into the clipboard will be saved
    as part of the desktop.  After several sessions this may make
    starting the Programmer's Platform take longer.  If this happens
    to you (you will see the message "Loading Desktop" while the
    Programmer's Platform is loading), you can speed things up by
    deleting unneeded things from the clipboard.  Just select Alt-E/S
    to show the clipboard, and start deleting.

  - In some rather unusual situations when stepping through
    a program in the IDE you may get a message saying "Line
    too complex".  This means that the Programmer's Platform
    can't step past the line it is currently on.  To continue
    stepping, you should move the cursor to the next line in
    the program and press F4 (Go to Cursor).  If the line where
    this message occurs is the last line in a function, use
    the Call Stack (Ctrl-F3 or Alt-D/C) to see where the function
    was called from, select the calling function (by moving the
    highlight to it and pressing Enter), move the cursor to the
    next line, and press F4.

  - If you change your keyboard settings using the Editor Commands 
    choice in TCINST, you may lose some key assignments.  To avoid
    this, use the following procedure:
        1)  don't save the modifications to the EXE; instead invoke
            TCINST with the name of your configuration file, by default
            TCCONFIG.TC.
        2)  create a file containing the following line:
               Tab: SmartTab;
            and invoke TEMC with the name of that file and the name
            of your configuration file as arguments.
    As an example, you can follow these exact steps:
             CD \TC\BIN
             TCINST TCCONFIG.TC
	     <make changes, save, and exit TCINST>
	     COPY CON TEMP.TEM
             Tab: SmartTab;
             <Ctrl-Z>
             TEMC TEMP.TEM TCCONFIG.TC
         

5. Testing Your Expanded Memory: EMSTEST.COM
--------------------------------------------

  Included with Turbo C++ is a program to test your Expanded Memory
  hardware and software. If you have problems using Turbo C++ with
  your EMS, type EMSTEST at the DOS prompt and follow the instructions.

6.  Corrections to the Documents
--------------------------------

  GETTING STARTED

  - Chapter 4, Page 61: The operator precedence and associativity
    tables should be corrected to match the following information.
    Note there are now sixteen precedence categories. Operators within
    a category have the same precedence. Precedence goes from highest
    to lowest; therefore, any operator in category 1 has precedence
    over any operator in categories 2 through 16; any operator in
    category 2 has precedence over any operator in categories 3
    through 16, and so on.


    Operators                            Associativity
    --------------------------------------------------
    1.  ( )  [ ]   ->   ::   .           Left to right
    2.  !  ~  +  -  ++  --  &  *
        (typecast)  sizeof  new  delete  Right to left
    3.  .*   ->*                         Left to right
    4.  *   /    %                       Left to right
    5.  +   -                            Left to right
    6.  <<  >>                           Left to right
    7.  <   <=   >   >=                  Left to right
    8.  ==  !=                           Left to right
    9.  &                                Left to right
    10. ^                                Left to right
    11. |                                Left to right
    12. &&                               Left to right
    13. ||                               Left to right
    14. ?: (conditional expression)      Right to left
    15. =  *=  /=  %=  +=  -=  &=
        ^=  |=  <<=  >>=                 Right to left
    16. ,                                Left to right


  USER'S GUIDE

  - Chapter 1, Page 69: The $TASM macro has another macro inside it; to
    wit, $SAVE CUR.

  - Chapter 4: There is one new command-line compiler option: -V.

    The -V option controls the C++ virtual tables. You have four
    variations of the -V option:

    -V      Smart C++ virtual tables
    -Vs     Local C++ virtual tables
    -V0     External C++ virtual tables
    -V1     Public C++ virtual tables

    -V is equivalent to the Programmer's Platform command Smart C++ Virtual
      Tables. Use it when you want to generate C++ virtual tables and
      inline functions not expanded inline so that only one instance of a
      given virtual table or inline function will be included in the
      program. This produces the smallest and most efficient executables,
      but uses .OBJ and .ASM extensions only available with TLINK 3.0 and
      TASM 2.0 or newer.

    -Vs is equivalent to the Programmer's Platform command Local C++ Virtual
      Tables. Use it when you want Turbo C++ to generate local virtual
      tables and inline functions not expanded inline such that each module
      gets its own private copy of each virtual table or inline function it
      uses. This option uses only standard .OBJ (and .ASM) constructs, but
      produces larger executables.

    -V0 and -V1 cooperate to produce global virtual tables.  If you don't
      want to use the Smart or Local options (-V or -Vs), you can use -V0
      and -V1 to produce and reference global virtual tables.  -V0 generates
      external references to virtual tables and inline functions not
      expanded inline.  -V1 produces global tables and inline functions.
      One of the modules in the program must be compiled with the -V1 option
      to supply the definitions for the virtual tables and inline functions.
      All other modules should be compiled with the -V0 option to refer to
      that Public copy of the virtual tables and inline functions.

  - Appendix A, Page 230: The WindowsMenu macro is now called the
      WindowMenu macro (no s). It works as documented.

  PROGRAMMER'S GUIDE

  - In Chapter 1, on page 75: the operator precedence table should be
    changed in accordance with the notes above for the Getting Started
    manual.

  - In Chapter 4, on page 200, just after the table, add the following
    information. It replaces the list of information on segment pointers
    on pages 199-200, and also replaces the two sentences (on page 200,
    following the table) describing the _seg modifier.

      Segment pointers

      Use _seg in segment pointer type declarators. The resulting pointers
      are 16-bit segment pointers. The syntax for _seg is:

        <datatype> _seg *<identifier> ;

      For example,

        int _seg *name;

      Any indirection through <identifier> has an assumed offset of 0. In
      arithmetic involving segment pointers the following rules hold true:

      1. You can't use the ++, --, +=, or -= operators with segment
         pointers.

      2. You cannot subtract one segment pointer from another.

      3. When adding a near pointer to a segment pointer, the result is a
         far pointer that is formed by using the segment from the segment
         pointer and the offset from the near pointer. Therefore, the two
         pointers must either point to the same type, or one must be a pointer
         to void. There is no multiplication of the offset regardless of the
         type pointed to.

      4. When a segment pointer is used in an indirection expression, it is
         also implicitly converted to a far pointer.

      5. When adding or subtracting an integer operand to or from a segment
         pointer, the result is a far pointer, with the segment taken from
         the segment pointer and the offset found by multiplying the size
         of the object pointed to by the integer operand. The arithmetic is
         performed as if the integer were added to or subtracted from the far
         pointer.

      6. Segment pointers can be assigned, initialized, passed into and out
         of functions, compared and so forth. (Segment pointers are compared
         as if their values were unsigned integers.) In other words, other
         than the above restrictions, they are treated exactly like any other
         pointer.


  - Also in Chapter 4, page 200, just before "Declaring functions to be
    near or far," add the following text:

      Declaring far objects

      You can declare far objects in Turbo C++. For example,

        int far x = 5;
        int far z;
        extern int far y = 4;
        static long j;

      Turbo C++ creates a separate segment for each far object. The
      command-line compiler options -zE, -zF, and -zH (which can also be set
      using #pragma option) affect the far segment name, class, and group,
      respectively. When you change them with #pragma option, you can change
      them at any time and they apply to any ensuing far object declarations.
      Thus you could use the following sequence to create a far object in a
      specific segment:

        #pragma option -zEmysegment -zHmygroup -zFmyclass
        int far x;
        #pragma option -zE* -zH* -zF*

      This will put x in segment MYSEGMENT 'MYCLASS' in the group 'MYGROUP',
      then reset all of the far object items to the default values. Note
      that by using these options, several far objects can be forced into a
      single segment:

        #pragma option -zEcombined -zFmyclass
        int far x;
        double far y;
        #pragma option -zE* -zF*

      Both x and y will appear in the segment COMBINED 'MYCLASS' with no
      group.

  LIBRARY REFERENCE

  - The examples printed in the Library Reference may not
    necessarily match what's in the help file and on the
    distribution disks. The help file and distribution disk
    examples are the most current.

  - Page 43: The return value for function bioskey has been changed. For
    subfunction ONE the return value is zero if no key is waiting,
    0xFFFF(-1) if control-break was pressed, or the normal code for
    any other key.

7. TCTOUR
---------

  TCTOUR is a visual introduction to the new Programmer's Platform.
  Since the Programmer's Platform is Borland's newest interface,
  taking the tour is time well spent even if you are already familiar
  with other Borland products.

  To start the tour, type "TCTOUR" from the DOS prompt.

  - TCTOUR remembers what lessons a user has completed, and if
    you quit a lesson before completing it, what screen # you last saw.
    This information is stored in a .USR file, and can be recalled by
    starting TCTOUR again and typing your user name at the prompt just
    after the color rainbow.
  
    Lessons that a user has completed should show up without shading
    on the main TCTOUR menu.  Only new users (no .USR file) get the
    excursion through "Using Tour."

  - The Navigator can be pulled up within any lesson file and within
    "Using TCTOUR", but nowhere else.  It is pulled up by pressing the
    Control key, which allows you to move forward, backward, to the
    beginning of a lesson, to the end of a lesson, to the lesson summary,
    to the main menu, to get a reminder, to quit. Ctrl-B (backwards) is
    disabled when you are on the first slide of a lesson.

  - Hints (or Reminders) pop up in any lesson files and in "Using TCTOUR".
    They pop up if:
        1) you wait 30 - 60 seconds before doing any action
        2) you press Ctrl-R
        3) you make an incorrect action

8. FILES ON THE DISKS
---------------------

  DISK 1
  ------
  INSTALL   EXE - Installation program
  README    COM - Reads this README
  UNZIP     EXE - Program to unzip the .ZIP files
  HELP      CA2 - File used by install program to create TCHELP.TCH

  TOUR      ZIP - Turbo C++ demonstration program
     TCTOUR    EXE - Demonstration program
     TCTOUR    OVL - Overlay for TCTOUR.EXE
     TCTOUR0   CBT - Data file for demonstration program
     TCTOUR1   CBT - Data file for demonstration program
     TCTOUR2   CBT - Data file for demonstration program
     TCTOUR3   CBT - Data file for demonstration program
     TCTOUR_M  CBT - Data file for demonstration program
     TCTOUR_P  CBT - Data file for demonstration program
     TCTOUR_S  CBT - Data file for demonstration program
     TCTOUR_U  CBT - Data file for demonstration program

  README - This file

  DISK 2
  ------
  TC        CA1 - File used by install program to create TC.EXE

  DISK 3
  ------
  HELP      CA1 - File used by install program to create TCHELP.TCH

  DISK 4
  ------
  TC        CA2 - File used by install program to create TC.EXE

  TCALC     ZIP -  Tcalc sources and doc
     TCALC     C   - TurboCalc main program source code
     TCALC     DOC - TurboCalc documentation
     TCALC     H   - The header file for TurboCalc
     TCALC     PRJ - The TurboCalc project file
     TCDISPLY  C   - TurboCalc screen display source code
     TCINPUT   C   - TurboCalc input routines source code
     TCOMMAND  C   - TurboCalc commands source code
     TCPARSER  C   - TurboCalc input parser source code
     TCUTIL    C   - TurboCalc utilities source code

  TCC       ZIP - Command-line compiler
     TCC       EXE - Command-line version of Turbo C++ Compiler


  DISK 5
  ------
  BGI       ZIP - Graphics drivers
     ATT       BGI - Graphics driver for ATT400 graphics card
     BGIDEMO   C   - Graphics demonstration program
     BGIOBJ    EXE - Conversion program for fonts and drivers
     CGA       BGI - Graphics driver for CGA
     EGAVGA    BGI - Graphics driver for EGA and VGA
     GOTH      CHR - Font for gothic character set
     HERC      BGI - Graphics driver for Hercules
     IBM8514   BGI - Graphics driver for IBM 8514 graphics card
     LITT      CHR - Font for small character set
     PC3270    BGI - Graphics driver for PC3270
     SANS      CHR - Font for sans serif character set
     TRIP      CHR - Font for triplex character set

  BIN1      ZIP - Miscellaneous binary files
     CPP       EXE - Turbo C++ preprocessor
     EMSTEST   COM - Utility program for detecting expanded memory
     MAKE      EXE - Program for managing projects
     TCINST    EXE - Installation program for TC.EXE
     TLIB      EXE - Borland Turbo Librarian
     TLINK     EXE - Borland Turbo Linker

  BIN2      ZIP
     GREP      COM - Turbo GREP program
     GREP2MSG  EXE - GREP filter program for IDE
     OBJXREF   COM - Object file cross-reference utility
     PRJCNVT   EXE - Utility to convert from Turbo C 2.x project files
                     to Turbo C++ project files
     TASM2MSG  EXE - TASM filter program for IDE
     TEMC      EXE - Turbo editor macro compiler
     THELP     COM - Pop-up utility to access TCHELP.TCH
     TOUCH     COM - Program that updates a file's date and time
     TRIGRAPH  EXE - Trigraph conversion utility


  DISK 6
  ------
  HLIB      ZIP - Huge model libraries
     C0H       OBJ - Huge model startup code
     CH        LIB - Huge model run-time library
     MATHH     LIB - Huge model math library
     OLDSTRMH  LIB - C++ 1.x stream library for huge model

  LLIB      ZIP - Large model libraries
     C0L       OBJ - Large model startup code
     CL        LIB - Large model run-time library
     MATHL     LIB - Large model math library
     OLDSTRML  LIB - C++ 1.x stream library for large model

  SLIB      ZIP - Small model libraries
     C0S       OBJ - Small model startup code
     C0T       OBJ - Tiny model startup code
     CS        LIB - Small model run-time library
     MATHS     LIB - Small model math library
     OLDSTRMS  LIB - C++ 1.x stream library for small model

  STARTUP   ZIP - Startup code files
     BUILD-C0  BAT - Batch file for building the startup code modules
     C0        ASM - Assembler source for startup code
     RULES     ASI - Assembler include file for interfacing with
                     Turbo C++


  DISK 7
  ------
  CLIB      ZIP - Compact model libraries
     C0C       OBJ - Compact model startup code
     CC        LIB - Compact model run-time library
     MATHC     LIB - Compact model math library
     OLDSTRMC  LIB - C++ 1.x stream library for compact model

  EXAMPLES  ZIP - Example programs
     BARCHART  C   - C example file
     CPASDEMO  C   - C example module for the Turbo Pascal - Turbo C++
                     interface demonstration
     CPASDEMO  PAS - Pascal program that demonstrates Turbo Pascal -
                     Turbo C++ interface
     CIRCLE    CPP - C++ example file
     CIRCLE    PRJ - Project file for CIRCLE.CPP
     CTOPAS    CFG - Command-line configuration file for Turbo Pascal -
                     Turbo C++ interface
     CTOPAS    PRJ - Project file for use with TC.EXE that
                     creates Turbo C++ modules in the correct format
                     for linking with Turbo Pascal programs
     DCOPY     CPP - C++ example file
     DEF       CPP - C++ example module used by DICTION.CPP
     DEF       H   - Header file for DEF.CPP
     DEF2      CPP - C++ example - another version of DEF.CPP
     DEF2      H   - Header file for DEF.CPP
     DICTION   CPP - C++ example program
     DICTION   H   - Header file for DICTION.CPP
     DYNPOINT  CPP - C++ example file
     DYNPOINT  PRJ - Project file for DYNPOINT.CPP
     EX??????  PRJ - C++ example programs
     EX??????  PRJ - Project files for C++ example programs
     FIGDEMO   CPP - C++ example file
     FIGDEMO   PRJ - Project file for FIGDEMO.CPP
     FIGURES   CPP - C++ example file
     FIGURES   H   - Header file for FIGURES.CPP
     FILTER    H   - Header file for TASM2MSG.C and GREP2MSG.C
     GAME      C   - C example - simulated baseball game
     GETOPT    C   - Parses options in command line
     GREP2MSG  C   - Example program for Turbo C++ filters
     HELLO     C   - Example Turbo C++ program
     INTRO???  C   - Examples from Getting Started manual
     LIST      CPP - C++ example program - linked list implementation
     LIST      H   - Header file for LIST.CPP
     LIST2     CPP - Another version of LIST.CPP
     LIST2     H   - Header file for LIST2.CPP
     LISTDEMO  CPP - C++ example file
     LISTDEMO  PRJ - Project file for LISTDEMO.CPP
     MATHERR   C   - Source code for handling math library exceptions
     MCIRCLE   CPP - C++ example file
     MCIRCLE   PRJ - Project file for MCIRCLE.CPP
     PIXEL     CPP - C++ example file
     PIXEL     PRJ - Project file for PIXEL.CPP
     PLANETS   C   - C++ graphics example
     PLOTEMP   C   - C graphics example
     PLOTEMP1  C   - C graphics example - bar graphs
     PLOTEMP2  C   - C example - modification of PLOTEMP1.C
     PLOTEMP3  C   - C example - modification of PLOTEMP2.C
     PLOTEMP4  C   - C example - modification of PLOTEMP3.C
     PLOTEMP5  C   - C example - modification of PLOTEMP4.C
     PLOTEMP6  C   - C example - modification of PLOTEMP5.C
     POINT     CPP - C++ example program
     POINT     H   - Header file for POINT.CPP
     POINT2    CPP - C++ example program
     SALESTAG  C   - C example from Chapter 4 of Getting Started
     SOLAR     C   - C example from Chapter 4 of Getting Started
     STACK     CPP - C++ example program - stack implementation
     STACK     H   - Header file for STACK.CPP
     STACK2    CPP - Another version of STACK.CPP
     STACK2    H   - Header file for STACK.CPP
     STRING    CPP - C++ example program
     TASM2MSG  C   - Example program for Turbo C++ filters
     VCIRC     CPP - C++ example program
     VCIRC     PRJ - Project file for VCIRC.CPP
     VPOINT    CPP - C++ example program
     VPOINT    H   - Header file for VPOINT.CPP
     XSTRING   CPP - C++ example program

  INCLUDE   ZIP - Turbo C++ header files
     ????????  H   - Header files

  MLIB      ZIP - Medium model libraries
     C0M       OBJ - Medium model startup code
     CM        LIB - Medium model run-time library
     MATHM     LIB - Medium model math library
     OLDSTRMM  LIB - C++ 1.x stream library for medium model


  DISK 8
  ------
  DOC       ZIP - Miscellaneous documentation
     HELPME!   DOC - Answers to commonly asked questions
     OLDSTR    DOC - Information about C++ 1.x streams
     UTIL      DOC - Information about Turbo C++ utilities
     THELP     DOC - Information about THELP.EXE

  CLASSEXM  ZIP - C++ class library example files
     DIRECTRY  CPP - Directory class example file
     DIRECTRY  H   - Header file for DIRECTRY.CPP
     DIRECTRY  PRJ - Project file for DIRECTRY.CPP
     FILEDATA  CPP - FileData class example file
     FILEDATA  H   - Header file for FILEDATA.CPP
     LOOKUP    CPP - Lookup table example
     LOOKUP    PRJ - Project file for LOOKUP.CPP
     QUEUETST  CPP - Queue class example file
     QUEUETST  PRJ - Project file for QUEUETST.CPP
     REVERSE   CPP - String class example file
     REVERSE   PRJ - Project file for REVERSE.CPP
     STRNGMAX  CPP - String class example file
     STRNGMAX  PRJ - Project file for STRNGMAX.CPP
     TESTDIR   CPP - Directory example file

  CLASSINC  ZIP - Include files for C++ class library
     ????????  H   - Header files

  CLASSLIB  ZIP - C++ class library
     TCLASSS   LIB - Library file for C++ classes

  CLASSSRC  ZIP - Source files to C++ class library
     ABSTARRY  CPP - Abstract array class definitions
     ARRAY     CPP - Basic array class definitions
     ASSOC     CPP - Association class (used by dictionary class)
     BAG       CPP - Bag class definitions
     BUILD     BAT - Batch file for building class library
     CLASSLIB  DOC - C++ class library documentation
     CLASSLIB  RSP - Response file for building class library
     COLLECT   CPP - Ordered collection class definitions
     CONTAIN   CPP - Container class definitions
     DBLLIST   CPP - Doubly linked list class definitions
     DEQUE     CPP - Dequeue definitions for queue class
     DICT      CPP - Dictionary class definitions
     HASHTBL   CPP - Hash table class definitions
     LDATE     CPP - Date class definitions
     LIST      CPP - List class definitions
     LTIME     CPP - Time class definitions
     OBJECT    CPP - Base class for other objects
     QUEUE     CPP - Queue class definitions
     SET       CPP - Set class definitions
     SORTABLE  CPP - Sorted table class definitions
     SORTARRY  CPP - Sorted array class definitions
     STACK     CPP - Stack class definitions
     STRNG     CPP - String class definitions

  XLIB      ZIP - Math and utility libraries
     EMU       LIB - 8087 emulator library
     FP87      LIB - 8087 library
     GRAPHICS  LIB - Graphics library
     OVERLAY   LIB - Overlays library
     WILDARGS  OBJ - Object code for module to expand wildcard arguments


