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

   EHC.EXE - The Expert Help Compiler

   Usage: EHC [@]<file.ext> 
              [-I<path>] 
              [-O<path>] 
              [-E<file.ext] 
              [-NG] 
              [-NP] 
              [-S]

   Where...

        @<file.ext>       =  Specifies a Response File
        <file.ext>        =  Text Source File
        -I<path>          =  Source File Input Path Directory
        -O<path>          =  Object File Output Path Directory
        -E<file.ext>      =  File to Capture Error Messages
        -NG               =  Enables NG Engine Compatibility
        -NP               =  No Pause when Processing is Finished
        -S                =  Activates the Selective Compiling Option

   All Parameters must be entered in the exact order specified above.

   Note: If you are using multiple files on the command line
         or are using a RESPONSE file. EHC will not pause until ALL
         specified files have been processed.

   A USAGE screen is displayed if no command line parameters are detected.

   Input / Output Directory Parameters:
   The -I -O parameters need only be specified if you have stored your files
   in a directory other than the current one.

   SMART-COMPILE:
      The Expert Help Compiler will only compile files that have been
      modified since the last compile cycle. This feature dramatically
      reduces the time it takes to re-compile/link a Help File. To
      utilize this feature, be sure not to delete your ".EHO" object
      files after compiling. To force a recompile of a specific object
      file...simply delete it...the compiler will create a new file.


   EHC can except multiple filenames on the command line as follows.

        EHC <file.ext> <file.ext> <file.ext> <file.ext>

   You can specify a single filename, a series of filenames
   (no commas please) or a response file.

   Using a RESPONSE file:
   A response file is a text file that contains a list of the source
   filenames that you want the help compiler to process. The use of a
   response file eliminates the need to specify each file on the command
   line. This reduces errors and saves you time. Unnecessary re-compiles
   never occur because the Expert Help Compiler only compiles the files
   that have modified since the last compile process.

   You can create a response file from scratch with the following format:

        fname1.ext
        fname2.ext
        fname3.ext
        etc...
   
   
   .... or you can dump the directory into a text file.
   
           Example:
           
               DIR *.txt > MYFILE.RSP
                 
   If you use this method be sure to delete all lines above the first
   filename.
   
   Note: All text after each filename is ignored.

   Here is sample file created by the directory dump method.

    +--  Delete these lines.
    |
    |--.     Directory of  c:\aaa\*.txt                                  
    |--.                                                                 
    |        eh_001.txt      56760   5-28-92  9:58a                      
    |        eh_002.txt       7627   5-28-92 10:24a                      
    |        eh_003.txt      29980   4-20-92  5:02p                      
    |        eh_004.txt      34105   4-20-92  5:42p                      
    |        eh_005.txt       2945   5-26-92 11:46a                      
    |        eh_006.txt       1658  12-15-91  7:06p                      
    |        eh_007.txt      29058  12-15-91  7:06p                      
    |        eh_008.txt       6677  12-15-91  7:06p                      
    |        eh_009.txt      17906  12-15-91  7:06p                      
    |        eh_010.txt      26542  12-15-91  7:06p                      
    |        eh_011.txt      17122   5-28-92 10:13a                      
    |--.       241,259 bytes in 13 file(s)       303,104 bytes allocated 
    +--.     81,649,664 bytes free                                       


   This will leave you with a response file that looks like the following.

            eh_001.txt      56760   5-28-92  9:58a                       
            eh_002.txt       7627   5-28-92 10:24a  
            eh_003.txt      29980   4-20-92  5:02p  
            eh_004.txt      34105   4-20-92  5:42p  
            eh_005.txt       2945   5-26-92 11:46a  
            eh_006.txt       1658  12-15-91  7:06p  
            eh_007.txt      29058  12-15-91  7:06p  
            eh_008.txt       6677  12-15-91  7:06p  
            eh_009.txt      17906  12-15-91  7:06p  
            eh_010.txt      26542  12-15-91  7:06p  
            eh_011.txt      17122   5-28-92 10:13a  

   Norton Guides Engine Compatibility (-NG compile option)
   The -NG switch will allow you to create files that can be read
   by the Norton Guides Engine. If you want to ensure that your help 
   file is compatible with the Norton Guide Engine, use the -NG switch 
   on the EHC compiler command line. When linking, EHML will monitor 
   each file for the -NG flag. All files must be compiled with the 
   -NG flag in order for a Norton Guide compatible help file to be
   created.
   
   If you use the -NG option, the object file will be limited to
   Short Topic Lists or Longs Entry lengths of 17k. This is the maximum
   size that the Norton Guides Engine will handle properly.

   If you choose not to use the -NG switch, the linker will assume that
   the help file is beyond the NG limitations and will create a help
   file that cannot be read by the Norton Guides Engine. This only
   becomes an issue if you are going to give an Expert Help file to
   a user who has the Norton Guides Engine.
   
   The default is the Expert Help limit of...
               64k for the entire Short Topic List
                                and
               64k for each Long Entry in the file.
              
   Limitations to keep in mind when creating text source files
   -------------------------------------------------------------------
   Number of lines per Long Entry or Short Topic List:    2000

   Max line length in text source files:                  1024 chars.

   Max screen width:                                      78 chars.

   Maximum Long Entry size:                               64k

   Max Short Topic List size:                             64k 

   Max Number of (!file: and !seealso:) calls per file:   Unlimited

   Max !Seealso: hyperlinks per long entry                20
   (length 72 characters each)

   Maximum Object .EHO File Size:                         129 MB
   -------------------------------------------------------------------
   Note:
      Each .EHO file can be made up of...

                   64k or 2000 Short Topics
                             and
                   Each Short Topic can have 64k of Long Entry text
                   immediately following the Short Topic. (For a total
                   of 2000 * 64k Long Entries).

      Each Source Text File can be up 129MB in size.

   Selective Compiling (-S option)
   The Selective Compile feature allows you to selectively turn the 
   compiler parser ON and OFF while processing a file. This allows the 
   compiler to extract specific information from source files. This lets
   you build help files from documents, source code etc..

   The Selective Compile feature is comprised of two parts.
   
   1. The -S command line switch.
   
   Description:
       This switch tells the compiler to look  for embedded compile flags 
       within the source file. When the -S switch is used, initial 
       compiling is turned OFF until the first [EH+] flag is encountered.

   2. The [EH+] and [EH-] switches (The [] brackets are significant).

   Description:
            These switches are embedded in the source file.

       [EH+]    Turns the Compiler ON
       [EH-]    Turns the Compiler OFF

       Note: These flags can be embedded anywhere in the source file. 

   Example of usage in the C language:

            /*[EH+] Turns the compiler parser on*/
            text to include
               ...
               ...
            /*[EH-] Turns the compiler parser off*/


   Example of usage in the C++ language:

            //[EH+] Turns the compiler parser on
            text to include
               ...
               ...
            //[EH-] Turns the compiler parser off

   Example of usage in the Xbase language:

            *[EH+] Turns the compiler parser on
            text to include
               ...
               ...
            *[EH-] Turns the compiler parser off