neulab/tldr huggingface dataset:
The Extended Tcl Tk shell, wishx, has an additional master directory and initialization file.  It use the environment variable TK_LIBRARY to override the default location of the Tk master directory.
The help facility allows one to look up help pages which where extracted from the standard Tcl manual pages and Tcl scripts during Tcl installation.  Help files are structured as a multilevel tree of subjects and help pages.  Help files are found by searching directories named help in the directories listed in the auto_path variable.  All of the files in the list of help directories form a virtual root of the help tree.  This method allows multiple applications to provide help trees without having the files reside in the same directory.
The help facility can be accessed in two ways, as interactive commands in the Extended Tcl shell or as an interactive Tk-based program (if you have built Extended Tcl with Tk).
To run the Tk-based interactive help program:
tclhelp ?addpaths? Where addpaths are additional paths to search for help directories.  By default, only the auto_path used by tclhelp is search.  This will result in help on Tcl, Extended Tcl and Tk.
The following interactive Tcl commands and options are provided with the help package:
help Help, without arguments, lists of all the help subjects and pages under the current help subject.
help subject Displays all of help pages and lower level subjects (if any exist) under the subject subject.
help subject/helppage Display the specified help page.  The help output is passed through a simple pager if output exceeds 23 lines, pausing waiting for a return to be entered.  If any other character is entered, the output is terminated.
helpcd ?subject? Change the current subject, which is much like the Unix current directory.  If subject is not specified, return to the top-level of the help tree.  Help subject path names may also include ``..'' elements.
helppwd Displays the current help subject.
help help | ? Displays help on the help facility at any directory level.
apropos pattern This command locates subjects by searching their one-line descriptions for a pattern.  Apropos is useful when you can remember part of the name or description of a command, and want to search through the one-line summaries for matching lines.  Full regular expressions may be specified (see the regexp command).
Extended Tcl supports standard Tcl tclIndex libraries and package libraries. A package library file can contain multiple independent Tcl packages.  A package is a named collection of related Tcl procedures and initialization code.
The package library file is just a regular Unix text file, editable with your favorite text editor, containing packages of Tcl source code. The package library file name must have the suffix .tlib.  An index file with the suffix .tndx, corresponding to the package library.  The .tndx will be automatically created by Tcl whenever it is out of date or missing (provided there is write access to the directory.
The variable auto_path contains a list of directories that are searched for libraries.  The first time an unknown command trap is take, the indexes for the libraries are loaded into memory. If the auto_path variable is changed during execution of a program, it will be re- searched. Only the first package of a given name found during the execution of a program is loaded.  This can be overridden with loadlibindex command.
The start of a package is delimited by:
#@package: package_name proc1 ?..procN?
These lines must start in column one.  Everything between the #@package: keyword and the next #@package: keyword or a #@packend keyword, or the end of the file, becomes part of the named package.  The specified procedures, proc1..procN, are the entry points of the package.  When a command named in a package specification is executed and detected as an unknown command, all code in the specified package will be sourced.  This package should define all of the procedures named on the package line, define any support procedures required by the package and do any package- specific initialization.  Packages declarations maybe continued on subsequent lines using standard Tcl backslash line continuations.  The #@packend keyword is useful to make sure only the minimum required section of code is sourced.  Thus for example a large comment block at the beginning of the next file won't be loaded.
Care should be taken in defining package_name, as the first package found in the path by with a given name is loaded.  This can be useful in developing new version of packages installed on the system.
For example, in a package source file, the presence of the following line:
#@package: directory_stack pushd popd dirs
says that the text lines following that line in the package file up to the next package line or the end of the file is a package named directory_stack and that an attempt to execute either pushd, popd or dirs when the routine is not already defined will cause the directory_stack portion of the package file to be loaded.
Several commands are available for building and managing package libraries.  Commands that are extended versions of the standard Tcl library commands are listed here.  All of the standard Tcl library management commands and variables are also supported.
auto_commands ?-loaders? Lists the names of all known loadable procedures and commands procedures.  If -loaders is specified, the command that will be executed to load the command will also be returned.
buildpackageindex libfilelist Build index files for package libraries.  The argument libfilelist is a list of package libraries.  Each name must end with the suffix .tlib.  A corresponding .tndx file will be built.  The user must have write access to the directory containing each library.
convert_lib tclIndex packagelib ?ignore? Convert a Ousterhout style tclIndex index file and associate source files into a package library packagelib.  If packagelib does not have a .tlib extension, one will be added.  Any files specified in tclIndex that are in the list ignore will be skipped. Files listed in ignore should just be the base file names, not full paths.
auto_load ?command? Attempt to load the specified command from a loadable library. loading the package containing the procedure.  If the package indexes have not been loaded for all package libraries in auto_path, they will be loaded.  Out-of-date library indexes will be rebuilt if they are writable.  The procedure returns 1 if the command was sucessfully loaded, or 0 if it was not.
Duplicated package names are skipped, the first package of a given name found in the path is loaded.  If the auto_path has changed since the last load, indexes will be reloaded (duplicate packages will not be redefined).
If command is not specified, the indexes will be loaded, if they have not alreay been loaded or if the auto_path variable has changed, but no command will be loaded.
This command overrides the standard Tcl procedure of the same name.
loadlibindex libfile.tlib Load the package library index of the library file libfile (which must have the suffix .tlib).  Package library indexes along the auto_path are loaded automatically on the first demand_load; this command is provided to explicitly load libraries that are not in the path.  If the index file (with a .tndx suffix) does not exists or is out of date, it will be rebuilt if the user has directory permissions to create it. If a package with the same name as a package in libfile.tlib has already been loaded, its definition will be overridden by the new package.  However, if any procedure has actually been used from the previously defined package, the procedures from libfile.tlib will not be loaded.
This command will also load an index built by mkindex.tcl program supplied with standard Tcl.  This file must be named "tclIndex".
auto_packages ?-location? Returns a list of the names of all defined packages. If -location is specified, a list of pairs of package name and the .tlib path name, offset and length of the package within the library.
auto_load_file file Source a file, as with the source command, except search auto_path for the file.
searchpath path file Search all directories in the specified path, which is a Tcl list, for the specified file.  Returns the full path name of the file, or an empty string if the requested file could not be found.
SPHINX-BUILD(1)                      Sphinx                      SPHINX-BUILD(1)
sphinx-build - Sphinx documentation generator tool
sphinx-build [options] <sourcedir> <outputdir> [filenames ...]
sphinx-build generates documentation from the files in <sourcedir> and places it in the <outputdir>.
sphinx-build looks for <sourcedir>/conf.py for the configuration settings.  sphinx-quickstart(1) may be used to generate template files, including conf.py.
sphinx-build can create documentation in different formats.  A format is selected by specifying the builder name on the command line; it defaults to HTML.  Builders can also perform other tasks related to documentation processing.
By default, everything that is outdated is built.  Output only for selected files can be built by specifying individual filenames.
For a list of available options, refer to sphinx-build -b.
-b buildername The most important option: it selects a builder.  The most common builders are:
html   Build HTML pages.  This is the default builder.
dirhtml Build HTML pages, but with a single directory per document. Makes for prettier URLs (no .html) if served from a webserver.
singlehtml Build a single HTML with the whole content.
htmlhelp, qthelp, devhelp, epub Build HTML files with additional information for building a documentation collection in one of these formats.
applehelp Build an Apple Help Book.  Requires hiutil and codesign, which are not Open Source and presently only available on Mac OS X 10.6 and higher.
latex  Build LaTeX sources that can be compiled to a PDF document using pdflatex.
man    Build manual pages in groff format for UNIX systems.
texinfo Build Texinfo files that can be processed into Info files using makeinfo.
text   Build plain text files.
gettext Build gettext-style message catalogs (.pot files).
doctest Run all doctests in the documentation, if the doctest extension is enabled.
linkcheck Check the integrity of all external links.
xml    Build Docutils-native XML files.
pseudoxml Build compact pretty-printed "pseudo-XML" files displaying the internal structure of the intermediate document trees.
See /usage/builders/index for a list of all builders shipped with Sphinx.  Extensions can add their own builders.
-M buildername Alternative to -b. Uses the Sphinx make_mode module, which provides the same build functionality as a default Makefile or Make.bat. In addition to all Sphinx /usage/builders/index, the following build pipelines are available:
latexpdf Build LaTeX files and run them through pdflatex, or as per latex_engine setting.  If language is set to 'ja', will use automatically the platex/dvipdfmx latex to PDF pipeline.
info   Build Texinfo files and run them through makeinfo.
IMPORTANT: Sphinx only recognizes the -M option if it is placed first.
New in version 1.2.1.
-a     If given, always write all output files. The default is to only write output files for new and changed source files. (This may not apply to all builders.)
-E     Don't use a saved environment (the structure caching all cross-references), but rebuild it completely.  The default is to only read and parse source files that are new or have changed since the last run.
-t tag Define the tag tag.  This is relevant for only directives that only include their content if this tag is set.
New in version 0.6.
-d path Since Sphinx has to read and parse all source files before it can write an output file, the parsed source files are cached as "doctree pickles".  Normally, these files are put in a directory called .doctrees under the build directory; with this option you can select a different cache directory (the doctrees can be shared between all builders).
-j N   Distribute the build over N processes in parallel, to make building on multiprocessor machines more effective.  Note that not all parts and not all builders of Sphinx can be parallelized.  If auto argument is given, Sphinx uses the number of CPUs as N.
New in version 1.2: This option should be considered experimental.
Changed in version 1.7: Support auto argument.
-c path Don't look for the conf.py in the source directory, but use the given configuration directory instead.  Note that various other files and paths given by configuration values are expected to be relative to the configuration directory, so they will have to be present at this location too.
New in version 0.3.
-C     Don't look for a configuration file; only take options via the -D option.
New in version 0.5.
-D setting=value Override a configuration value set in the conf.py file.  The value must be a number, string, list or dictionary value.
For lists, you can separate elements with a comma like this: -D html_theme_path=path1,path2.
For dictionary values, supply the setting name and key like this: -D latex_elements.docclass=scrartcl.
For boolean values, use 0 or 1 as the value.
Changed in version 0.6: The value can now be a dictionary value.
Changed in version 1.3: The value can now also be a list value.
-A name=value Make the name assigned to value in the HTML templates.
-n     Run in nit-picky mode.  Currently, this generates warnings for all missing references.  See the config value nitpick_ignore for a way to exclude some references as "known missing".
-N     Do not emit colored output.
-v     Increase verbosity (loglevel).  This option can be given up to three times to get more debug logging output.  It implies -T.
New in version 1.2.
-q     Do not output anything on standard output, only write warnings and errors to standard error.
-Q     Do not output anything on standard output, also suppress warnings. Only errors are written to standard error.
-w file Write warnings (and errors) to the given file, in addition to standard error.
-W     Turn warnings into errors.  This means that the build stops at the first warning and sphinx-build exits with exit status 1.
--keep-going With -W option, keep going processing when getting warnings to the end of build, and sphinx-build exits with exit status 1.
New in version 1.8.
-T     Display the full traceback when an unhandled exception occurs. Otherwise, only a summary is displayed and the traceback information is saved to a file for further analysis.
-P     (Useful for debugging only.)  Run the Python debugger, pdb, if an unhandled exception occurs while building.
-h, --help, --version Display usage summary or Sphinx version.
You can also give one or more filenames on the command line after the source and build directories. Sphinx will then try to build only these output files (and their dependencies).
The sphinx-build refers following environment variables:
MAKE   A path to make command.  A command name is also allowed. sphinx-build uses it to invoke sub-build process on make-mode. Makefile Options
The Makefile and make.bat files created by sphinx-quickstart usually run sphinx-build only with the -b and -d options.  However, they support the following variables to customize behavior:
PAPER  This sets the 'papersize' key of latex_elements: i.e. PAPER=a4 sets it to 'a4paper' and PAPER=letter to 'letterpaper'.
NOTE: Usage of this environment variable got broken at Sphinx 1.5 as a4 or letter ended up as option to LaTeX document in place of the needed a4paper, resp. letterpaper.  Fixed at 1.7.7.
SPHINXBUILD The command to use instead of sphinx-build.
BUILDDIR The build directory to use instead of the one chosen in sphinx-quickstart.
SPHINXOPTS Additional options for sphinx-build.
If any deprecation warning like RemovedInSphinxXXXWarning are displayed when building a user's document, some Sphinx extension is using deprecated features. In that case, please report it to author of the extension.
To disable the deprecation warnings, please set PYTHONWARNINGS= environment variable to your environment. For example:
• PYTHONWARNINGS= make html (Linux/Mac)
• export PYTHONWARNINGS= and do make html (Linux/Mac)
• set PYTHONWARNINGS= and do make html (Windows)
• modify your Makefile/make.bat and set the environment variable
sphinx-quickstart(1)
2007-2019, Georg Brandl and the Sphinx team
gh-completion - Generate shell completion scripts
gh completion -s <shell>
Generate shell completion scripts for GitHub CLI commands.
When installing GitHub CLI through a package manager, it's possible that no additional shell configuration is necessary to gain completion support. For Homebrew, see https://docs.brew.sh/Shell-Completion ⟨https://docs.brew.sh/Shell-Completion⟩
If you need to set up completions manually, follow the instructions below. The exact config file locations might vary based on your system. Make sure to restart your shell before testing whether completions are working.
bash First, ensure that you install bash-completion using your package manager.
After, add this to your ~/.bash_profile:
eval "$(gh completion -s bash)"
zsh Generate a _gh completion script and put it somewhere in your $fpath:
gh completion -s zsh > /usr/local/share/zsh/site-functions/_gh
Ensure that the following is present in your ~/.zshrc:
autoload -U compinit compinit -i
Zsh version 5.7 or later is recommended.
fish Generate a gh.fish completion script:
gh completion -s fish > ~/.config/fish/completions/gh.fish
PowerShell Open your profile script with:
mkdir -Path (Split-Path -Parent $profile) -ErrorAction SilentlyContinue notepad $profile
Add the line and save the file:
Invoke-Expression -Command $(gh completion -s powershell | Out-String)
-s, --shell=""      Shell type: {bash|zsh|fish|powershell}
ZIP(1L)                                                                  ZIP(1L)
zip - package and compress (archive) files
zip [-aABcdDeEfFghjklLmoqrRSTuvVwXyz!@$] [--longoption ...]  [-b path] [-n suffixes] [-t date] [-tt date] [zipfile [file ...]]  [-xi list]
zipcloak (see separate man page)
zipnote (see separate man page)
zipsplit (see separate man page)
Note:  Command line processing in zip has been changed to support long options and handle all options and arguments more consistently.  Some old command lines that depend on command line inconsistencies may no longer work.
zip is a compression and file packaging utility for Unix, VMS, MSDOS, OS/2, Windows 9x/NT/XP, Minix, Atari, Macintosh, Amiga, and Acorn RISC OS.  It is analogous to a combination of the Unix commands tar(1) and compress(1) and is compatible with PKZIP (Phil Katz's ZIP for MSDOS systems).
A companion program (unzip(1L)) unpacks zip archives.  The zip and unzip(1L) programs can work with archives produced by PKZIP (supporting most PKZIP features up to PKZIP version 4.6), and PKZIP and PKUNZIP can work with archives produced by zip (with some exceptions, notably streamed archives, but recent changes in the zip file standard may facilitate better compatibility).  zip version 3.0 is compatible with PKZIP 2.04 and also supports the Zip64 extensions of PKZIP 4.5 which allow archives as well as files to exceed the previous 2 GB limit (4 GB in some cases).  zip also now supports bzip2 compression if the bzip2 library is included when zip is compiled.  Note that PKUNZIP 1.10 cannot extract files produced by PKZIP 2.04 or zip 3.0. You must use PKUNZIP 2.04g or unzip 5.0p1 (or later versions) to extract them.
See the EXAMPLES section at the bottom of this page for examples of some typical uses of zip.
Large Archives and Zip64.  zip automatically uses the Zip64 extensions when files larger than 4 GB are added to an archive, an archive containing Zip64 entries is updated (if the resulting archive still needs Zip64), the size of the archive will exceed 4 GB, or when the number of entries in the archive will exceed about 64K.  Zip64 is also used for archives streamed from standard input as the size of such archives are not known in advance, but the option -fz- can be used to force zip to create PKZIP 2 compatible archives (as long as Zip64 extensions are not needed).  You must use a PKZIP 4.5 compatible unzip, such as unzip 6.0 or later, to extract files using the Zip64 extensions.
In addition, streamed archives, entries encrypted with standard encryption, or split archives created with the pause option may not be compatible with PKZIP as data descriptors are used and PKZIP at the time of this writing does not support data descriptors (but recent changes in the PKWare published zip standard now include some support for the data descriptor format zip uses).
Mac OS X.  Though previous Mac versions had their own zip port, zip supports Mac OS X as part of the Unix port and most Unix features apply. References to "MacOS" below generally refer to MacOS versions older than OS X.  Support for some Mac OS features in the Unix Mac OS X port, such as resource forks, is expected in the next zip release.
For a brief help on zip and unzip, run each without specifying any parameters on the command line.
The program is useful for packaging a set of files for distribution; for archiving files; and for saving disk space by temporarily compressing unused files or directories.
The zip program puts one or more compressed files into a single zip archive, along with information about the files (name, path, date, time of last modification, protection, and check information to verify file integrity).  An entire directory structure can be packed into a zip archive with a single command.  Compression ratios of 2:1 to 3:1 are common for text files.  zip has one compression method (deflation) and can also store files without compression.  (If bzip2 support is added, zip can also compress using bzip2 compression, but such entries require a reasonably modern unzip to decompress.  When bzip2 compression is selected, it replaces deflation as the default method.)  zip automatically chooses the better of the two (deflation or store or, if bzip2 is selected, bzip2 or store) for each file to be compressed.
Command format.  The basic command format is
zip options archive inpath inpath ...
where archive is a new or existing zip archive and inpath is a directory or file path optionally including wildcards.  When given the name of an existing zip archive, zip will replace identically named entries in the zip archive (matching the relative names as stored in the archive) or add entries for new names.  For example, if foo.zip exists and contains foo/file1 and foo/file2, and the directory foo contains the files foo/file1 and foo/file3, then:
zip -r foo.zip foo
or more concisely
zip -r foo foo
will replace foo/file1 in foo.zip and add foo/file3 to foo.zip.  After this, foo.zip contains foo/file1, foo/file2, and foo/file3, with foo/file2 unchanged from before.
So if before the zip command is executed foo.zip has:
foo/file1 foo/file2
and directory foo has:
file1 file3
then foo.zip will have:
foo/file1 foo/file2 foo/file3
where foo/file1 is replaced and foo/file3 is new.
-@ file lists.  If a file list is specified as -@ [Not on MacOS], zip takes the list of input files from standard input instead of from the command line.  For example,
zip -@ foo
will store the files listed one per line on stdin in foo.zip.
Under Unix, this option can be used to powerful effect in conjunction with the find (1) command.  For example, to archive all the C source files in the current directory and its subdirectories:
find . -name "*.[ch]" -print | zip source -@
(note that the pattern must be quoted to keep the shell from expanding it).
Streaming input and output.  zip will also accept a single dash ("-") as the zip file name, in which case it will write the zip file to standard output, allowing the output to be piped to another program. For example:
zip -r - . | dd of=/dev/nrst0 obs=16k
would write the zip output directly to a tape with the specified block size for the purpose of backing up the current directory.
zip also accepts a single dash ("-") as the name of a file to be compressed, in which case it will read the file from standard input, allowing zip to take input from another program. For example:
tar cf - . | zip backup -
would compress the output of the tar command for the purpose of backing up the current directory. This generally produces better compression than the previous example using the -r option because zip can take advantage of redundancy between files. The backup can be restored using the command
unzip -p backup | tar xf -
When no zip file name is given and stdout is not a terminal, zip acts as a filter, compressing standard input to standard output.  For example,
tar cf - . | zip | dd of=/dev/nrst0 obs=16k
tar cf - . | zip - - | dd of=/dev/nrst0 obs=16k
zip archives created in this manner can be extracted with the program funzip which is provided in the unzip package, or by gunzip which is provided in the gzip package (but some gunzip may not support this if zip used the Zip64 extensions). For example:
dd if=/dev/nrst0  ibs=16k | funzip | tar xvf -
The stream can also be saved to a file and unzip used.
If Zip64 support for large files and archives is enabled and zip is used as a filter, zip creates a Zip64 archive that requires a PKZIP 4.5 or later compatible unzip to read it.  This is to avoid amgibuities in the zip file structure as defined in the current zip standard (PKWARE AppNote) where the decision to use Zip64 needs to be made before data is written for the entry, but for a stream the size of the data is not known at that point.  If the data is known to be smaller than 4 GB, the option -fz- can be used to prevent use of Zip64, but zip will exit with an error if Zip64 was in fact needed.  zip 3 and unzip 6 and later can read archives with Zip64 entries.  Also, zip removes the Zip64 extensions if not needed when archive entries are copied (see the -U (--copy) option).
When directing the output to another file, note that all options should be before the redirection including -x.  For example:
zip archive "*.h" "*.c" -x donotinclude.h orthis.h > tofile
Zip files.  When changing an existing zip archive, zip will write a temporary file with the new contents, and only replace the old one when the process of creating the new version has been completed without error.
If the name of the zip archive does not contain an extension, the extension .zip is added. If the name already contains an extension other than .zip, the existing extension is kept unchanged.  However, split archives (archives split over multiple files) require the .zip extension on the last split.
Scanning and reading files.  When zip starts, it scans for files to process (if needed).  If this scan takes longer than about 5 seconds, zip will display a "Scanning files" message and start displaying progress dots every 2 seconds or every so many entries processed, whichever takes longer.  If there is more than 2 seconds between dots it could indicate that finding each file is taking time and could mean a slow network connection for example.  (Actually the initial file scan is a two-step process where the directory scan is followed by a sort and these two steps are separated with a space in the dots.  If updating an existing archive, a space also appears between the existing file scan and the new file scan.)  The scanning files dots are not controlled by the -ds dot size option, but the dots are turned off by the -q quiet option.  The -sf show files option can be used to scan for files and get the list of files scanned without actually processing them.
If zip is not able to read a file, it issues a warning but continues. See the -MM option below for more on how zip handles patterns that are not matched and files that are not readable.  If some files were skipped, a warning is issued at the end of the zip operation noting how many files were read and how many skipped.
Command modes.  zip now supports two distinct types of command modes, external and internal.  The external modes (add, update, and freshen) read files from the file system (as well as from an existing archive) while the internal modes (delete and copy) operate exclusively on entries in an existing archive.
add Update existing entries and add new files.  If the archive does not exist create it.  This is the default mode.
update (-u) Update existing entries if newer on the file system and add new files.  If the archive does not exist issue warning then create a new archive.
freshen (-f) Update existing entries of an archive if newer on the file system. Does not add new files to the archive.
delete (-d) Select entries in an existing archive and delete them.
copy (-U) Select entries in an existing archive and copy them to a new archive.  This new mode is similar to update but command line patterns select entries in the existing archive rather than files from the file system and it uses the --out option to write the resulting archive to a new file rather than update the existing archive, leaving the original archive unchanged.
The new File Sync option (-FS) is also considered a new mode, though it is similar to update.  This mode synchronizes the archive with the files on the OS, only replacing files in the archive if the file time or size of the OS file is different, adding new files, and deleting entries from the archive where there is no matching file.  As this mode can delete entries from the archive, consider making a backup copy of the archive.
Also see -DF for creating difference archives.
See each option description below for details and the EXAMPLES section below for examples.
Split archives.  zip version 3.0 and later can create split archives.  A split archive is a standard zip archive split over multiple files.  (Note that split archives are not just archives split in to pieces, as the offsets of entries are now based on the start of each split. Concatenating the pieces together will invalidate these offsets, but unzip can usually deal with it.  zip will usually refuse to process such a spliced archive unless the -FF fix option is used to fix the offsets.)
One use of split archives is storing a large archive on multiple removable media.  For a split archive with 20 split files the files are typically named (replace ARCHIVE with the name of your archive) ARCHIVE.z01, ARCHIVE.z02, ..., ARCHIVE.z19, ARCHIVE.zip.  Note that the last file is the .zip file.  In contrast, spanned archives are the original multi-disk archive generally requiring floppy disks and using volume labels to store disk numbers.  zip supports split archives but not spanned archives, though a procedure exists for converting split archives of the right size to spanned archives.  The reverse is also true, where each file of a spanned archive can be copied in order to files with the above names to create a split archive.
Use -s to set the split size and create a split archive.  The size is given as a number followed optionally by one of k (kB), m (MB), g (GB), or t (TB) (the default is m).  The -sp option can be used to pause zip between splits to allow changing removable media, for example, but read the descriptions and warnings for both -s and -sp below.
Though zip does not update split archives, zip provides the new option -O (--output-file or --out) to allow split archives to be updated and saved in a new archive.  For example,
zip inarchive.zip foo.c bar.c --out outarchive.zip
reads archive inarchive.zip, even if split, adds the files foo.c and bar.c, and writes the resulting archive to outarchive.zip.  If inarchive.zip is split then outarchive.zip defaults to the same split size.  Be aware that if outarchive.zip and any split files that are created with it already exist, these are always overwritten as needed without warning.  This may be changed in the future.
Unicode.  Though the zip standard requires storing paths in an archive using a specific character set, in practice zips have stored paths in archives in whatever the local character set is.  This creates problems when an archive is created or updated on a system using one character set and then extracted on another system using a different character set. When compiled with Unicode support enabled on platforms that support wide characters, zip now stores, in addition to the standard local path for backward compatibility, the UTF-8 translation of the path.  This provides a common universal character set for storing paths that allows these paths to be fully extracted on other systems that support Unicode and to match as close as possible on systems that don't.
On Win32 systems where paths are internally stored as Unicode but represented in the local character set, it's possible that some paths will be skipped during a local character set directory scan.  zip with Unicode support now can read and store these paths.  Note that Win 9x systems and FAT file systems don't fully support Unicode.
Be aware that console windows on Win32 and Unix, for example, sometimes don't accurately show all characters due to how each operating system switches in character sets for display.  However, directory navigation tools should show the correct paths if the needed fonts are loaded.
Command line format.  This version of zip has updated command line processing and support for long options.
Short options take the form
-s[-][s[-]...][value][=value][ value]
where s is a one or two character short option.  A short option that takes a value is last in an argument and anything after it is taken as the value.  If the option can be negated and "-" immediately follows the option, the option is negated.  Short options can also be given as separate arguments
-s[-][value][=value][ value] -s[-][value][=value][ value] ...
Short options in general take values either as part of the same argument or as the following argument.  An optional = is also supported.  So
-ttmmddyyyy
-tt=mmddyyyy
-tt mmddyyyy
all work.  The -x and -i options accept lists of values and use a slightly different format described below.  See the -x and -i options.
Long options take the form
--longoption[-][=value][ value]
where the option starts with --, has a multicharacter name, can include a trailing dash to negate the option (if the option supports it), and can have a value (option argument) specified by preceeding it with = (no spaces).  Values can also follow the argument.  So
--before-date=mmddyyyy
--before-date mmddyyyy
both work.
Long option names can be shortened to the shortest unique abbreviation. See the option descriptions below for which support long options.  To avoid confusion, avoid abbreviating a negatable option with an embedded dash ("-") at the dash if you plan to negate it (the parser would consider a trailing dash, such as for the option --some-option using --some- as the option, as part of the name rather than a negating dash). This may be changed to force the last dash in --some- to be negating in the future.
-a --ascii [Systems using EBCDIC] Translate file to ASCII format.
-A --adjust-sfx Adjust self-extracting executable archive.  A self-extracting executable archive is created by prepending the SFX stub to an existing archive. The -A option tells zip to adjust the entry offsets stored in the archive to take into account this "preamble" data.
Note: self-extracting archives for the Amiga are a special case.  At present, only the Amiga port of zip is capable of adjusting or updating these without corrupting them. -J can be used to remove the SFX stub if other updates need to be made.
-AC --archive-clear [WIN32]  Once archive is created (and tested if -T is used, which is recommended), clear the archive bits of files processed. WARNING: Once the bits are cleared they are cleared.  You may want to use the -sf show files option to store the list of files processed in case the archive operation must be repeated.  Also consider using the -MM must match option.  Be sure to check out -DF as a possibly better way to do incremental backups.
-AS --archive-set [WIN32]  Only include files that have the archive bit set. Directories are not stored when -AS is used, though by default the paths of entries, including directories, are stored as usual and can be used by most unzips to recreate directories.
The archive bit is set by the operating system when a file is modified and, if used with -AC, -AS can provide an incremental backup capability.  However, other applications can modify the archive bit and it may not be a reliable indicator of which files have changed since the last archive operation.  Alternative ways to create incremental backups are using -t to use file dates, though this won't catch old files copied to directories being archived, and -DF to create a differential archive.
-B --binary [VM/CMS and MVS] force file to be read binary (default is text).
-Bn    [TANDEM] set Edit/Enscribe formatting options with n defined as bit  0: Don't add delimiter (Edit/Enscribe) bit  1: Use LF rather than CR/LF as delimiter (Edit/Enscribe) bit  2: Space fill record to maximum record length (Enscribe) bit  3: Trim trailing space (Enscribe) bit  8: Force 30K (Expand) large read for unstructured files
-b path --temp-path path Use the specified path for the temporary zip archive. For example:
zip -b /tmp stuff *
will put the temporary zip archive in the directory /tmp, copying over stuff.zip to the current directory when done. This option is useful when updating an existing archive and the file system containing this old archive does not have enough space to hold both old and new archives at the same time.  It may also be useful when streaming in some cases to avoid the need for data descriptors.  Note that using this option may require zip take additional time to copy the archive file when done to the destination file system.
-c --entry-comments Add one-line comments for each file.  File operations (adding, updating) are done first, and the user is then prompted for a one- line comment for each file.  Enter the comment followed by return, or just return for no comment.
-C --preserve-case [VMS]  Preserve case all on VMS.  Negating this option (-C-) downcases.
-C2 --preserve-case-2 [VMS]  Preserve case ODS2 on VMS.  Negating this option (-C2-) downcases.
-C5 --preserve-case-5 [VMS]  Preserve case ODS5 on VMS.  Negating this option (-C5-) downcases.
-d --delete Remove (delete) entries from a zip archive.  For example:
zip -d foo foo/tom/junk foo/harry/\* \*.o
will remove the entry foo/tom/junk, all of the files that start with foo/harry/, and all of the files that end with .o (in any path).  Note that shell pathname expansion has been inhibited with backslashes, so that zip can see the asterisks, enabling zip to match on the contents of the zip archive instead of the contents of the current directory.  (The backslashes are not used on MSDOS- based platforms.)  Can also use quotes to escape the asterisks as in
zip -d foo foo/tom/junk "foo/harry/*" "*.o"
Not escaping the asterisks on a system where the shell expands wildcards could result in the asterisks being converted to a list of files in the current directory and that list used to delete entries from the archive.
Under MSDOS, -d is case sensitive when it matches names in the zip archive.  This requires that file names be entered in upper case if they were zipped by PKZIP on an MSDOS system.  (We considered making this case insensitive on systems where paths were case insensitive, but it is possible the archive came from a system where case does matter and the archive could include both Bar and bar as separate files in the archive.)  But see the new option -ic to ignore case in the archive.
-db --display-bytes Display running byte counts showing the bytes zipped and the bytes to go.
-dc --display-counts Display running count of entries zipped and entries to go.
-dd --display-dots Display dots while each entry is zipped (except on ports that have their own progress indicator).  See -ds below for setting dot size.  The default is a dot every 10 MB of input file processed. The -v option also displays dots (previously at a much higher rate than this but now -v also defaults to 10 MB) and this rate is also controlled by -ds.
-df --datafork [MacOS] Include only data-fork of files zipped into the archive. Good for exporting files to foreign operating-systems.  Resource- forks will be ignored at all.
-dg --display-globaldots Display progress dots for the archive instead of for each file. The command
zip -qdgds 10m
will turn off most output except dots every 10 MB.
-ds size --dot-size size Set amount of input file processed for each dot displayed.  See -dd to enable displaying dots.  Setting this option implies -dd. Size is in the format nm where n is a number and m is a multiplier.  Currently m can be k (KB), m (MB), g (GB), or t (TB), so if n is 100 and m is k, size would be 100k which is 100 KB. The default is 10 MB.
The -v option also displays dots and now defaults to 10 MB also. This rate is also controlled by this option.  A size of 0 turns dots off.
This option does not control the dots from the "Scanning files" message as zip scans for input files.  The dot size for that is fixed at 2 seconds or a fixed number of entries, whichever is longer.
-du --display-usize Display the uncompressed size of each entry.
-dv --display-volume Display the volume (disk) number each entry is being read from, if reading an existing archive, and being written to.
-D --no-dir-entries Do not create entries in the zip archive for directories. Directory entries are created by default so that their attributes can be saved in the zip archive.  The environment variable ZIPOPT can be used to change the default options. For example under Unix with sh:
ZIPOPT="-D"; export ZIPOPT
(The variable ZIPOPT can be used for any option, including -i and -x using a new option format detailed below, and can include several options.) The option -D is a shorthand for -x "*/" but the latter previously could not be set as default in the ZIPOPT environment variable as the contents of ZIPOPT gets inserted near the beginning of the command line and the file list had to end at the end of the line.
This version of zip does allow -x and -i options in ZIPOPT if the form
-x file file ... @
is used, where the @ (an argument that is just @) terminates the list.
-DF --difference-archive Create an archive that contains all new and changed files since the original archive was created.  For this to work, the input file list and current directory must be the same as during the original zip operation.
For example, if the existing archive was created using
zip -r foofull .
from the bar directory, then the command
zip -r foofull . -DF --out foonew
also from the bar directory creates the archive foonew with just the files not in foofull and the files where the size or file time of the files do not match those in foofull.
Note that the timezone environment variable TZ should be set according to the local timezone in order for this option to work correctly.  A change in timezone since the original archive was created could result in no times matching and all files being included.
A possible approach to backing up a directory might be to create a normal archive of the contents of the directory as a full backup, then use this option to create incremental backups.
-e --encrypt Encrypt the contents of the zip archive using a password which is entered on the terminal in response to a prompt (this will not be echoed; if standard error is not a tty, zip will exit with an error).  The password prompt is repeated to save the user from typing errors.
-E --longnames [OS/2] Use the .LONGNAME Extended Attribute (if found) as filename.
-f --freshen Replace (freshen) an existing entry in the zip archive only if it has been modified more recently than the version already in the zip archive; unlike the update option (-u) this will not add files that are not already in the zip archive.  For example:
zip -f foo
This command should be run from the same directory from which the original zip command was run, since paths stored in zip archives are always relative.
Note that the timezone environment variable TZ should be set according to the local timezone in order for the -f, -u and -o options to work correctly.
The reasons behind this are somewhat subtle but have to do with the differences between the Unix-format file times (always in GMT) and most of the other operating systems (always local time) and the necessity to compare the two.  A typical TZ value is ``MET-1MEST'' (Middle European time with automatic adjustment for ``summertime'' or Daylight Savings Time).
The format is TTThhDDD, where TTT is the time zone such as MET, hh is the difference between GMT and local time such as -1 above, and DDD is the time zone when daylight savings time is in effect. Leave off the DDD if there is no daylight savings time.  For the US Eastern time zone EST5EDT.
-F --fix -FF --fixfix Fix the zip archive. The -F option can be used if some portions of the archive are missing, but requires a reasonably intact central directory.  The input archive is scanned as usual, but zip will ignore some problems.  The resulting archive should be valid, but any inconsistent entries will be left out.
When doubled as in -FF, the archive is scanned from the beginning and zip scans for special signatures to identify the limits between the archive members. The single -F is more reliable if the archive is not too much damaged, so try this option first.
If the archive is too damaged or the end has been truncated, you must use -FF.  This is a change from zip 2.32, where the -F option is able to read a truncated archive.  The -F option now more reliably fixes archives with minor damage and the -FF option is needed to fix archives where -F might have been sufficient before.
Neither option will recover archives that have been incorrectly transferred in ascii mode instead of binary. After the repair, the -t option of unzip may show that some files have a bad CRC. Such files cannot be recovered; you can remove them from the archive using the -d option of zip.
Note that -FF may have trouble fixing archives that include an embedded zip archive that was stored (without compression) in the archive and, depending on the damage, it may find the entries in the embedded archive rather than the archive itself.  Try -F first as it does not have this problem.
The format of the fix commands have changed.  For example, to fix the damaged archive foo.zip,
zip -F foo --out foofix
tries to read the entries normally, copying good entries to the new archive foofix.zip.  If this doesn't work, as when the archive is truncated, or if some entries you know are in the archive are missed, then try
zip -FF foo --out foofixfix
and compare the resulting archive to the archive created by -F. The -FF option may create an inconsistent archive.  Depending on what is damaged, you can then use the -F option to fix that archive.
A split archive with missing split files can be fixed using -F if you have the last split of the archive (the .zip file).  If this file is missing, you must use -FF to fix the archive, which will prompt you for the splits you have.
Currently the fix options can't recover entries that have a bad checksum or are otherwise damaged.
-FI --fifo [Unix]  Normally zip skips reading any FIFOs (named pipes) encountered, as zip can hang if the FIFO is not being fed.  This option tells zip to read the contents of any FIFO it finds.
-FS --filesync Synchronize the contents of an archive with the files on the OS. Normally when an archive is updated, new files are added and changed files are updated but files that no longer exist on the OS are not deleted from the archive.  This option enables a new mode that checks entries in the archive against the file system.  If the file time and file size of the entry matches that of the OS file, the entry is copied from the old archive instead of being read from the file system and compressed.  If the OS file has changed, the entry is read and compressed as usual.  If the entry in the archive does not match a file on the OS, the entry is deleted.  Enabling this option should create archives that are the same as new archives, but since existing entries are copied instead of compressed, updating an existing archive with -FS can be much faster than creating a new archive.  Also consider using -u for updating an archive.
For this option to work, the archive should be updated from the same directory it was created in so the relative paths match.  If few files are being copied from the old archive, it may be faster to create a new archive instead.
Note that the timezone environment variable TZ should be set according to the local timezone in order for this option to work correctly.  A change in timezone since the original archive was created could result in no times matching and recompression of all files.