{"id":6323,"date":"2022-12-20T18:58:09","date_gmt":"2022-12-20T21:58:09","guid":{"rendered":"http:\/\/lode.uno\/linux-man\/index.php\/2022\/12\/20\/zlib-mann\/"},"modified":"2022-12-20T18:58:09","modified_gmt":"2022-12-20T21:58:09","slug":"zlib-mann","status":"publish","type":"post","link":"https:\/\/lode.uno\/linux-man\/2022\/12\/20\/zlib-mann\/","title":{"rendered":"zlib (mann)"},"content":{"rendered":"

zlib<\/h1>\n

NAME<\/a>
SYNOPSIS<\/a>
DESCRIPTION<\/a>
STREAMING INSTANCE COMMAND<\/a>
EXAMPLES<\/a>
SEE ALSO<\/a>
KEYWORDS<\/a> <\/p>\n

\n

______________________________________________________________________________<\/p>\n

NAME <\/a> <\/h2>\n

zlib \u2212 compression and decompression operations<\/p>\n

SYNOPSIS <\/a> <\/h2>\n

zlib<\/b> subcommand arg …<\/i> ______________________________________________________________________________<\/p>\n

DESCRIPTION <\/a> <\/h2>\n

The zlib<\/b> command provides access to the compression and check-summing facilities of the Zlib library by Jean-loup Gailly and Mark Adler. It has the following subcommands.<\/p>\n

COMPRESSION SUBCOMMANDS
zlib compress<\/b> string<\/i> ?level<\/i>?<\/p>\n

Returns the zlib-format compressed binary data of the binary string in string<\/i>. If present, level<\/i> gives the compression level to use (from 0, which is uncompressed, to 9, maximally compressed).<\/p>\n

zlib decompress<\/b> string<\/i> ?bufferSize<\/i>?<\/p>\n

Returns the uncompressed version of the raw compressed binary data in string<\/i>. If present, bufferSize<\/i> is a hint as to what size of buffer is to be used to receive the data.<\/p>\n

zlib deflate<\/b> string<\/i> ?level<\/i>?<\/p>\n

Returns the raw compressed binary data of the binary string in string<\/i>. If present, level<\/i> gives the compression level to use (from 0, which is uncompressed, to 9, maximally compressed).<\/p>\n

zlib gunzip<\/b> string<\/i> ?\u2212headerVar<\/b> varName<\/i>?<\/p>\n

Return the uncompressed contents of binary string string<\/i>, which must have been in gzip format. If \u2212headerVar<\/b> is given, store a dictionary describing the contents of the gzip header in the variable called varName<\/i>. The keys of the dictionary that may be present are:
comment<\/b><\/p>\n

The comment field from the header, if present.<\/p>\n\n\n
<\/td>\n\n

crc<\/b><\/p>\n<\/td>\n

<\/td>\n\n

A boolean value describing whether a CRC of the header is computed.<\/p>\n<\/td>\n<\/tr>\n<\/table>\n

filename<\/b><\/p>\n

The filename field from the header, if present.<\/p>\n\n\n\n\n\n
<\/td>\n\n

os<\/b><\/p>\n<\/td>\n

<\/td>\n\n

The operating system type code field from the header (if not the QW unknown value). See RFC 1952 for the meaning of these codes.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

size<\/b><\/p>\n<\/td>\n

<\/td>\n\n

The size of the uncompressed data.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

time<\/b><\/p>\n<\/td>\n

<\/td>\n\n

The time field from the header if non-zero, expected to be time that the file named by the filename<\/b> field was modified. Suitable for use with clock format<\/b>.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

type<\/b><\/p>\n<\/td>\n

<\/td>\n\n

The type of the uncompressed data (binary<\/b> or text<\/b>) if known.<\/p>\n<\/td>\n<\/tr>\n<\/table>\n

zlib gzip<\/b> string<\/i> ?\u2212level<\/b> level<\/i>? ?\u2212header<\/b> dict<\/i>?<\/p>\n

Return the compressed contents of binary string string<\/i> in gzip format. If \u2212level<\/b> is given, level<\/i> gives the compression level to use (from 0, which is uncompressed, to 9, maximally compressed). If \u2212header<\/b> is given, dict<\/i> is a dictionary containing values used for the gzip header. The following keys may be defined:
comment<\/b><\/p>\n

Add the given comment to the header of the gzip-format data.<\/p>\n\n\n
<\/td>\n\n

crc<\/b><\/p>\n<\/td>\n

<\/td>\n\n

A boolean saying whether to compute a CRC of the header. Note that if the data is to be interchanged with the gzip<\/b> program, a header CRC should not<\/i> be computed.<\/p>\n<\/td>\n<\/tr>\n<\/table>\n

filename<\/b><\/p>\n

The name of the file that the data to be compressed came from.<\/p>\n\n\n\n\n
<\/td>\n\n

os<\/b><\/p>\n<\/td>\n

<\/td>\n\n

The operating system type code, which should be one of the values described in RFC 1952.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

time<\/b><\/p>\n<\/td>\n

<\/td>\n\n

The time that the file named in the filename<\/b> key was last modified. This will be in the same as is returned by clock seconds<\/b> or file mtime<\/b>.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

type<\/b><\/p>\n<\/td>\n

<\/td>\n\n

The type of the data being compressed, being binary<\/b> or text<\/b>.<\/p>\n<\/td>\n<\/tr>\n<\/table>\n

zlib inflate<\/b> string<\/i> ?bufferSize<\/i>?<\/p>\n

Returns the uncompressed version of the raw compressed binary data in string<\/i>. If present, bufferSize<\/i> is a hint as to what size of buffer is to be used to receive the data.<\/p>\n

CHANNEL SUBCOMMAND
zlib push<\/b> mode channel<\/i> ?options …<\/i>?<\/p>\n

Pushes a compressing or decompressing transformation onto the channel channel<\/i>. The transformation can be removed again with chan pop<\/b>. The mode<\/i> argument determines what type of transformation is pushed; the following are supported:
compress<\/b><\/p>\n

The transformation will be a compressing transformation that produces zlib-format data on channel<\/i>, which must be writable.<\/p>\n

decompress<\/b><\/p>\n

The transformation will be a decompressing transformation that reads zlib-format data from channel<\/i>, which must be readable.<\/p>\n

deflate<\/b><\/p>\n

The transformation will be a compressing transformation that produces raw compressed data on channel<\/i>, which must be writable.<\/p>\n\n\n\n
<\/td>\n\n

gunzip<\/b><\/p>\n<\/td>\n

<\/td>\n\n

The transformation will be a decompressing transformation that reads gzip-format data from channel<\/i>, which must be readable.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

gzip<\/b><\/p>\n<\/td>\n

<\/td>\n\n

The transformation will be a compressing transformation that produces gzip-format data on channel<\/i>, which must be writable.<\/p>\n<\/td>\n<\/tr>\n<\/table>\n

inflate<\/b><\/p>\n

The transformation will be a decompressing transformation that reads raw compressed data from channel<\/i>, which must be readable.<\/p>\n

The following options may be set when creating a transformation via the \u201coptions …<\/i>\u201d to the zlib push<\/b> command:
\u2212dictionary<\/b> binData<\/i><\/p>\n

Sets the compression dictionary to use when working with \u2502<\/big> compressing or decompressing the data to be binData<\/i>. Not \u2502<\/big> valid for transformations that work with gzip-format \u2502<\/big> data. The dictionary should consist of strings (byte \u2502<\/big> sequences) that are likely to be encountered later in the \u2502<\/big> data to be compressed, with the most commonly used \u2502<\/big> strings preferably put towards the end of the dictionary. \u2502<\/big> Tcl provides no mechanism for choosing a good such \u2502<\/big> dictionary for a particular data sequence.<\/p>\n

\u2212header<\/b> dictionary<\/i><\/p>\n

Passes a description of the gzip header to create, in the same format that zlib gzip<\/b> understands.<\/p>\n

\u2212level<\/b> compressionLevel<\/i><\/p>\n

How hard to compress the data. Must be an integer from 0 (uncompressed) to 9 (maximally compressed).<\/p>\n

\u2212limit<\/b> readaheadLimit<\/i><\/p>\n

The maximum number of bytes ahead to read when decompressing. This defaults to 1, which ensures that data is always decompressed correctly, but may be increased to improve performance. This is more useful when the channel is non-blocking.<\/p>\n

Both compressing and decompressing channel transformations add extra configuration options that may be accessed through chan configure<\/b>. The options are:
\u2212checksum<\/b> checksum<\/i><\/p>\n

This read-only option gets the current checksum for the uncompressed data that the compression engine has seen so far. It is valid for both compressing and decompressing transforms, but not for the raw inflate and deflate formats. The compression algorithm depends on what format is being produced or consumed.<\/p>\n

\u2212dictionary<\/b> binData<\/i><\/p>\n

This read-write options gets or sets the initial \u2502<\/big> compression dictionary to use when working with \u2502<\/big> compressing or decompressing the data to be binData<\/i>. It \u2502<\/big> is not valid for transformations that work with \u2502<\/big> gzip-format data, and should not normally be set on \u2502<\/big> compressing transformations other than at the point where \u2502<\/big> the transformation is stacked. Note that this cannot be \u2502<\/big> used to get the current active compression dictionary \u2502<\/big> mid-stream, as that information is not exposed by the \u2502<\/big> underlying library.<\/p>\n

\u2212flush<\/b> type<\/i><\/p>\n

This write-only operation flushes the current state of the compressor to the underlying channel. It is only valid for compressing transformations. The type<\/i> must be either sync<\/b> or full<\/b> for a normal flush or an expensive flush respectively. Flushing degrades the compression ratio, but makes it easier for a decompressor to recover more of the file in the case of data corruption.<\/p>\n

\u2212header<\/b> dictionary<\/i><\/p>\n

This read-only option, only valid for decompressing transforms that are processing gzip-format data, returns the dictionary describing the header read off the data stream.<\/p>\n

\u2212limit<\/b> readaheadLimit<\/i><\/p>\n

This read-write option is used by decompressing channels to control the maximum number of bytes ahead to read from the underlying data source. This defaults to 1, which ensures that data is always decompressed correctly, but may be increased to improve performance. This is more useful when the channel is non-blocking.<\/p>\n

STREAMING SUBCOMMAND
zlib stream<\/b> mode<\/i> ?options<\/i>?<\/p>\n

Creates a streaming compression or decompression command based on the mode<\/i>, and return the name of the command. For a description of how that command works, see STREAMING INSTANCE COMMAND<\/b> below. The following modes and options<\/i> are supported:
zlib stream compress<\/b> ?\u2212dictionary<\/b> bindata<\/i>? ?\u2212level<\/b> level<\/i>?<\/p>\n

The stream will be a compressing stream that produces zlib-format output, using compression level level<\/i> (if specified) which will be an integer from 0 to 9, and the \u2502<\/big> compression dictionary bindata<\/i> (if specified).<\/p>\n

zlib stream decompress<\/b> ?\u2212dictionary<\/b> bindata<\/i>?<\/p>\n

The stream will be a decompressing stream that takes zlib-format input and produces uncompressed output. If \u2502<\/big> bindata<\/i> is supplied, it is a compression dictionary to \u2502<\/big> use if required.<\/p>\n

zlib stream deflate<\/b> ?\u2212dictionary<\/b> bindata<\/i>? ?\u2212level<\/b> level<\/i>?<\/p>\n

The stream will be a compressing stream that produces raw output, using compression level level<\/i> (if specified) which will be an integer from 0 to 9, and the compression \u2502<\/big> dictionary bindata<\/i> (if specified). Note that the raw \u2502<\/big> compressed data includes no metadata about what \u2502<\/big> compression dictionary was used, if any; that is a \u2502<\/big> feature of the zlib-format data.<\/p>\n

zlib stream gunzip<\/b><\/p>\n

The stream will be a decompressing stream that takes gzip-format input and produces uncompressed output.<\/p>\n

zlib stream gzip<\/b> ?\u2212header<\/b> header<\/i>? ?\u2212level<\/b> level<\/i>?<\/p>\n

The stream will be a compressing stream that produces gzip-format output, using compression level level<\/i> (if specified) which will be an integer from 0 to 9, and the header descriptor dictionary header<\/i> (if specified; for keys see zlib gzip<\/b>).<\/p>\n

zlib stream inflate<\/b> ?\u2212dictionary<\/b> bindata<\/i>?<\/p>\n

The stream will be a decompressing stream that takes raw compressed input and produces uncompressed output. If \u2502<\/big> bindata<\/i> is supplied, it is a compression dictionary to \u2502<\/big> use. Note that there are no checks in place to determine \u2502<\/big> whether the compression dictionary is correct.<\/p>\n

CHECKSUMMING SUBCOMMANDS
zlib adler32<\/b> string<\/i> ?initValue<\/i>?<\/p>\n

Compute a checksum of binary string string<\/i> using the Adler-32 algorithm. If given, initValue<\/i> is used to initialize the checksum engine.<\/p>\n

zlib crc32<\/b> string<\/i> ?initValue<\/i>?<\/p>\n

Compute a checksum of binary string string<\/i> using the CRC-32 algorithm. If given, initValue<\/i> is used to initialize the checksum engine.<\/p>\n

STREAMING INSTANCE COMMAND <\/a> <\/h2>\n

Streaming compression instance commands are produced by the zlib stream<\/b> command. They are used by calling their put<\/b> subcommand one or more times to load data in, and their get<\/b> subcommand one or more times to extract the transformed data.<\/p>\n

The full set of subcommands supported by a streaming instance command, stream<\/i>, is as follows:
stream<\/i> add<\/b> ?option…<\/i>? data<\/i><\/p>\n

A short-cut for \u201cstream<\/i> put<\/b> ?option…<\/i>? data<\/i>\u201d followed by \u201cstream<\/i> get<\/b>\u201d.<\/p>\n

stream<\/i> checksum<\/b><\/p>\n

Returns the checksum of the uncompressed data seen so far by this stream.<\/p>\n

stream<\/i> close<\/b><\/p>\n

Deletes this stream and frees up all resources associated with it.<\/p>\n

stream<\/i> eof<\/b><\/p>\n

Returns a boolean indicating whether the end of the stream (as determined by the compressed data itself) has been reached. Not all formats support detection of the end of the stream.<\/p>\n

stream<\/i> finalize<\/b><\/p>\n

A short-cut for \u201cstream<\/i> put \u2212finalize {}<\/b>\u201d.<\/p>\n

stream<\/i> flush<\/b><\/p>\n

A short-cut for \u201cstream<\/i> put \u2212flush {}<\/b>\u201d.<\/p>\n

stream<\/i> fullflush<\/b><\/p>\n

A short-cut for \u201cstream<\/i> put \u2212fullflush {}<\/b>\u201d.<\/p>\n

stream<\/i> get<\/b> ?count<\/i>?<\/p>\n

Return up to count<\/i> bytes from stream<\/i>\u2019s internal buffers with the transformation applied. If count<\/i> is omitted, the entire contents of the buffers are returned. stream<\/i> header<\/b> Return the gzip header description dictionary extracted from the stream. Only supported for streams created with their mode<\/i> parameter set to gunzip<\/b>.<\/p>\n

stream<\/i> put<\/b> ?option…<\/i>? data<\/i><\/p>\n

Append the contents of the binary string data<\/i> to stream<\/i>\u2019s internal buffers while applying the transformation. The following option<\/i>s are supported (or an unambiguous prefix of them), which are used to modify the way in which the transformation is applied:
\u2212dictionary<\/b> binData<\/i><\/p>\n

Sets the compression dictionary to use when working with \u2502<\/big> compressing or decompressing the data to be binData<\/i>.<\/p>\n

\u2212finalize<\/b><\/p>\n

Mark the stream as finished, ensuring that all bytes have been wholly compressed or decompressed. For gzip streams, this also ensures that the footer is written to the stream. The stream will need to be reset before having more data written to it after this, though data can still be read out of the stream with the get<\/b> subcommand.<\/p>\n

This option is mutually exclusive with the \u2212flush<\/b> and \u2212fullflush<\/b> options.<\/p>\n\n\n
<\/td>\n\n

\u2212flush<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Ensure that a decompressor consuming the bytes that the current (compressing) stream is producing will be able to produce all the bytes that have been compressed so far, at some performance penalty.<\/p>\n<\/td>\n<\/tr>\n<\/table>\n

This option is mutually exclusive with the \u2212finalize<\/b> and \u2212fullflush<\/b> options.<\/p>\n

\u2212fullflush<\/b><\/p>\n

Ensure that not only can a decompressor handle all the bytes produced so far (as with \u2212flush<\/b> above) but also that it can restart from this point if it detects that the stream is partially corrupt. This incurs a substantial performance penalty.<\/p>\n

This option is mutually exclusive with the \u2212finalize<\/b> and \u2212flush<\/b> options.<\/p>\n

stream<\/i> reset<\/b><\/p>\n

Puts any stream, including those that have been finalized or that have reached eof, back into a state where it can process more data. Throws away all internally buffered data.<\/p>\n

EXAMPLES <\/a> <\/h2>\n

To compress a Tcl string, it should be first converted to a particular charset encoding since the zlib<\/b> command always operates on binary strings.<\/p>\n

set binData [encoding convertto utf-8 $string]
set compData [zlib compress<\/b> $binData]<\/p>\n

When converting back, it is also important to reverse the charset encoding:<\/p>\n

set binData [zlib decompress<\/b> $compData]
set string [encoding convertfrom utf-8 $binData]<\/p>\n

The compression operation from above can also be done with streams, which is especially helpful when you want to accumulate the data by stages:<\/p>\n

set strm [zlib stream<\/b> compress]
$strm<\/i> put<\/b> [encoding convertto utf-8 $string]
# …
$strm<\/i> finalize<\/b>
set compData [$strm<\/i> get<\/b>]
$strm<\/i> close<\/b><\/p>\n

SEE ALSO <\/a> <\/h2>\n

binary(n), chan(n), encoding(n), Tcl_ZlibDeflate(3), RFC1950 \u2212 RFC1952<\/p>\n

KEYWORDS <\/a> <\/h2>\n

compress, decompress, deflate, gzip, inflate, zlib<\/p>\n

\n","protected":false},"excerpt":{"rendered":"

zlib \u2212 compression and decompression operations <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3783,1],"tags":[2635,2921],"class_list":["post-6323","post","type-post","status-publish","format-standard","hentry","category-n-comandos-tcl-tk","category-sin-categoria","tag-mann","tag-zlib"],"gutentor_comment":0,"_links":{"self":[{"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/posts\/6323","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/comments?post=6323"}],"version-history":[{"count":0,"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/posts\/6323\/revisions"}],"wp:attachment":[{"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/media?parent=6323"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/categories?post=6323"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/tags?post=6323"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}