Convert S.IO.Compression.Native to C (#30179)

* Convert S.IO.Compression.Native to C

* Add DLLEXPORT

Author: kasper3

src/Native/Unix/System.IO.Compression.Native/CMakeLists.txt

@@ -3,7 +3,7 @@ project(System.IO.Compression.Native)
 find_package(ZLIB REQUIRED)
 
 set(NATIVECOMPRESSION_SOURCES
-    pal_zlib.cpp
+    pal_zlib.c
 )
 
 #Include Brotli include files

src/Native/Unix/System.IO.Compression.Native/pal_zlib.cpp renamed to src/Native/Unix/System.IO.Compression.Native/pal_zlib.c

@@ -6,37 +6,37 @@
 #include "pal_utilities.h"
 
 #include <assert.h>
-#include <memory>
+#include <stdlib.h>
 #include <zlib.h>
 
-static_assert(PAL_Z_NOFLUSH == Z_NO_FLUSH, "");
-static_assert(PAL_Z_FINISH == Z_FINISH, "");
+c_static_assert(PAL_Z_NOFLUSH == Z_NO_FLUSH);
+c_static_assert(PAL_Z_FINISH == Z_FINISH);
 
-static_assert(PAL_Z_OK == Z_OK, "");
-static_assert(PAL_Z_STREAMEND == Z_STREAM_END, "");
-static_assert(PAL_Z_STREAMERROR == Z_STREAM_ERROR, "");
-static_assert(PAL_Z_DATAERROR == Z_DATA_ERROR, "");
-static_assert(PAL_Z_MEMERROR == Z_MEM_ERROR, "");
-static_assert(PAL_Z_BUFERROR == Z_BUF_ERROR, "");
-static_assert(PAL_Z_VERSIONERROR == Z_VERSION_ERROR, "");
+c_static_assert(PAL_Z_OK == Z_OK);
+c_static_assert(PAL_Z_STREAMEND == Z_STREAM_END);
+c_static_assert(PAL_Z_STREAMERROR == Z_STREAM_ERROR);
+c_static_assert(PAL_Z_DATAERROR == Z_DATA_ERROR);
+c_static_assert(PAL_Z_MEMERROR == Z_MEM_ERROR);
+c_static_assert(PAL_Z_BUFERROR == Z_BUF_ERROR);
+c_static_assert(PAL_Z_VERSIONERROR == Z_VERSION_ERROR);
 
-static_assert(PAL_Z_NOCOMPRESSION == Z_NO_COMPRESSION, "");
-static_assert(PAL_Z_BESTSPEED == Z_BEST_SPEED, "");
-static_assert(PAL_Z_DEFAULTCOMPRESSION == Z_DEFAULT_COMPRESSION, "");
+c_static_assert(PAL_Z_NOCOMPRESSION == Z_NO_COMPRESSION);
+c_static_assert(PAL_Z_BESTSPEED == Z_BEST_SPEED);
+c_static_assert(PAL_Z_DEFAULTCOMPRESSION == Z_DEFAULT_COMPRESSION);
 
-static_assert(PAL_Z_DEFAULTSTRATEGY == Z_DEFAULT_STRATEGY, "");
+c_static_assert(PAL_Z_DEFAULTSTRATEGY == Z_DEFAULT_STRATEGY);
 
-static_assert(PAL_Z_DEFLATED == Z_DEFLATED, "");
+c_static_assert(PAL_Z_DEFLATED == Z_DEFLATED);
 
 /*
 Initializes the PAL_ZStream by creating and setting its underlying z_stream.
 */
 static int32_t Init(PAL_ZStream* stream)
 {
-    z_stream* zStream = new (std::nothrow) z_stream;
+    z_stream* zStream = (z_stream*)malloc(sizeof(z_stream));
     stream->internalState = zStream;
 
-    if (zStream != nullptr)
+    if (zStream != NULL)
     {
         zStream->zalloc = Z_NULL;
         zStream->zfree = Z_NULL;
@@ -54,19 +54,19 @@ Frees any memory on the PAL_ZStream that was created by Init.
 */
 static void End(PAL_ZStream* stream)
 {
-    z_stream* zStream = reinterpret_cast<z_stream*>(stream->internalState);
-    assert(zStream != nullptr);
-    if (zStream != nullptr)
+    z_stream* zStream = (z_stream*)(stream->internalState);
+    assert(zStream != NULL);
+    if (zStream != NULL)
     {
-        delete zStream;
-        stream->internalState = nullptr;
+        free(zStream);
+        stream->internalState = NULL;
     }
 }
 
 /*
 Transfers the output values from the underlying z_stream to the PAL_ZStream.
 */
-static void TransferState(z_stream* from, PAL_ZStream* to)
+static void TransferStateToPalZStream(z_stream* from, PAL_ZStream* to)
 {
     to->nextIn = from->next_in;
     to->availIn = from->avail_in;
@@ -80,7 +80,7 @@ static void TransferState(z_stream* from, PAL_ZStream* to)
 /*
 Transfers the input values from the PAL_ZStream to the underlying z_stream object.
 */
-static void TransferState(PAL_ZStream* from, z_stream* to)
+static void TransferStateFromPalZStream(PAL_ZStream* from, z_stream* to)
 {
     to->next_in = from->nextIn;
     to->avail_in = from->availIn;
@@ -97,43 +97,43 @@ since the current values are always needed.
 */
 static z_stream* GetCurrentZStream(PAL_ZStream* stream)
 {
-    z_stream* zStream = reinterpret_cast<z_stream*>(stream->internalState);
-    assert(zStream != nullptr);
+    z_stream* zStream = (z_stream*)(stream->internalState);
+    assert(zStream != NULL);
 
-    TransferState(stream, zStream);
+    TransferStateFromPalZStream(stream, zStream);
     return zStream;
 }
 
-extern "C" int32_t CompressionNative_DeflateInit2_(
+int32_t CompressionNative_DeflateInit2_(
     PAL_ZStream* stream, int32_t level, int32_t method, int32_t windowBits, int32_t memLevel, int32_t strategy)
 {
-    assert(stream != nullptr);
+    assert(stream != NULL);
 
     int32_t result = Init(stream);
     if (result == PAL_Z_OK)
     {
         z_stream* zStream = GetCurrentZStream(stream);
         result = deflateInit2(zStream, level, method, windowBits, memLevel, strategy);
-        TransferState(zStream, stream);
+        TransferStateToPalZStream(zStream, stream);
     }
 
     return result;
 }
 
-extern "C" int32_t CompressionNative_Deflate(PAL_ZStream* stream, int32_t flush)
+int32_t CompressionNative_Deflate(PAL_ZStream* stream, int32_t flush)
 {
-    assert(stream != nullptr);
+    assert(stream != NULL);
 
     z_stream* zStream = GetCurrentZStream(stream);
     int32_t result = deflate(zStream, flush);
-    TransferState(zStream, stream);
+    TransferStateToPalZStream(zStream, stream);
 
     return result;
 }
 
-extern "C" int32_t CompressionNative_DeflateEnd(PAL_ZStream* stream)
+int32_t CompressionNative_DeflateEnd(PAL_ZStream* stream)
 {
-    assert(stream != nullptr);
+    assert(stream != NULL);
 
     z_stream* zStream = GetCurrentZStream(stream);
     int32_t result = deflateEnd(zStream);
@@ -142,35 +142,35 @@ extern "C" int32_t CompressionNative_DeflateEnd(PAL_ZStream* stream)
     return result;
 }
 
-extern "C" int32_t CompressionNative_InflateInit2_(PAL_ZStream* stream, int32_t windowBits)
+int32_t CompressionNative_InflateInit2_(PAL_ZStream* stream, int32_t windowBits)
 {
-    assert(stream != nullptr);
+    assert(stream != NULL);
 
     int32_t result = Init(stream);
     if (result == PAL_Z_OK)
     {
         z_stream* zStream = GetCurrentZStream(stream);
         result = inflateInit2(zStream, windowBits);
-        TransferState(zStream, stream);
+        TransferStateToPalZStream(zStream, stream);
     }
 
     return result;
 }
 
-extern "C" int32_t CompressionNative_Inflate(PAL_ZStream* stream, int32_t flush)
+int32_t CompressionNative_Inflate(PAL_ZStream* stream, int32_t flush)
 {
-    assert(stream != nullptr);
+    assert(stream != NULL);
 
     z_stream* zStream = GetCurrentZStream(stream);
     int32_t result = inflate(zStream, flush);
-    TransferState(zStream, stream);
+    TransferStateToPalZStream(zStream, stream);
 
     return result;
 }
 
-extern "C" int32_t CompressionNative_InflateEnd(PAL_ZStream* stream)
+int32_t CompressionNative_InflateEnd(PAL_ZStream* stream)
 {
-    assert(stream != nullptr);
+    assert(stream != NULL);
 
     z_stream* zStream = GetCurrentZStream(stream);
     int32_t result = inflateEnd(zStream);
@@ -179,11 +179,11 @@ extern "C" int32_t CompressionNative_InflateEnd(PAL_ZStream* stream)
     return result;
 }
 
-extern "C" uint32_t CompressionNative_Crc32(uint32_t crc, uint8_t* buffer, int32_t len)
+uint32_t CompressionNative_Crc32(uint32_t crc, uint8_t* buffer, int32_t len)
 {
-    assert(buffer != nullptr);
+    assert(buffer != NULL);
 
-    unsigned long result = crc32(crc, buffer, UnsignedCast(len));
+    unsigned long result = crc32(crc, buffer, len);
     assert(result <= UINT32_MAX);
-    return static_cast<uint32_t>(result);
+    return (uint32_t)result;
 }

src/Native/Unix/System.IO.Compression.Native/pal_zlib.h

@@ -3,11 +3,12 @@
 // See the LICENSE file in the project root for more information.
 
 #include "pal_types.h"
+#include "pal_compiler.h"
 
 /*
 A structure that holds the input and output values for the zlib functions.
 */
-struct PAL_ZStream
+typedef struct PAL_ZStream
 {
     uint8_t* nextIn;  // next input byte
     uint8_t* nextOut; // next output byte should be put there
@@ -19,12 +20,12 @@ struct PAL_ZStream
 
     uint32_t availIn;  // number of bytes available at nextIn
     uint32_t availOut; // remaining free space at nextOut
-};
+} PAL_ZStream;
 
 /*
 Allowed flush values for the Deflate and Inflate functions.
 */
-enum PAL_FlushCode : int32_t
+enum PAL_FlushCode
 {
     PAL_Z_NOFLUSH = 0,
     PAL_Z_FINISH = 4,
@@ -33,7 +34,7 @@ enum PAL_FlushCode : int32_t
 /*
 Error codes from the zlib functions.
 */
-enum PAL_ErrorCode : int32_t
+enum PAL_ErrorCode
 {
     PAL_Z_OK = 0,
     PAL_Z_STREAMEND = 1,
@@ -47,7 +48,7 @@ enum PAL_ErrorCode : int32_t
 /*
 Compression levels
 */
-enum PAL_CompressionLevel : int32_t
+enum PAL_CompressionLevel
 {
     PAL_Z_NOCOMPRESSION = 0,
     PAL_Z_BESTSPEED = 1,
@@ -57,15 +58,15 @@ enum PAL_CompressionLevel : int32_t
 /*
 Compression strategy
 */
-enum PAL_CompressionStrategy : int32_t
+enum PAL_CompressionStrategy
 {
     PAL_Z_DEFAULTSTRATEGY = 0
 };
 
 /*
 The deflate compression method (the only one supported in this version)
 */
-enum PAL_CompressionMethod : int32_t
+enum PAL_CompressionMethod
 {
     PAL_Z_DEFLATED = 8
 };
@@ -75,7 +76,7 @@ Initializes the PAL_ZStream so the Deflate function can be invoked on it.
 
 Returns a PAL_ErrorCode indicating success or an error number on failure.
 */
-extern "C" int32_t CompressionNative_DeflateInit2_(
+DLLEXPORT int32_t CompressionNative_DeflateInit2_(
     PAL_ZStream* stream, int32_t level, int32_t method, int32_t windowBits, int32_t memLevel, int32_t strategy);
 
 /*
@@ -84,41 +85,41 @@ compressed bytes in nextOut.
 
 Returns a PAL_ErrorCode indicating success or an error number on failure.
 */
-extern "C" int32_t CompressionNative_Deflate(PAL_ZStream* stream, int32_t flush);
+DLLEXPORT int32_t CompressionNative_Deflate(PAL_ZStream* stream, int32_t flush);
 
 /*
 All dynamically allocated data structures for this stream are freed.
 
 Returns a PAL_ErrorCode indicating success or an error number on failure.
 */
-extern "C" int32_t CompressionNative_DeflateEnd(PAL_ZStream* stream);
+DLLEXPORT int32_t CompressionNative_DeflateEnd(PAL_ZStream* stream);
 
 /*
 Initializes the PAL_ZStream so the Inflate function can be invoked on it.
 
 Returns a PAL_ErrorCode indicating success or an error number on failure.
 */
-extern "C" int32_t CompressionNative_InflateInit2_(PAL_ZStream* stream, int32_t windowBits);
+DLLEXPORT int32_t CompressionNative_InflateInit2_(PAL_ZStream* stream, int32_t windowBits);
 
 /*
 Inflates (uncompresses) the bytes in the PAL_ZStream's nextIn buffer and puts the
 uncompressed bytes in nextOut.
 
 Returns a PAL_ErrorCode indicating success or an error number on failure.
 */
-extern "C" int32_t CompressionNative_Inflate(PAL_ZStream* stream, int32_t flush);
+DLLEXPORT int32_t CompressionNative_Inflate(PAL_ZStream* stream, int32_t flush);
 
 /*
 All dynamically allocated data structures for this stream are freed.
 
 Returns a PAL_ErrorCode indicating success or an error number on failure.
 */
-extern "C" int32_t CompressionNative_InflateEnd(PAL_ZStream* stream);
+DLLEXPORT int32_t CompressionNative_InflateEnd(PAL_ZStream* stream);
 
 /*
 Update a running CRC-32 with the bytes buffer[0..len-1] and return the
 updated CRC-32.
 
 Returns the updated CRC-32.
 */
-extern "C" uint32_t CompressionNative_Crc32(uint32_t crc, uint8_t* buffer, int32_t len);
+DLLEXPORT uint32_t CompressionNative_Crc32(uint32_t crc, uint8_t* buffer, int32_t len);