"

 COPYRIGHT (c) 2002 by eXept Software AG

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libbasic2' }"

CompressionStream subclass:#ZipStream

	instanceVariableNames:''

	classVariableNames:'Z_DEFLATED HEAD_OS_CODE HEAD_RESERVED HEAD_EXTRA_FIELD

		HEAD_ORIG_NAME HEAD_COMMENT HEAD_CRC GZ_MAGIC_ID'

	poolDictionaries:''

	category:'System-Compress'

!

!ZipStream primitiveDefinitions!

%{

/*

 * includes, defines, structure definitions

 * and typedefs come here.

 */

#include "zlib/zlib.h"

#include "zlib/zutil.h"

typedef enum {

	  e_opmode_unspecified          /* processing done */

	, e_opmode_deflate              /* running deflate */

	, e_opmode_inflate              /* running inflate */

} e_opmode;

typedef struct {

	z_stream        stream;         /* pointer to the external in -stream */

	Bytef *         in_ref;         /* size    of the external in -stream */

	Bytef *         out_ref;        /* pointer to the external out-stream */

	uLong           out_total;      /* size    of the external out-stream */

	e_opmode        op_mode;        /* current operational mode */

	uLong           crc_32;         /* keeps the current crc */

	Bytef           tail_buff[ 8 ]; /* store the tail in the read modus */

	uLong           tail_size;      /* to check the crc and data length */

} zstream_s;

%}

! !

!ZipStream class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 2002 by eXept Software AG

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    Zip compression and decompression (used in gzip and zip)

    [author:]

	Claus Atzkern

    [instance variables:]

    [class variables:]

    [see also:]

"

!

examples

"

    |compressed zipStream|

    compressed := #[] writeStream.

    zipStream := self writeOpenOn:compressed.

    zipStream nextPutAll:'This is some text 1234567890'.

    zipStream flush.

self halt.

    zipStream := self readOpenOn:compressed contents readStream.

    self information:zipStream contents.

"

! !

!ZipStream class methodsFor:'initialization'!

initialize

    "setup class attributes derived from the library

    "

    |z_deflated os_code|

%{

    z_deflated = __MKSMALLINT( Z_DEFLATED );

    os_code    = __MKSMALLINT( OS_CODE );

%}.

    Z_DEFLATED            := z_deflated.

    HEAD_OS_CODE          := os_code.

    HEAD_RESERVED         := 16rE0.     " bits 5..7:  reserved "

    HEAD_EXTRA_FIELD      := 16r04.     " bit 2 set:  extra field present "

    HEAD_ORIG_NAME        := 16r08.     " bit 3 set:  original file name present "

    HEAD_COMMENT          := 16r10.     " bit 4 set:  file comment present "

    HEAD_CRC              := 16r02.     " bit 1 set:  header CRC present "

    GZ_MAGIC_ID           := #[ 16r1f 16r8b ]

! !

!ZipStream class methodsFor:'ZipInterface compatibility - compress/uncompress'!

compress: aUncompressedByteArray into: aCompressedByteArray

    ""

    ^ self flatBytesIn: aUncompressedByteArray

		  from: 1

		    to: (aUncompressedByteArray size)

		  into: aCompressedByteArray

	    doCompress: true.

!

flatBytesIn:bytesIn from:start to:stop into:bytesOut doCompress:doCompress

    "compress or uncompress the bytesIn buffer into the bytesOut buffer; returns

     the un/compressed size; on error an exception is raised

    "

    |errorNr size|

     size := stop - start + 1.

     (    (start between:1 and:stop)

      and:[size > 0

      and:[bytesIn  size >= stop

      and:[bytesOut size >  0]]]

     ) ifFalse:[

        ^ self error:'invalid argument size'

    ].

%{

    char *  __bytesIn  = 0;

    uLong   __countIn  = 0;

    char *  __bytesOut = 0;

    uLong   __countOut = 0;

    if( (__isSmallInteger(start)) && (__isSmallInteger(stop)) && (__isSmallInteger(size)) )

    {

        __countIn = __intVal( size );

        if (__isBytes(bytesIn)) {

            __bytesIn = __ByteArrayInstPtr(bytesIn)->ba_element;

        } else {

            if (__isString(bytesIn)) {

                __bytesIn = __stringVal( bytesIn );

            }

        }

        if (__isBytes(bytesOut)) {

            __bytesOut = __ByteArrayInstPtr(bytesOut)->ba_element;

            __countOut = __byteArraySize( bytesOut );

        } else {

            if (__isString(bytesOut)) {

                __bytesOut = __stringVal( bytesOut );

                __countOut = __stringSize( bytesOut );

            }

        }

    }

    if( __bytesOut && __bytesIn )

    {

        int __result = Z_OK;

        __bytesIn += (__intVal( start)) - 1;

        if( doCompress == true )

            __result   = compress  ( (Byte *) __bytesOut, & __countOut, (Byte *) __bytesIn, __countIn );

        else

            __result   = uncompress( (Byte *) __bytesOut, & __countOut, (Byte *) __bytesIn, __countIn );

        if( __result == Z_OK )

            { RETURN(__MKSMALLINT(__countOut)); }

        errorNr = __MKSMALLINT( __result );

    }

%}.

    errorNr isNil ifTrue:[ ^ self error:'invalid arguments' ].

    errorNr ==  1 ifTrue:[ ^ self error:'stream at end' ].

    errorNr == -3 ifTrue:[ ^ self error:'input data are corrupted' ].

    errorNr == -4 ifTrue:[ ^ self error:'not enough memory' ].

    errorNr == -5 ifTrue:[ ^ self error:'not enough memory in the output stream' ].

    self error:('compressing error: ', errorNr printString).

