Source

IronPython.Zlib / IronPython.Zlib / ZlibModule.cs

Full commit
Jeff Hardy 2f2ba64 

Jeff Hardy 8620ace 
Jeff Hardy 2f2ba64 











Jeff Hardy b00168f 



Jeff Hardy 0193714 
Jeff Hardy 8620ace 
Jeff Hardy b00168f 






Jeff Hardy 0193714 
Jeff Hardy b00168f 
Jeff Hardy 0193714 








Jeff Hardy b00168f 
Jeff Hardy 0193714 



Jeff Hardy b00168f 
Jeff Hardy 0193714 


Jeff Hardy b00168f 
Jeff Hardy 0193714 


Jeff Hardy b00168f 


Jeff Hardy 0193714 
Jeff Hardy b00168f 




Jeff Hardy 797d814 
Jeff Hardy b00168f 
Jeff Hardy 797d814 
Jeff Hardy b00168f 

Jeff Hardy 797d814 
Jeff Hardy b00168f 
Jeff Hardy 797d814 
Jeff Hardy b00168f 





Jeff Hardy 797d814 
Jeff Hardy b00168f 
Jeff Hardy 797d814 






Jeff Hardy b00168f 

Jeff Hardy 797d814 
Jeff Hardy b00168f 
Jeff Hardy 797d814 






Jeff Hardy b00168f 





Jeff Hardy ba92874 









Jeff Hardy b00168f 





















Jeff Hardy 0193714 
Jeff Hardy b00168f 




















































































Jeff Hardy 0193714 
Jeff Hardy b00168f 

































































/* ****************************************************************************
 *
 * Copyright (c) Jeff Hardy 2007-2009.
 *
 * This source code is subject to terms and conditions of the Microsoft Public License. A 
 * copy of the license can be found in the License.txt file at the root of this distribution. If 
 * you cannot locate the  Microsoft Public License, please send an email to 
 * jdhardy@gmail.com. By using this source code in any fashion, you are agreeing to be bound 
 * by the terms of the Microsoft Public License.
 *
 * You must not remove this notice, or any other, from this software.
 *
 * ***************************************************************************/

using System;
using System.Collections.Generic;
using System.Text;
using IronPython.Runtime;
using IronPython.Runtime.Types;
using ComponentAce.Compression.Libs.ZLib;
using System.Runtime.InteropServices;

[assembly: PythonModule("zlib", typeof(IronPython.Zlib.ZlibModule))]

namespace IronPython.Zlib
{
    public static class ZlibModule
    {
        public const string ZLIB_VERSION = "1.2.3";     // just match the zlib version in Python 2.6

        internal const int Z_OK = (int)ZLibResultCode.Z_OK;
        internal const int Z_STREAM_END = (int)ZLibResultCode.Z_STREAM_END;
        internal const int Z_NEED_DICT = (int)ZLibResultCode.Z_NEED_DICT;
        internal const int Z_ERRNO = (int)ZLibResultCode.Z_ERRNO;
        internal const int Z_STREAM_ERROR = (int)ZLibResultCode.Z_STREAM_ERROR;
        internal const int Z_DATA_ERROR = (int)ZLibResultCode.Z_DATA_ERROR;
        internal const int Z_MEM_ERROR = (int)ZLibResultCode.Z_MEM_ERROR;
        internal const int Z_BUF_ERROR = (int)ZLibResultCode.Z_BUF_ERROR;
        internal const int Z_VERSION_ERROR = (int)ZLibResultCode.Z_VERSION_ERROR;

        public const int Z_NO_FLUSH = (int)FlushStrategy.Z_NO_FLUSH;
        public const int Z_SYNC_FLUSH = (int)FlushStrategy.Z_SYNC_FLUSH;
        public const int Z_FULL_FLUSH = (int)FlushStrategy.Z_FULL_FLUSH;
        public const int Z_FINISH = (int)FlushStrategy.Z_FINISH;

        public const int Z_BEST_SPEED = ZLibCompressionLevel.Z_BEST_SPEED;
        public const int Z_BEST_COMPRESSION = ZLibCompressionLevel.Z_BEST_COMPRESSION;
        public const int Z_DEFAULT_COMPRESSION = ZLibCompressionLevel.Z_DEFAULT_COMPRESSION;

        public const int Z_FILTERED = (int)CompressionStrategy.Z_FILTERED;
        public const int Z_HUFFMAN_ONLY = (int)CompressionStrategy.Z_HUFFMAN_ONLY;
        public const int Z_DEFAULT_STRATEGY = (int)CompressionStrategy.Z_DEFAULT_STRATEGY;

        public const int DEFLATED = 8;
        public const int DEF_MEM_LEVEL = 8;
        public const int MAX_WBITS = ZLibUtil.MAX_WBITS;

        internal const int DEFAULTALLOC = 16 * 1024;

        #region adler32

        public static int adler32(string data, [DefaultParameterValue(1L)] long baseValue)
        {
            return adler32(Latin1.GetBytes(data), baseValue);
        }

        public static int adler32(byte[] data, [DefaultParameterValue(1L)] long baseValue)
        {
            return (int)Adler32.GetAdler32Checksum(baseValue, data, 0, data.Length);
        }

        #endregion

        #region crc32

        public static int crc32(string data, [DefaultParameterValue(0L)] long baseValue)
        {
            if(baseValue < int.MinValue || baseValue > uint.MaxValue)
                throw new ArgumentOutOfRangeException("baseValue");

            if(baseValue >= 0 && baseValue <= uint.MaxValue)
                return IronPython.Modules.PythonBinaryAscii.crc32(data, (uint)baseValue);
            else
                return IronPython.Modules.PythonBinaryAscii.crc32(data, (int)baseValue);
        }

