jli  Linuxx86_641.10.3v1.10.30b4590a5507d3f3046e5bafc007cacbbfc9b310bj CodecZlibZ\xfK1S=84/opt/julia/packages/CodecZlib/Ndt0H/src/CodecZlib.jl|^A#BŦ&(P;TranscodingStreamszTח?QXZwZlib_jll//opt/julia/packages/CodecZlib/Ndt0H/src/libz.jl|^A6/opt/julia/packages/CodecZlib/Ndt0H/src/compression.jl|^A8/opt/julia/packages/CodecZlib/Ndt0H/src/decompression.jl|^A CoremуJ5Basemу]J5MainmуJ5ArgToolsBń x(mуF K5 Artifactsmr-V3|mу K5Base64UlD*_mу> K5CRC32c\y.jmуj K5 FileWatchingXzsy`{,zmуh& K5LibdluVW59˗,mу-" K5LoggingT{VhUXM=mуrU" K5MmapP~:xg,Omу|' K5NetworkOptionsC0YW,mуʠ, K5SHAQ<$!<%mу1 K5 Serialization [)*k1mу-G K5Sockets1V$ bdސݗmуYBY K5UnicodeP>I>Nrmуeszo K5 LinearAlgebraSm7̏mуuux K5 OpenBLAS_jll[(Śb6EcQ FmуDux K5libblastrampoline_jllLSۆ }lxӠmу^} K5MarkdownZPn7z`smу/Ed~ K5Printfg^cX׸QDmу;h K5Random_ɢ?\Ymу? K5TarOi>աmу!t, K5DatesEY8pj2 mуX K5FuturebS;3{I xVMmуsD K5InteractiveUtilsWL ~@'ZmуVg K5LibGit2Z[&RPTv3EКRmу8J K5 LibGit2_jll YXg}]$mуD K5 MbedTLS_jllAX 3ȡ_mу- K5 LibSSH2_jlloTZk)߆ (code: $(code))" else return "zlib error: $(unsafe_string(zstream.msg)) (code: $(code))" end end 6/opt/julia/packages/CodecZlib/Ndt0H/src/compression.jl# Compressor Codecs # ================== abstract type CompressorCodec <: TranscodingStreams.Codec end function Base.show(io::IO, codec::CompressorCodec) print(io, summary(codec), "(level=$(codec.level), windowbits=$(codec.windowbits))") end # Gzip # ---- struct GzipCompressor <: CompressorCodec zstream::ZStream level::Int windowbits::Int end """ GzipCompressor(;level=$(Z_DEFAULT_COMPRESSION), windowbits=$(Z_DEFAULT_WINDOWBITS)) Create a gzip compression codec. Arguments --------- - `level`: compression level (-1..9) - `windowbits`: size of history buffer (8..15) """ function GzipCompressor(;level::Integer=Z_DEFAULT_COMPRESSION, windowbits::Integer=Z_DEFAULT_WINDOWBITS) if !(-1 ≤ level ≤ 9) throw(ArgumentError("compression level must be within -1..9")) elseif !(8 ≤ windowbits ≤ 15) throw(ArgumentError("windowbits must be within 8..15")) end return GzipCompressor(ZStream(), level, windowbits+16) end const GzipCompressorStream{S} = TranscodingStream{GzipCompressor,S} where S<:IO """ GzipCompressorStream(stream::IO; kwargs...) Create a gzip compression stream (see `GzipCompressor` for `kwargs`). """ function GzipCompressorStream(stream::IO; kwargs...) x, y = splitkwargs(kwargs, (:level, :windowbits)) return TranscodingStream(GzipCompressor(;x...), stream; y...) end # Zlib # ---- struct ZlibCompressor <: CompressorCodec zstream::ZStream level::Int windowbits::Int end """ ZlibCompressor(;level=$(Z_DEFAULT_COMPRESSION), windowbits=$(Z_DEFAULT_WINDOWBITS)) Create a zlib compression codec. Arguments --------- - `level`: compression level (-1..9) - `windowbits`: size of history buffer (8..15) """ function ZlibCompressor(;level::Integer=Z_DEFAULT_COMPRESSION, windowbits::Integer=Z_DEFAULT_WINDOWBITS) if !(-1 ≤ level ≤ 9) throw(ArgumentError("compression level must be within -1..9")) elseif !(8 ≤ windowbits ≤ 15) throw(ArgumentError("windowbits must be within 8..15")) end return ZlibCompressor(ZStream(), level, windowbits) end const ZlibCompressorStream{S} = TranscodingStream{ZlibCompressor,S} where S<:IO """ ZlibCompressorStream(stream::IO) Create a zlib compression stream (see `ZlibCompressor` for `kwargs`). """ function ZlibCompressorStream(stream::IO; kwargs...) x, y = splitkwargs(kwargs, (:level, :windowbits)) return TranscodingStream(ZlibCompressor(;x...), stream; y...) end # Deflate # ------- struct DeflateCompressor <: CompressorCodec zstream::ZStream level::Int windowbits::Int end """ DeflateCompressor(;level=$(Z_DEFAULT_COMPRESSION), windowbits=$(Z_DEFAULT_COMPRESSION)) Create a deflate compression codec. Arguments --------- - `level`: compression level (-1..9) - `windowbits`: size of history buffer (8..15) """ function DeflateCompressor(;level::Integer=Z_DEFAULT_COMPRESSION, windowbits::Integer=Z_DEFAULT_WINDOWBITS) if !(-1 ≤ level ≤ 9) throw(ArgumentError("compression level must be within -1..9")) elseif !(8 ≤ windowbits ≤ 15) throw(ArgumentError("windowbits must be within 8..15")) end return DeflateCompressor(ZStream(), level, -Int(windowbits)) end const DeflateCompressorStream{S} = TranscodingStream{DeflateCompressor,S} where S<:IO """ DeflateCompressorStream(stream::IO; kwargs...) Create a deflate compression stream (see `DeflateCompressor` for `kwargs`). """ function DeflateCompressorStream(stream::IO; kwargs...) x, y = splitkwargs(kwargs, (:level, :windowbits)) return TranscodingStream(DeflateCompressor(;x...), stream; y...) end # Methods # ------- function TranscodingStreams.initialize(codec::CompressorCodec) code = deflate_init!(codec.zstream, codec.level, codec.windowbits) if code != Z_OK zerror(codec.zstream, code) end return end function TranscodingStreams.finalize(codec::CompressorCodec) zstream = codec.zstream if zstream.state != C_NULL code = deflate_end!(zstream) if code != Z_OK zerror(zstream, code) end end return end function TranscodingStreams.startproc(codec::CompressorCodec, state::Symbol, error::Error) code = deflate_reset!(codec.zstream) if code == Z_OK return :ok else error[] = ErrorException(zlib_error_message(codec.zstream, code)) return :error end end function TranscodingStreams.process(codec::CompressorCodec, input::Memory, output::Memory, error::Error) zstream = codec.zstream zstream.next_in = input.ptr avail_in = min(input.size, typemax(UInt32)) zstream.avail_in = avail_in zstream.next_out = output.ptr avail_out = min(output.size, typemax(UInt32)) zstream.avail_out = avail_out code = deflate!(zstream, zstream.avail_in > 0 ? Z_NO_FLUSH : Z_FINISH) Δin = Int(avail_in - zstream.avail_in) Δout = Int(avail_out - zstream.avail_out) if code == Z_OK return Δin, Δout, :ok elseif code == Z_STREAM_END return Δin, Δout, :end else error[] = ErrorException(zlib_error_message(zstream, code)) return Δin, Δout, :error end end 8/opt/julia/packages/CodecZlib/Ndt0H/src/decompression.jlU# Decompressor Codecs # ==================== abstract type DecompressorCodec <: TranscodingStreams.Codec end function Base.show(io::IO, codec::DecompressorCodec) print(io, summary(codec), "(windowbits=$(codec.windowbits))") end # Gzip # ---- struct GzipDecompressor <: DecompressorCodec zstream::ZStream windowbits::Int end """ GzipDecompressor(;windowbits=$(Z_DEFAULT_WINDOWBITS), gziponly=false) Create a gzip decompressor codec. If `gziponly` is `false`, this codec can decompress the zlib format as well. Arguments --------- - `windowbits`: size of history buffer (8..15) - `gziponly`: flag to inactivate data format detection """ function GzipDecompressor(;windowbits::Integer=Z_DEFAULT_WINDOWBITS, gziponly::Bool=false) if !(8 ≤ windowbits ≤ 15) throw(ArgumentError("windowbits must be within 8..15")) end return GzipDecompressor(ZStream(), windowbits+(gziponly ? 16 : 32)) end const GzipDecompressorStream{S} = TranscodingStream{GzipDecompressor,S} where S<:IO """ GzipDecompressorStream(stream::IO; kwargs...) Create a gzip decompression stream (see `GzipDecompressor` for `kwargs`). """ function GzipDecompressorStream(stream::IO; kwargs...) x, y = splitkwargs(kwargs, (:windowbits, :gziponly)) return TranscodingStream(GzipDecompressor(;x...), stream; y...) end # Zlib # ---- struct ZlibDecompressor <: DecompressorCodec zstream::ZStream windowbits::Int end """ ZlibDecompressor(;windowbits=$(Z_DEFAULT_WINDOWBITS)) Create a zlib decompression codec. Arguments --------- - `windowbits`: size of history buffer (8..15) """ function ZlibDecompressor(;windowbits::Integer=Z_DEFAULT_WINDOWBITS) if !(8 ≤ windowbits ≤ 15) throw(ArgumentError("windowbits must be within 8..15")) end return ZlibDecompressor(ZStream(), windowbits) end const ZlibDecompressorStream{S} = TranscodingStream{ZlibDecompressor,S} where S<:IO """ ZlibDecompressorStream(stream::IO; kwargs...) Create a deflate decompression stream (see `ZlibDecompressor` for `kwargs`). """ function ZlibDecompressorStream(stream::IO; kwargs...) x, y = splitkwargs(kwargs, (:windowbits,)) return TranscodingStream(ZlibDecompressor(;x...), stream; y...) end # Deflate # ------- struct DeflateDecompressor <: DecompressorCodec zstream::ZStream windowbits::Int end """ DeflateDecompressor(;windowbits=$(Z_DEFAULT_WINDOWBITS)) Create a deflate decompression codec. Arguments --------- - `windowbits`: size of history buffer (8..15) """ function DeflateDecompressor(;windowbits::Integer=Z_DEFAULT_WINDOWBITS) if !(8 ≤ windowbits ≤ 15) throw(ArgumentError("windowbits must be within 8..15")) end return DeflateDecompressor(ZStream(), -Int(windowbits)) end const DeflateDecompressorStream{S} = TranscodingStream{DeflateDecompressor,S} where S<:IO """ DeflateDecompressorStream(stream::IO; kwargs...) Create a deflate decompression stream (see `DeflateDecompressor` for `kwargs`). """ function DeflateDecompressorStream(stream::IO; kwargs...) x, y = splitkwargs(kwargs, (:windowbits,)) return TranscodingStream(DeflateDecompressor(;x...), stream; y...) end # Methods # ------- function TranscodingStreams.initialize(codec::DecompressorCodec) code = inflate_init!(codec.zstream, codec.windowbits) if code != Z_OK zerror(codec.zstream, code) end return end function TranscodingStreams.finalize(codec::DecompressorCodec) zstream = codec.zstream if zstream.state != C_NULL code = inflate_end!(zstream) if code != Z_OK zerror(zstream, code) end end return end function TranscodingStreams.startproc(codec::DecompressorCodec, ::Symbol, error::Error) code = inflate_reset!(codec.zstream) if code == Z_OK return :ok else error[] = ErrorException(zlib_error_message(codec.zstream, code)) return :error end end function TranscodingStreams.process(codec::DecompressorCodec, input::Memory, output::Memory, error::Error) zstream = codec.zstream zstream.next_in = input.ptr avail_in = min(input.size, typemax(UInt32)) zstream.avail_in = avail_in zstream.next_out = output.ptr avail_out = min(output.size, typemax(UInt32)) zstream.avail_out = avail_out code = inflate!(zstream, Z_NO_FLUSH) Δin = Int(avail_in - zstream.avail_in) Δout = Int(avail_out - zstream.avail_out) if code == Z_OK return Δin, Δout, :ok elseif code == Z_STREAM_END return Δin, Δout, :end else error[] = ErrorException(zlib_error_message(zstream, code)) return Δin, Δout, :error end end | ǯLl