!

uncompress: aCompressedByteArray into: aUncompressedByteArray

    ""

    ^ self flatBytesIn: aCompressedByteArray

		  from: 1

		    to: (aCompressedByteArray size)

		  into: aUncompressedByteArray

	    doCompress: false.

! !

!ZipStream class methodsFor:'ZipInterface compatibility - crc'!

crc32BytesIn:bytesIn

    "compute crc with the bytes buf[1.. bytesIn size]

     and return the crc

    "

    ^ self crc32BytesIn:bytesIn from:1

!

crc32BytesIn:bytesIn crc:aCrc

    "Update a running crc with the bytes buf[1.. bytesIn size]

     and return the updated

    "

    ^ self crc32BytesIn:bytesIn from:1 crc:aCrc

!

crc32BytesIn:bytesIn from:start

    "compute crc with the bytes buf[start.. bytesIn size]

     and return the crc

    "

    ^ self crc32BytesIn:bytesIn from:start to:(bytesIn size)

!

crc32BytesIn:bytesIn from:start crc:aCrc

    "Update a running crc with the bytes buf[start.. bytesIn size]

     and return the updated

    "

    ^ self crc32BytesIn:bytesIn from:start to:(bytesIn size) crc:aCrc

!

crc32BytesIn:bytesIn from:start to:stop

    "compute crc with the bytes buf[start.. stop]

     and return the crc

    "

    ^ self crc32BytesIn:bytesIn from:start to:stop crc:0

!

crc32BytesIn:bytesIn from:start to:stop crc:crc

    "Update a running crc with the bytes buf[start.. stop]

     and return the updated

    "

    |size|

     size := stop - start + 1.

     (    (start between:1 and:stop)

      and:[size > 0

      and:[bytesIn size >= stop]]

     ) ifFalse:[

	^ self error:'invalid argument size'

    ].

%{

    if( (__isInteger(crc)) && (__isSmallInteger(start)) && (__isSmallInteger(size)) )

    {

	char * __bytes  = 0;

	if (__isBytes(bytesIn)) {

	    __bytes = __ByteArrayInstPtr(bytesIn)->ba_element;

	} else {

	    if (__isString(bytesIn)) {

		__bytes = __stringVal( bytesIn );

	    }

	}

	if( __bytes )

	{

	    uLong  __crc  = __longIntVal( crc );

	    uInt   __size = __intVal( size );

	    __bytes += (__intVal( start)) - 1;

	    __crc = crc32(__crc, (Byte *) __bytes, __size );

	    RETURN( __MKUINT(__crc) );

	}

    }

%}.

    ^ self error:'invalid argument size'

! !

!ZipStream methodsFor:'low level'!

zclose

    "low level close of the zip stream

    "

%{

    OBJ _zstreamObj = __INST( zstream );

    if( _zstreamObj != nil )

    {

        zstream_s * _zstream = (zstream_s *) __externalBytesAddress( _zstreamObj );

        __INST(zstream) = nil;

        if( _zstream->stream.state != NULL )

        {

            if( _zstream->op_mode == e_opmode_inflate )

                inflateEnd( & _zstream->stream );

            else

                deflateEnd( & _zstream->stream );

        }

        free( _zstream );

    }

%}.

!

zdeflate

    |errorNo|

    errorNo := nil.

%{

    OBJ _zstreamObj = __INST( zstream );

    if( _zstreamObj != nil )

    {

    }

%}.

    errorNo ifNil:[

    ].

    self zerror:errorNo.

!

zdeflateInit

    |errorNo level|

    errorNo := nil.

    level   := BlockSize.

%{

    OBJ _zstreamObj = __INST( zstream );

    if( (_zstreamObj != nil) && __isSmallInteger(level) )

    {

    }

%}.

    errorNo ifNil:[

    ].

    self zerror:errorNo.

!

zget_avail_out

    "low level - get the number of available out bytes

    "

%{

    OBJ _zstreamObj = __INST( zstream );

    if( _zstreamObj != nil )

    {

	uInt        _count;

	zstream_s * _zstream = (zstream_s *) __externalBytesAddress( _zstreamObj );

	_count = _zstream->out_total - _zstream->stream.avail_out;

	RETURN( __MKSMALLINT (_count) );

    }

%}.

    self errorNotOpen.

!

zinflate

    "low level - inflate

    "

    |errorNo tailError|

    tailError := nil.

    errorNo   := nil.

%{

    OBJ _zstreamObj = __INST( zstream );

    if( _zstreamObj != nil )

    {

	int         _errorNo, _count;

	zstream_s * _zstream;

	int         _avail_in;

	_zstream = (zstream_s *) __externalBytesAddress( _zstreamObj );

	if( _zstream->op_mode != e_opmode_inflate )

	    RETURN( nil );

	_avail_in = _zstream->stream.avail_in;

	if( _zstream->stream.state == NULL )

	{

	    /* processing finished : check crc and data length */

	    Bytef * _next_in;

	    Bytef * _buff;

	    uLong   _tnum;

	    int     _i;

	    _next_in   = _zstream->stream.next_in;

	    _buff = _zstream->tail_buff;

	    _tnum = _zstream->tail_size;