        public static int crc32(byte[] data, [DefaultParameterValue(0L)] long baseValue)
        {
            if(baseValue < int.MinValue || baseValue > uint.MaxValue)
                throw new ArgumentOutOfRangeException("baseValue");

            if(baseValue >= 0 && baseValue <= uint.MaxValue)
                return IronPython.Modules.PythonBinaryAscii.crc32(data, (uint)baseValue);
            else
                return IronPython.Modules.PythonBinaryAscii.crc32(data, (int)baseValue);
        }

        #endregion

        #region compress

        public static string compress(PythonBuffer data)
        {
            return compress(data, Z_DEFAULT_COMPRESSION);
        }

        public static string compress(PythonBuffer data, int level)
        {
            return compress(data.ToString(), level);
        }

        public static string compress(string data)
        {
            return compress(data, Z_DEFAULT_COMPRESSION);
        }

        public static string compress(string data, int level)
        {
            byte[] input = Latin1.GetBytes(data);
            byte[] output = new byte[input.Length + input.Length / 1000 + 12 + 1];

            ZStream zst = new ZStream();
            zst.next_in = input;
            zst.avail_in = input.Length;
            zst.next_out = output;
            zst.avail_out = output.Length;

            int err = zst.deflateInit(level);
            if(err != Z_OK)
            {
                throw new ZStreamException();
            }

            err = zst.deflate(FlushStrategy.Z_FINISH);

            if(err != Z_STREAM_END)
            {
                zst.deflateEnd();
                throw new ZStreamException();
            }

            err = zst.deflateEnd();

            if(err == Z_OK)
                return Latin1.GetString(output, 0, (int)zst.total_out);
            else
                throw new ZStreamException();
        }

        #endregion

        #region compressobj

        public static Compress compressobj()
        {
            return compressobj(Z_DEFAULT_COMPRESSION, DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
        }

        public static Compress compressobj(int level)
        {
            return new Compress(level, DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
        }

        public static Compress compressobj(int level, int method)
        {
            return new Compress(level, method, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
        }

        public static Compress compressobj(int level, int method, int wbits)
        {
            return new Compress(level, method, wbits, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
        }

        public static Compress compressobj(int level, int method, int wbits, int memlevel)
        {
            return new Compress(level, method, wbits, memlevel, Z_DEFAULT_STRATEGY);
        }

        public static Compress compressobj(int level, int method, int wbits, int memlevel, int strategy)
        {
            return new Compress(level, method, wbits, memlevel, strategy);
        }

        #endregion

        #region decompress

        public static string decompress(string data)
        {
            return decompress(data, MAX_WBITS, DEFAULTALLOC);
        }

        public static string decompress(string data, int wbits)
        {
            return decompress(data, wbits, DEFAULTALLOC);
        }

        public static string decompress(string data, int wbits, int bufsize)
        {
            byte[] input = Latin1.GetBytes(data);

            byte[] outputBuffer = new byte[bufsize];
            byte[] output = new byte[bufsize];
            int outputOffset = 0;

            ZStream zst = new ZStream();
            zst.next_in = input;
            zst.avail_in = input.Length;
            zst.next_out = outputBuffer;
            zst.avail_out = outputBuffer.Length;

            int err = zst.inflateInit(wbits);
            if(err != Z_OK)
            {
                throw new ZStreamException();
            }

            do
            {
                err = zst.inflate(FlushStrategy.Z_FINISH);

                if(err != Z_STREAM_END)
                {
                    if(err == Z_BUF_ERROR && zst.avail_out > 0)
                    {
                        zst.inflateEnd();
                        throw new ZStreamException();
                    }
                    else if(err == Z_OK || (err == Z_BUF_ERROR && zst.avail_out == 0))
                    {
                        // copy to the output and reset the buffer
                        if(outputOffset + outputBuffer.Length > output.Length)
                            Array.Resize(ref output, output.Length * 2);

                        Array.Copy(outputBuffer, 0, output, outputOffset, outputBuffer.Length);
                        outputOffset += outputBuffer.Length;

                        zst.next_out = outputBuffer;
                        zst.avail_out = outputBuffer.Length;
                        zst.next_out_index = 0;
                    }
                    else
                    {
                        zst.inflateEnd();
                        throw new ZStreamException();
                    }
                }

            } while(err != Z_STREAM_END);

            err = zst.inflateEnd();
            if(err != Z_OK)
            {
                throw new ZStreamException();
            }

            if(outputOffset + outputBuffer.Length - zst.avail_out > output.Length)
                Array.Resize(ref output, output.Length * 2);

            Array.Copy(outputBuffer, 0, output, outputOffset, outputBuffer.Length - zst.avail_out);
            outputOffset += outputBuffer.Length - zst.avail_out;

            return Latin1.GetString(output, 0, outputOffset);
        }

        #endregion

        #region decompressobj

        public static Decompress decompressobj()
        {
            return decompressobj(MAX_WBITS);
        }

        public static Decompress decompressobj(int wbits)
        {
            return new Decompress(wbits);
        }

        #endregion

        public static readonly PythonType/*!*/ ZlibErrorType = DynamicHelpers.GetPythonTypeFromType(typeof(ZStreamException));
        public static readonly PythonType/*!*/ error = ZlibErrorType;

        internal static System.Text.Encoding Latin1 = System.Text.Encoding.GetEncoding("iso-8859-1");
    }
}