CMake build fixes
- Include directories publicly
- Don't modify git tree
- Dropped autotools support

zlib 1.2.12

Fix crc32.c to compile local functions only if used.

Check for cc masquerading as gcc or clang in configure.

Remove destructive aspects of make distclean.

Separate out address sanitizing from warnings in configure.

Eliminate use of ULL constants.

0xffffffffffffffffULL was causing warnings for C99 usage. The
suffix for the constant is not necessary anyway, so this commit
removes them.

Add fallthrough comments for gcc.

Note intentional switch case fall throughs to avoid gcc warnings.

Clean up minizip to reduce warnings for testing.

Also fix Makefile test target and permit added compile options.

Fix unztell64() in minizip to work past 4GB. (Daniël Hörchner)

The issue is that unztell64() does not return the correct value if
the position in the current file (in the ZIP archive) is beyond 4
GB. The cause is that unzReadCurrentFile() does not account for
pfile_in_zip_read_info->stream.total_out at line 1854 of unzip.c
wrapping around (it is a 32-bit variable). So, on line 1860
uTotalOutAfter can be *less* than uTotalOutBefore, propagating the
wraparound to uOutThis, which in turn is added to
pfile_in_zip_read_info->total_out_64. That has the effect of
subtracting 4 GB.

minizip warning fix if MAXU32 already defined. (gvollant)

Replace black/white with allow/block. (theresa-m)

Fix indentation in minizip's zip.c.

Improve portability of contrib/minizip.

Correct typo in blast.c.

Change macro name in inflate.c to avoid collision in VxWorks.

Clarify gz* function interfaces, referring to parameter names.

Fix error in comment on the polynomial representation of a byte.

Fix memory leak on error in gzlog.c.

Thank you Adam Richter.

Avoid adding empty gzip member after gzflush with Z_FINISH.

Explicitly note that the 32-bit check values are 32 bits.

Use ARM crc32 instructions if the ARM architecture has them.

The ARM crc32 instructions will be used only if an architecture is
explicitly specified at compile time that has those instructions.
For example, -march=armv8.1-a or -march=armv8-a+crc, or if the
machine being compiled on has the instructions, -march=native.

Add use of the ARMv8 crc32 instructions when requested.

Define the macro Z_ARM_CRC32 at compile time to use the ARMv8
(aarch64) crc32x and crc32b instructions. This code does not check
for the presence of the crc32 instructions. Those instructions are
optional for ARMv8.0, though mandatory for ARMv8.1 and later. The
use of the crc32 instructions is about ten times as fast as the
software braided calculation of the CRC-32. This can noticeably
speed up the decompression of gzip streams.

Correct comment in crc32.c.

Don't bother computing check value after successful inflateSync().

inflateSync() is used to skip invalid deflate data, which means
that the check value that was being computed is no longer useful.
This commit turns off the check value computation, and furthermore
allows a successful return if the compressed data terminated in a
graceful manner. This commit also fixes a bug in the case that
inflateSync() is used before a header is ever processed. In that
case, there is no knowledge of a trailer, so the remainder is
treated as raw.

Use atomic test and set, if available, for dynamic CRC tables.

Speed up software CRC-32 computation by a factor of 1.5 to 3.

Use the interleaved method of Kadatch and Jenkins in order to make
use of pipelined instructions through multiple ALUs in a single
core. This also speeds up and simplifies the combination of CRCs,
and updates the functions to pre-calculate and use an operator for
CRC combination.

Add crc32_combine_gen() and crc32_combine_op() for fast combines.

When the same len2 is used repeatedly, it is faster to use
crc32_combine_gen() to generate an operator, that is then used to
combine CRCs with crc32_combine_op().

Add tables for crc32_combine(), to speed it up by a factor of 200.

Fix the zran.c example to work on a multiple-member gzip file.

Add gznorm.c example, which normalizes gzip files.

Show all the codes for the maximum tables size in enough.c.

Clarify that prefix codes are counted in enough.c.

There is no assurance that all prefix codes are reachable as
optimal Huffman codes for the numbers of symbols encountered in
a deflate block. This code considers all possible prefix codes,
which might be a larger set than all possible Huffman codes,
depending on the constraints.

Use inline function instead of macro for index in enough.c.

Clean up code style in enough.c, update version.

Use a macro for the printf format of big_t in enough.c.

Use a structure to make globals in enough.c evident.

Assure that the number of bits for deflatePrime() is valid.

Fix a bug that can crash deflate on some input when using Z_FIXED.

This bug was reported by Danilo Ramos of Eideticom, Inc. It has
lain in wait 13 years before being found! The bug was introduced
in zlib 1.2.2.2, with the addition of the Z_FIXED option. That
option forces the use of fixed Huffman codes. For rare inputs with
a large number of distant matches, the pending buffer into which
the compressed data is written can overwrite the distance symbol
table which it overlays. That results in corrupted output due to
invalid distances, and can result in out-of-bound accesses,
crashing the application.

The fix here combines the distance buffer and literal/length
buffers into a single symbol buffer. Now three bytes of pending
buffer space are opened up for each literal or length/distance
pair consumed, instead of the previous two bytes. This assures
that the pending buffer cannot overwrite the symbol table, since
the maximum fixed code compressed length/distance is 31 bits, and
since there are four bytes of pending space for every three bytes
of symbol space.

Correct the initialization requirements for deflateInit2().

Emphasize the need to continue decompressing gzip members.

Add legal disclaimer to README.

Fix deflateEnd() to not report an error at start of raw deflate.

Remove old assembler code in which bugs have manifested.

