File: README

package info (click to toggle)
cl-zip 20150608-1
  • links: PTS
  • area: main
  • in suites: bullseye, buster, sid, stretch
  • size: 136 kB
  • sloc: lisp: 1,229; makefile: 15
file content (145 lines) | stat: -rw-r--r-- 5,121 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
                            Common Lisp ZIP library

   A library for .zip-file reading and writing, written in Common Lisp.

   Credits: David Lichteblau, Tomas Hlavaty. Thanks to everyone who has
   contributed patches.

   Send bug reports to [1]<zip-devel@common-lisp.net> ([2]list
   information).

   Thanks to [3]common-lisp.net for web site and mailing list hosting.
   Please note the repository on [4]github.

   Uses [5]salza2 for compression, [6]flexi-streams for external format
   support, [7]trivial-gray-streams for gray streams portability, and
   includes [8]inflate.cl for decompression.

Recent changes

   2015: Move to github, and backport of changes from downstream fork
   (Thanks to Tomas Hlavaty.)

   2006 -- 2011: During this time a fork occurred. The common-lisp.net
   version of the library received little attention, except that it was
   ported to ASDF2. (Thanks to Faré Rideau.)

   2006: Fixed the gray stream port, including a data corruption bug that
   was in CVS for some time. (Thanks to Kevin Reid and others.) Switched
   to flexi-stream external-format functions for portability. Uses
   trivial-gray-streams now. Allegro 8.0 fix (thanks to Edi Weitz).
   Comment support (thanks to Surendra Singhi). Incompatible change: Don't
   bind *locale* on Allegro anymore.

   2005-04-05: ACL fixes (thank to Edi Weitz). Lispworks port (thanks to
   Sean Ross). Store file-write-date (also fixes FilZip compatibility).

Download

     * Using Quicklisp (if in doubt, this is a good way to get started):
(ql:quickload :zip)
     * From github:
git clone https://github.com/bluelisp/zip
     * Using clbuild2 from github:
clbuild install-from-upstream zip
       -- For the one or two clbuild users out there
     * Using clbuild2 via QuickLisp:
clbuild quickload zip
       -- Ditto
     * Tarball releases -- Unfortunately we are not currently offering a
       release tarball for download.

Portability

   Needs gray streams. The original version had separate support
   out-of-the-box on SBCL, Lispworks, and ACL. The fork briefly introduced
   some features specific to simple-stream / ACL. We believe the library
   to currently be portable to most popular Common Lisp implementations,
   but patches are welcome.

ZIP-file reading

   Zip archives are represented as opaque handles. Entries of the zip-file
   are named by strings and represented as objects, too.

   Function OPEN-ZIPFILE (pathname) => zipfile

   Open .zip-file pathname for reading and return a handle for it.

   Function CLOSE-ZIPFILE (zipfile)

   Close the file handle.

   Macro WITH-ZIPFILE ((var pathname) &body body) => result of body

   Bind var to the result of open-zipfile, evaluate body as an implicit
   progn and call close-zipfile before exiting.

   Function GET-ZIPFILE-ENTRY (name zipfile) => zipfile-entry

   Return an entry handle for the file called name.

   Function ZIPFILE-ENTRIES (zipfile) => hash-table

   Return a hash-table mapping filenames to entry handles for all files
   contained in the zip archive.

   Macro DO-ZIPFILE-ENTRIES ((name-var entry-var zipfile) &body body) =>
   nil

   Map over all entries in zipfile binding name-var and entry-var to each
   file name and entry handle in turn. Establish implicit block named nil
   around the loop.

   Function ZIPFILE-ENTRY-NAME (zipfile-entry) => string

   Return an entry's file name as a string.

   Function ZIPFILE-ENTRY-CONTENTS (entry &optional stream) => see below

   If stream is given, extract entry to the (unsigned-byte 8) stream given
   as the argument. Otherwise, return the entry contents as an
   (unsigned-byte 8) vector.

   Function UNZIP (pathname target-directory &key if-exists verbose) =>
   nil

   Extract all entries from the zip archive at pathname into
   target-directory. if-exists as for [9]cl:open.

ZIP-file writing

   zipwriters are handles used to create zip archives. They are distinct
   from the zip handles used for reading.

   Macro WITH-OUTPUT-TO-ZIPFILE ((var pathname &key if-exists) &body body)

   Function WRITE-ZIPENTRY (zipwriter name data &key file-write-date)

   Append a new entry called name to zipwriter. Read data from
   (unsigned-byte 8) stream data until EOF and compress it into
   "deflate"-format. Use file-write-date as the entry's date and time.
   Default to (file-write-date data), use 1980-01-01T00:00 if nil.

   Function ZIP (pathname source-directory &key if-exists)

   Compress all files in source-directory recursively into a new zip
   archive at pathname. Note that entry file names will not contain the
   name source-directory.

Bookmark

   [10]spec

References

   1. mailto:zip-devel@common-lisp.net
   2. http://common-lisp.net/cgi-bin/mailman/listinfo/zip-devel
   3. http://common-lisp.net/
   4. https://github.com/bluelisp/zip
   5. http://www.xach.com/lisp/salza2/
   6. http://www.weitz.de/flexi-streams/
   7. http://common-lisp.net/project/cl-plus-ssl/#trivial-gray-streams
   8. http://opensource.franz.com/deflate/
   9. http://www.xach.com/clhs.php?open
  10. http://www.pkware.com/company/standards/appnote/appnote.txt