'COMPILE.HLP - is the help file for use with QuickCompile. It must reside in
               the same directory as QuickCompile.

               Each section of this file is maked as follows:

                  A starting mark consisting of "BC." or "LINK."
                  followed by the text for that option from
                  QuickCompile's menu is located on the line above.

                  An ending mark,  (chr$(29)) is located on the line
                  below each section.

                  This document may be edited by the user to display
                  additional info, but the following should be observed.
                      Do not remove any starting or ending marks.
                      Do not change the text of the Start or End lines.
                      Do not allow any section to become longer than 20 lines.
                      Do not edit the original file, make a copy and edit it.

'---------------------------------BC OPTIONS---------------------------------
    BC.EXE Requiring BRUNxx.EXE
    EXE Requiring BRUNxx.EXE

        This is the default when you compile within the QB environment.
        However, it has been our experience that most people prefer
        building stand-alone .EXE files. Therefore QuickCompile defaults
        to stand-alone and specifies the /O switch.

        Normally, this option is most useful if you are distributing a 
        software package that contains many .EXE files, and want to
        conserve disk space. Also, when chaining programs, BRUNxx.EXE
        operates faster because the library need not be loaded again.
        
        If you choose this option, you must be certain that the end user has
        a copy of the correct BRUNxx.EXE file, or the program will not run.

        For optimum program execution speed, you will not want to use the
        EXE Requiring BRUNxx.EXE option. Stand Alone executables are always
        faster, use less memory, and are easier to manage.
        
    BC./t
    /T  Terse Error Display

        Causes BC to not display the copyright notice or warning messages
        (if errors are encountered) during compiling.
        
        (/T is a QB Environment default.)

        We normally don't recommend using this switch because it's helpful
        to know all you can about possible errors in your program.
        
    BC./d
    /D  Produce Debug Code

        Produces debugging code for runtime error checking. Also Enables
        CTRL-BREAK.

        This option is useful when developing and debugging a program because
        you may hit CTRL-BREAK at any point in program execution and exit.
        
        QuickBASIC programs do not check for overflow errors when performing
        integer math. /D enables integer math overflow error checking.
        
        When you're not using the /AH switch, compiled QuickBASIC programs do
        not check to see if an array is in bounds or not. If an attempt is
        made to access an array element that is out of bounds, other data
        will be overwritten without warning. Using the /D switch will warn
        when such a condition exists.

        However, you should not use the /D switch in the final version of
        your program because it slows execution and adds to the file size.
        
    BC./a
    /A  Disassembled List File

        Produces a list file showing each source line disassembled, and
        it's compiler generated assembly language instructions.
        
   BC./zi
   /ZI  CodeView Object Code

        Produces an object file of information for use by the MicroSoft
        CodeView debugger that comes with several of their other languages.

        You cannot use the LINK /E (exepack) option when compiling with /ZI.
        
   BC./zd
   /ZD  Symbolic Debugger Code

        Produces an object file with line numbers that correspond to the
        lines of your source file. Useful for source level debugging with
        MicroSoft's SYMDEB Symbolic Debugger.

        You must use the LINK /li (line numbers) option when compiling with
        /ZD.
        
    BC./s
    /S  Quoted Strings to OBJ

        Places quoted strings in the object file instead of the symbol
        table. Useful for avoiding "Out of memory" errors in programs
        with many string constants.

        This option may also reduce the size of your .EXE file.
        
    BC./r
    /R  Row-Major Order Arrays

        Useful when using routines from other languages that store arrays
        in this order. QuickBasic stores it's arrays in column-major order
        normally.
        
   BC./ah
   /AH  $DYNAMIC Arrays > 64k

        Allows arrays of Records, fixed-length strings, and numeric data
        to be dynamic. These arrays may use all of available memory.

        When not used and arrays are not dimensioned with REDIM, arrays are
        Static and are limited to a maximum of 64k each.

        Note that variable-length string arrays are always Static. Only
        fixed-length string arrays may be Dynamic and make use of this option.
        
    BC./c:num
    /C:<number>   Communications Routines

        Sets the receive buffer size of the comm ports. Default is 512
        bytes total for both ports. Maximum receive buffer size may be
        set to 32,767 bytes. This option has no effect on the transmit
        buffer which is set to 128 bytes for each port and can't be
        changed.

        Note that communications routines may be unnecessarily placed in
        your .EXE file without your knowledge, even if you don't specify
        this switch.
        
        Read the section on NOCOM.OBJ in the "Hints & Kinks
        for Compiling and Linking" Booklet to insure that your programs
        don't waste 4K of disk space with uncalled comm routines.
        
  BC./mbf
  /MBF  MicroSoft Binary Format

        Allows your programs to read and write floating point values
        stored in MicroSoft Binary Format.
        
        MKS$, MKD$, CVS, and CVD functions are converted to MKSMBF$,
        MKDMBF$, CVSMBF, and CVDMBF.
        
    BC./x
    /X  ON ERROR/RESUME <NEXT> <0>

        Use when your program contains ON ERROR with RESUME, RESUME NEXT,
        or RESUME 0.

        Note: Using ON ERROR will slow program execution and cause your
              .EXE file size to noticeably increase.

              Avoid using any ON ERROR statements in your program if at
              all possible. Many Shareware and Commercial add-on libraries
              have functions with built in error checking to help avoid
              QuickBASIC's ON ERROR.

              One often needed error trap is checking to see if a file
              exists. We have created a Basic module to help you avoid
              using ON ERROR in this case. See the section on EXISTS.BAS
              in the "Hints & Kinks for Compiling and Linking" Booklet
              for details.
        
    BC./e
    /E  ON ERROR/RESUME <LineNumber>

        Use when your program contains an ON ERROR with a RESUME statement
        containing a line number.

        Note: Using ON ERROR will slow program execution and cause your
              .EXE file size to noticeably increase.

              Avoid using any ON ERROR statements in your program if at
              all possible. Many Shareware and Commercial add-on libraries
              have functions with built in error checking to help avoid
              QuickBASIC's ON ERROR.

              One often needed error trap is checking to see if a file
              exists. We have created a Basic module to help you avoid
              using ON ERROR in this case. See the section on EXISTS.BAS
              in the "Hints & Kinks for Compiling and Linking" Booklet
              for details.
        
    BC./v
    /V  ON [event] Normal Trap 

        Use for event trapping the Comm Port (COM), LightPen (PEN),
        JoyStick (STRIG), Timer (TIMER), Music Buffer (PLAY) and 
        Function Keys (KEY).
        
        Checks between each program statement for an event to occur. This
        will cause events to be recognized earlier, but will slow program
        execution and increase file size because BC must place code to
        check for events between each program statement.
        

    BC./w
    /W  ON [event] Fast Trap

        Use for event trapping the Comm Port (COM), LightPen (PEN),
        JoyStick (STRIG), Timer (TIMER), Music Buffer (PLAY) and 
        Function Keys (KEY).
        
        Same as /V option, but checks at each program label (or line number)
        for an event to occur.

        Checks for events only at labels (or line numbers). Because event
        checking code is only placed at labels, you control where and how
        much event checking is performed.
        
        If it's not absolutely necessary to check between each program
        statement, then /W is the preferred switch for event trapping.
        
    BC.NO [event] Trapping
    NO [event] Trapping

        QuickCompile Defaults to No Event Trapping as most programs don't
        use ON [event] statements.
        
    BC.Source List File
    Source List File

        This QuickCompile option is used to produce a Source list File
        containing the address of each line in your source file.
        
        All source text, it's size, and any error messages are also
        included in the file.
        
    BC.Delete OBJ Code
    Delete OBJ Code

        This QuickCompile option causes the .OBJ file to be deleted after
        Compiling and Linking are complete. This saves time and disk space.
        If your program contains only one module (.BAS file), you should use
        this option.

        However, if your program has more than one module, you may not want
        to use this option. When changes are made to only one module of a
        multi-module program, it is only necessary to recompile that one
        module.

        When compiling and linking multi-module programs, QuickCompile checks
        to see which modules have changed by comparing the date/time stamp
        of each modules source (.BAS) file and object (.OBJ) file. 

        Time and wear and tear on your disk will be saved because only
        modules that have changed will be recompiled by BC. But, if you have
        deleted a module's .OBJ file, it must be recompiled.
        
