zip – команды

Чтобы сжать файл с помощью zip, введите:

zip -r files

В этом примере filename определяет имя создаваемого файла, а files определяет какие файлы вы хотите включить в архив:

Чтобы извлечь содержимое файла zip, введите:


Вы можете сжать с помощью zip или gzip сразу несколько файлов. Перечислите имена файлов, разделив их пробелами.

gzip filename.gz file1 file2 file3 /user/work/school 
     zip, zipcloak, zipnote,  zipsplit  -  package  and  compress
     (archive) files

     zip       [-AcdDeEfFghjklLmoqrRSTuvVwXyz@$]        [-b path]
     [-n suffixes] [-t mmddyyyy] [-tt mmddyyyy] [ zipfile [ file1
     file2 ...]]  [-xi list]

     zipcloak [-dhL] [-b path] zipfile

     zipnote [-hwL] [-b path] zipfile

     zipsplit [-hiLpst] [-n size] [-b path] zipfile

     zip is a compression and file packaging  utility  for  Unix,
     VMS,  MSDOS,  OS/2,  Windows NT, Minix, Atari and 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, and PKZIP and PKUNZIP can work with archives  pro-
     duced  by  zip.   zip  version  2.2 is compatible with PKZIP
     2.04.  Note that PKUNZIP 1.10 cannot extract files  produced
     by  PKZIP  2.04  or  zip  2.2. You must use PKUNZIP 2.04g or
     unzip 5.0p1 (or later versions) to extract them.

     For a brief help on zip and unzip, run each without specify-
     ing any parameters on the command line.

     The program is useful for packaging a set of files for  dis-
     tribution; 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.  zip automati-
     cally chooses the better of the two  for  each  file  to  be

     When given the name of an existing  zip  archive,  zip  will
     replace  identically named entries in the zip archive or add
     entries for new names.  For example, if  exists  and
     contains foo/file1 and foo/file2, and the directory foo con-
     tains the files foo/file1 and foo/file3, then:

          zip -r foo foo

     will replace foo/file1  in  and  add  foo/file3  to  After this, contains foo/file1, foo/file2,
     and foo/file3, with foo/file2 unchanged from before.

     If the file list is specified as -@, zip takes the  list  of
     input  files  from  standard input.  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).  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 pro-
     gram. 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

     is equivalent to

          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.  For

     dd if=/dev/nrst0  ibs=16k | funzip | tar xvf -

     When changing an existing zip archive, zip will write a tem-
     porary  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  exten-
     sion,  the extension .zip is added. If the name already con-
     tains an extension other than .zip the existing extension is
     kept unchanged.

     -A   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

     -b 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 to the current directory
          when done. This option is only 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.

     -c   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

     -d   Remove (delete) entries from a zip archive.  For  exam-

               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.

          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.

     -D   Do not create entries in the  zip  archive  for  direc-
          tories.   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  except
          -i  and -x and can include several options.) The option
          -D is a shorthand for -x "*/" but the latter cannot  be
          set as default in the ZIPOPT environment variable.

     -e   Encrypt the contents of the zip archive using  a  pass-
          word  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.

     -f   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 com-
          pare the two.  A  typical  TZ  value  is  ``MET-1MEST''
          (Middle  European  time  with  automatic adjustment for
          ``summertime'' or Daylight Savings Time).

     -F   Fix the zip archive. This option can be  used  if  some
          portions   of  the  archive  are  missing.  It  is  not
          guaranteed to work, so you MUST make a  backup  of  the
          original archive first.

          When doubled as  in  -FF  the  compressed  sizes  given
          inside  the  damaged  archive  are  not trusted 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,  for
          example  if  it  has  only  been truncated, so try this
          option first.

          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.

     -g   Grow (append to) the specified zip archive, instead  of
          creating  a  new  one.  If  this  operation  fails, zip
          attempts to restore the archive to its original  state.
          If the restoration fails, the archive might become cor-
          rupted. This option is ignored when there's no existing
          archive  or  when  at  least one archive member must be
          updated or deleted.

     -h   Display the zip help information (this also appears  if
          zip is run with no arguments).

     -i files
          Include only the specified files, as in:

               zip -r foo . -i \*.c

          which will include only the files that end in .c in the
          current  directory  and  its  subdirectories. (Note for
          PKZIP users: the equivalent command is

               pkzip -rP foo *.c

          PKZIP does not allow  recursion  in  directories  other
          than  the current one.)  The backslash avoids the shell
          filename substitution, so that  the  name  matching  is
          performed by zip at all directory levels.

          Also possible:

               zip -r foo  . -i@include.lst

          which will only include the files in the current direc-
          tory  and its subdirectories that match the patterns in
          the file include.lst.

     -I   Don't scan through Image files. This option  is  avail-
          able  on  Acorn  RISC  OS only; when used, zip will not
          consider Image  files  (eg.  DOS  partitions  or  Spark
          archives  when  SparkFS  is  loaded) as directories but
          will store them as single files.

          For example, if you  have  SparkFS  loaded,  zipping  a
          Spark  archive  will  result  in a zipfile containing a
          directory (and its content) while using the 'I'  option
          will  result  in  a zipfile containing a Spark archive.
          Obviously  this  second  case  will  also  be  obtained
          (without the 'I' option) if SparkFS isn't loaded.

     -j   Store just the name of a saved file  (junk  the  path),
          and  do not store directory names. By default, zip will
          store the full path (relative to the current path).

     -J   Strip any prepended data (e.g. a  SFX  stub)  from  the

     -k   Attempt to convert the names and paths  to  conform  to
          MSDOS,  store  only  the MSDOS attribute (just the user
          write attribute from UNIX), and mark the entry as  made
          under MSDOS (even though it was not); for compatibility
          with PKUNZIP under MSDOS which  cannot  handle  certain
          names such as those with two dots.

     -l   Translate the Unix end-of-line character  LF  into  the
          MSDOS  convention CR LF. This option should not be used
          on binary files.  This option can be used  on  Unix  if
          the  zip  file  is intended for PKUNZIP under MSDOS. If
          the input files already contain CR LF, this option adds
          an extra CR. This ensure that unzip -a on Unix will get
          back an exact copy of the original file,  to  undo  the
          effect of zip -l.

     -ll  Translate the MSDOS end-of-line CR  LF  into  Unix  LF.
          This  option  should not be used on binary files.  This
          option can be used on MSDOS if the zip file is intended
          for unzip under Unix.

     -L   Display the zip license.

     -m   Move the specified files into the  zip  archive;  actu-
          ally,  this  deletes the target directories/files after
          making  the  specified  zip  archive.  If  a  directory
          becomes empty after removal of the files, the directory
          is also removed. No deletions are done  until  zip  has
          created  the archive without error.  This is useful for
          conserving disk space, but is potentially dangerous  so
          it  is  recommended to use it in combination with -T to
          test the archive before removing all input files.

     -n suffixes
          Do not attempt to compress files named with  the  given
          suffixes. Such files are simply stored (0% compression)
          in the output zip file, so that zip doesn't  waste  its
          time   trying  to  compress  them.   The  suffixes  are
          separated by either colons or semicolons.  For example:

               zip -rn  foo foo

          will copy everything from foo into,  but  will
          store  any  files that end in .Z, .zip, .tiff, .gif, or
          .snd without trying to compress them (image  and  sound
          files  often  have  their  own  specialized compression
          methods).  By default, zip does not compress files with
          extensions  in  the  list
          Such files are stored directly in the  output  archive.
          The  environment  variable ZIPOPT can be used to change
          the default options. For example under Unix with csh:

               setenv ZIPOPT "-n"

          To attempt compression on all files, use:

               zip -n : foo

          The  maximum  compression  option  -9   also   attempts
          compression on all files regardless of extension.

          On Acorn RISC OS  systems  the  suffixes  are  actually
          filetypes  (3  hex  digit format). By default, zip does
          not  compress  files  with  filetypes   in   the   list
          DDC:D96:68E  (i.e.  Archives,  CFS  files  and  PackDir

     -N   Save Amiga filenotes as zipfile comments. They  can  be
          restored  by  using the -N option of unzip. This option
          is available on the Amiga only. If -c is used also, you
          are  prompted for comments only for those files that do
          not have filenotes.

     -o   Set the "last modified" time of the zip archive to  the
          latest  (oldest)  "last  modified" time found among the
          entries in the zip archive.  This can be  used  without
          any other operations, if desired.  For example:

          zip -o foo

          will change the last modified time of  to  the
          latest time of the entries in

          In this case, all the files and directories in foo  are
          saved  in  a zip archive named, including files
          with names starting with ".", since the recursion  does
          not  use  the shell's file-name substitution mechanism.
          If you wish to include only a specific  subset  of  the
          files  in directory foo and its subdirectories, use the
          -i option  to  specify  the  pattern  of  files  to  be
          included.   You  should  not use -r with the name ".*",
          since that matches ".."  which will attempt to  zip  up
          the parent directory (probably not what was intended).

     -R   Travel the directory structure recursively starting  at
          the current directory; for example:

               zip -R foo *.c

          In this case, all the files matching *.c  in  the  tree
          starting at the current directory are stored into a zip
          archive named   Note  for  PKZIP  users:  the
          equivalent command is

               pkzip -rP foo *.c

     -S   Include system and hidden files. This option is  effec-
          tive on some systems only; it is ignored on Unix.

     -t mmddyyyy
          Do not operate on files modified prior to the specified
          date,  where  mm  is the month (0-12), dd is the day of
          the month (1-31), and yyyy is the year.  For example:

               zip -rt 12071991 infamy foo

          will add all the files in foo  and  its  subdirectories
          that were last modified on or after 7 December 1991, to
          the zip archive

     -tt mmddyyyy
          Do not operate on files modified after or at the speci-
          fied  date, where mm is the month (0-12), dd is the day
          of the month (1-31), and yyyy is the year.   For  exam-
               zip -rtt 11301995 infamy foo

          will add all the files in foo  and  its  subdirectories
          that were last modified before the 30 November 1995, to
          the zip archive

     -T   Test the integrity of the new zip file.  If  the  check
          fails,  the  old zip file is unchanged and (with the -m
          option) no input files are removed.

     -u   Replace (update) an existing entry in the  zip  archive
          only  if  it  has  been modified more recently than the
          version already in the zip archive.  For example:

               zip -u stuff *

          will add any new files in the  current  directory,  and
          update any files which have been modified since the zip
          archive was last created/modified (note  that
          zip will not try to pack into itself when you
          do this).

          Note that the -u option with no arguments acts like the
          -f (freshen) option.

     -v   Verbose mode or print diagnostic version info.

          Normally, when applied to real operations, this  option
          enables  the  display  of  a  progress indicator during
          compression and requests verbose diagnostic info  about
          zipfile structure oddities.

          When -v is the only command line argument,  and  stdout
          is  not  redirected  to  a file, a diagnostic screen is
          printed. In addition to the  help  screen  header  with
          program  name, version, and release date, some pointers
          to the Info-ZIP home and distribution sites are  given.
          Then, it shows information about the target environment
          (compiler type and  version,  OS  version,  compilation
          date  and  the enabled optional features used to create
          the zip executable.

     -V   Save VMS file attributes. This option is  available  on
          VMS  only;  zip  archives created with this option will
          generally not be usable on other systems.

     -w   Append the version number of the  files  to  the  name,
          including  multiple  versions  of  files.   (VMS  only;
          default:  use only the most recent version of a  speci-
          fied file).

     -x files
          Explicitly exclude the specified files, as in:

               zip -r foo foo -x \*.o

          which will include the contents of foo in while
          excluding  all the files that end in .o.  The backslash
          avoids the shell filename  substitution,  so  that  the
          name matching is performed by zip at all directory lev-

          Also possible:

               zip -r foo foo -x@exclude.lst

          which will include the contents of foo in while
          excluding  all the files that match the patterns in the
          file exclude.lst.

     -X   Do not save extra file attributes (Extended  Attributes
          on OS/2, uid/gid and file times on Unix).

     -y   Store symbolic  links  as  such  in  the  zip  archive,
          instead of compressing and storing the file referred to
          by the link (UNIX only).

     -z   Prompt for a multi-line  comment  for  the  entire  zip
          archive.   The  comment  is  ended by a line containing
          just a period, or an end of file condition (^D on UNIX,
          ^Z  on  MSDOS,  OS/2, and VAX/VMS).  The comment can be
          taken from a file:

               zip -z foo < foowhat

     -#   Regulate the speed of compression using  the  specified
          digit  #,  where -0 indicates no compression (store all
          files), -1 indicates  the  fastest  compression  method
          (less   compression)   and  -9  indicates  the  slowest
          compression method (optimal  compression,  ignores  the
          suffix list). The default compression level is -6.

     -@   Take the list of input files from standard input.  Only
          one filename per line.

     -$   Include the volume label for the the drive holding  the
          first  file  to  be compressed.  If you want to include
          only the volume label or to force a specific drive, use
          the drive name as first file name, as in:

               zip -$ foo a: c:bar

          This option is effective on some  systems  only  (MSDOS
          and OS/2); it is ignored on Unix.

     The simplest example:

          zip stuff *

     creates the archive (assuming it does  not  exist)
     and  puts  all  the files in the current directory in it, in
     compressed form (the .zip  suffix  is  added  automatically,
     unless  that archive name given contains a dot already; this
     allows the explicit specification of other suffixes).

     Because of the way the  shell  does  filename  substitution,
     files  starting  with "." are not included; to include these
     as well:

          zip stuff .* *

     Even this will  not  include  any  subdirectories  from  the
     current directory.

     To zip up an entire directory, the command:

          zip -r foo foo

     creates the archive, containing all  the  files  and
     directories  in  the  directory foo that is contained within
     the current directory.

     You may want to make a zip archive that contains  the  files
     in  foo, without recording the directory name, foo.  You can
     use the -j option to leave off the paths, as in:

          zip -j foo foo/*

     If you are short on disk space, you might  not  have  enough
     room to hold both the original directory and the correspond-
     ing compressed zip archive.  In this case,  you  can  create
     the  archive  in steps using the -m option.  If foo contains
     the subdirectories tom, dick, and harry, you can:

          zip -rm foo foo/tom
          zip -rm foo foo/dick
          zip -rm foo foo/harry

     where the first command creates, and  the  next  two
     add  to it.  At the completion of each zip command, the last
     created archive is deleted, making room  for  the  next  zip
     command to function.

     This section applies only to UNIX.   Watch  this  space  for
     details on MSDOS and VMS operation.
     The UNIX shells (sh(1) and csh(1)) do filename  substitution
     on command arguments.  The special characters are:

     ?    match any single character

     *    match any number of characters (including none)

     []   match any character in the range indicated  within  the
          brackets (example: [a-f], [0-9]).

     When these characters are encountered (without being escaped
     with  a  backslash or quotes), the shell will look for files
     relative to the current path that  match  the  pattern,  and
     replace the argument with a list of the names that matched.

     The zip program can do the same matching on names  that  are
     in  the zip archive being modified or, in the case of the -x
     (exclude) or -i (include) options, on the list of  files  to
     be  operated  on, by using backslashes or quotes to tell the
     shell not to do the name expansion.  In  general,  when  zip
     encounters a name in the list of files to do, it first looks
     for the name in the file system.  If it finds  it,  it  then
     adds it to the list of files to do.  If it does not find it,
     it looks for the name in the zip archive being modified  (if
     it  exists), using the pattern matching characters described
     above, if present.  For each match, it will add that name to
     the  list of files to be processed, unless this name matches
     one given with the -x option, or does  not  match  any  name
     given with the -i option.

     The pattern matching includes the path, and so patterns like
     \*.o  match  names that end in ".o", no matter what the path
     prefix is.  Note that the backslash must precede every  spe-
     cial  character  (i.e. ?*[]), or the entire argument must be
     enclosed in double quotes ("").

     In general, use backslash to make zip do the pattern  match-
     ing with the -f (freshen) and -d (delete) options, and some-
     times after the  -x  (exclude)  option  when  used  with  an
     appropriate operation (add, -u, -f, or -d).

     compress(1), shar(1L), tar(1), unzip(1L), gzip(1L)

     The exit status (or error level) approximates the exit codes
     defined  by PKWARE and takes on the following values, except
     under VMS:

          0    normal; no errors or warnings detected.

          2    unexpected end of zip file.
          3    a  generic  error  in  the  zipfile   format   was
               detected.   Processing may have completed success-
               fully anyway;  some  broken  zipfiles  created  by
               other archivers have simple work-arounds.

          4    zip was unable to allocate memory for one or  more
               buffers during program initialization.

          5    a severe error in the zipfile format was detected.
               Processing probably failed immediately.

          6    entry too large to be split with zipsplit

          7    invalid comment format

          8    zip -T failed or out of memory

          9    the user aborted zip  prematurely  with  control-C
               (or similar)

          10   zip encountered an error while using a temp file

          11   read or seek error

          12   zip has nothing to do

          13   missing or empty zip file

          14   error writing to a file

          15   zip was unable to create a file to write to

          16   bad command line parameters

          18   zip could not open a specified file to read

     VMS interprets standard Unix (or PC) return values as other,
     scarier-looking  things,  so zip instead maps them into VMS-
     style status codes.  The current mapping is as follows:    1
     (success) for normal exit,
      and  (0x7fff000?  +  16*normal_zip_exit_status)   for   all
     errors,  where  the  `?'  is 0 (warning) for zip value 12, 2
     (error) for the zip values 3, 6, 7, 9, 13,  16,  18,  and  4
     (fatal error) for the remaining ones.

     zip 2.2 is not compatible with PKUNZIP 1.10. Use zip 1.1  to
     produce zip files which can be extracted by PKUNZIP 1.10.

     zip files produced by zip 2.2 must not be updated by zip 1.1
     or  PKZIP 1.10, if they contain encrypted members or if they
     have been produced in a pipe or on  a  non-seekable  device.
     The  old  versions  of  zip or PKZIP would create an archive
     with an incorrect format.  The old  versions  can  list  the
     contents  of  the  zip  file  but  cannot  extract it anyway
     (because of the new compression algorithm).  If you  do  not
     use  encryption  and use regular disk files, you do not have
     to care about this problem.

     Under VMS, not all of the odd file formats are treated prop-
     erly.   Only stream-LF format zip files are expected to work
     with zip.  Others can be converted using Rahul Dhesi's  BILF
     program.  This version of zip handles some of the conversion
     internally.  When using Kermit to transfer  zip  files  from
     Vax  to  MSDOS, type "set file type block" on the Vax.  When
     transfering from MSDOS to Vax, type "set file type fixed" on
     the  Vax.   In  both  cases,  type "set file type binary" on

     Under VMS, zip hangs for file specification that uses DECnet
     syntax foo::*.*.

     On OS/2, zip cannot match some names, such as those  includ-
     ing  an  exclamation  mark or a hash sign.  This is a bug in
     OS/2 itself: the 32-bit DosFindFirst/Next  don't  find  such
     names.   Other programs such as GNU tar are also affected by
     this bug.

     Under OS/2, the amount of Extended Attributes  displayed  by
     DIR is (for compatibility) the amount returned by the 16-bit
     version of DosQueryPathInfo(). Otherwise OS/2  1.3  and  2.0
     would  report  different  EA sizes when DIRing a file.  How-
     ever,  the  structure  layout   returned   by   the   32-bit
     DosQueryPathInfo() is a bit different, it uses extra padding
     bytes and link pointers (it's a linked  list)  to  have  all
     fields  on  4-byte boundaries for portability to future RISC
     OS/2 versions. Therefore the value reported  by  zip  (which
     uses  this  32-bit-mode  size) differs from that reported by
     DIR.  zip stores the 32-bit format for portability, even the
     16-bit  MS-C-compiled  version  running on OS/2 1.3, so even
     this one shows the 32-bit-mode size.

     Copyright (C) 1990-1997 Mark Adler, Richard B. Wales,  Jean-
     loup  Gailly, Onno van der Linden, Kai Uwe Rommel, Igor Man-
     drichenko,  John  Bush  and  Paul  Kienitz.   Permission  is
     granted  to  any  individual or institution to use, copy, or
     redistribute this software so long as all  of  the  original
     files are included, that it is not sold for profit, and that
     this copyright notice is retained.


     Please  send  bug  reports  and  comments   by   email   to:  For bug reports, please include the
     version of zip (see zip-h ), the make options used  to  com-
     pile  it  see  zip-v  ), the machine and operating system in
     use, and as much additional information as possible.

     Thanks to R. P. Byrne  for  his  Shrink.Pas  program,  which
     inspired  this  project, and from which the shrink algorithm
     was stolen; to Phil Katz for placing in  the  public  domain
     the  zip  file format, compression format, and .ZIP filename
     extension, and for accepting minor changes to the file  for-
     mat; to Steve Burg for clarifications on the deflate format;
     to Haruhiko Okumura and Leonid Broukhis for  providing  some
     useful  ideas for the compression algorithm; to Keith Peter-
     sen, Rich Wales, Hunter Goatley and Mark Adler for providing
     a  mailing  list and ftp site for the Info-ZIP group to use;
     and most importantly, to the Info-ZIP group  itself  (listed
     in  the file infozip.who) without whose tireless testing and
     bug-fixing efforts a portable zip would not have been possi-
     ble.   Finally  we  should  thank (blame) the first Info-ZIP
     moderator, David Kirschbaum, for getting us into  this  mess
     in  the first place.  The manual page was rewritten for UNIX
     by R. P. C. Rodgers.

If you found an error, highlight it and press Shift + Enter or click here to inform us.

Author: master

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *