home *** CD-ROM | disk | FTP | other *** search
/ ftp.wwiv.com / ftp.wwiv.com.zip / ftp.wwiv.com / pub / GENUTIL / jar102x.exe / JAR.DOC < prev    next >
Text File  |  1997-09-18  |  129KB  |  3,178 lines
  1.  
  2.     USER'S MANUAL FOR THE JAR ARCHIVER PROGRAM                 August 1997
  3.  
  4.  
  5.     TOPICS COVERED IN THIS DOCUMENT
  6.     -------------------------------
  7.  
  8.     MAJOR FEATURES OF JAR
  9.     ARCHIVER BENCHMARKING
  10.     INSTALLATION
  11.     QUICK START TO USING JAR
  12.     CONVERTING OTHER ARCHIVE FILES TO JAR FORMAT
  13.     HOW TO USE JAR
  14.     IMPORTANT NOTES
  15.     USING JAR AS A BACKUP PROGRAM
  16.     JAR ERROR SITUATIONS
  17.     HOW JAR USES AVAILABLE MEMORY
  18.     ARCHIVE CHAPTERS
  19.     ARCHIVE VOLUMES
  20.     JAR USER ACTION PROMPTS
  21.     JAR COMMAND LINE SYNTAX
  22.     JAR COMMANDS
  23.     JAR SWITCH OPTIONS
  24.     CONFIGURATION FILE
  25.     CONFIGURATION FILE KEYWORDS
  26.     IMPORTANT DIFFERENCES BETWEEN JAR AND ARJ
  27.     JAR LIMITATIONS
  28.     JAR ARCHIVE ACCESS MODES
  29.     HOW JAR SHARES FILES TO COMPRESS
  30.     2000 YEAR PROBLEM AND JAR
  31.     JAR ARCHIVE FLAGS
  32.     JAR ERROR LEVELS
  33.     FREQUENTLY ASKED QUESTIONS
  34.     FINAL COMMENTS
  35.  
  36.  
  37.     MAJOR FEATURES OF JAR:
  38.  
  39.  
  40.       JAR comes as a 16-bit executable (JAR16.EXE) for DOS and a 32-bit
  41.       executable (JAR32.EXE) for Windows 95 and Windows NT (version 3.50 or
  42.       higher). The latter takes full advantage of 32-bit instructions and
  43.       the "flat" memory model. Sometimes this 32-bit executable is referred
  44.       to as the "Win32 JAR version".
  45.  
  46.       Currently, JAR ranks as one of the best in compression in terms of
  47.       size reduction of the currently available archivers.  JAR compresses
  48.       significantly better than such popular archivers as PKZIP 2.04, UC2
  49.       rev 3, RAR 1.55, RAR 2, and LHA.  JAR uses a modified form of SOLID
  50.       archive technology to provide excellent compression, fast updates
  51.       and fast extraction.
  52.  
  53.       The ability to process and archive more than 50,000 files at one
  54.       time.
  55.  
  56.       JAR provides the CHAPTERS concept which allows one to store multiple
  57.       backups in the same archive using incremental compression.
  58.  
  59.       Archive individual file or chapter comments with the option of
  60.       inputting comments from a file.
  61.  
  62.       Support of ANSI style comments.
  63.  
  64.       JAR has MS-DOS international language support for the proper casing
  65.       of filenames.
  66.  
  67.       The ability to put the entire JAR command line in a response type
  68.       file as in "JAR @command.rsp".  Supports nested response files.
  69.  
  70.       32 bit CRC file integrity check.
  71.  
  72.       Total percentage milestone display for the entire archive build.
  73.  
  74.       Option to test new archive before overwriting the original archive
  75.       including the option to do a byte for byte file compare during a
  76.       build.
  77.  
  78.       Archives that can span diskettes. This allows the user to backup a
  79.       full hard disk drive to multiple floppies.  Recovery of individual
  80.       files is convenient because the JAR archive header keeps information
  81.       about the disk location of each file.
  82.  
  83.       Built-in facility to recover files from broken archives. Also, the
  84.       capability to add recovery records to important archives which allow
  85.       one to repair damaged archives.
  86.  
  87.       Internal integrity check in JAR to resist hacking or virus attacks.
  88.  
  89.       Archive security envelope "seal" feature to resist tampering with
  90.       secured archives. This feature disallows ANY changes to a secured
  91.       archive.
  92.  
  93.       Archive and chapters locking feature.
  94.  
  95.       Password option to protect archived files both using authentication
  96.       or encryption.
  97.  
  98.       Specification of the files to be added to or exclude from an archive
  99.       via one or more list files. In addition, JAR can generate a list
  100.       file.
  101.  
  102.       Specification of files to be excluded from processing by JAR.
  103.  
  104.       Special command to test JAR reliability. "testjar.bat" is a
  105.       ready-to-use batch file for testing on specified drive.
  106.  
  107.       Optional long filenames translation into short names when extracting
  108.       files in DOS.
  109.  
  110.       Configuration file which allows the customization of default JAR
  111.       behavior. Includes a set of default options for each command.
  112.  
  113.       Breaks 640K DOS barrier using EMS and/or XMS.
  114.  
  115.       Query option when wildcard selection is not suitable.
  116.  
  117.       Files sorting in list commands.
  118.  
  119.       32-bit JAR version allows the use or storage of both long and/or
  120.       short filenames. It uses filenames compatible with DOS OEM encoding.
  121.  
  122.  
  123.     ARCHIVER BENCHMARKING:
  124.  
  125.  
  126.       Benchmarking results are very dependent upon the data used for the
  127.       tests.  We compared JAR with some of the leading commercial
  128.       archivers: PKZIP 2.04g, UltraCompressor II Version 3, RAR 2.00 for
  129.       Win32, and RAR 2.00 for DOS.  LHA 2.X and ARJ 2.X are not included.
  130.       Their compression size numbers are very similar to those of PKZIP
  131.       2.04g.
  132.  
  133.       COMPUTER: Pentium-100, 24MB memory, no external cache
  134.       OPERATING SYSTEM: Windows 95
  135.       CONFIG.SYS:
  136.          device=c:\win95\himem.sys
  137.          dos=high
  138.          files=40
  139.          devicehigh=c:\dos\power.exe
  140.       JAR.CFG:
  141.          32MemoryLimit=10240
  142.          CheckAvailableMemory=No
  143.  
  144.       The only exception is JAR16.EXE which was tested in DOS 6.22 with 16M
  145.       of EMS memory.  This was due to the slow Windows 95 EMS
  146.       implementation which decreases JAR's performance relative to the
  147.       amount of EMS used (up to 1.5 times).   We recommend the use of
  148.       JAR32.EXE in Windows 95 and Windows NT.
  149.  
  150.  
  151.       FILE SET:  The Calgary Corpus (18 files totaling 3,251,493 bytes,
  152.       popular file set used to compression rates).
  153.  
  154.       Archiver              Method      Compression time  Compressed size
  155.  
  156.       JAR32                 Maximum           31s           903,863  (100%)
  157.       JAR32                 Default           21s           910,676  (101%)
  158.       JAR16 under DOS 6.22  Maximum           41s           935,675  (104%)
  159.             with 16MB EMS
  160.       JAR16 under DOS 6.22  Default           29s           945,690  (105%)
  161.             with 16MB EMS
  162.       RAR 2.00              -m5 -mde -s      261s           951,992  (105%)
  163.       RAR 2.00              Default solid     48s           997,418  (110%)
  164.       RAR 2.00              Default           41s         1,008,455  (112%)
  165.       RAR 2.00 for DOS      Default solid     25s         1,030,894  (114%)
  166.       UC2 rev 3             Default           30s         1,051,516  (116%)
  167.       PKZIP 2.04            Default           17s         1.074,550  (119%)
  168.  
  169.  
  170.       FILE SET:  Microsoft Visual C++ 1.52 (462 files and directories
  171.       totaling 18,806,153 bytes, mix of executables, text, DLLs, and object
  172.       files).
  173.  
  174.       Archiver              Method      Compression time  Compressed size
  175.  
  176.       JAR32                 Maximum          264s         5,984,311  (100%)
  177.       JAR16 under DOS 6.22  Maximum          341s         6,279,415  (105%)
  178.             with 16MB EMS
  179.       RAR 2.00              -m5 -mde -s     1004s         6,351,777  (106%)
  180.       JAR32                 Default          173s         7,050,008  (118%)
  181.       JAR16 under DOS 6.22  Default          250s         7,267,567  (121%)
  182.             with 16MB EMS
  183.       RAR 2.00              Default solid    273s         7,856,362  (131%)
  184.       RAR 2.00 for DOS      Default solid    151s         8,314,078  (139%)
  185.       UC2 rev 3             Default          190s         8,556,558  (143%)
  186.       PKZIP 2.04            -ex              140s         8,906,367  (149%)
  187.       PKZIP 2.04            Default           96s         8,945,476  (149%)
  188.  
  189.       JAR16/JAR32 shows its best compression with large directories of
  190.       files.
  191.  
  192.  
  193.     INSTALLATION:
  194.  
  195.  
  196.       This assumes that you have already executed the self-extracting
  197.       distribution archive and extracted its archived files into a
  198.       directory.
  199.  
  200.       To install the JAR software, simply copy JAR16.EXE, JAR32.EXE,
  201.       JAR.CFG, REARJ.EXE, REARJ.CFG and optionally JAR_C.COM, JAR_C.DLL
  202.       (available in non-export version only) to one of the directories
  203.       named in your DOS PATH statement found in your AUTOEXEC.BAT. On many
  204.       PCs, this directory may be C:\DOS or C:\BIN.
  205.  
  206.       In addition, for a DOS machine or for a DOS environment one MB of
  207.       available XMS strongly recommended.  Four MB of EMS preferred for
  208.       outstanding compression.  More memory is better.  Detailed
  209.       information about memory usage is available in section "HOW JAR USES
  210.       AVAILABLE MEMORY".
  211.  
  212.  
  213.     QUICK START TO USING JAR:
  214.  
  215.  
  216.       See the document INTRO.DOC.
  217.  
  218.  
  219.     CONVERTING OTHER ARCHIVE FILES TO JAR FORMAT:
  220.  
  221.  
  222.       Included with this software is the program REARJ.  This program can
  223.       be used to individually or collectively convert archive files from
  224.       other formats to the JAR format.  Read REARJ.DOC for more details.
  225.  
  226.  
  227.     HOW TO USE JAR:
  228.  
  229.  
  230.       If you type JAR16 [return], you will see a simple help screen.
  231.  
  232.       If you type JAR16 -? [return], you will see more detailed help
  233.       information.
  234.  
  235.       Please note that unless specifically indicated, references to JAR16
  236.       also include JAR32.EXE.
  237.  
  238.  
  239.     IMPORTANT NOTES:
  240.  
  241.  
  242.       When using the "-w" working directory switch, JAR does not check on
  243.       space availability before overwriting the original archive if it
  244.       exists. Be sure that you have enough disk space for the new archive
  245.       before using the "-w" switch. If JAR aborts in this situation because
  246.       of disk space, JAR will keep the temporary archive.
  247.  
  248.       Like ARJ and PKZIP, JAR requires extra disk space to UPDATE an
  249.       archive file. JAR will backup the original archive while it creates
  250.       the new archive, so enough room must be available for both archives
  251.       at the same time. Also JAR requires additional space for a swap file
  252.       which is used to store the archive header and a list of files to add
  253.       during processing.
  254.  
  255.       By default during an add command, JAR will ALSO add to the archive
  256.       all directories scanned while searching for matching filenames.  Even
  257.       if NO files were found, JAR will build an archive if any directories
  258.       were scanned during the operation.  This behavior may be changed
  259.       by using the JAR configuration file.  See the "-hb" option and
  260.       the default configuration file for more information.
  261.  
  262.       Currently, JAR will not extract overwriting a readonly file unless
  263.       the "-ha" option is specified.
  264.  
  265.       JAR uses a configuration file to store global user settings. By
  266.       default the configuration file is named "JAR.CFG" and must be placed
  267.       into the same directory as the JAR16.EXE and JAR32.EXE directory.
  268.  
  269.  
  270.     USING JAR AS A BACKUP PROGRAM:
  271.  
  272.  
  273.       JAR can be used as a substitute for a backup program.
  274.  
  275.       The following partial command lines illustrate a full backup command,
  276.       an incremental backup command, and a restore command. The only parts
  277.       missing are the names of the files to backup/restore.
  278.  
  279.       JAR16 a backup1 -jt -r -m4 -b0
  280.       JAR16 a backup2 -hba1 -b0 -jt -r -m4
  281.       JAR16 x backup2
  282.  
  283.       You may then copy archive into diskettes:
  284.  
  285.       JAR16 y backup -oa:backup -vvas -hk
  286.  
  287.       Or you may create backup directly on diskettes:
  288.  
  289.       JAR16 a a:backup -jt -r -m4 -b0 -hk -wc:\ -vvas
  290.  
  291.       You should familiarize yourself with the above switches so that you
  292.       can modify the above command lines as needed.
  293.  
  294.       Another possibility for incremental backups is to use chapter
  295.       archives:
  296.  
  297.       JAR16 ac chapters -ht1 -r -js1 -hl -hz
  298.  
  299.       To restore the last chapter use:
  300.  
  301.       JAR16 x chapters
  302.  
  303.       To restore any other chapter (in our example #5) use:
  304.  
  305.       JAR16 x chapters -jb5
  306.  
  307.       It may be useful to review chapter comments:
  308.  
  309.       JAR16 lc chapters
  310.  
  311.       We also recommend you test JAR reliability with your computer and
  312.       software using the JAR "test" command.  See TESTJAR.BAT.
  313.  
  314.  
  315.     JAR ERROR SITUATIONS:
  316.  
  317.  
  318.       ADD:
  319.  
  320.         If a user specified file is not found during an add, JAR will
  321.         continue processing. Note that files specified within an JAR
  322.         listfile that are not found during an add will NOT trigger an error
  323.         unless the "-hl" option is also specified.
  324.  
  325.         In a disk full condition or any other file i/o error, JAR will
  326.         promptly terminate with an error condition and delete the temporary
  327.         archive.
  328.  
  329.       MOVE:
  330.  
  331.         JAR will only delete files after all them have been successfully
  332.         added to the archive.
  333.  
  334.       EXTRACT:
  335.  
  336.         In a disk full condition or any other file i/o error, JAR will
  337.         promptly terminate with an error condition and delete the current
  338.         output file.
  339.  
  340.       CRC ERRORS OR BAD FILE DATA:
  341.  
  342.         In the case where an JAR archive has been corrupted, JAR will
  343.         report a CRC error or a Bad file data error. These corruptions can
  344.         be the result of an unreliable diskette, a computer memory problem,
  345.         a file transfer glitch, or incompatible CACHING software or memory
  346.         manager.
  347.  
  348.         Most of these errors are the result of file transfer glitches and
  349.         bad diskettes.
  350.  
  351.       CRITICAL ERROR HANDLER:
  352.  
  353.         JAR sets up an interactive critical error handler to handle DOS
  354.         critical errors like "sector not found" and "drive not ready". When
  355.         a critical error occurs, JAR will prompt the user with the message
  356.         "Retry Y/N?". The user may retry the failed operation by pressing
  357.         "Y". Pressing "N" will fail the operation. The user can press
  358.         Control BREAK to abort to DOS.
  359.  
  360.         There is an option to disable the critical error handler in the JAR
  361.         configuration file.
  362.  
  363.         JAR32.EXE doesn't have an interactive hardware error handler.
  364.  
  365.  
  366.     HOW JAR USES AVAILABLE MEMORY:
  367.  
  368.  
  369.       One of JAR's advantages is its ability to use additional memory for
  370.       better compression.  Unlike most other archivers the JAR DOS version
  371.       can use EMS or XMS to improve compression.
  372.  
  373.  
  374.       JAR DOS version
  375.  
  376.         JAR uses a fixed amount of XMS memory to cache its overlay code
  377.         (about 300K) and requires an additional 500K of XMS memory for
  378.         better performance. When JAR compresses data it first looks at
  379.         available EMS memory. If there are more than about 640 Kbytes EMS
  380.         and the compression method is -m2..-m4 then JAR allocates EMS and
  381.         uses it to improve compression. You may specify that JAR use up to
  382.         16384 Kbytes of this memory. The more EMS - the better compression
  383.         achieved, but JAR will work slower.
  384.  
  385.         If there is not enough EMS then JAR uses XMS instead. But "XMS
  386.         based" compression is significantly worse. JAR compression rate and
  387.         speed does not depend significantly on the XMS amount used. The
  388.         optimal value is less than 4 Mbytes. The JAR XMS engine consumes
  389.         about 60K more DOS conventional memory compared to the EMS engine.
  390.  
  391.         When extracting, JAR uses available XMS or EMS for faster
  392.         decompression. The recommended value for data that has been
  393.         compressed using the "-m2" and "-m3" method is 1.5 Mbytes of free
  394.         EMS and/or XMS, for the "-m4" method, use at least 3 Mbytes of free
  395.         EMS/XMS. With less memory JAR may use a swap file instead (this
  396.         results in worse performance).
  397.  
  398.         When both EMS and XMS are available JAR itself chooses the optimal
  399.         memory amount and type for the selected command.
  400.  
  401.         The JAR DOS version requires EMS 4.0+ and XMS 2.0+ versions.
  402.  
  403.         Although the JAR DOS version achieves significantly better
  404.         compression and uses less memory with EMS available, special care
  405.         is required to ensure that the EMS driver (such as EMM386.EXE) is
  406.         configured and works properly.
  407.  
  408.         The EMS driver works in a more "complex" way than XMS. It searches
  409.         for a "hole" in DOS address space for the page frame. Usually it
  410.         also works with 386+ memory paging enabled. As result some older
  411.         DOS software or hardware may conflict with the EMS driver. Refer to
  412.         your memory manager documentation for details. We strongly
  413.         recommend that you ensure that DOS JAR works reliably with EMS
  414.         enabled using the "test" command. If you detected problems then you
  415.         must disable EMS usage using "EmsLimit=0" in the JAR configuration
  416.         file.
  417.  
  418.         When running JAR in Windows 3.X or OS/2 be sure the PIF file/DOS
  419.         session settings allow JAR to use EMS and XMS. By default XMS and
  420.         EMS usage may be limited to 1 Mbyte. We recommend increasing these
  421.         settings to 4 Mbytes or more.
  422.  
  423.  
  424.       JAR Win32 version
  425.  
  426.         JAR for Win32 requires about 1 Mbyte of memory for executable and
  427.         data. The compression engine may use additional free memory for
  428.         better compression since more available memory allows the JAR
  429.         compression engine to match strings at larger offset distances.
  430.  
  431.         Very good compression is achieved when JAR uses 3-4 Mbytes of
  432.         memory. 8-10 Mbytes gives the best compression. JAR may use less
  433.         memory (0.5-3 Mbytes) for good compression, too.
  434.  
  435.         The JAR Win32 version works significantly faster and compresses
  436.         better than the DOS version. So in Windows NT and Windows 95, you
  437.         should use the Win32 JAR version. In DOS, Windows 3.X and OS/2 -
  438.         use the DOS JAR version.
  439.  
  440.  
  441.       Both versions
  442.  
  443.         The simplest way to tune JAR memory usage is to set
  444.         "CheckAvailableMemory=Yes" in the configuration file. Then JAR
  445.         detects the free physical memory currently available and uses it.
  446.         Note that JAR never uses more memory than the limits that are set
  447.         in the configuration file ("XmsLimit", "EmsLimit", "32MemoryLimit")
  448.         even if there is actually more free memory. If
  449.         "CheckAvailableMemory=Yes" you may use very large limit settings
  450.         (e.g., 8192 Kbytes each).
  451.  
  452.         Experienced users may set "CheckAvailableMemory=No" and then
  453.         specify the "real" memory amounts in "XmsLimit", "EmsLimit",
  454.         "32MemoryLimit". Be sure that the memory specified is really
  455.         available; otherwise, in operating systems as Windows 95, Windows
  456.         NT, OS/2, intensive memory swapping may occur which will decrease
  457.         overall system performance. "CheckAvailableMemory=No" is also
  458.         recommended for batch processing. But again SPECIFY MEMORY AMOUNTS
  459.         that ARE REALLY AVAILABLE. It is better to specify a smaller memory
  460.         amount than wait for hours due to swapping.
  461.  
  462.         The EMS implementation in Windows NT is slow. So for good
  463.         compression do not use the JAR DOS version. Use the JAR Win32
  464.         version instead.
  465.  
  466.  
  467.     ARCHIVE CHAPTERS
  468.  
  469.  
  470.       The advantage of a chapter archive over a series of separate archives
  471.       of the same set of files is that space can be saved when files to be
  472.       archived do not change or change slightly. One chapter archive can
  473.       produce the same results as one hundred standard archive backups. In
  474.       other words, one can update a chapter archive one hundred times and
  475.       fully recover any one of those updates.
  476.  
  477.       Technically speaking, each file in a chapter archive has a chapter
  478.       lifespan range. When a file is backed up and has not changed since
  479.       the last backup, only the lifespan range is changed. A copy of the
  480.       file is NOT added to the archive since a copy already exists. If the
  481.       backed up file is different from the previous version, that file is
  482.       added to the archive with an appropriate chapter range. The previous
  483.       version of the file is still kept in the chapter archive.  When a
  484.       particular chapter is restored, JAR selects only the files whose
  485.       lifespan includes the chapter number requested. As an example,
  486.       suppose one made a series of daily chapter backups of a document
  487.       directory where only one document out of the one hundred documents
  488.       changes on a daily basis. The chapter archive would contain the
  489.       original one hundred documents plus a copy of each day's changed
  490.       document.
  491.  
  492.       JAR provides a lot of services for chapter management: keeps chapter
  493.       creation/modification time, allows commenting or locking, can extract
  494.       a specified chapter and also, subsequent changes to it.
  495.  
  496.       EXAMPLE
  497.  
  498.         Suppose you started to develop a new programming project and
  499.         decided to use a JAR chapter archive for backups.
  500.  
  501.         The project directory is "c:\prj\", so you have written a
  502.         special "back.bat" with the command line:
  503.  
  504.         JAR16 ac archive c:\prj\*.* -r -x*.obj -x*.exe -jt
  505.  
  506.         You are not interested in object or exe file backups so they are
  507.         excluded. "-jt" stands for temporary archive testing after each
  508.         update.
  509.  
  510.         After some coding you have completed the "main.h" file. "back.bat"
  511.         adds this file into first archive chapter.
  512.  
  513.         Next thing you have completed is the "main.c" file.  The second run
  514.         of "back.bat" detects that there is no change to "main.h" since the
  515.         previous chapter as file size and modification time have not
  516.         changed. So JAR compresses only the new "main.c" file.  As noted
  517.         before each file has a chapter lifespan range.  In your archive
  518.  
  519.         main.h lifespan range became from 1 to 2  ("<1-2>" in JAR notation)
  520.         main.c - " - " -             from 2 to 2  ("<2-2>" in JAR notation)
  521.  
  522.         Obviously JAR saved additional space as it did not compress and
  523.         save main.h twice.
  524.  
  525.         JAR16 x archive -jb1
  526.  
  527.         extracts file(s) which are included in the first chapter. That is
  528.         only "main.h". The "-jb1" option is used to select chapter #1.
  529.  
  530.         JAR16 x archive -jb2
  531.  
  532.         extracts the second chapter: both "main.c" and "main.h". The same
  533.         result occurs when extracting without the option "-jb2" since JAR
  534.         by default extracts (or lists/updates) the last chapter in the
  535.         archive.
  536.  
  537.         Next step is a bug fix in file "main.h" and another backup.
  538.         JAR detects the change of "main.h" and no changes to "main.c". So now
  539.         the archive contains 3 files:
  540.  
  541.         main.c <2-3>   main.h <1-2>   main.h <3-3>
  542.  
  543.         (can be listed using   JAR16 ls archive -jb1-3 )
  544.  
  545.         Yes, there are two files named "main.h". However, the first one
  546.         belongs to chapters 1 and 2 while the second belongs to chapter 3
  547.         only.  So with the "-jb" option you can fully reconstruct any of these
  548.         chapters.
  549.  
  550.         If you used separate archives for each backup then they would
  551.         contain now 1+2+2=5 files (instead of only 3 files in chapters
  552.         case).  Moreover, in the case of chapter archives JAR optimizes the
  553.         compression as it detects that  main.h <1-2>  and  main.h <3-3>
  554.         do not differ very much, so it compresses only the difference
  555.         between them.
  556.  
  557.         Suppose two days later your project contains 20 files. And chapter
  558.         archive contains 30 updates. You can list or extract any of them.
  559.         Archive is still very small as JAR compresses only changes between
  560.         chapters. If you used 30 separate archives instead of a single
  561.         chapter archive, they would occupy probably 10 times more disk space.
  562.  
  563.         Suppose you noted that somewhere in the previous backups that an
  564.         important piece of code was deleted from "main.h".  You don't need
  565.         to search all 30 archives for this code!
  566.  
  567.         JAR16 e archive main.h -jb1-30
  568.  
  569.         extracts "main.h" from chapters 1-30 each into separate
  570.         directories. Chapters where "main.h" has not been changed are
  571.         skipped. The directory name is generated by enclosing in brackets
  572.         the lifespan start number.  As a result JAR extracts like this:
  573.  
  574.         main.h <1-2>    to   (1)\main.h
  575.         main.h <3-15>   to   (3)\main.h
  576.         main.h <16-30>  to   (16)\main.h
  577.  
  578.         You need to review only these 3 files to find the required code as
  579.         all other chapters contain duplicates. Upon a successful search you
  580.         may decide to comment chapter 3 with a special note about the useful
  581.         code using the:
  582.  
  583.         JAR16 c archive -jb3 -hz
  584.  
  585.         command.
  586.  
  587.         So the main advantage of chapters archive is compact and convenient
  588.         storage of many updates within single archive.  There is easy
  589.         access to any chapters. And of course, there is major disk space
  590.         savings compare to multiple separate backups.  Even if you decide
  591.         to start a new archive backup after the 100'th chapter, your
  592.         savings in compressed size will be outstanding.
  593.  
  594.         If you use a chapter archive as a backup mechanism, you should take
  595.         reasonable precautions in the care and use of such archives.  In
  596.         other words, these archives should be TESTED and COPIED to storage
  597.         media on a regular basis.
  598.  
  599.  
  600.       END OF EXAMPLE
  601.  
  602.       Please read the "ac", "lc" commands, "-js" and "-jb" options for
  603.       further information about chapters.
  604.  
  605.  
  606.     ARCHIVE VOLUMES:
  607.  
  608.  
  609.       A JAR volume archive is an archive which is contained in two or more
  610.       files.  Individual JAR volumes are NOT separate archives. All of the
  611.       volumes taken together represent a single JAR archive.
  612.  
  613.       One can list or extract files directly from a multiple volume
  614.       archive.  However, it is not possible to directly delete, update or
  615.       add files to a volume archive.  You must first concatenate the
  616.       volumes into a single archive and then do the update.
  617.  
  618.       JAR volumes are suffixed in the following order: .j01, .j02, ...
  619.       .j99, .100, .101 ... .990.  The LAST VOLUME by default is suffixed
  620.       .j.  To reference a JAR volume archive,  all commands must specify
  621.       the LAST volume filename in the command line.
  622.  
  623.       See the "-v" option and "y" command for details on how to create
  624.       volume archives, concatenate volumes, and resize or split archives.
  625.  
  626.  
  627.     JAR USER ACTION PROMPTS:
  628.  
  629.  
  630.       JAR prompts the user for action at certain times. There are several
  631.       types of prompts. One is for yes/no permission, another is for a
  632.       new filename, another is for archive comments.
  633.  
  634.       The JAR yes/no user prompts provide a lot of flexibility. In
  635.       addition to the normal yes and no responses, JAR also accepts the
  636.       following responses: quit, always, skip, global, and command.
  637.  
  638.       "Global" sets JAR to inhibit all subsequent user prompts by
  639.       assuming YES for all queries as if "-y" were specified.
  640.  
  641.       "Always" sets JAR to assume YES for subsequent queries of the same
  642.       class. For example, answering ALWAYS to the overwrite query will
  643.       assume YES for ALL subsequent overwrite queries.
  644.  
  645.       "Skip" sets JAR to assume NO for ALL subsequent queries of the same
  646.       class.
  647.  
  648.       "Command" prompts for one DOS command and then executes it. JAR
  649.       then returns to expect an answer to the current yes/no query. Do
  650.       not install a TSR program using this command prompt as JAR may not
  651.       have enough memory left to continue execution.
  652.  
  653.       Abbreviated responses such as "y", "n", "g", "a", "s", "c" are
  654.       allowed.
  655.  
  656.  
  657.     JAR COMMAND LINE SYNTAX:
  658.  
  659.  
  660.       JAR{16|32} <command> [<switch>...] <archive_name>[.j] [<arguments>...]
  661.  
  662.       <arguments> ::= <switch> | <wildcard> | <filename> | <list_file> |
  663.                      <response_file>
  664.  
  665.       <switch> ::= {'/'|'-'}<switch_character>['-'|<option>]
  666.  
  667.       <list_file> ::= '!'<filename>
  668.  
  669.       <response_file> ::= '@'<filename>
  670.  
  671.       Commands and switches can be entered in upper or lower case.
  672.       Command is the first non-switch argument.
  673.  
  674.       JAR supports the use of either "-" or "/" as the switch option
  675.       character. You may mix them.
  676.  
  677.       -s        turns on switch "s"
  678.       -s-       turns off switch "s"
  679.       -sname    provides the name argument for switch "-s".
  680.  
  681.       Wildcards or filenames with spaces must be quoted:
  682.  
  683.       "c:\Program files\*" or
  684.       c:\"Program files"\*
  685.  
  686.       Wildcards or filenames that can be parsed as a switch option must
  687.       be quoted, too. JAR parses a switch option until the first quote.
  688.       The remaining part may only be a switch argument:
  689.  
  690.       -x     is switch
  691.       "-x"   is filename
  692.       -x-    turns off "-x" option
  693.       -x"-"  excludes filename "-"
  694.       -"x-"  reports error as "-" is not followed by a switch character
  695.              (instead argument 'x-' is supplied)
  696.  
  697.       If you need to specify a quote character as an argument then you
  698.       must specify two consecutive quotes (and argument itself must be
  699.       quoted too):
  700.  
  701.       JAR16 a test -g123""""4567  or
  702.       JAR16 a test -g"123""4567"
  703.  
  704.       in both cases password
  705.  
  706.       1234"4567
  707.  
  708.       is specified.
  709.  
  710.       Switch options can be combined to save command line length.
  711.       However, some switch options take optional string arguments and
  712.       therefore, must be the last option in a combined argument token
  713.       string because JAR accepts the rest of the argument token as the
  714.       optional argument. You can combine "-r" and "-y" to make "-ry". You
  715.       can combine "-wd:\" and "-r" with "-rwd:\", because the switch
  716.       option taking the string argument is last. Please note that
  717.       switches that only accept the "-", "0", "1", "2" modifiers can be
  718.       combined in any order.
  719.  
  720.       WARNING:  The "j" in "-jX" option switch is a SHIFT symbol.
  721.       Therefore, a combined "-jftl" is a combination of "-jf", "-jt", and
  722.       "-jl", since the "j" shifts the meaning of subsequent symbols in
  723.       the argument token string.
  724.  
  725.       Examples: -ryjftl   <=>  -r -y -jf -jt -jl
  726.                 -b1ywd:\  <=>  -b1 -y -wd:\
  727.  
  728.       The "h" is another SHIFT symbol.
  729.  
  730.       The standard JAR file suffix is ".j".
  731.  
  732.       The JAR archive name must be the first filename on the command line
  733.       after the command. The switches and other filenames can be in any
  734.       order.
  735.  
  736.       Both JAR versions use wild name matching similar to Windows 95 (which
  737.       supercedes DOS wild name matching).
  738.  
  739.       (*) wildcard means "a sequence of arbitrary characters" (includes
  740.       the empty sequence).  JAR interprets a wildcard (?) as "any character".
  741.       Unlike in DOS, wild names allow the arbitrary placing of (*) and (?)
  742.       wildcards.
  743.  
  744.       If filename being matched doesn't have the extension and dot at the
  745.       end, then JAR in addition tries to match the filename with appended
  746.       '.'  (Example: "file" is considered "file.").
  747.  
  748.       Examples: "*" or "*.*" means all files
  749.                 "*."         means all files without extension
  750.                 "*.DOC"      means all files with an extension of ".DOC"
  751.                 "?B*"        means all files with a second character of "B"
  752.                 "??"         means all two character length filenames
  753.                 "*1*"        means all names that contains character "1"
  754.                 "*.*.*"      means all names that contain two "." characters
  755.  
  756.       NOTE: There are minor differences with Windows NT wildcard
  757.       matching. JAR interprets a wildcard (?) as "any character" instead
  758.       of "zero or one character".
  759.  
  760.       The default for <wild_name> for all commands except for "d" is "*".
  761.       The argument "" may be used as the wildcard that never matches any
  762.       files.
  763.  
  764.       You can supply one or more filenames for files containing lists of
  765.       files to be added to an archive. The filenames must be listed one
  766.       per line. The list filename(s) must be prefixed with "!" as in
  767.       "!listfile".
  768.  
  769.       You can also build a long command line using response files.  The
  770.       response file is "included" into the command line at the specified
  771.       place. Multiple and nested response files are allowed. The command
  772.       line may be split over as many lines as necessary.
  773.  
  774.       Example: JAR16 a archive @switches.txt @wildcards.txt
  775.  
  776.  
  777.     JAR COMMANDS:
  778.  
  779.  
  780.       a: Add files to archive
  781.  
  782.         This is the basic command to add disk files to a JAR archive. If
  783.         you specify the "-r" switch (recurse subdirectories), JAR will add
  784.         all of the files in all of the subdirectories that match the
  785.         specified wildname.  Along with these files JAR also will add all of
  786.         the scanned subdirectories.
  787.  
  788.         Note that this last action is similar to UC2 but different from ARJ
  789.         behavior.  See the "-hb" option for more information.
  790.  
  791.         Examples: JAR16 a archive subdir\*
  792.                   Archive all files in directory "subdir".
  793.  
  794.                   JAR32 a archive "c:\Program files\*" -r
  795.                   Archive all files in directory "Program files" and
  796.                   subdirectories.
  797.  
  798.         NOTE: Both DOS and Win32 JAR versions ALWAYS use Windows 95 like
  799.         wildcard matching style. This means that "subdir\*" works like
  800.         "subdir\*.*". The wildname "subdir\*." selects files without
  801.         extension.
  802.  
  803.         After add and listing commands with all files selected JAR shows
  804.         the total archived data ratio. This ratio does not include JAR
  805.         headers and recovery records. Only "pure" compressed data.
  806.  
  807.         JAR compresses archive header. As a result whole archive size
  808.         differs time to time even when compressing the same data.
  809.  
  810.  
  811.       ac: Add new Chapter
  812.  
  813.         The "ac" command works like the "a" command, but adds files into a
  814.         newly created chapter. JAR manages an almost unlimited number of
  815.         chapters.
  816.  
  817.         See the "-js" option for IMPORTANT DETAILS about methods on how
  818.         files are added to a new chapter.
  819.  
  820.         Example: JAR16 ac archive subdir\*
  821.                  Add all files in the directory "subdir" into new chapter
  822.  
  823.         JAR uses two compression methods. The "solid" method is used to
  824.         compress files in the usual manner.  The "version" method is used
  825.         to compress files with the same path but within different chapters.
  826.         This method is optimized to compress only the DIFFERENCES between
  827.         files while updating from chapter to chapter.
  828.  
  829.         NOTE: The current JAR version supports "version" compression method
  830.         only for files with a size less than about 500 Kbytes.
  831.  
  832.         "Version" compression also allows faster updates to an archive. The
  833.         only exception is the first time that a new file version is
  834.         compressed. In this case JAR must change the compression method
  835.         used for the file (from "solid" to "version") and this takes
  836.         additional time. The next version update will be significantly
  837.         faster.
  838.  
  839.         See the "-jb" option for more details how to extract or list chapters.
  840.  
  841.  
  842.       c: Comment archive files
  843.  
  844.         This command allows you to comment the archive header or individual
  845.         files or archive chapters. JAR will prompt you for each comment.
  846.         The user will be prompted for up to 50 lines for each comment. A
  847.         line containing only a [return] will terminate the comment. The
  848.         user can choose to input comment data from a file by entering the
  849.         comment filename preceded by an "!" as in "!archive.txt" starting
  850.         in column 1 of the first comment line. This file is read as a text
  851.         file. Only the first 4096 bytes of the file will be accepted by
  852.         JAR.
  853.  
  854.         To erase a comment from an archive, type [space] [return] on the
  855.         first comment line and [return] on the second comment line.
  856.  
  857.         To add file comments but not archive comment, use following
  858.         command:
  859.  
  860.         JAR16 c archive
  861.  
  862.         To add the archive comment but not file comments, use the following
  863.         command:
  864.  
  865.         JAR16 c archive -z
  866.  
  867.         To add only the archive comment at the command line, use the
  868.         following command:
  869.  
  870.         JAR16 c archive -zcomment.txt
  871.  
  872.         To remove a comment via the command line, use predefined "NUL"
  873.         filename:
  874.  
  875.         JAR16 c archive -zNUL
  876.  
  877.         You may also comment an archive with other update commands:
  878.  
  879.         JAR16 a -zcomment.txt archive *.txt
  880.  
  881.         JAR allows the storing of ANSI style comments. While displaying
  882.         these comments JAR itself emulates ANSI.SYS driver behavior in a
  883.         virtual screen and then dumps the complete picture to the output.
  884.         NOTE: The virtual screen is two columns narrower than the current
  885.         "real" screen.
  886.  
  887.  
  888.       cfg: extract default configuration file
  889.  
  890.         This command accepts a single argument - destination filename. If
  891.         it is omitted, JAR extracts the configuration file as "jar.cfg".
  892.  
  893.         This command is useful if the configuration file is missing or
  894.         damaged.
  895.  
  896.  
  897.       d: Delete files from archive
  898.  
  899.         This command allows you to delete files from the archive. When
  900.         wildcard selection is not suitable, you can use the "-q" switch to
  901.         set JAR to prompt you for deletion for each file selected. These
  902.         deleted files are physically removed from the archive.
  903.  
  904.         Examples: JAR16 d archive *.c
  905.                   Delete all files in archive ending in ".c"
  906.  
  907.                   JAR16 d -q archive *.c
  908.                   Prompt before deleting each file ending in ".c".
  909.  
  910.         Even if JAR removes all the files, the empty archive WILL NOT be
  911.         deleted.
  912.  
  913.         You can specify the "-n" (new) option to delete the files in the
  914.         archive that DO NOT EXIST on the disk. Then the "-o" option may be
  915.         used to specify the directory to scan.
  916.  
  917.         Example: JAR16 d archive *.* -n
  918.  
  919.  
  920.       da: Delete files in All chapters
  921.  
  922.         Delete the specified files in all chapters while showing the
  923.         deleted files with the corresponding chapter lifespan ranges. The
  924.         arguments are the same wildcards as used with the "d" command.
  925.  
  926.         Example: JAR16 da archive *.c
  927.                  Deletes all files in all chapters ending in ".c".
  928.  
  929.  
  930.       dc: Delete Chapters
  931.  
  932.         Delete chapters in the specified range. The command arguments are
  933.         chapter range "1-", "-2", "1-5" like. The "-x" option may be used
  934.         to exclude a range. Each file's chapter lifespan range is modified
  935.         with regard to the existing chapters. If there are no remaining
  936.         chapters then the file is removed.
  937.  
  938.         Examples: JAR16 dc arch 5 6 8            deletes chapters 5, 6 and 8
  939.                   JAR16 dc arch 5-8 11-12 -x6-7  deletes chapters
  940.                                                    5, 8, 11, 12
  941.                   JAR16 dc arch "-10"            deletes first ten chapters
  942.                   JAR16 dc arch 10-              deletes all chapters
  943.                                                    from 10 and above
  944.  
  945.  
  946.       e: Extract files from archive
  947.  
  948.         This command will extract one or more files from the archive to the
  949.         current directory or to the output directory if specified. JAR will
  950.         prompt the user before overwriting existing files unless the user
  951.         specifies the "-y" switch. If the user gives a "no" answer, JAR
  952.         will prompt must file be extracted to other filename. Then a "no"
  953.         answer skips file and "yes" prompts for new filename.
  954.  
  955.         JAR does not ask overwrite permission while extracting existing
  956.         directories unless the archive directory and existing directory
  957.         attributes do not match.
  958.  
  959.         The "-o" option can be used to specify the destination directory.
  960.  
  961.         Example: JAR16 e archive -osoft\ *.c
  962.                  Extract all files ending in ".c" to subdirectory "soft".
  963.  
  964.         If JAR encounters a CRC or Bad file data error during extraction,
  965.         JAR will delete the corrupted extracted file unless the "-jr"
  966.         option is used.
  967.  
  968.         You can extract files from a specified chapter using the "-jb"
  969.         option:
  970.  
  971.         JAR16 e archive *.txt -jb20
  972.  
  973.         Using same option you can also extract files which span a specified
  974.         chapter range.
  975.  
  976.         Example: JAR16 e archive file.txt -jb5-10
  977.                  Extracts the "file.txt" changes in chapters 5-10.
  978.  
  979.         For convenience when extracting a chapter range, JAR places files
  980.         with different starting chapters into different directories
  981.         "(5)","(6)"... (brackets enclose starting chapter number).
  982.  
  983.         NOTE: During extraction JAR DOES NOT EXTRACT DUPLICATE files into
  984.         all chapter directories from the file lifespan range. A file is
  985.         extracted ONLY into the starting chapter directory of the file.
  986.         This feature saves space and lets one easily find chapters where
  987.         the selected file has been changed.
  988.  
  989.         So "JAR16 x archive -jb5-10" will reconstruct the full chapter 5,
  990.         BUT EXTRACT ONLY THE CHANGES in chapters 6-10.
  991.  
  992.  
  993.       f: Freshen files in archive
  994.  
  995.         Update matching files in the archive that are OLDER than the
  996.         selected disk files.
  997.  
  998.         Example: JAR16 f archive *.c *.h
  999.  
  1000.  
  1001.       l: List contents of archive
  1002.  
  1003.         List contents of archive. You can get sorted output by using the
  1004.         "-ju" option.
  1005.  
  1006.         Example: JAR16 l archive *.c *.h
  1007.  
  1008.         You can specify the "-n" (new) option to list the files in the
  1009.         archive that DO NOT EXIST on the disk. The "-o" option may be used
  1010.         to specify directory to scan.
  1011.  
  1012.         Example: JAR16 l -n -oc:\source archive *.c *.h
  1013.  
  1014.         When listing a few chapters JAR appends the corresponding file's
  1015.         chapter lifespan range in the format "<from-to>".
  1016.  
  1017.         Example: JAR16 l archive *.c *.h -jb1-10
  1018.  
  1019.  
  1020.       lc: List Chapters
  1021.  
  1022.         List chapter information: comment, creation and modification time,
  1023.         and lock flag.  The command arguments are sets of chapter ranges as
  1024.         in the "dc" command.
  1025.  
  1026.         Example: JAR16 lc archive
  1027.                  List all chapter information in archive
  1028.  
  1029.  
  1030.       ls: List contents of archive (Short form)
  1031.  
  1032.         List contents of archive in the shortest form.
  1033.  
  1034.         Example: JAR16 ls archive *.c *.h
  1035.  
  1036.  
  1037.       lt: List Technical information for shells
  1038.  
  1039.         List technical information for archiver shell programs. This
  1040.         command accepts a single parameter - a file that must not exist on
  1041.         disk. JAR dumps the archive header information to this file.
  1042.  
  1043.         Example: JAR16 lt archive header.txt
  1044.  
  1045.         See TECHNOTE.DOC for details.
  1046.  
  1047.  
  1048.       m: Move files to archive
  1049.  
  1050.         The "m" command adds the selected files to the archive. If the adds
  1051.         are successful, then the added files and directories are deleted.
  1052.         The move command does not ask permission before deleting the files.
  1053.  
  1054.         Example: JAR16 m archive soft\*.*
  1055.  
  1056.         It is STRONGLY suggested that you always use the "-jt" option with
  1057.         move commands to set JAR to verify the archive before deleting the
  1058.         input files.
  1059.  
  1060.  
  1061.       reg: register program
  1062.  
  1063.         The "reg" registration command is available only in the JAR DOS
  1064.         version.
  1065.  
  1066.         When you order JAR, you will get a registration key which matches
  1067.         the OWNER and security envelope SIGNATURE specified on the order
  1068.         form.
  1069.  
  1070.         The "reg" command simultaneously registers both JAR16.EXE and
  1071.         JAR32.EXE. Both executables must be in the same directory before
  1072.         processing. Since JAR will modify both executables, JAR16.EXE and
  1073.         JAR32.EXE must not be in use.
  1074.  
  1075.         If the "reg" command is executed without a filename argument, JAR
  1076.         will prompt for the registration key interactively.  Otherwise, JAR
  1077.         will search for the registration key within the file specified.
  1078.  
  1079.         Examples:  JAR16 reg key.txt
  1080.                    JAR16 reg
  1081.  
  1082.  
  1083.       rh: Recover archive Header
  1084.  
  1085.         This command is available only in Win32 JAR version. If your
  1086.         archive is damaged, the remaining undamaged files may be recovered
  1087.         in the following ways:
  1088.  
  1089.         - you can try to extract files using the "-hx" option. This option
  1090.           uses the recovery records (if available in archive) to repair
  1091.           slightly damaged archives.
  1092.  
  1093.         - you can try to extract files using the "-jr" option (this
  1094.           prevents JAR from aborting on damaged files). The "-hx" and "-jr"
  1095.           options can be combined.
  1096.  
  1097.         Both listed options do not help if the archive header is damaged.
  1098.  
  1099.         The "rh" command may recover useful archive data (if such) and the
  1100.         header from a seriously damaged archive. It uses signatures to
  1101.         search for valid compressed data chains. You must place all damaged
  1102.         archive volumes into same directory and then run:
  1103.  
  1104.         JAR32 rh archive
  1105.  
  1106.         JAR will output the recovered archive into the current directory as
  1107.         "$recover.j".  The archive may still contain partially damaged data
  1108.         so it may be necessary to use the "-jr" option to extract data from
  1109.         the archive.
  1110.  
  1111.         NOTE: The "rh" command recovers only the most important archive
  1112.         data: file contents, file CRC, file modification date but not time.
  1113.         The file's chapter lifespan range information is lost, too, but JAR
  1114.         tries to group different versions of the same file into different
  1115.         chapters.
  1116.  
  1117.         Be sure you specify the correct password and method for the
  1118.         protected damaged file; otherwise, JAR will report that there is no
  1119.         recoverable data.
  1120.  
  1121.         After repair of archive with multiple chapters, "$recover.j" may
  1122.         contain a smaller number of files than the original archive (even
  1123.         if it has not been damaged).  This is due to the loss of "CHAPTER
  1124.         range" information and as a result two files with the SAME DATA in
  1125.         neighboring chapters may be recovered as a single file.
  1126.  
  1127.         If you have lost one or more volumes of a multiple volume archive,
  1128.         you can recover the archive with the following steps:
  1129.  
  1130.         - place the existing volumes into a single directory.
  1131.  
  1132.         - for lost volumes substitute any file over 64 bytes in size.
  1133.           For example, you can replace a missing volume "archive.j02" with
  1134.           a file that contains 65 spaces.
  1135.  
  1136.         - execute JAR "rh" command.
  1137.  
  1138.         JAR will not find recoverable data in such volume substitution;
  1139.         however, these substitutions will allow the JAR "rh" command to
  1140.         process through all the volumes.
  1141.  
  1142.  
  1143.       sl: Scan Locked files
  1144.  
  1145.         After command scans selected file set it tries to open each file
  1146.         for reading. Files which JAR failed to open are listed. You can
  1147.         copy this list into file using "-l" option. Later this list file
  1148.         may be used to exclude locked files.
  1149.  
  1150.         Command does not accept archive name.
  1151.  
  1152.         Example:
  1153.  
  1154.         JAR32 sl c:\* -r -l"To be excluded"
  1155.  
  1156.         NOTE: When wildcard used with "-x" or "-x!" does not contain path
  1157.         specified (only filename) then this wildcard is used to match to
  1158.         ALL filenames (path is ignored). You must keep this in mind when
  1159.         using exclude lists generated by "sl" command. Read "-x" option for
  1160.         details.
  1161.  
  1162.  
  1163.       t: Test integrity of archive
  1164.  
  1165.         Test the contents of ALL files for the correct CRC value. JAR uses
  1166.         a 32 bit CRC to validate the contents of the files.
  1167.  
  1168.  
  1169.       test: test JAR reliability
  1170.  
  1171.         This is the command to test the reliability of JAR compressing and
  1172.         decompressing selected files. When executing this command JAR works
  1173.         in similar way like "add" command.  But after each compressed file
  1174.         portion JAR decompresses and tests files using comparison and then
  1175.         removes compressed data. This saves disk space and allows JAR to
  1176.         test gigabytes of files with limited free disk space.
  1177.  
  1178.         This command requires a temporary archive filename which will be
  1179.         used for testing.  The needed free disk space can be found from the
  1180.         following table (in megabytes):
  1181.  
  1182.         Compression method:       -m1,-m2,-m3             -m4
  1183.  
  1184.         1,000 files to test            6M                 20M
  1185.         5,000 files to test           10M                 30M
  1186.         20,000 files to test          20M                 40M
  1187.         50,000+ files                 60M                 60M
  1188.  
  1189.         This table assumes that the JAR swap file is located on the same
  1190.         drive as the temporary archive. Otherwise, use following table
  1191.         (space for temporary archive/swap file):
  1192.  
  1193.         Compression method:       -m1,-m2,-m3             -m4
  1194.  
  1195.         1,000 files to test          4M/3M               20M/5M
  1196.         5,000 files to test          4M/5M               20M/7M
  1197.         20,000 files to test         4M/10M              20M/15M
  1198.         50,000+ files                4M/30M              20M/30M
  1199.  
  1200.         Depending on the free disk space JAR will also skip files too large
  1201.         to test.  JAR must have enough space to store whole compressed file
  1202.         before testing decompression and comparing contents.
  1203.  
  1204.         When running this command JAR also uses additional methods to
  1205.         detect conflicts with hardware or software, memory or disk
  1206.         corruption. If JAR detects such problems then it will report the
  1207.         following errors:
  1208.  
  1209.           Wrong program flow detected at (<module>,<line>)
  1210.           Possibly conflict with used software or hardware
  1211.  
  1212.         or
  1213.  
  1214.           Internal at (<module>,<line>)
  1215.           Possibly conflict with hardware
  1216.  
  1217.         We strongly recommend that you run such tests before using JAR,
  1218.         especially for backup purposes. It is also useful to retest JAR
  1219.         after hardware upgrades or installation of new memory managers or
  1220.         other "critical" software.
  1221.  
  1222.         TESTJAR.BAT contains a ready-to-run command line. You can modify
  1223.         this batch file to test other compression methods (-m1,-m3, or -m4)
  1224.         or other drives.
  1225.  
  1226.         JAR16.EXE and JAR32.EXE should be tested separately in the intended
  1227.         operating environments.
  1228.  
  1229.         Example: JAR16 test archive c:\* d:\* -r -m1 -ho -jf -xwin386.swp
  1230.                  Test compression/decompression of the files on few drives.
  1231.                  "win386.swp" is excluded as it may be locked.
  1232.  
  1233.         Be sure you exclude files which may be locked for reading during
  1234.         testing; otherwise, JAR will abort on the locked file.
  1235.  
  1236.         Testing may take a long time (hours or days). You can interrupt or
  1237.         shorten any test by pressing CTL BREAK.
  1238.  
  1239.         With the "-ht0" option JAR will test the decompression using CRC32
  1240.         only instead of a file contents comparison. This may work faster.
  1241.  
  1242.         It may be useful also to test encryption/protection using "-g" and
  1243.         "-hg" options together with "test" command.
  1244.  
  1245.  
  1246.       u: Update files to archive
  1247.  
  1248.         Update older files in the archive and add files that are new to the
  1249.         archive.
  1250.  
  1251.         Example: JAR16 u software
  1252.  
  1253.  
  1254.       v: Verbosely list contents of archive
  1255.  
  1256.         This command lists the full pathname and comments of the archive
  1257.         files as well as the same information as the "l" command. It also
  1258.         shows the compression method, file access and creation time, and
  1259.         host OS. This command may be used with the "-hf" options to look at
  1260.         long filename translations.
  1261.  
  1262.  
  1263.       x: eXtract files with full pathname
  1264.  
  1265.         This command extracts one or more files from the archive to their
  1266.         full paths in the current directory or to the output directory if
  1267.         specified.
  1268.  
  1269.         Example: JAR16 x archive *.c
  1270.  
  1271.         Refer to the description of the "e" command for more information
  1272.         about extraction.
  1273.  
  1274.  
  1275.       y: copY archive with new options
  1276.  
  1277.         The JAR "y" command provides an easy interface to the options that
  1278.         change archive settings.
  1279.  
  1280.         Examples: JAR16 y archive -jl            locks archive
  1281.                   JAR16 y archive -g? -jg?       changes archive password
  1282.                   JAR16 y archive -hk            adds recovery records to
  1283.                                                    archive
  1284.                   JAR16 y archive -hk-           removes recovery records
  1285.                   JAR16 y archive -v20k -osplit  splits archive into 20K
  1286.                                                    volumes
  1287.                   JAR16 y split -oarchive        concatenates archive
  1288.                                                    volumes back
  1289.                   JAR16 y archive -hx            repairs damaged archive
  1290.                                                    using recovery records
  1291.  
  1292.         NOTE: When changing the password JAR always tests the archive.
  1293.  
  1294.  
  1295.     JAR SWITCH OPTIONS:
  1296.  
  1297.  
  1298.       b0: reset archive bits
  1299.  
  1300.         The "-b0" switch does NOT affect file selection. It causes JAR to
  1301.         reset the archive bits of added files. If the "f", "u", or "ac"
  1302.         command has been selected, JAR will also reset the archive bits of
  1303.         files that are already duplicated in the archive.
  1304.  
  1305.         Example: JAR16 a e:archive c:\*.* -b0 -r
  1306.                  archives all files on the C drive and resets all archive
  1307.                  bits.
  1308.  
  1309.         This option also causes JAR to reset the archive bit of extracted
  1310.         files.
  1311.  
  1312.         NOTE: JAR ignores archive bit set/reset errors. If error occurs
  1313.         then added file archive bit value is not changed. For extracted
  1314.         file archive bit remains set to 1.
  1315.  
  1316.  
  1317.       b1: set archive bits
  1318.  
  1319.         Works like "-b0" but sets the archive bit instead.
  1320.  
  1321.  
  1322.       d: with Delete (move)
  1323.  
  1324.         This switch with the "a" command is similar to the standard MOVE
  1325.         command. Successfully added files will be deleted. When used with
  1326.         the "f", "u", or "ac" command, JAR will also delete files that are
  1327.         already duplicated in the archive. JAR will prompt the user before
  1328.         deleting the files unless the "-y" or "-jyd" switch is specified.
  1329.         Also, you can use the "m" command which does not prompt before
  1330.         deleting the files.
  1331.  
  1332.         Example: JAR16 a archive filename -d -y       is equivalent to
  1333.                  JAR16 m archive filename
  1334.  
  1335.         This option works with "add" type commands only.
  1336.  
  1337.  
  1338.       f: Freshen existing files
  1339.  
  1340.         This switch works only with the "e" and "x" commands.
  1341.  
  1342.         "-f" specifies JAR to extract newer files from the archive.
  1343.  
  1344.         "-f1" specifies to extract older files.
  1345.  
  1346.         "-f2" specifies to files with a changed date/time or size.
  1347.  
  1348.         NOTE: JAR ignores date/time comparison between directories (always
  1349.         assumed are the same).
  1350.  
  1351.         Example: JAR16 x archive -osource -f
  1352.                  Extract newer files
  1353.  
  1354.  
  1355.       g: specify archive password
  1356.  
  1357.         This switch will specify the archive password. An archive can be
  1358.         protected from unauthorized access by using a password with either
  1359.         of two different protection methods.
  1360.  
  1361.         The protection method may be specified using the "-hg" option. The
  1362.         "Authenticate" method establishes an archive password WITHOUT the
  1363.         actual encryption of its contents. The "GOST v1.01" method uses
  1364.         GOST 28147-89 encryption in CBC mode to encrypt archive files (but
  1365.         NOT archive header which contains comments and filenames).
  1366.  
  1367.         With the default configuration file and without specifying the
  1368.         protection method ("-hg") JAR uses the "Authenticate" method. The
  1369.         "DefaultAccessProtection" setting in the CFG file allows one to
  1370.         change this behavior.
  1371.  
  1372.         NOTE: Encryption is not available in the export JAR version.
  1373.  
  1374.         Once an archive is protected, JAR requires the password when
  1375.         extracting or updating the archive.
  1376.  
  1377.         JAR stores within the archive header a secure password hash. This
  1378.         allows verification of the specified password before the actual
  1379.         update/extract operation. But there is a very small (smaller than
  1380.         1e-30) probability that the hash function will not detect an
  1381.         incorrect password during an update operation. In this case,
  1382.         different files may be encrypted using different passwords. So JAR
  1383.         may report "CRC error" or "Bad data" when using the wrong password
  1384.         for update.
  1385.  
  1386.         Short and trivial passwords allow brute-force attacks against
  1387.         protected archive. We recommend to use passwords longer than 16
  1388.         characters. Special characters and digits in password also
  1389.         recommended.
  1390.  
  1391.         Example: JAR16 e archive -gpassword
  1392.  
  1393.         If the "-g" option is followed by a question mark "?", JAR will
  1394.         prompt the user for the password without displaying the password.
  1395.         The backspace key can be used to erase characters.
  1396.  
  1397.         Example: JAR16 a archive -g?
  1398.  
  1399.         Use the "y" command with "-jg" option to remove/set password for an
  1400.         already existing JAR archive.
  1401.  
  1402.         Please save your password in a safe place. There is no trick,
  1403.         trapdoor, or shortcut to recovering a lost password.
  1404.  
  1405.         NOTE: The first JAR 1.01 BETA used the now obsolete
  1406.                "Authentication" method to protect an archive. Please read
  1407.                WHATSNEW.DOC for details.
  1408.  
  1409.         NOTE: Concerning password to 256-bit GOST key conversion in "GOST
  1410.               v1.01" method ...
  1411.  
  1412.               The password is always cyclically filled to a complete 8
  1413.               character block before further conversion into a 256-bit key.
  1414.               For example, the password "abcdefgh0123" (1) is filled to
  1415.               "abcdefgh0123abcd" (2). As a result, an archive with password
  1416.               (1) may be decrypted using password (2) and vice-versa.
  1417.  
  1418.               We have noted that such password "cyclical filling" is not
  1419.               the best choice. However as long as the current method does
  1420.               not affect encryption reliability we have decided to keep it
  1421.               for compatibility with previous JAR BETA versions.
  1422.  
  1423.               We are planning to release additional encryption method(s)
  1424.               without this disadvantage. The current encryption methods
  1425.               will be continued to be supported.
  1426.  
  1427.  
  1428.       h: selects (second) alternate set of switch characters.
  1429.  
  1430.         Works like the "-j" shift option but selects another set of switch
  1431.         characters. See the "-j" switch for more details.
  1432.  
  1433.  
  1434.       j: selects alternate set of switch characters.
  1435.  
  1436.         This switch toggles the set of switch characters. The toggle is
  1437.         reset at end at of each separate switch sequence back to the main
  1438.         set of switch characters.
  1439.  
  1440.         For example, "-jf" is not the same function as "-f".  However,
  1441.         "-jjf" is the same as "-f" because of the double toggle.  Also,
  1442.         "-jljf" is NOT the same as "-jl -jf".  The switch sequence "-jlf"
  1443.         is the same as "-jl -jf". It is not recommended that you use these
  1444.         combined shift sequences.
  1445.  
  1446.  
  1447.       l: create List_name file
  1448.  
  1449.         This switch will set JAR to dump to the filename specified after
  1450.         the "-l" switch all of the filenames to be processed by this JAR
  1451.         command.
  1452.  
  1453.         For add type commands, this list contains all files that matched
  1454.         the file wildnames given on the command line.
  1455.  
  1456.         For "sl" command, this list contains files which JAR failed to open
  1457.         for reading.
  1458.  
  1459.         For other commands, the file will contain only the original
  1460.         filenames and/or wildcard names. Other options do NOT affect the
  1461.         output of filenames to this list file.
  1462.  
  1463.         This list file can be used as a listfile on the command line.
  1464.  
  1465.         Example: JAR16 a -lname.lst archive *.exe
  1466.                  This example will create a file named "name.lst" with all
  1467.                  scanned *.exe files.
  1468.  
  1469.  
  1470.       m: with Method 1, 2, 3, 4
  1471.  
  1472.         Method 1 = fastest compression. This method uses a small fixed
  1473.         memory amount for compression in comparison with -m2..4 .
  1474.  
  1475.         Method 2 = normal compression (default). JAR uses available memory
  1476.         to improve compression.
  1477.  
  1478.         Method 3 = better compression. This method works slower but may
  1479.         improve compression a few percent.
  1480.  
  1481.         Method 4 = best compression. This method may compress better with
  1482.         large amounts of data (>2 Mbytes). "-m4" is not recommended for
  1483.         archives that may be modified in future. JAR requires up to 12
  1484.         Mbytes of additional disk space for a swap file when updating these
  1485.         archives. In addition, updates are much slower compared to the
  1486.         other methods.
  1487.  
  1488.         Examples:  JAR16 a archive *.exe -m3
  1489.                    Better compression
  1490.  
  1491.                    JAR16 a archive *.exe -m4
  1492.                    Uses the best compression
  1493.  
  1494.         Recommended values of free memory for decompression depend on the
  1495.         method used:
  1496.  
  1497.         "-m1"              - does not require additional memory
  1498.         "-m2" and "-m3"    - 1.5 Mbytes
  1499.         "-m4"              - 3.0 Mbytes
  1500.  
  1501.         These values are RECOMMENDED for optimal operation; however, JAR
  1502.         will decompress files with less memory.
  1503.  
  1504.         Usually methods "-m3" and "-m4" work 1.5 times slower than default
  1505.         "-m2".
  1506.  
  1507.         What is difference between these methods? JAR uses a greatly
  1508.         improved LZ family algorithm.  "-m1"  matches strings at
  1509.         short distances (comparable with PKZIP - about 32Kbytes). "-m2"
  1510.         searches for strings at large distances (about 500K-1000Kbytes and
  1511.         sometimes more) depending on the memory amount used. "-m3" method
  1512.         works like "-m2" but does a more exhaustive slower search. "-m4"
  1513.         matches strings at even larger distances and like "-m3" uses an
  1514.         exhaustive search.
  1515.  
  1516.         The second difference between methods is data block size. For
  1517.         "-m1", "-m2", "-m3", JAR concatenates files into 1000K-1500Kbytes
  1518.         pieces to obtain good compression and reasonable update speed.
  1519.         This also makes a JAR archive more robust than a "FULLY" solid
  1520.         archive (a damaged byte affects at most a single block, not the
  1521.         whole archive).  The only drawback is a slight loss in compression
  1522.         rate.
  1523.  
  1524.         Before concatenating files into blocks JAR sorts them using a few
  1525.         criteria (file extension, size) so that files with likely similar
  1526.         structure tends to be compressed together.
  1527.  
  1528.         "-m4" compresses better by concatenating files into significantly
  1529.         larger blocks - up to 12Mbytes.
  1530.  
  1531.         Therefore, we recommend the use of "-m2" for archives which may be
  1532.         updated frequently and "-m4" for the "best and solid" compression.
  1533.  
  1534.  
  1535.       n: only New files (not exist)
  1536.  
  1537.         With the "a" command, add files that do not exist in the target
  1538.         archive.
  1539.  
  1540.         With the "d" command, delete files that do not exist in the target
  1541.         directory.  With the list type command, list files that do not
  1542.         exist.  Target directory may be specified using "-o" option.
  1543.  
  1544.  
  1545.       o: Output directory/file
  1546.  
  1547.         For commands which scan files this option specifies the destination
  1548.         directory within the archive for scanned files.
  1549.  
  1550.         Example: JAR16 a archive dir1\a.txt -oversion1 -jf-
  1551.                  File will be added to archive as "version1\dir1\a.txt"
  1552.  
  1553.         For extraction commands this option specifies the destination
  1554.         directory where files are to be extracted.
  1555.  
  1556.         Example: JAR16 e archive dir1\a.txt -oc:\version1 -jf-
  1557.                  File will be extracted to "c:\version1\a.txt"
  1558.  
  1559.         For the "y" command, this option specifies the updated archive
  1560.         name. Currently, the "y" command together with "-o" option is the
  1561.         only way to update a multi-volume JAR archive.
  1562.  
  1563.         Examples: JAR16 y archive -oa:archive
  1564.                   Copies archive to floppy
  1565.  
  1566.                   JAR16 y archive -oa:archive -va
  1567.                   Copies archive to multiple floppies and automatically
  1568.                   splits to volumes
  1569.  
  1570.         See the "y" command description for more details.
  1571.  
  1572.         For the "d", "l", "v", "ls" commands with the "-n" (new files)
  1573.         option, the "-o" option specifies the directory to scan.
  1574.  
  1575.  
  1576.       q: Query on each file
  1577.  
  1578.         This switch causes JAR to prompt the user prior to acting upon each
  1579.         archived file for all but the "l", "lc", "ls", "lt", "rh", "t", "v"
  1580.         and "y" commands. This allows you to selectively extract, delete,
  1581.         add, etc.
  1582.  
  1583.  
  1584.       r: Recurse subdirectories
  1585.  
  1586.         This switch will set JAR to recurse any wildcards specified on the
  1587.         command line by traversing all subdirectories scanning for matches.
  1588.  
  1589.         JAR will also recurse non-wildcard filenames as in:
  1590.         JAR16 a archive FILE.BBS -r
  1591.  
  1592.         By default this option is ON for all commands that matches files
  1593.         within archive ("c", "d", "e", "da", "l", "ls", "v", "x"). By
  1594.         default this option is toggled OFF for all commands that scan files
  1595.         ("a", "ac", "f", "m", "u", "test").
  1596.  
  1597.         Examples: JAR16 l archive -r- *.doc
  1598.                   List *.doc files only in root archive directory.
  1599.  
  1600.                   JAR16 d archive *.doc
  1601.                   Delete ALL *.doc files from archive
  1602.  
  1603.                   JAR16 d archive test\*.doc -r-
  1604.                   Delete *.doc files from test\ directory, but not
  1605.                   subdirectories
  1606.  
  1607.  
  1608.       s: set archive time-Stamp
  1609.  
  1610.         This switch causes JAR to set the date-time stamp of the archive to
  1611.         that of the newest file in the archive. This option works only with
  1612.         update operations.
  1613.  
  1614.         The "-s1" switch is used to keep the old archive date-time stamp.
  1615.         The new archive will have the same date-time stamp as the original
  1616.         archive.
  1617.  
  1618.  
  1619.       u: Update files
  1620.  
  1621.         This switch works only with the "e" and "x" commands.
  1622.  
  1623.         "-u" specifies JAR to extract only newer and non-existing files
  1624.         from the archive.
  1625.  
  1626.         "-u1" specifies to extract only older and non-existing files.
  1627.  
  1628.         "-u2" specifies to extract non-existing files and files that
  1629.         date/time or size changed.
  1630.  
  1631.         NOTE: JAR ignores date/time comparison between directories (always
  1632.         assumed are the same).
  1633.  
  1634.         Example: JAR16 x archive -osource -u2
  1635.                  Extracts new or changed files
  1636.  
  1637.  
  1638.       v: enable multiple Volumes
  1639.  
  1640.         While creating a NEW archive this option specifies the new archive
  1641.         volume size. This option cannot be used while updating an existing
  1642.         archive. The only exception is the "y" command with the "-o"
  1643.         option. As such, the "y" command allows one to split an archive, to
  1644.         change the existing archive volume size, or to concatenate all the
  1645.         volumes into one volume.
  1646.  
  1647.         The "-v" option is unnecessary for non-update operations since the
  1648.         JAR archive header contains information about each volume created
  1649.         and its size. JAR will report an error when "-v" is used together
  1650.         with unsupported command.
  1651.  
  1652.         Thus while extracting a single file JAR will only prompt for the
  1653.         required volume(s). To list the archive contents JAR usually
  1654.         requires only the last volume (".j" default extension). In rare
  1655.         cases, a few last volumes are required as the archive header may
  1656.         not fit the last volume.
  1657.  
  1658.         JAR volumes are suffixed in following order: .j01, .j02, ... .j99,
  1659.         .100, .101 ... .990. The LAST VOLUME by default is suffixed .j and
  1660.         it must be used in the command line for future access to the
  1661.         archive. JAR supports up to 990 volumes.
  1662.  
  1663.         IMPORTANT: The archive name specified in the command line is used
  1664.         to name the LAST VOLUME. The other volumes are ALWAYS named with an
  1665.         extension starting with .j01 and so on. This behavior differs from
  1666.         that of the ARJ or RAR archivers. They use the command line archive
  1667.         name for the first volume. Subsequent volumes have "incremented"
  1668.         names. This is not so with JAR.
  1669.  
  1670.         When creating new volumes on a removable drive JAR pauses and
  1671.         checks that the diskette has been really changed. However, this
  1672.         check is limited to 3 retries for the same volume. This test can be
  1673.         inhibited with the "i" modifier. JAR does not do this check when
  1674.         accessing volumes for reading or testing.
  1675.  
  1676.         Example: JAR16 a a:archive -vi -va
  1677.  
  1678.         The "-v" switch will accept the abbreviations 360, 720, 1200, and
  1679.         1440. These will be translated to 362,000, 730,000, 1,213,000, and
  1680.         1,457,000 bytes, respectively. Please note that if the available
  1681.         disk space is less than the requested amount, JAR will prompt the
  1682.         user for permission to continue. You can use the "K" modifier as a
  1683.         shortcut for "000". For example, 100K means 100000. "K" does NOT
  1684.         mean 1024.
  1685.  
  1686.         The "-va" switch sets the disk space auto-detect option. JAR will
  1687.         check for the disk space available on the target drive and try to
  1688.         use all or most of it. This option is aimed at diskette usage.
  1689.         Please note that this switch option detects free disk space. It
  1690.         does NOT detect formatted disk space. If the space available is
  1691.         less than 10,000 bytes, JAR will prompt the user for permission to
  1692.         continue.
  1693.  
  1694.         Examples: JAR16 a a:backup -va
  1695.                   JAR16 a backup -v360
  1696.  
  1697.         The "v" modifier turns on the next volume beep option. When you
  1698.         select this option, JAR will sound a beep prior to the next volume.
  1699.  
  1700.         The "r" modifier allows the reservation of disk space on the first
  1701.         volume. The number after the "r" specifies the space to reserve.
  1702.  
  1703.         Example: JAR16 a install -v360r50K
  1704.                  Make first volume 50000 bytes smaller than 360K.
  1705.  
  1706.         The switch modifier "s" can be used to make JAR execute one
  1707.         specified system command prior creation of new volume or make JAR
  1708.         pause for manual execution of system commands. This is useful for
  1709.         purging target diskettes before JAR writes to them.
  1710.  
  1711.         Note that JAR always checks the first diskette for the presence of
  1712.         the JAR archive before executing the "-vs" argument. As a result
  1713.         users who archive directly to unformatted diskettes using
  1714.         -vs"FORMAT a:" will encounter a disk error on the first diskette.
  1715.         To avoid this error, the user should use a formatted diskette for
  1716.         the first diskette. Subsequent diskettes may be unformatted.
  1717.  
  1718.         The switch modifier "z" is identical to the "s" modifier except
  1719.         that the system command is not echoed to the screen.
  1720.  
  1721.         Optionally, after the "s" modifier, you can specify a system
  1722.         command or batch filename. JAR will automatically execute the
  1723.         command or batch file before creating each new volume. If the
  1724.         command has embedded blanks, then the switch option must be
  1725.         surrounded by double quotes. The system command is executed before
  1726.         JAR executes the auto-detect space option.
  1727.  
  1728.         Examples: JAR16 a A:backup -vas
  1729.                   JAR16 a A:backup -vvas
  1730.                   JAR16 a A:backup -v360s
  1731.                   JAR16 a A:backup -vv360s
  1732.                   JAR16 a A:backup -vaspurge.bat
  1733.                   JAR16 a A:backup -v360sdelete.bat
  1734.                   JAR16 a A:backup -vas"FORMAT A:"
  1735.                   JAR16 a A:backup -vas"DIR C:\"
  1736.  
  1737.         The "-v" switch accepts its modifiers in any order. The "s" and "z"
  1738.         modifiers must be last because any succeeding text is considered
  1739.         the system command to execute.
  1740.  
  1741.         You can suppress the next volume prompt with the "-y" or the "jyv"
  1742.         option. However, when using the "-y" option with multiple volume
  1743.         JAR archives on removable media drives, JAR will ALWAYS PROMPT for
  1744.         the next diskette. The "-jyv" option WILL ALWAYS suppress the
  1745.         prompt even for removable media.
  1746.  
  1747.         During JAR operation in non-update commands, JAR will not abort
  1748.         when it cannot open the correct sequential JAR volume archive. It
  1749.         will report the open error and proceed to the prompt. At this point
  1750.         it is possible to swap diskettes to put the correct volume in
  1751.         place. This feature is disabled if the "next volume" prompt has
  1752.         been disabled.
  1753.  
  1754.         While creating a new volume, if JAR detects an existing file
  1755.         with the same volume name, it asks permission to overwrite and
  1756.         optionally prompts for a new filename. With the "-y" or "-jyo"
  1757.         options, JAR overwrites this file without asking.
  1758.  
  1759.  
  1760.       w: assign Work directory
  1761.  
  1762.         This switch option is HIGHLY recommended if you are archiving
  1763.         directly to diskettes.
  1764.  
  1765.         By default, JAR builds a new JAR archive file in the same directory
  1766.         as the old archive file. By specifying the "-w" switch, you can
  1767.         specify the working directory where the temporary archive file will
  1768.         be built. After the temporary archive file is built, it is copied
  1769.         over the original archive and deleted.
  1770.  
  1771.         Normally JAR requires enough disk space for the original archive
  1772.         and the new temporary archive. Specifying the "-w" switch allows
  1773.         you to move some of that disk space requirement to another
  1774.         directory.
  1775.  
  1776.         When using the "-w" switch while archiving to multiple volumes, JAR
  1777.         will check the available disk space in the work directory. If there
  1778.         is not enough space, JAR will prompt for permission to continue.
  1779.         This prompt can be suppressed with the "-y" and "-jyk" switches.
  1780.  
  1781.         If the copy of the temporary archive on top of the original archive
  1782.         aborts, you must do the copy manually. JAR will not delete the
  1783.         temporary archive in this error situation.
  1784.  
  1785.         Example: JAR16 a -we:\temp\ archive *.c
  1786.  
  1787.         For speed reasons, you should always use the "-w" option when
  1788.         creating or modifying archives on diskettes. You should specify a
  1789.         work directory on your hard disk or a sufficiently sized RAMDISK.
  1790.  
  1791.         Example: JAR16 a -we:\ b:archive *.c
  1792.  
  1793.  
  1794.       x: Exclude filenames
  1795.  
  1796.         This switch is used to exclude filenames or wildnames from the list
  1797.         of filenames to be processed.
  1798.  
  1799.         Example: JAR16 a archive soft\* -r -x*.exe -x*.obj -xtest
  1800.  
  1801.         This example will archive all files in the "soft" directory and
  1802.         subdirectories except for any files named "test" or ending in
  1803.         ".exe" and ".obj".
  1804.  
  1805.         You can also specify an exclude file list by preceding the filename
  1806.         with the list character "!". The exclude file list must contain a
  1807.         list of filenames/wildnames specified one per line.
  1808.  
  1809.         Example: JAR16 a archive soft\* -r -x!exclude.lst
  1810.  
  1811.         You can specify a pathname to exclude as in:
  1812.  
  1813.         JAR16 a archive \dir\*.* -r -x\dir\*.*
  1814.  
  1815.         In the above example, JAR will exclude all files in \dir but not
  1816.         the subdirectories in \dir.
  1817.  
  1818.         The "-x" option also allows you to exclude an entire path including
  1819.         subdirectories from being selected for processing.
  1820.  
  1821.         Syntax: JAR16 a archive C:\*.* -xC:\TEMP\
  1822.  
  1823.         The "\" after C:\TEMP indicates to JAR that everything below
  1824.         C:\TEMP\ is to be excluded.
  1825.  
  1826.         Note that the exclude directory option requires that the directory
  1827.         be specified in the same relative path that the selected files use.
  1828.  
  1829.         Example:
  1830.         JAR16 a archive \temp\*.* -x\temp\firstdir    is correct usage
  1831.         JAR16 a archive \temp\*.* -xC:\temp\firstdir  is NOT correct because
  1832.                                                       of the C:
  1833.  
  1834.         The "-x" switch also works for non-update commands like "e" and
  1835.         "l".
  1836.  
  1837.         Examples: JAR16 e archive -x*.exe
  1838.                   Extract all files except *.exe files
  1839.  
  1840.                   JAR16 l archive -x*.exe -x*.obj
  1841.                   List all files except *.exe and *.obj
  1842.  
  1843.                   JAR16 e archive \ -xdir\*.c
  1844.                   Extract all files except *.c in directory "dir"
  1845.  
  1846.         The "-x" switch with "lc" and "dc" allows the exclusion of chapter
  1847.         ranges:
  1848.  
  1849.         JAR16 lc archive -x1-50
  1850.         List all chapters except first 50.
  1851.  
  1852.  
  1853.       y: assume Yes on all queries
  1854.  
  1855.         Use this switch for batch type uses of JAR. This switch disables
  1856.         most of the normal user queries during JAR execution. Use this
  1857.         switch to suppress overwrite queries in the "e" and "x" commands,
  1858.         to suppress the make new directory query in the "e" and "x"
  1859.         commands, to suppress the new filename prompt when an open file
  1860.         operation fails in the "e" and "x" commands and to suppress the
  1861.         next volume pause using the "-v" option to create volumes on the
  1862.         hard disk.
  1863.  
  1864.         The "-y" switch will NOT suppress the "-v" next volume prompt when
  1865.         the archive is located on a drive with removable media such as a
  1866.         diskette drive.
  1867.  
  1868.         Use this option with due caution, especially during extraction as
  1869.         this sets JAR to overwrite files. NOTE: JAR does not overwrite
  1870.         readonly files unless the "-ha" option is used.
  1871.  
  1872.         As an alternative, you can use the "-jy" option that lets you
  1873.         suppress individual types of user queries.
  1874.  
  1875.  
  1876.       z: supply file for archive comment
  1877.  
  1878.         The "-z" switch has been provided to facilitate batch commenting of
  1879.         JAR archives with the "c" command. When the "-z" option has been
  1880.         specified with or without a comment file, JAR will only process the
  1881.         archive header comment.
  1882.  
  1883.         A comment file containing only a single blank can be used to erase
  1884.         comments from JAR archives.
  1885.  
  1886.         Syntax: JAR16 c archive -z
  1887.                 JAR16 c archive -zcomment.txt
  1888.                 JAR16 a archive -zcomment.txt
  1889.  
  1890.         Another method to erase the comment is to specify the predefined
  1891.         "NUL" filename:
  1892.  
  1893.                 JAR16 c all -zNUL
  1894.  
  1895.         The "-z" option also allows one to dump the JAR archive header
  1896.         comment to a file. This will extract only the main archive comment
  1897.         and not the individual file comments.
  1898.  
  1899.         Syntax: JAR16 e archive "" -zcomment.txt    dumps only the comment
  1900.                 JAR16 x archive -zcomment.txt       dumps comment and files
  1901.  
  1902.  
  1903.       jb: select chapter or chapter range
  1904.  
  1905.         Syntax: -jb10        Selects chapter 10
  1906.                  -jb10-      Selects all chapters from 10 and above
  1907.                  -jb-10      Selects chapters from 1 to 10
  1908.                  -jb10-20    Selects chapters from 10 to 20
  1909.                  -jb1-       Selects all chapters
  1910.                  -jb"-"      Also selects all chapters
  1911.  
  1912.         For listing commands ("v", "l", "ls"), this option specifies the
  1913.         file chapter range to list.
  1914.  
  1915.         Examples: JAR16 l archive -jb10
  1916.                   Lists chapter 10
  1917.  
  1918.                   JAR16 l archive -jb1-
  1919.                   Lists all files in all chapters
  1920.  
  1921.                   JAR16 l archive
  1922.                   Lists LAST chapter
  1923.  
  1924.         For the comment command ("c"), this option specifies the range
  1925.         of chapters to comment or files in the chapter range to comment.
  1926.  
  1927.         Examples: JAR16 c archive -hz -jb1-10
  1928.                   Comment a few chapters
  1929.  
  1930.                   JAR16 c archive -jb1-10
  1931.                   Comments all files in chapters from 1 to 10
  1932.  
  1933.                   JAR16 c archive -hz"Ansi comment".txt
  1934.                   Comments last chapter from archive
  1935.  
  1936.         Commenting will fail if the affected chapter is locked.
  1937.  
  1938.         For extract commands ("e", "x"), this option specifies the chapter
  1939.         to extract.
  1940.  
  1941.         Examples: JAR16 x archive -jb5 -oc:\dest
  1942.                   Extracts whole chapter 5 into "c:\dest"
  1943.  
  1944.                   JAR16 x archive *.c
  1945.                   Extracts selected files from LAST chapter
  1946.  
  1947.         JAR can also extract one chapter and subsequent changes to it in
  1948.         selected chapter range.
  1949.  
  1950.         Example: JAR16 x archive -jb5-10 text.txt
  1951.                  Will extract the full chapter 5 and ONLY the changed
  1952.                  "text.txt" versions in chapters from 6 to 10. JAR uses the
  1953.                  corresponding chapter number in destination path in the
  1954.                  form "(5)","(6)"...
  1955.  
  1956.         See also the "e" command for more details.
  1957.  
  1958.         If selected operation affects few chapters at once then JAR shows
  1959.         each file lifespan range in the format "<from-to>".
  1960.  
  1961.         The switch "-jb" can not be used with other commands.
  1962.  
  1963.         With update commands "a", "f", "m", "u", "d" you can access only
  1964.         the LAST chapter. You can delete from a few chapters at once using
  1965.         "da" or "dc" commands.
  1966.  
  1967.  
  1968.       jf: store Full matched path
  1969.  
  1970.         JAR uses two methods to store the scanned file path within an
  1971.         archive. If the "-jf" option is ON then the full scanned file path
  1972.         is stored. Only the drive letter and root slash is removed.
  1973.  
  1974.         If the "-jf" option is OFF then the RELATIVE scanned file path with
  1975.         respect to the wildcard is stored.
  1976.  
  1977.         Examples:
  1978.         JAR16 a all c:\dir1\dir2\a.txt -jf
  1979.         file will be stored within archive as "dir1\dir2\a.txt"
  1980.  
  1981.         JAR16 a all c:\dir1\dir2\a.txt -jf-
  1982.         file will be stored within archive as "a.txt"
  1983.  
  1984.         JAR does not support storing an archive path which contains ".\"
  1985.         and "..\".  Only the path back to the ".\" or "..\" is stored (-jf
  1986.         is ON).
  1987.  
  1988.         Examples:
  1989.         JAR16 a all c:\dir1\..\dir2\a.txt -jf
  1990.         file will be stored within archive as "dir2\a.txt"
  1991.  
  1992.         JAR16 a all c:\dir1\..\dir2\a.txt -jf-
  1993.         file will be stored within archive as "a.txt"
  1994.  
  1995.         This option affects only the commands that scan files ("a", "ac",
  1996.         "u", "f", "m"). The default value for the "-jf" option may be
  1997.         changed within the configuration file. See the "FullPath" keyword
  1998.         for additional information.
  1999.  
  2000.  
  2001.       jg: specify new password
  2002.  
  2003.         This option with the "y" command can be used to remove or set or
  2004.         change the archive password.
  2005.  
  2006.         JAR16 y archive -goldpassword -jgnewpassword
  2007.         Changes archive password
  2008.  
  2009.         JAR16 y archive -gpassword -jg
  2010.         Removes archive password
  2011.  
  2012.         JAR16 y archive -jgpassword -hg1
  2013.         Sets archive password (GOST encryption method)
  2014.  
  2015.         With "-jg?" JAR will prompt for new password.
  2016.  
  2017.         Example: JAR32 y archive -jg? -v20k -o"Split and garbled"
  2018.                  splits and garbles archive into new "Split and garbled.j"
  2019.                  archive
  2020.  
  2021.         NOTE: After the password is changed JAR always tests the temporary
  2022.         archive before overwriting the original archive.
  2023.  
  2024.  
  2025.       jl: Lock archive
  2026.  
  2027.         This option sets a global archive flag for update operations. An
  2028.         archive with this flag set does not allow any archive
  2029.         modifications. There is no way to clear this "Lock" flag. You can
  2030.         only decompress or list files from a locked archive.
  2031.  
  2032.         Example: JAR16 y archive -jl
  2033.                  Lock existing archive
  2034.  
  2035.  
  2036.       jl1: Lock existing chapters
  2037.  
  2038.         This option locks all existing chapters. Any update operation that
  2039.         attempts to modify locked chapters, files in locked chapters, or
  2040.         their comments will fail. There is no way to "unlock" the chapter.
  2041.         You can only decompress and list this chapter.
  2042.  
  2043.         Unlike the "-jl" option, new chapters may be added to the archive
  2044.         and they will not be locked.
  2045.  
  2046.         Example: JAR16 ac archive c:\* -jl1
  2047.                  Add new chapter and lock all chapters
  2048.  
  2049.  
  2050.       jl2: make auto-Lockable archive
  2051.  
  2052.         This option sets the global archive flag "auto-lock".  Now after
  2053.         each "ac" command, JAR immediately locks the newly created chapter.
  2054.         So you can only list files, extract files or add new chapters. No
  2055.         other modifications are allowed.
  2056.  
  2057.         Example: JAR16 y archive -jl2
  2058.                  Makes existing archive "auto-lockable"
  2059.  
  2060.         There is no way to clear "auto-lock" flag.
  2061.  
  2062.  
  2063.       jr: Recover broken archive files
  2064.  
  2065.         This option is available only in the Win32 JAR version.
  2066.  
  2067.         This switch is used to access files in an archive corrupted either
  2068.         with bad data or missing data. JAR will continue processing despite
  2069.         these errors.
  2070.  
  2071.         NOTE: JAR does not scan the whole archive during extraction as it
  2072.         knows the exact location of each compressed file. So JAR can "skip
  2073.         around" the damaged files if you exclude them from the requested
  2074.         files set.
  2075.  
  2076.         This switch also will allow the extraction of files with CRC or Bad
  2077.         file data errors. Normally, JAR will delete these extracted files.
  2078.  
  2079.         Example:  JAR32 e archive -jr
  2080.  
  2081.         With this option JAR will NOT check that the supplied volume is
  2082.         correct.  Substituting another volume is one possible workaround in
  2083.         the case of a lost volume.
  2084.  
  2085.  
  2086.       js: Select chapter creation mode
  2087.  
  2088.         Each file in archive has a chapter lifespan range. When a file is
  2089.         backed up using the "ac" command and has not changed since the last
  2090.         chapter in archive, only the lifespan range is changed. A copy of
  2091.         the file is NOT added to the archive since a copy already exists in
  2092.         the archive. If the backed up file is different from the previous
  2093.         version, then that file is added to the archive with an appropriate
  2094.         chapter range.
  2095.  
  2096.         The "-js" option selects method used to detect changed (different)
  2097.         files.
  2098.  
  2099.         If "-js0" is set, then JAR considers a file different if its size
  2100.         or modification date/time or creation date/time do not equal the
  2101.         corresponding values of the file stored within the archive in the
  2102.         last chapter.
  2103.  
  2104.         If "-js1" is specified JAR works like "-js0" but IGNORES a changed
  2105.         creation time. So the file may have different creation date/time
  2106.         but still will be considered as the same as the file in archive.
  2107.         This option is useful when working with DOS tools. DOS programs do
  2108.         not know about file creation time and so do not store/restore it
  2109.         properly (e.g., DOS archivers). JAR for DOS assumes the scanned
  2110.         file creation time is equal to the file modification time.  So the
  2111.         "-js1" option is also useful when adding new chapters into the same
  2112.         archive with both JAR for Win32 and JAR for DOS.
  2113.  
  2114.         The "-js1" option is default.
  2115.  
  2116.         With "-js0" or "-js1" JAR does NOT consider a file different if the
  2117.         file attributes (read only/system/hidden/archive) are the only file
  2118.         properties changed.
  2119.  
  2120.         With "-js0" or "-js1" JAR NEVER adds copy of a directory. Instead,
  2121.         JAR modifies the directory's chapter lifespan range.
  2122.  
  2123.         You can also specify the "-js-" option.  Then JAR will assume ALL
  2124.         files and directories are different in comparison with the last
  2125.         archive chapter. This causes JAR to work slower as ALL files must
  2126.         be compressed again.
  2127.  
  2128.         NOTE: JAR uses a special compression method that compresses only
  2129.         the difference between different file versions in subsequent
  2130.         chapters. This produces a major compression improvement for a
  2131.         multiple-chapter archive. Currently JAR does not use this
  2132.         compression method if the file size is more than about 500 Kbytes.
  2133.  
  2134.         The "-js" options may be used only with the "ac" command.  During
  2135.         this command JAR reports all unchanged files as "marked". This
  2136.         message may be turned off using a configuration file setting. See
  2137.         the "HideMarkedFiles" keyword.
  2138.  
  2139.         See the "ac" command for other details.
  2140.  
  2141.  
  2142.       jt: Test temporary archive
  2143.  
  2144.         The "-jt" switch can be used to set JAR to execute an archive
  2145.         integrity check on an intermediate temporary archive before
  2146.         overwriting any pre-existing original archive. If any error occurs,
  2147.         JAR will not overwrite the original archive.
  2148.  
  2149.         With the "-w" option JAR also will verify that the temporary
  2150.         archive is successfully copied.
  2151.  
  2152.         Example:  JAR16 m archive *.c -jt
  2153.  
  2154.  
  2155.       ju0: sort files by name during listing
  2156.  
  2157.         This option sorts files with the "l", "ls" and "v" commands. This
  2158.         option is set by default. To prevent JAR from sorting, use the
  2159.         "-ju-" option. This causes JAR to work a bit faster.
  2160.  
  2161.         Example: JAR16 ls archive -ju0
  2162.  
  2163.  
  2164.       ju1: sort files by extension during listing
  2165.  
  2166.         This is like "-ju0" but it first sorts files by extension, then by
  2167.         name.
  2168.  
  2169.         Example: JAR16 ls archive -ju1
  2170.  
  2171.  
  2172.       jx: hide archive contents
  2173.  
  2174.         Together with any update command this option sets the "HIDDEN"
  2175.         archive flag. When this flag is ON, JAR asks for the archive access
  2176.         password for ALL operations.
  2177.  
  2178.         By default (HIDDEN flag is OFF) JAR asks for the archive password
  2179.         only when it is necessary. This means that the password is NOT
  2180.         asked for when using list commands and some "y" and "c" commands.
  2181.         The "-jx" option specifies JAR to ask for the password before any
  2182.         operation with the archive.
  2183.  
  2184.         The option is ignored for archives that are not protected/encrypted.
  2185.  
  2186.         NOTE: This option only enables an internal JAR check, it does NOT
  2187.               encrypt the JAR archive header. If you need a more secure
  2188.               method for hiding archive header information then you need to
  2189.               compress and encrypt this archive into another archive.
  2190.  
  2191.         NOTE: Encryption is not available in export JAR version.
  2192.  
  2193.         Example: JAR16 y archive -jx
  2194.                  If "archive.j" is protected then this command "hides" archive
  2195.                  contents
  2196.                  JAR16 y archive -gpassword -jx-
  2197.                  Now archive contents can be listed without specifying
  2198.                  password
  2199.  
  2200.  
  2201.       jy: suppress queries assuming Yes
  2202.  
  2203.         This switch is used to suppress individual JAR user prompts.
  2204.  
  2205.         Syntax: JAR16 e archive -jy<flags>
  2206.  
  2207.         where <flags> is one or more of the following characters: c, d, k,
  2208.         n, o, t, v. For each flag selected, JAR will act as if you had
  2209.         answered YES to the suppressed question.
  2210.  
  2211.         C - skip create directory query
  2212.         D - skip delete files query
  2213.         K - skip disk space availability query
  2214.         N - skip new filename prompt
  2215.         O - skip overwriting existing file query
  2216.         T - skip overwriting directory attributes query
  2217.         V - skip ok to proceed to next volume query
  2218.  
  2219.         Example:  JAR16 x volume -v -jyco
  2220.                   Suppress create, and overwrite prompts.
  2221.  
  2222.         JAR will allow you to specify individual "jy" options in separate
  2223.         switch strings as in "-jyo -jyc". You may inhibit a switch as in
  2224.         "-jyc-".
  2225.  
  2226.  
  2227.       jz: supply file for file comment
  2228.  
  2229.         The "-jz" switch has been provided to facilitate batch commenting
  2230.         of one or more files within an JAR archive. Only one comment file
  2231.         can be specified. That file will be used to comment each file
  2232.         specified on the command line.
  2233.  
  2234.         A comment file containing only a single blank can be used to erase
  2235.         comments from JAR archives. Another method to erase the comment is
  2236.         to specify the predefined filename "NUL".
  2237.  
  2238.         Example: JAR16 c archive -jzNUL
  2239.  
  2240.  
  2241.       ha: ignore readonly Attribute
  2242.  
  2243.         The "-ha" switch sets JAR to reset the attributes of a file to be
  2244.         overwritten or a file to be deleted.  This allows the overwrite or
  2245.         delete operation to proceed.
  2246.  
  2247.         Examples: JAR16 e archive -ha
  2248.                   JAR16 m archive -ha dir\*.*
  2249.  
  2250.  
  2251.       hb: select files by attributes
  2252.  
  2253.         Option requires parameter in the form:
  2254.  
  2255.         [<bits which must be equal 0>'0'][<bits which must be equal 1>'1']
  2256.  
  2257.         Bits encoded as:
  2258.         a - archive
  2259.         d - directory
  2260.         h - hidden
  2261.         r - readonly
  2262.         s - system
  2263.  
  2264.         To emulate the directory handling of archivers such as ARJ, you
  2265.         should use the "-hbd0" option.  Normally, JAR will scan and add all
  2266.         directories that are encountered as files are searched via the
  2267.         wildcards.  With a command like "JAR a test c:\*.doc -r", JAR by
  2268.         will search the C drive for all .DOC files and also add ALL
  2269.         directories found on the C drive unless the option "-hbd0" is
  2270.         specified.
  2271.  
  2272.         Examples: JAR16 a archive c:\* -r -hba1 -b0
  2273.                   Add all files with archive bit set and then reset this bit
  2274.                   JAR16 a archive *.* -r -hbd0
  2275.                   Do not add directories (allows a bit smaller archives)
  2276.                   JAR16 e archive -hbsh0
  2277.                   Extract all files except "system" or "hidden"
  2278.                   JAR16 a archive *.* -hbd0r1
  2279.                   Add readonly files (but NOT directories)
  2280.  
  2281.  
  2282.       he: skip test of security Envelope
  2283.  
  2284.         The "-he" switch sets JAR to skip the verification step when
  2285.         processing a JAR-SECURED archive. If a JAR archive has a damaged
  2286.         JAR-SECURITY envelope, you will have to use the "-he" option to
  2287.         extract the archive.
  2288.  
  2289.  
  2290.       hf: match long and short Filenames
  2291.  
  2292.         This option affects only the Win32 JAR version and is only usable
  2293.         with commands that scan files.
  2294.  
  2295.         By default JAR matches wildcards using only long filenames. This
  2296.         option will match both short and long scanned filenames. This dual
  2297.         matching behavior is the default for the DIR command in Windows 95.
  2298.  
  2299.         Suppose there is a file "New document.doc" with the short name
  2300.         "NEWDOC~1.DOC". Then:
  2301.  
  2302.         JAR32 a archive NEWDOC~1.doc
  2303.         Will report "No such files"
  2304.  
  2305.         JAR32 a archive -hf NEWDOC~1.doc
  2306.         Will add file "New document.doc" to archive as its short name is
  2307.         matched by wildcard
  2308.  
  2309.         Example: JAR32 a archive *~* -x*2* -hf
  2310.                  Add all files in current directory with a short or long
  2311.                  filename that contains "~" but not "2"
  2312.  
  2313.  
  2314.       hf1: use only short Filenames
  2315.  
  2316.         This option affects only the Win32 JAR version and is only usable
  2317.         with commands that scan files.
  2318.  
  2319.         This switch disables long filenames usage. The Win32 JAR version
  2320.         will work like the DOS version during file scanning.
  2321.  
  2322.         Example: JAR32 a archive *~* -x*2* -hf1
  2323.                  Add all files in current directory with a short filename that
  2324.                  contains "~" but not "2"
  2325.  
  2326.  
  2327.       hf2: convert long Filenames into short
  2328.  
  2329.         This option sets JAR to do long filename translation during extract
  2330.         and list commands. It is useful when extracting files in DOS that
  2331.         have been previously compressed by the Win32 JAR version.
  2332.  
  2333.         After reading the archive header JAR converts all long filenames
  2334.         into a shortened form.  The process is similar to that done by
  2335.         Windows 95 to generate short filenames.
  2336.  
  2337.         During this conversion JAR substitutes characters that are not
  2338.         supported in DOS filenames using underscore "_".  Then the filename
  2339.         is trimmed to 8.3 form. If there is another file with the same
  2340.         shortname, "~1","~2",... is appended until the generated shortname
  2341.         is unique.
  2342.  
  2343.         JAR guarantee that files from different directories will remain in
  2344.         different directories after name conversion.
  2345.  
  2346.         Suppose archive contains 3 files:
  2347.         "long name\Document1.doc"
  2348.         "long name2\Document2.doc"
  2349.         "long name2\Document3.doc"
  2350.  
  2351.         After conversion filenames will be:
  2352.         "LONG_NAM\DOCUME~1.DOC"
  2353.         "LONG_N~2\DOCUME~2.DOC"
  2354.         "LONG_N~2\DOCUME~3.DOC" or so.
  2355.  
  2356.         The exact generated short name also depends on the operating system
  2357.         in which the file is stored. This is because the Win32 JAR version
  2358.         always stores the SHORT filename (if available) along with the LONG
  2359.         filename as a HINT for future filename translations. This HINT
  2360.         takes precedence over the JAR filename trimming algorithm.
  2361.  
  2362.         Before extraction you can review conversion results using the "v"
  2363.         command and the "-hf2" option which will show both the original
  2364.         long filename with the shortened name. The "l" and "ls" commands
  2365.         with "-hf2" will show only the shortened filenames. Afterwards, you
  2366.         can extract the files using:
  2367.  
  2368.         JAR16 x archive -hf2
  2369.  
  2370.         The "-hf2" option does not work with update commands.
  2371.  
  2372.  
  2373.       hf3: convert long Filenames into short (second method)
  2374.  
  2375.         This switch works exactly like "-hf2" but also converts those
  2376.         filenames that contain "international" characters with hex code
  2377.         greater than or equal to 0x80.  These characters are substituted
  2378.         with the underscore "_".
  2379.  
  2380.         This option helps to solve problems when extracting filenames
  2381.         encoded using a different OEM code page.
  2382.  
  2383.  
  2384.       hg: access protection method
  2385.  
  2386.         This option accepts argument - method name. Currently, JAR can
  2387.         protect the information in an archive from unauthorized access by
  2388.         using either of two methods:
  2389.  
  2390.         -hg"Authenticate" or
  2391.         -hg"GOST v1.01"
  2392.  
  2393.         The first method establishes archive password WITHOUT actual
  2394.         encryption of its contents. The second method uses GOST 28147-89
  2395.         encryption in CBC mode to encrypt archive files (but NOT archive
  2396.         header which contains comments and filename information).
  2397.  
  2398.         The "Authenticate" method sets JAR to make a password check before
  2399.         processing the archive. If the password is incorrect then JAR
  2400.         aborts. Thus the "Authenticate" method is very fast but the data in
  2401.         the archive is NOT encrypted.
  2402.  
  2403.         The "method" also can be chosen using shorthand notation "-hg0" for
  2404.         "Authenticate" and "-hg1" for "GOST v1.01" encryption.
  2405.  
  2406.         NOTE: Encryption is not available in export JAR version.
  2407.  
  2408.         Any time you are creating a new archive and using the "-g" option
  2409.         (specify password) you can select the protection method using the
  2410.         "-hg" option. Otherwise, JAR will use the "DefaultAccessProtection"
  2411.         setting in the CFG file (see description for more details). The
  2412.         default CFG file specifies to use "Authenticate" if no "-hg" option
  2413.         is specified.
  2414.  
  2415.         You can also specify the method when protecting an unprotected
  2416.         archive with the "y" command:
  2417.  
  2418.         JAR16 y archive -jgpassword -hg1
  2419.  
  2420.         If you need to change the protection method then you must first
  2421.         remove the archive password:
  2422.  
  2423.         JAR16 y archive -gpassword -jg
  2424.  
  2425.         and then protect the archive as in the first example.
  2426.  
  2427.         Because these two protection methods give significantly different
  2428.         security levels, JAR prints different messages when accessing
  2429.         protected archives. JAR prints that an archive is "PROTECTED" when
  2430.         using the "Authenticate" method and "ENCRYPTED" when using the
  2431.         "GOST" method.
  2432.  
  2433.         To access protected archives, you need to specify the password for
  2434.         most operations. The "-jx" option establishes a password check for
  2435.         ALL operations.
  2436.  
  2437.         See "-g", "-jg", "-jx" options for more details.
  2438.  
  2439.         NOTE: The first JAR 1.01 BETA used the now obsolete
  2440.         "Authentication" method to protect an archive.  Please read
  2441.         WHATSNEW.DOC for details.
  2442.  
  2443.  
  2444.       hk: add recovery records
  2445.  
  2446.         This switch sets the global archive flag that specifies adding of
  2447.         data recovery records to the archive after each update.
  2448.  
  2449.         These records allow the repair of a slightly damaged archive. See
  2450.         the "-hx" option on how to use previously stored recovery records.
  2451.  
  2452.         This option increases the size of a medium size archive about 2
  2453.         percent with a minimum of a 2 Kbyte increase. Large files (more
  2454.         than 3 Mbytes) will expand about 0.5 percent in size. This
  2455.         additional space is used to store tables which will allow the
  2456.         repair of archive damage.
  2457.  
  2458.         With a very high probability JAR is able to recover about 28 Kbytes
  2459.         of damaged archive section(s) on a 1440K volume.
  2460.  
  2461.         If your archive is damaged and recovery records are present then
  2462.         JAR will report an error unless the "-hx" option is specified. This
  2463.         option lets JAR recover damaged archive sections "on the fly".
  2464.  
  2465.         The global archive "add recovery records" flag may be turned off on
  2466.         any update using the option "-hk-".
  2467.  
  2468.         Example: JAR16 y archive -hk
  2469.                  Makes archive with "recovery records"
  2470.  
  2471.                  JAR16 y archive -hk-
  2472.                  Makes archive without "recovery records""
  2473.  
  2474.  
  2475.       hl: warn of non-matching wildcards
  2476.  
  2477.         With "-hl" switch JAR reports non-matching wildcards/filespecs
  2478.         during an "add" type command ("a", "f", "m", "u", "ac"). A
  2479.         wildcard/filespec is considered "non-matching" if it does NOT match
  2480.         any files (NOT including directories).
  2481.  
  2482.         JAR will subsequently return a non-zero DOS errorlevel when a
  2483.         non-matching wildcard or filespec has been specified.
  2484.  
  2485.         Example: JAR16 a a:backup !listfile -va -hl -hbd0
  2486.  
  2487.  
  2488.       hm: On or after date YYMMDDHHMMSS
  2489.  
  2490.         The switch "-hm" by itself will select files modified today. If
  2491.         "-hm" is followed by a date and optionally a time, JAR will select
  2492.         files modified on or after that date-time.
  2493.  
  2494.         Example: JAR16 a test -hm9601021700
  2495.                  means select files modified on or after Jan 2, 1996, 5:00 PM.
  2496.  
  2497.         Years less than "80" will be considered as 21st century years.
  2498.  
  2499.         There is no option for using other date-time formats.
  2500.  
  2501.         The switch "-hmb" selects files modified before today. If "-hmb" is
  2502.         followed by a date and optionally a time, JAR will select files
  2503.         modified before that date-time.
  2504.  
  2505.         JAR accepts the use of "-hm" and "-hmb" options simultaneously to
  2506.         specify a range of selected dates. This is useful for selecting
  2507.         files on a specific date.
  2508.  
  2509.         Example: JAR16 a archive *.* -hm910101 -hmb910102
  2510.  
  2511.         The "-hm" option and/or the "-hmb" option will default to today's
  2512.         date at midnight (0000 hrs) when specified without dates.
  2513.  
  2514.         The "-hmd" switch sets JAR to select files no older than the
  2515.         specified number of days.  The days are calculated from midnight.
  2516.  
  2517.         Examples: JAR16 a archive -hmd0    select files modified today
  2518.                   JAR16 a archive -hmd1    select files modified yesterday
  2519.                                            and today
  2520.  
  2521.         "-hmd" and "-hmb" can be combined too.
  2522.  
  2523.  
  2524.       ho: Output directory translation
  2525.  
  2526.         For add type operations the "-ho" option allows one to specify the
  2527.         file destination directory within an archive depending on the file
  2528.         path on disk.
  2529.  
  2530.         This option accepts an argument in the form:
  2531.  
  2532.         -ho<archive path>:<disk path>
  2533.  
  2534.         During add type operations, all files with the specified <disk
  2535.         path> will be preceded with the corresponding <archive path> when
  2536.         storing within an archive.
  2537.  
  2538.         JAR allows one to specify a set of translations. In such a case,
  2539.         the longest match is chosen.  The option "-ho-" disables all
  2540.         translations.
  2541.  
  2542.         Examples: JAR16 a archive c:\* d:\* -hodrive\c:c:\ -hodrive\d:d:\
  2543.                   files from disk "c:" will be stored into "drive\c" and
  2544.                   files from disk "d:" will be stored into "drive\d"
  2545.  
  2546.                   JAR16 a archive src\* src\lib\* -holib:src\lib -hofiles:src
  2547.                   stores files from "src\lib" into "lib\" and other
  2548.                   files from "src\" into "files\"
  2549.  
  2550.         NOTE: The destination directory for a file also depends on the "-o"
  2551.         and "-jf" options. JAR compares the <disk path> letter by letter,
  2552.         so you must specify path in the same form.
  2553.  
  2554.         During extraction JAR does a backward translation (replaces
  2555.         specified archive directory with destination directory).
  2556.  
  2557.         Example: JAR16 x archive -hodrive\c:c:\ -hodrive\d:d:\
  2558.                  files from "drive\c" will be extracted to "c:\" and from
  2559.                  "drive\d" into "d:\". All other files extracted into current
  2560.                  directory.
  2561.  
  2562.         JAR does not support the storing of two files with the same path
  2563.         within an archive.  Also, JAR does not support storing drive
  2564.         letters within an archive.  The "-ho" option provides a workaround
  2565.         for backing up and restoring data from/to different drives or
  2566.         network servers using a single archive.
  2567.  
  2568.         Example:
  2569.         JAR16 a archive \\server\user\* c:\* -hod:\\server\user -hoc:c:
  2570.  
  2571.         The "-ho" option without arguments selects the built-in default
  2572.         translation.  The default option translates all drives "a:\",
  2573.         "b:\"... into archive directories "_a_\", "_b_\"....
  2574.  
  2575.  
  2576.       ht: Test new/updated files
  2577.  
  2578.         This switch tests all newly compressed data. The "-ht0" option
  2579.         tests data using the file's CRC32 value. The "-ht1" option tests
  2580.         data by COMPARING the actual file contents.
  2581.  
  2582.         Example: JAR16 a archive c:\* -r -ht1
  2583.                  Verifies all added files using comparison
  2584.  
  2585.         With the "-w" option JAR will verify that the temporary archive is
  2586.         successfully copied.
  2587.  
  2588.         When used with volume archive this option may cause JAR to re-read
  2589.         previous volumes.
  2590.  
  2591.         You can use "-jt" option to test the whole updated archive. See
  2592.         this option for details.
  2593.  
  2594.  
  2595.       hx: use recovery records
  2596.  
  2597.         Sets JAR to use previously stored records to recover slight archive
  2598.         damage. It may be used with any command.
  2599.  
  2600.         It is recommended that this option be used with an existing archive
  2601.         containing "recovery records" on update operations. JAR does not
  2602.         detect archive damage unless the "-hx" option is specified or the
  2603.         JAR decompression engine fails on damaged data.
  2604.  
  2605.         Updating a damaged archive with "recovery records" without the
  2606.         "-hx" option may result in JAR computing new recovery records using
  2607.         corrupted data.
  2608.  
  2609.         Examples: JAR16 e archive -hx
  2610.                   Extract data from archive using recovery records
  2611.  
  2612.                   JAR16 y archive -hx
  2613.                   Repair damaged archive using recovery records
  2614.  
  2615.  
  2616.       hy: add security envelope
  2617.  
  2618.         JAR adds a security envelope to a JAR archive. This option is only
  2619.         available in the registered JAR version.
  2620.  
  2621.         The JAR-SECURITY ENVELOPE feature provides a facility similar to
  2622.         other archivers. This feature disallows any type of modification,
  2623.         even commenting, to a JAR-SECURE sealed archive by JAR. Moreover,
  2624.         there are additional internal checks to determine if the JAR-SECURE
  2625.         sealed archive has been modified in any way. This feature is
  2626.         intended for use by software developers who distribute their
  2627.         software in archived format or for businesses that distribute data
  2628.         files. However, there can be no guarantee that this mechanism
  2629.         cannot be defeated.
  2630.  
  2631.         When processing a JAR-SECURED archive, JAR will display a message
  2632.         indicating that JAR is verifying the security envelope. If the
  2633.         envelope is damaged, a message will be displayed indicating so. If
  2634.         the envelope is intact, then the JAR-SECURITY signature of the user
  2635.         "sealing" the archive will be displayed.
  2636.  
  2637.  
  2638.       hz: comment chapters
  2639.  
  2640.         This switch is used to comment a chapter during an update
  2641.         operation. It also may be used to specify a comment file.
  2642.  
  2643.         Examples: JAR16 ac archive c:\* -hz
  2644.                   Add new chapter and prompt for the comment for it
  2645.  
  2646.                   JAR16 c archive -hzcomment.txt -jb1-10
  2647.                   Comment chapters from 1 to 10 using file comment.txt
  2648.  
  2649.                   JAR16 c archive -hznul -jb"-"
  2650.                   Clears all chapter comments
  2651.  
  2652.  
  2653.     CONFIGURATION FILE:
  2654.  
  2655.  
  2656.       JAR uses a configuration file to store global user settings. By
  2657.       default the configuration file is named "JAR.CFG" and must be placed
  2658.       into the same directory as the JAR16.EXE and JAR32.EXE directory.
  2659.  
  2660.       The environment variable JAR_CFG_FILE is used to specify an alternate
  2661.       JAR configuration file location.
  2662.  
  2663.       Example: SET JAR_CFG_FILE=c:\user\jar.cfg
  2664.  
  2665.       The JAR configuration file format is very similar to Windows *.INI
  2666.       files. It contains strings of three types:
  2667.  
  2668.       1. Comments.  This string must start with ";" character
  2669.  
  2670.       2. Keys with set values in the form:
  2671.          <Key name>=<value>
  2672.          Key name is case insensitive.
  2673.  
  2674.       3. Section separators in the form:
  2675.          '['<Section name>']'
  2676.          Section name is case insensitive.
  2677.  
  2678.       Example:
  2679.       [OS/2 settings]
  2680.       ColoredOutput=No
  2681.       ; black and white output
  2682.       SwapFileDirectory=h:\tmp
  2683.  
  2684.       The given example contains one line with the section name, two lines
  2685.       with keys, and one line with a comment.
  2686.  
  2687.       On startup JAR reads predefined key values from the configuration
  2688.       file and uses these values as global settings.
  2689.  
  2690.       Sections are used to keep setting variants in a single file. You can
  2691.       set the JAR_CFG_SECTION environment variable to a section name which
  2692.       will take precedence over default values.
  2693.  
  2694.       Example:
  2695.  
  2696.       SwapFileDirectory=c:\tmp
  2697.       [OS/2 settings]
  2698.       SwapFileDirectory=d:\tmp
  2699.       [Windows NT settings]
  2700.       SwapFileDirectory=e:\tmp
  2701.  
  2702.       If JAR_CFG_SECTION has the value "OS/2 settings" then the JAR swap
  2703.       file will be located on drive D. If JAR_CFG_SECTION has the value
  2704.       "Windows NT settings" then the JAR swap file will be located on drive
  2705.       E. Otherwise, it will be located on drive C.
  2706.  
  2707.       If JAR does not find a key in the configuration file then it uses
  2708.       built-in default values.
  2709.  
  2710.  
  2711.     CONFIGURATION FILE KEYWORDS:
  2712.  
  2713.  
  2714.       The right side of "=" describes default key value (used if it is not
  2715.       set within configuration file).
  2716.  
  2717.  
  2718.       ColoredOutput=No
  2719.  
  2720.         Possible values: Yes/No. Specifies the kind of JAR screen output.
  2721.         Note that in colored mode JAR always uses black color as
  2722.         background.
  2723.  
  2724.  
  2725.       SwapFileDirectory=
  2726.  
  2727.         JAR chooses the swap file valid directory in the following order:
  2728.         - from CFG file but not equal to ""
  2729.         - from TMP environment variable (DOS JAR version) or temporary
  2730.           directory (Win32 JAR version)
  2731.         - current directory
  2732.  
  2733.         JAR swap file usage depends on the total files in archive and on
  2734.         command type. JAR may need up to a 2 Mbytes swap file when updating
  2735.         an existing medium-size archive (with about 1,000 files).
  2736.  
  2737.         Example: SwapFileDirectory=c:\tmp
  2738.  
  2739.  
  2740.       FullPath=Yes
  2741.  
  2742.         Possible values: Yes/No. Specifies the "-jf" switch default for
  2743.         JAR. Users who want ARJ-like file path storing should set this key
  2744.         to "Yes". Users who want UC2-like file path storing should set this
  2745.         key to "No".
  2746.  
  2747.  
  2748.       DefaultAccessProtection=Authenticate
  2749.  
  2750.         Possible values: "Authenticate" or "GOST v1.01". Specifies default
  2751.         archive protection method. See "-hg" option for details.
  2752.  
  2753.  
  2754.       XmsLimit=1024
  2755.       EmsLimit=0
  2756.  
  2757.         These settings LIMIT MAXIMUM XMS and EMS usage (in kilobytes) by
  2758.         the program. These settings are used only by the DOS JAR version.
  2759.         You can set corresponding values to 0 so JAR will not use XMS/EMS
  2760.         at all.
  2761.  
  2762.         It is strongly recommended to let JAR use at least 1024 kilobytes
  2763.         of XMS for better performance. Recommended - 3072. JAR does not
  2764.         necessarily use all the specified memory; instead, it chooses an
  2765.         optimal value based upon need. The maximum practical value is 5120.
  2766.  
  2767.         JAR uses EMS for better compression. JAR conventional memory
  2768.         consumption also decreases by about 60 kilobytes when EMS is
  2769.         available. Optimal value - 4096. Maximum amount used by JAR -
  2770.         16384. When more EMS is available, a better compression rate can be
  2771.         achieved.
  2772.  
  2773.         IMPORTANT NOTE: See the CheckAvailableMemory keyword for memory
  2774.         usage details.
  2775.  
  2776.  
  2777.       CheckAvailableMemory=Yes
  2778.  
  2779.         Possible values: Yes/No. If this key value is set to "Yes" then JAR
  2780.         empirically tests available memory before the compression engine
  2781.         starts and sets internal memory consumption limits that should not
  2782.         result in a decrease in overall system performance.
  2783.  
  2784.         Multitasking operating systems like OS/2 or Windows 95 report
  2785.         available virtual memory instead of real "physical" memory. A large
  2786.         allocation of virtual memory amount may drastically slow down the
  2787.         OS or even hang it due to a lack of resources.
  2788.  
  2789.         JAR uses memory access timings to allocate only "safe" memory
  2790.         amounts.
  2791.  
  2792.         If you are an experienced user you may toggle this feature off.
  2793.         Then JAR will not test for available memory, but will use as much
  2794.         as it decides but no more than the set current limits (see
  2795.         XmsLimit, EmsLimit, 32MemoryLimit). JAR also starts faster when the
  2796.         "No" value is set.
  2797.  
  2798.         This setting is ignored by list and extraction JAR commands.
  2799.  
  2800.  
  2801.       32MemoryLimit=0
  2802.  
  2803.         Limits memory usage by the COMPRESSION ENGINE. This setting is used
  2804.         only by the Win32 JAR version. Recommended value 4096. Maximum
  2805.         which may be used - 10240 kilobytes.
  2806.  
  2807.         IMPORTANT NOTE: See the CheckAvailableMemory keyword for memory
  2808.         usage details.
  2809.  
  2810.  
  2811.       DOS InteractiveCriticalErrorHandler=Yes
  2812.  
  2813.         Possible values: Yes/No. The interactive handler asks "Abort,
  2814.         Retry?" on such hardware errors like "Drive not ready". For batch
  2815.         processing you can disable these prompts.
  2816.  
  2817.         This setting is used only by the DOS JAR version.
  2818.  
  2819.  
  2820.       ErrorsToStdout=No
  2821.  
  2822.  
  2823.         If "Yes" then reports errors to stdout instead of stderr. So you
  2824.         redirect error messages to a file using ">" or ">>" as well as all
  2825.         other JAR output.
  2826.  
  2827.  
  2828.       EmulateANSIComments=Yes
  2829.  
  2830.         Possible values: Yes/No. This option is used to disable the JAR
  2831.         ANSI comments emulation.
  2832.  
  2833.  
  2834.       OptionsForCommand A=
  2835.       OptionsForCommand AC=
  2836.       ...
  2837.  
  2838.         This group of keys is used to specify SEPARATE default options for
  2839.         ANY JAR command. The specified options are parsed before the
  2840.         command line is parsed.  So you always can overwrite this setting.
  2841.  
  2842.         Examples: OptionsForCommand L=-ju1
  2843.                   Now "l" command by default will sort files by extension
  2844.  
  2845.                   OptionsForCommand V=-ju- -r-
  2846.                   By default "v" command will not sort and recurse files
  2847.  
  2848.  
  2849.       HideMarkedFiles=Yes
  2850.  
  2851.         Possible values: Yes/No. This setting hides the "Marking file"
  2852.         message for "ac" command.
  2853.  
  2854.  
  2855.       DefaultColor=7
  2856.       ErrorColor=12
  2857.       SignalColor=15
  2858.       CommentColor=3
  2859.       HighlightColor=2
  2860.  
  2861.         Possible values 0-15. It is used to customize colored JAR output.
  2862.         The following table must be used for color translation:
  2863.  
  2864.         BLACK   (0)    GREY          (8)
  2865.         BLUE    (1)    LIGHT BLUE    (9)
  2866.         GREEN   (2)    LIGHT GREEN   (10)
  2867.         CYAN    (3)    LIGHT CYAN    (11)
  2868.         RED     (4)    LIGHT RED     (12)
  2869.         MAGENTA (5)    LIGHT MAGENTA (13)
  2870.         BROWN   (6)    YELLOW        (14)
  2871.         WHITE   (7)    LIGHT WHITE   (15)
  2872.  
  2873.  
  2874.       HighIntensityColors=No
  2875.  
  2876.         Possible values: Yes/No. It uses only "light" colors for JAR
  2877.         output. This may be useful for windowed DOS sessions.
  2878.  
  2879.  
  2880.     IMPORTANT DIFFERENCES BETWEEN JAR AND ARJ:
  2881.  
  2882.  
  2883.       Most JAR commands and switches follow ARJ naming. This DOES NOT mean
  2884.       that all JAR options and commands work exactly as in ARJ. Please read
  2885.       the documentation for details.
  2886.  
  2887.       These are a list of useful options that work slightly differently
  2888.       from ARJ:
  2889.  
  2890.       -b0 -b1 -r -jb -jf -hf -hg
  2891.  
  2892.       These are a list of options that have different meanings:
  2893.  
  2894.       -o -jg -jl -ju -js -jx -hm -ho -ht -hx -hz
  2895.  
  2896.       JAR DOES NOT support the ARJ base/target directory option. JAR
  2897.       provides the "-o" option instead.
  2898.  
  2899.       JAR always adds files with "system" and "hidden" attributes. ARJ by
  2900.       default does not.
  2901.  
  2902.       By default during an add command, JAR adds all directories scanned
  2903.       while searching for files that match the specified wildcards.  An
  2904.       archive may be created with directory names only even if no files
  2905.       were found.  For example, "JAR16 a archive c:\abcdefgh.* -r" would
  2906.       create an archive containing every directory name on drive C and
  2907.       probably no files.  Use the "-hbd0" option to not include the
  2908.       directories.
  2909.  
  2910.       By default for commands that scan an archive, JAR wildcarding uses
  2911.       directory recursion.  This means that the specified directory and all
  2912.       sub-directories will be scanned by the command.  To get ARJ-like
  2913.       scanning behavior, you need to specify the "-r-" option to turn off
  2914.       recursion.
  2915.  
  2916.       Example: JAR16 x archive dir\docs\*.* -r-
  2917.  
  2918.       There are significant differences in volume archives design. ARJ
  2919.       volumes are like separate archives. JAR volumes are parts of a single
  2920.       archive.
  2921.  
  2922.       Unlike ARJ, JAR cannot join archives. Instead, JAR has the option of
  2923.       using the "y" command to join volumes into a single "solid" archive.
  2924.       It is also possible to change the archive volume size.
  2925.  
  2926.       The JAR archive name specified in the command line is used to name
  2927.       the LAST VOLUME. The other volumes are ALWAYS named with an extension
  2928.       starting with .j01, .j02,  and so on. Conversely, ARJ uses the
  2929.       command line archive name for the first volume and the next volume
  2930.       name is generated incrementally.
  2931.  
  2932.  
  2933.     JAR LIMITATIONS:
  2934.  
  2935.  
  2936.       JAR uses a "central directory" scheme to store information about the
  2937.       compressed files in an archive. Since such a directory may be very
  2938.       large, JAR uses built-in virtual memory (VM) which allows JAR to work
  2939.       in a limited amount of physical memory (then swap file is used). VM
  2940.       is also used to store other intermediate data: list of files to add,
  2941.       temporary compression buffers, etc.
  2942.  
  2943.       During archive UPDATE operations VM size is limited to 25 Mbytes. If
  2944.       JAR exceeds this then the update operation fails. As a result, the
  2945.       maximum number of files that can be stored within an archive is about
  2946.       80,000 files (depends on files path length). An archive compressed
  2947.       with the "-m4" method can be updated if it contains less than about
  2948.       40,000 files.
  2949.  
  2950.       DOS JAR version memory usage:
  2951.  
  2952.                    EMS available   No EMS, XMS only   No EMS and XMS
  2953.                    -------------   ----------------   --------------
  2954.  
  2955.       Update         431K(*)            484K              517K
  2956.       commands
  2957.  
  2958.       Extract         368K              434K              467K
  2959.       commands
  2960.  
  2961.       List            351K              351K              384K
  2962.       commands
  2963.  
  2964.       (*) - 484K for "-m1" method
  2965.  
  2966.       "K" means kilobyte (1024 bytes)
  2967.  
  2968.       Processing an ENCRYPTED archive requires an additional 8 Kbytes of
  2969.       memory.
  2970.  
  2971.       JAR32 is a console Win32 application and uses OEM encoding to process
  2972.       and to store filenames. As a result JAR32 cannot process filenames
  2973.       with characters which have no equivalent mapping into the current OEM
  2974.       codepage. For example, special symbols like the copyright symbol
  2975.       (circle c) usually have no equivalent.
  2976.  
  2977.  
  2978.     JAR ARCHIVE ACCESS MODES:
  2979.  
  2980.  
  2981.       Below is a description of the archive file opening modes used by JAR.
  2982.       This information may be important when sharing archives on networks.
  2983.  
  2984.       JAR does the following steps:
  2985.  
  2986.       1. Opens archive file (last volume), reads archive header and then
  2987.          closes archive file. Sometimes archive header does not fit in the
  2988.          last volume and is distributed within the last few volumes.
  2989.  
  2990.       2. Using the archive header information, JAR decides which archive
  2991.          volume is required for future processing.
  2992.  
  2993.       3. Opens necessary volume, reads data, opens another volume and so
  2994.          on...
  2995.  
  2996.       So even in case of a single volume, JAR opens an archive twice.
  2997.       First to read the header and second to read the actual compressed
  2998.       data.
  2999.  
  3000.       On update type operations both DOS and Win32 JAR open an archive
  3001.       using "DENY READ and WRITE" mode (exclusive mode).
  3002.  
  3003.       On non-update type operations DOS JAR opens an archive using
  3004.       "COMPATIBILITY" mode and Win32 JAR - using "DENY WRITE" mode.
  3005.  
  3006.       As a result you can simultaneously list or extract from archives on
  3007.       network.
  3008.  
  3009.  
  3010.     HOW JAR SHARES FILES TO COMPRESS:
  3011.  
  3012.  
  3013.       Win32 JAR version uses "DENY WRITE" mode and DOS JAR version uses
  3014.       "COMPATIBILITY" mode while reading files to compress.
  3015.  
  3016.  
  3017.     2000 YEAR PROBLEM AND JAR:
  3018.  
  3019.  
  3020.       There is no 2000 year problem with JAR.
  3021.  
  3022.       In all internal data structures and archive headers, JAR stores the
  3023.       year using a 16-bit binary value. As a result, the valid year range
  3024.       is 1 to 65535.
  3025.  
  3026.       There is a minor limitation with the "-hm" option (select files using
  3027.       date/time filter). Due to the option argument SYNTAX (and ONLY due to
  3028.       this reason), this option accepts year dates in the range 1980 to
  3029.       2079.
  3030.  
  3031.  
  3032.     JAR ARCHIVE FLAGS:
  3033.  
  3034.  
  3035.       JAR shows the archive flags and archive comment any time the archive
  3036.       is accessed. Here is a list of possible flags with a short
  3037.       explanation:
  3038.  
  3039.       ENCRYPTED
  3040.  
  3041.         Archive is protected using encryption.
  3042.  
  3043.       PROTECTED
  3044.  
  3045.         Archive is protected using "Authenticate" method.
  3046.  
  3047.       PROTECTED(obsolete method)
  3048.  
  3049.         Archive is protected using "Authentication" method. This obsolete
  3050.         method was used by the first JAR 1.01 BETA.  Please read
  3051.         WHATSNEW.DOC for details.
  3052.  
  3053.       HIDDEN
  3054.  
  3055.         Archive created using "-jx" option (requires password for any
  3056.         command).
  3057.  
  3058.       SECURED
  3059.  
  3060.         JAR_SECURED archive created using "-hy" option.
  3061.  
  3062.       RECOVERY RECORDS
  3063.  
  3064.         Archive contains recovery records ("-hk" option).
  3065.  
  3066.       LOCKED
  3067.  
  3068.         Archive is locked using "-jl" option. Archive cannot be updated.
  3069.  
  3070.       AUTO-LOCK
  3071.  
  3072.         Archive is auto-lockable ("-jl2" option).
  3073.  
  3074.  
  3075.     JAR ERROR LEVELS:
  3076.  
  3077.  
  3078.       0 ->  success
  3079.       1 ->  warning
  3080.       2 ->  fatal error
  3081.       3 ->  CRC error
  3082.       5 ->  disk full or write error
  3083.       6 ->  cannot open archive
  3084.       7 ->  simple user error (bad parameters)
  3085.       8 ->  not enough memory
  3086.       9 ->  not a JAR archive
  3087.       10 -> internal error
  3088.       11 -> Ctrl+C pressed
  3089.  
  3090.  
  3091.     FREQUENTLY ASKED QUESTIONS:
  3092.  
  3093.  
  3094.       Q.  I compressed the same data twice. Why did JAR create archives
  3095.           with different sizes?
  3096.  
  3097.       A.  JAR uses a compressed archive header.  The header stores (along
  3098.           with other data) the archive creation and modification time and
  3099.           the file's last access time.  These values differ even when
  3100.           archiving the same set of files.  Compressing these slightly
  3101.           different headers results in different compressed header sizes
  3102.           and therefore different JAR archive sizes.
  3103.  
  3104.  
  3105.       Q.  JAR uses an archive header to store information about compressed
  3106.           files. What happens to an archive if its header is damaged?
  3107.  
  3108.       A.  For reliability the most important information about archived
  3109.           files is duplicated and included with the compressed file data.
  3110.           As a result even if a JAR archive header is damaged, you can
  3111.           recover the archive and extract data using the "rh" command.
  3112.  
  3113.           JAR uses signatures to search compressed data chains during a
  3114.           repair.  So undamaged data may be recovered even in the case of
  3115.           missing file directory and attribute information.
  3116.  
  3117.           Keep in mind that the -m1,-m2 and -m3 compression methods
  3118.           concatenate files into shorter blocks than -m4.  Thus data may
  3119.           be recovered with a higher probability.  Recovery records
  3120.           ("-hk") is another option which makes archive more resistant to
  3121.           damage.
  3122.  
  3123.  
  3124.       Q.  JAR by default stores all scanned directories into archive. Can
  3125.           I have by default ARJ-like behavior (not store directories)?
  3126.  
  3127.       A.  Yes, this is possible.  The default JAR.CFG file contains a
  3128.           section which when uncommented sets JAR to use "-hbd0" option
  3129.           ("skip directories") for add type commands.  An "-hb" option
  3130.           specified on the command line overwrites this default.
  3131.  
  3132.  
  3133.       Q.  Can I extract files with long filenames in DOS?
  3134.  
  3135.       A.  DOS itself does not support long filenames and thus JAR can't
  3136.           restore long filenames while running in this OS.
  3137.  
  3138.           By default JAR will not use any conversions during extraction
  3139.           and pass long filenames to DOS system calls directly. This
  3140.           results in long filename truncation. As a result restored files
  3141.           may contain spaces that are non-standard for DOS.
  3142.  
  3143.           We recommend the use of the "-hf2" or "-hf3" options instead.
  3144.           These set JAR to convert long file and directory names into
  3145.           correct DOS short names using a similar algorithm to that used
  3146.           by Windows 95 for aliases.  See JAR.DOC for details.
  3147.  
  3148.  
  3149.     FINAL COMMENTS:
  3150.  
  3151.  
  3152.       We do hope that you find this program as useful as we have. We would
  3153.       appreciate any suggestions to improve this archiver.
  3154.  
  3155.       You can reach us at:
  3156.  
  3157.       Internet address:  robjung@world.std.com
  3158.  
  3159.       CompuServe userid: 72077,445
  3160.  
  3161.       JAR users are encouraged to use the above addresses to submit
  3162.       questions, problems, and new features requests.
  3163.  
  3164.  
  3165.       ***** UPDATED MAILING ADDRESS *****
  3166.  
  3167.       ARJ Software, Inc.
  3168.       P.O. Box 249
  3169.       Norwood MA 02062
  3170.       USA
  3171.  
  3172.       Fax number: 781-769-4893
  3173.  
  3174.       ***********************************
  3175.  
  3176.  
  3177.     end of document
  3178.