In addition, there is not sufficient gain from the inflate
assembler code to warrant its inclusion.

Make the names in functions declarations identical to definitions.

Avoid an undefined behavior of memcpy() in _tr_stored_block().

Allegedly the behavior of memcpy() is undefined if the source
pointer is NULL, even if the number of bytes to copy is zero.

Avoid undefined behaviors of memcpy() in gz*printf().

Avoid an undefined behavior of memcpy() in gzappend().

Avoid the use of ptrdiff_t.

This isn't the right type anyway to assure that it contains a
pointer. That type would be intptr_t or uintptr_t. However the C99
standard says that those types are optional, so their use would not
be portable. This commit simply uses size_t or whatever configure
decided to use for size_t. That would be the same length as
ptrdiff_t, and so will work just as well. The code checks to see if
the length of the type used is the same as the length of a void
pointer, so there is already protection against the use of the
wrong type. The use of size_t (or ptrdiff_t) will almost always
work, as all modern architectures have an array size that is the
same as the pointer size. Only old segmented architectures would
have to fall back to the slower CRC-32 calculation, where the
amount of memory that can be accessed is larger than the maximum
array size.

Handle case where inflateSync used when header never processed.

If zlib and/or gzip header processing was requested, but a header
was never provided and inflateSync was used successfully, then the
inflate state would be inconsistent, trying to compute a check
value but with no flags set. This commit sets the inflate mode to
raw in this case, since there is no other assumption that can be
made if a header was requested but never seen.

Don't compute check value for raw inflate if asked to validate.

Add address checking in clang to -w option of configure.

Return an error if the gzputs string length can't fit in an int.

Small speedup to inflate [psumbera].

Seeing a few percent speedup by using a pointer instead of an
assigned structure. This seems to help the compiler to optimize
better.

Update use of errno for newer Windows CE versions.

Avoid some conversion warnings in gzread.c and gzwrite.c.

Have Makefile return non-zero error code on test failure.

Avoid a conversion error in gzseek when off_t type too small.

This is a problem in the odd case that the second argument of
LSEEK is a larger type than off_t. Apparently MinGW defines off_t
to be 32 bits, but _lseeki64 has a 64-bit second argument.

Also undo a previous commit to permit MinGW to use _lseeki64.

Fix CLEAR_HASH macro to be usable as a single statement.

As it is used in deflateParams().

Fix bug when window full in deflate_stored().

Limit hash table inserts after switch from stored deflate.

This limits hash table inserts to the available data in the window
and to the sliding window size in deflate_stored(). The hash table
inserts are deferred until deflateParams() switches to a non-zero
compression level.

Permit a deflateParams() parameter change as soon as possible.

This commit allows a parameter change even if the input data has
not all been compressed and copied to the application output
buffer, so long as all of the input data has been compressed to
the internal pending output buffer. This also allows an immediate
deflateParams change so long as there have been no deflate calls
since initialization or reset.

Cygwin does not have _wopen(), so do not create gzopen_w() there.

Change version number to 1.2.11.1.

zlib 1.2.11

Permit immediate deflateParams changes before any deflate input.

This permits deflateParams to change the strategy and level right
after deflateInit, without having to wait until a header has been
written. The parameters can be changed immediately up until the
first deflate call that consumes any input data.

Update high water mark in deflate_stored.

This avoids unnecessary filling of bytes in the sliding window
buffer when switching from level zero to a non-zero level. This
also provides a consistent indication of deflate having taken
input for a later commit ...

Update vestigial comment from very old Info-ZIP deflate.

Fix deflate stored bug when pulling last block from window.

And some cosmetic cleanups.

Update location of Visual Studio project files.

Delete user-specific Visual Studio project files.

Change version number to 1.2.10.1.

zlib 1.2.10

Fix compilation with --solo and --debug combined.

However this ends up not really being solo, since it has to
include external libraries.

Add warnings when compiling with assembler code.

There have been many reports of bugs in the assembler codes
intended to speed up deflate and inflate. They are third-party
contributions in contrib, and so are not supported by the zlib
maintainers.

Remove files to be installed before copying them in Makefile.in.

Fix bug in gzwrite.c that produced corrupt gzip files.

Fix bug in deflate_stored() for zero-length input.

Minor edits and clarifications of comments.

Avoid warnings on snprintf() return value.

Change version number to zlib 1.2.9.1.

Fix some stray 1.2.8.1 version numbers.

zlib 1.2.9

Update Visual Studio project files (AraHaan).

Add crc32_z() and adler32_z() functions with size_t lengths.

Make z_size_t unsigned long for non-standard C.

Also declare z_size_t when compiling solo.

Avoid the need for ssize_t.

Limit read() and write() requests to sizes that fit in an int.
This allows storing the return value in an int, and avoiding the
need to use or construct an ssize_t type. This is required for
Microsoft C, whose _read and _write functions take an unsigned
request and return an int.

Use a uniform approach for the largest value of an unsigned type.

Use intptr_t for z_ssize_t on MSVC.

Avoid some random compiler warnings on various platforms.

Allow minigzip to compile when testing with ./configure --solo.

Replace as400 with os400 for OS/400 support (Monnerat).

Detect clang in cc version.

Fix init macros to use z_ prefix when requested.

Fix character encoding and link in contrib README.

Use snprintf() for later versions of Microsoft C.

Add deflateGetDictionary() function.

Per request, but its utility is likely to be very limited. See the
comments in zlib.h.

No need to check for NULL argument to free().

Add gzfwrite(), duplicating the interface of fwrite().

Add gzfread(), duplicating the interface of fread().