Use IBufferProtocol in zlib (#979)

* Use IBufferProtocol in zlib

* Update help strings

Author: BCSharp

Src/IronPython.Modules/binascii.cs

@@ -374,20 +374,19 @@ private static int crc_hqx_impl(IList<byte> data, int crc) {
 
         #region crc32
 
-        [Documentation("crc32(string[, value]) -> string\n\nComputes a CRC (Cyclic Redundancy Check) checksum of string.")]
-        public static object crc32([NotNull]IBufferProtocol data, uint crc = 0)
-            => crc32_impl(data.ToBytes(), crc);
-
-        private static object crc32_impl(IList<byte> bytes, uint crc) {
-            var res = crc32(bytes, 0, bytes.Count, crc);
+        [Documentation("crc32(data[, crc]) -> string\n\nComputes a CRC (Cyclic Redundancy Check) checksum of data.")]
+        public static object crc32([NotNull]IBufferProtocol data, uint crc = 0) {
+            // TODO: [PythonIndex(overflow=mask)] uint crc = 0
+            using var buffer = data.GetBuffer();
+            var res = crc32(buffer.AsReadOnlySpan(), crc);
             if (res <= int.MaxValue) return (int)res;
             return (BigInteger)res;
         }
 
-        internal static uint crc32(IList<byte> buffer, int offset, int count, uint baseValue) {
+        private static uint crc32(ReadOnlySpan<byte> buffer, uint baseValue) {
             uint remainder = (baseValue ^ 0xffffffff);
-            for (int i = offset; i < offset + count; i++) {
-                remainder ^= buffer[i];
+            foreach (byte val in buffer) {
+                remainder ^= val;
                 for (int j = 0; j < 8; j++) {
                     if ((remainder & 0x01) != 0) {
                         remainder = (remainder >> 1) ^ 0xEDB88320;

Src/IronPython.Modules/zlib/ZlibModule.cs

@@ -27,11 +27,11 @@ public static class ZlibModule
         public const string __doc__ = @"The functions in this module allow compression and decompression using the
 zlib library, which is based on GNU zip.
 
-adler32(string[, start]) -- Compute an Adler-32 checksum.
-compress(string[, level]) -- Compress string, with compression level in 1-9.
+adler32(data[, value]) -- Compute an Adler-32 checksum.
+compress(data[, level]) -- Compress data, with compression level 1-9.
 compressobj([level]) -- Return a compressor object.
-crc32(string[, start]) -- Compute a CRC-32 checksum.
-decompress(string,[wbits],[bufsize]) -- Decompresses a compressed string.
+crc32(data[, value]) -- Compute a CRC-32 checksum.
+decompress(data,[wbits],[bufsize]) -- Decompresses compressed data.
 decompressobj([wbits]) -- Return a decompressor object.
 
 'wbits' is window buffer size.
@@ -69,34 +69,32 @@ public static class ZlibModule
 
         internal const int DEFAULTALLOC = 16 * 1024;
 
-        [Documentation(@"adler32(string[, start]) -- Compute an Adler-32 checksum of string.
+        [Documentation(@"adler32(data[, value]) -- Compute an Adler-32 checksum of data.
 
 An optional starting value can be specified.  The returned checksum is
 a signed integer.")]
-        public static int adler32([BytesLike]IList<byte> data, long baseValue=1L)
+        public static int adler32([NotNull] IBufferProtocol data, long value=1L)
         {
-            return (int)Adler32.GetAdler32Checksum(baseValue, data.ToArray(), 0, data.Count);
+            using var buffer = data.GetBuffer();
+            return (int)Adler32.GetAdler32Checksum(value, buffer.AsUnsafeArray() ?? buffer.ToArray(), 0, buffer.NumBytes());
         }
 
-        [Documentation(@"crc32(string[, start]) -- Compute a CRC-32 checksum of string.
+        [Documentation(@"crc32(data[, value]) -- Compute a CRC-32 checksum of data.
 
 An optional starting value can be specified.  The returned checksum is
 a signed integer.")]
-        public static BigInteger crc32([BytesLike]IList<byte> data, long baseValue=0L)
-        {
-            if(baseValue < int.MinValue || baseValue > uint.MaxValue)
-                throw new ArgumentOutOfRangeException(nameof(baseValue));
-
-            return IronPython.Modules.PythonBinaryAscii.crc32(data, 0, data.Count, (uint)baseValue);
-        }
+        public static object crc32([NotNull] IBufferProtocol data, uint value = 0)
+            // TODO: [PythonIndex(overflow=mask)] uint value = 0
+            => IronPython.Modules.PythonBinaryAscii.crc32(data, value);
 
-        [Documentation(@"compress(string[, level]) -- Returned compressed string.
+        [Documentation(@"compress(data[, level]) -- Returns a bytes object containing compressed data.
 
 Optional arg level is the compression level, in 1-9.")]
-        public static Bytes compress([BytesLike]IList<byte> data,
+        public static Bytes compress([NotNull] IBufferProtocol data,
             int level=Z_DEFAULT_COMPRESSION)
         {
-            byte[] input = data.ToArray();
+            using var buffer = data.GetBuffer();
+            byte[] input = buffer.AsUnsafeArray() ?? buffer.ToArray();
             byte[] output = new byte[input.Length + input.Length / 1000 + 12 + 1];
 
             ZStream zst = new ZStream();
@@ -154,15 +152,16 @@ public static Compress compressobj(
             return new Compress(level, method, wbits, memlevel, strategy);
         }
 
-        [Documentation(@"decompress(string[, wbits[, bufsize]]) -- Return decompressed string.
+        [Documentation(@"decompress(data[, wbits[, bufsize]]) -- Returns a bytes object containing the uncompressed data.
 
 Optional arg wbits is the window buffer size.  Optional arg bufsize is
 the initial output buffer size.")]
-        public static Bytes decompress([BytesLike]IList<byte> data,
+        public static Bytes decompress([NotNull] IBufferProtocol data,
             int wbits=MAX_WBITS,
             int bufsize=DEFAULTALLOC)
         {
-            var bytes = Decompress(data.ToArray(), wbits, bufsize);
+            using var buffer = data.GetBuffer();
+            var bytes = Decompress(buffer.AsUnsafeArray() ?? buffer.ToArray(), wbits, bufsize);
             return Bytes.Make(bytes);
         }
 

Src/IronPython/Runtime/BufferProtocol.cs

@@ -7,6 +7,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 
 using IronPython.Runtime.Exceptions;
 
@@ -272,6 +273,24 @@ public static void CopyTo(this IPythonBuffer buffer, Span<byte> dest) {
                 }
             }
         }
+
+        internal static byte[]? AsUnsafeArray(this IPythonBuffer buffer) {
+            if (!buffer.IsCContiguous())
+                return null;
+
+            if (buffer.Object is Bytes b)
+                return b.UnsafeByteArray;
+
+            if (buffer.Object is Memory<byte> mem) {
+                if (MemoryMarshal.TryGetArray(mem, out ArraySegment<byte> seg) && seg.Array != null && seg.Offset == 0 && seg.Count == seg.Array.Length)
+                    return seg.Array;
+            } else if (buffer.Object is ReadOnlyMemory<byte> rom) {
+                if (MemoryMarshal.TryGetArray(rom, out ArraySegment<byte> seg) && seg.Array != null && seg.Offset == 0 && seg.Count == seg.Array.Length)
+                    return seg.Array;
+            }
+
+            return null;
+        }
     }
 
     public ref struct BufferBytesEnumerator {