'--------------------------------LINK OPTIONS--------------------------------
    LINK./e
    /E  EXEPACK (optimized exe size)

        Optimizes the load time allocation table by removing sequences of
        repeated bytes (usually null characters). Linking with /E will
        cause .EXE files to be smaller and load faster. This switch is
        a QuickCompile and QB environment default. You will normally want
        to use this option.

        NOTE: If you plan to use an executable file compressor (like
              LZEXE or PKLITE), you should not use this switch. These
              utilities will usually perform better on files that were
              not previously packed with EXEPACK.

              Exepack cannot be used when compiling a program for
              codeview use (ie: BC's / zi and LINK's /co options).
              QuickCompile senses this and turns off /E by default.
        
  LINK./pau
  /PAU  PAUSE before exe write

        Causes LINK to pause and prompt you before writing the .EXE file.
        Useful if you wish to insert another disk to write the .EXE file
        to.

        It's doubtful if hard disk users will ever want to use this option.
        
    LINK./i
    /I  Show Link INFORMATION

        Causes LINK to display information about the current linking 
        process. Shows the current phase in linking, and the name of
        files being linked.

        Although not normally necessary, this switch is helpful for
        better understanding how link works.
        
    LINK./b
    /B  BATCH mode (no prompts)

        Causes LINK not to stop and prompt you when it cannot find a
        file you specified. LINK continues to operate without prompting.

        The only time this option is useful is when you are linking
        several separate programs in one link session. Because QuickCompile
        does not operate in this fashion, this switch is not helpful.

        We advise you avoid this option because you will not be alerted
        to errors.
        
    LINK./m
    /M  Create MAPFILE

        Creates a MAPFILE that list the program's segments and public
        symbols sorted by address. See the QuickBASIC, Programming in
        BASIC book for more details.
        
   LINK./li
   /LI  MapFile with LINENUMBERS

        Creates a MAPFILE that list the program's segments and public
        symbols sorted by address. See the QuickBASIC, Programming in
        BASIC book for more details.
        
        Same as the /M option, but includes line number and addresses of
        the source file.

        This option must be selected when compiling with /zd (SYMDEB).
        
  LINK./noi
  /NOI  NOIGNORECASE (observe case)

        Normally, LINK does not distinguish between upper and lower case
        letters. This option cause LINK to observe case.
        
  LINK./nod
  /NOD  NODEFAULTLIBRARY (using PDQ, etc...)

        Normally, LINK will always include the BRUN or BCOM libraries
        (which one depends on whether you specify QuickCompile's default
        stand-alone or .EXE file requiring BRUNxx.EXE).

        This option tells LINK not to include either. Use this option
        when you are linking with a replacement library like PDQ.
        QuickCompile automatically uses /NOD when you select PDQ.LIB as
        a library to link with. 

        This option is also useful if you place the BRUN and BCOM libraries
        in a path that LINK can't find. However, you must first select the
        library within QuickCompile so LINK will know the new path.

        We suggest that you place all libraries in the same path and set the
        "LIB" environment variable so that QuickCompile will always know 
        where your libraries are. This will save time and keystrokes. 
        Place the line   "SET LIB=<LibraryPath>"   in your AUTOEXEC.BAT file,
        where <LibraryPath> is the Drive/Directory where libraries are stored.
        
  LINK./noe
  /NOE  NOEXTDICTIONARY (using nocom, etc...)

        Causes LINK to search the individual object files instead of the
        dictionaries it has created to resolve certain conflicts.

        NOTE: If you link with NOEM.OBJ or NOCOM.OBJ, (or PDQ's stub files)
              you must use this option. In most cases, QuickCompile will
              automatically select this option for you.

        We suggest that you place all often used object code in the same
        path and set the "OBJ" environment variable so that QuickCompile
        will always know where these objects are. This will save time and
        unnecessary keystrokes (or mouse clicks).

        Place the line   "SET OBJ=<ObjectPath>"   in your AUTOEXEC.BAT file,
        where <ObjectPath> is the Drive/Directory where object files are
        stored. 
        
   LINK./se:num
   /SE:<number>  SEGMENTS

        Sets the number of segments that LINK will allow your program to
        have. You may specify any number from 1-1024. Default is 128. See
        the QuickBASIC, Programming in BASIC book for more details.
        
   LINK./co
   /CO  CODEVIEW preparation

        Prepares an .EXE file for debugging with MicroSoft's CodeView
        Debugger.

        NOTE: The object files must have been previously compiled with the
              /ZI option. 
        
  LINK./far
  /FAR  FAR

        Used with the /PAC option to help reduce the size and increase
        the speed of your .EXE files.

     WARNING: Although unlikely, circumstances may arise that will
              cause this option to crash your program. If you use
              this option, you should carefully test every function
              of your program.
        
  LINK./pac:num
  /PAC:<number>  PACKCODE

        Pack code segments. Causes link to group neighboring segment.
        Code segments that are in the same group will have the same segment
        address. You may specify the size limit of the groups. If not
        specified, the size limit defaults to 65,530. See the QuickBASIC,
        Programming in BASIC book for more details.

        NOTE: This option may be used with the /FAR option to optimize
              program execution speed and file size. 
     
     WARNING: Although unlikely, circumstances may arise that will
              cause this option to crash your program. If you use
              this option, you should carefully test every function
              of your program.
        
  LINK./st:num
  /ST:<number>  STACK
        
        This option allows you to specify how much memory to set aside
        for use as the stack.

        When a program has deeply nested calls to non-static procedures,
        or a recursive subprogram is called many times, stack space may
        become exhausted. /ST will allow you to set a larger stack size.

        The QB default stack size is 2048 bytes. Maximum allowed stack
        size is 65,535 bytes.
        
              
              

