libwz 0.1.0

package/deps/zlib/contrib/iostream2/zstream.h

@@ -0,0 +1,306 @@
+/*
+ *
+ * Copyright (c) 1997
+ * Christian Michelsen Research AS
+ * Advanced Computing
+ * Fantoftvegen 38, 5036 BERGEN, Norway
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Christian Michelsen Research AS makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef ZSTREAM__H
+#define ZSTREAM__H
+
+/*
+ * zstream.h - C++ interface to the 'zlib' general purpose compression library
+ * $Id: zstream.h 1.1 1997-06-25 12:00:56+02 tyge Exp tyge $
+ */
+
+#include <strstream.h>
+#include <string.h>
+#include <stdio.h>
+#include "zlib.h"
+
+#if defined(_WIN32)
+#   include <fcntl.h>
+#   include <io.h>
+#   define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
+#else
+#   define SET_BINARY_MODE(file)
+#endif
+
+class zstringlen {
+public:
+    zstringlen(class izstream&);
+    zstringlen(class ozstream&, const char*);
+    size_t value() const { return val.word; }
+private:
+    struct Val { unsigned char byte; size_t word; } val;
+};
+
+//  ----------------------------- izstream -----------------------------
+
+class izstream
+{
+    public:
+        izstream() : m_fp(0) {}
+        izstream(FILE* fp) : m_fp(0) { open(fp); }
+        izstream(const char* name) : m_fp(0) { open(name); }
+        ~izstream() { close(); }
+
+        /* Opens a gzip (.gz) file for reading.
+         * open() can be used to read a file which is not in gzip format;
+         * in this case read() will directly read from the file without
+         * decompression. errno can be checked to distinguish two error
+         * cases (if errno is zero, the zlib error is Z_MEM_ERROR).
+         */
+        void open(const char* name) {
+            if (m_fp) close();
+            m_fp = ::gzopen(name, "rb");
+        }
+
+        void open(FILE* fp) {
+            SET_BINARY_MODE(fp);
+            if (m_fp) close();
+            m_fp = ::gzdopen(fileno(fp), "rb");
+        }
+
+        /* Flushes all pending input if necessary, closes the compressed file
+         * and deallocates all the (de)compression state. The return value is
+         * the zlib error number (see function error() below).
+         */
+        int close() {
+            int r = ::gzclose(m_fp);
+            m_fp = 0; return r;
+        }
+
+        /* Binary read the given number of bytes from the compressed file.
+         */
+        int read(void* buf, size_t len) {
+            return ::gzread(m_fp, buf, len);
+        }
+
+        /* Returns the error message for the last error which occurred on the
+         * given compressed file. errnum is set to zlib error number. If an
+         * error occurred in the file system and not in the compression library,
+         * errnum is set to Z_ERRNO and the application may consult errno
+         * to get the exact error code.
+         */
+        const char* error(int* errnum) {
+            return ::gzerror(m_fp, errnum);
+        }
+
+        gzFile fp() { return m_fp; }
+
+    private:
+        gzFile m_fp;
+};
+
+/*
+ * Binary read the given (array of) object(s) from the compressed file.
+ * If the input file was not in gzip format, read() copies the objects number
+ * of bytes into the buffer.
+ * returns the number of uncompressed bytes actually read
+ * (0 for end of file, -1 for error).
+ */
+template <class T, class Items>
+inline int read(izstream& zs, T* x, Items items) {
+    return ::gzread(zs.fp(), x, items*sizeof(T));
+}
+
+/*
+ * Binary input with the '>' operator.
+ */
+template <class T>
+inline izstream& operator>(izstream& zs, T& x) {
+    ::gzread(zs.fp(), &x, sizeof(T));
+    return zs;
+}
+
+
+inline zstringlen::zstringlen(izstream& zs) {
+    zs > val.byte;
+    if (val.byte == 255) zs > val.word;
+    else val.word = val.byte;
+}
+
+/*
+ * Read length of string + the string with the '>' operator.
+ */
+inline izstream& operator>(izstream& zs, char* x) {
+    zstringlen len(zs);
+    ::gzread(zs.fp(), x, len.value());
+    x[len.value()] = '\0';
+    return zs;
+}
+
+inline char* read_string(izstream& zs) {
+    zstringlen len(zs);
+    char* x = new char[len.value()+1];
+    ::gzread(zs.fp(), x, len.value());
+    x[len.value()] = '\0';
+    return x;
+}
+
+// ----------------------------- ozstream -----------------------------
+
+class ozstream
+{
+    public:
+        ozstream() : m_fp(0), m_os(0) {
+        }
+        ozstream(FILE* fp, int level = Z_DEFAULT_COMPRESSION)
+            : m_fp(0), m_os(0) {
+            open(fp, level);
+        }
+        ozstream(const char* name, int level = Z_DEFAULT_COMPRESSION)
+            : m_fp(0), m_os(0) {
+            open(name, level);
+        }
+        ~ozstream() {
+            close();
+        }
+
+        /* Opens a gzip (.gz) file for writing.
+         * The compression level parameter should be in 0..9
+         * errno can be checked to distinguish two error cases
+         * (if errno is zero, the zlib error is Z_MEM_ERROR).
+         */
+        void open(const char* name, int level = Z_DEFAULT_COMPRESSION) {
+            char mode[4] = "wb\0";
+            if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
+            if (m_fp) close();
+            m_fp = ::gzopen(name, mode);
+        }
+
+        /* open from a FILE pointer.
+         */
+        void open(FILE* fp, int level = Z_DEFAULT_COMPRESSION) {
+            SET_BINARY_MODE(fp);
+            char mode[4] = "wb\0";
+            if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
+            if (m_fp) close();
+            m_fp = ::gzdopen(fileno(fp), mode);
+        }
+
+        /* Flushes all pending output if necessary, closes the compressed file
+         * and deallocates all the (de)compression state. The return value is
+         * the zlib error number (see function error() below).
+         */
+        int close() {
+            if (m_os) {
+                ::gzwrite(m_fp, m_os->str(), m_os->pcount());
+                delete[] m_os->str(); delete m_os; m_os = 0;
+            }
+            int r = ::gzclose(m_fp); m_fp = 0; return r;
+        }
+
+        /* Binary write the given number of bytes into the compressed file.
+         */
+        int write(const void* buf, size_t len) {
+            return ::gzwrite(m_fp, (voidp) buf, len);
+        }
+
+        /* Flushes all pending output into the compressed file. The parameter
+         * _flush is as in the deflate() function. The return value is the zlib
+         * error number (see function gzerror below). flush() returns Z_OK if
+         * the flush_ parameter is Z_FINISH and all output could be flushed.
+         * flush() should be called only when strictly necessary because it can
+         * degrade compression.
+         */
+        int flush(int _flush) {
+            os_flush();
+            return ::gzflush(m_fp, _flush);
+        }
+
+        /* Returns the error message for the last error which occurred on the
+         * given compressed file. errnum is set to zlib error number. If an
+         * error occurred in the file system and not in the compression library,
+         * errnum is set to Z_ERRNO and the application may consult errno
+         * to get the exact error code.
+         */
+        const char* error(int* errnum) {
+            return ::gzerror(m_fp, errnum);
+        }
+
+        gzFile fp() { return m_fp; }
+
+        ostream& os() {
+            if (m_os == 0) m_os = new ostrstream;
+            return *m_os;
+        }
+
+        void os_flush() {
+            if (m_os && m_os->pcount()>0) {
+                ostrstream* oss = new ostrstream;
+                oss->fill(m_os->fill());
+                oss->flags(m_os->flags());
+                oss->precision(m_os->precision());
+                oss->width(m_os->width());
+                ::gzwrite(m_fp, m_os->str(), m_os->pcount());
+                delete[] m_os->str(); delete m_os; m_os = oss;
+            }
+        }
+
+    private:
+        gzFile m_fp;
+        ostrstream* m_os;
+};
+
+/*
+ * Binary write the given (array of) object(s) into the compressed file.
+ * returns the number of uncompressed bytes actually written
+ * (0 in case of error).
+ */
+template <class T, class Items>
+inline int write(ozstream& zs, const T* x, Items items) {
+    return ::gzwrite(zs.fp(), (voidp) x, items*sizeof(T));
+}
+
+/*
+ * Binary output with the '<' operator.
+ */
+template <class T>
+inline ozstream& operator<(ozstream& zs, const T& x) {
+    ::gzwrite(zs.fp(), (voidp) &x, sizeof(T));
+    return zs;
+}
+
+inline zstringlen::zstringlen(ozstream& zs, const char* x) {
+    val.byte = 255;  val.word = ::strlen(x);
+    if (val.word < 255) zs < (val.byte = val.word);
+    else zs < val;
+}
+
+/*
+ * Write length of string + the string with the '<' operator.
+ */
+inline ozstream& operator<(ozstream& zs, const char* x) {
+    zstringlen len(zs, x);
+    ::gzwrite(zs.fp(), (voidp) x, len.value());
+    return zs;
+}
+
+#ifdef _MSC_VER
+inline ozstream& operator<(ozstream& zs, char* const& x) {
+    return zs < (const char*) x;
+}
+#endif
+
+/*
+ * Ascii write with the << operator;
+ */
+template <class T>
+inline ostream& operator<<(ozstream& zs, const T& x) {
+    zs.os_flush();
+    return zs.os() << x;
+}
+
+#endif

package/deps/zlib/contrib/iostream2/zstream_test.cpp

@@ -0,0 +1,25 @@
+#include "zstream.h"
+#include <math.h>
+#include <stdlib.h>
+#include <iomanip.h>
+
+void main() {
+    char h[256] = "Hello";
+    char* g = "Goodbye";
+    ozstream out("temp.gz");
+    out < "This works well" < h < g;
+    out.close();
+
+    izstream in("temp.gz"); // read it back
+    char *x = read_string(in), *y = new char[256], z[256];
+    in > y > z;
+    in.close();
+    cout << x << endl << y << endl << z << endl;
+
+    out.open("temp.gz"); // try ascii output; zcat temp.gz to see the results
+    out << setw(50) << setfill('#') << setprecision(20) << x << endl << y << endl << z << endl;
+    out << z << endl << y << endl << x << endl;
+    out << 1.1234567890123456789 << endl;
+
+    delete[] x; delete[] y;
+}

package/deps/zlib/contrib/iostream3/CMakeLists.txt

@@ -0,0 +1,200 @@
+cmake_minimum_required(VERSION 3.12...3.31)
+
+project(
+    iostreamV3
+    VERSION 1.0.0
+    LANGUAGES CXX
+    DESCRIPTION "A library for using C++ IOStreams with zlib V3"
+    HOMEPAGE_URL "https://www.zlib.net")
+
+option(ZLIB_IOSTREAM3_BUILD_SHARED "Enable building blast shared library" ON)
+option(ZLIB_IOSTREAM3_BUILD_STATIC "Enable building blast static library" ON)
+option(ZLIB_IOSTREAM3_BUILD_TESTING "Enable building tests for blast" ON)
+option(ZLIB_IOSTREAM3_INSTALL "Enable installation of iostream" ON)
+
+include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+
+if(NOT DEFINED ZLIB_BUILD_IOSTREAM3)
+    if(ZLIB_IOSTREAM3_BUILD_SHARED)
+        list(APPEND REQUIRED_COMPONENTS "shared")
+    endif(ZLIB_IOSTREAM3_BUILD_SHARED)
+
+    if(ZLIB_IOSTREAM3_BUILD_STATIC)
+        list(APPEND REQUIRED_COMPONENTS "static")
+    endif(ZLIB_IOSTREAM3_BUILD_STATIC)
+
+    find_package(ZLIB REQUIRED COMPONENTS ${REQUIRED_COMPONENTS} CONFIG)
+endif(NOT DEFINED ZLIB_BUILD_IOSTREAM3)
+
+if(WIN32 OR CYGWIN)
+    set(zlibIOStream3_static_suffix "s")
+    set(CMAKE_DEBUG_POSTFIX "d")
+endif(WIN32 OR CYGWIN)
+
+
+function(iostreamv3_findTestEnv testName)
+    set(testEnv "PATH=")
+
+    if(MSVC OR MINGW)
+        set(separator "\\\;")
+    else()
+        set(separator ":")
+    endif()
+
+    string(APPEND testEnv "$<TARGET_FILE_DIR:zlib_iostream3_iostreamv3>${separator}")
+    string(APPEND testEnv "$<TARGET_FILE_DIR:ZLIB::ZLIB>${separator}")
+    string(APPEND testEnv "$ENV{PATH}")
+
+    set_tests_properties(${testName} PROPERTIES ENVIRONMENT "${testEnv}")
+endfunction(iostreamv3_findTestEnv testName)
+
+if(ZLIB_IOSTREAM3_BUILD_SHARED)
+    add_library(zlib_iostream3_iostreamv3 SHARED
+                zfstream.cc
+                zfstream.h)
+
+    add_library(IOSTREAMV3::IOSTREAMV3 ALIAS zlib_iostream3_iostreamv3)
+
+    if(NOT CYGWIN)
+        set_target_properties(zlib_iostream3_iostreamv3
+            PROPERTIES
+                SOVERSION ${iostreamV3_VERSION_MAJOR}
+                VERSION ${iostreamV3_VERSION})
+    endif(NOT CYGWIN)
+
+    set_target_properties(zlib_iostream3_iostreamv3
+        PROPERTIES
+            EXPORT_NAME IOSTREAMV3
+            OUTPUT_NAME iostream3)
+
+    target_link_libraries(zlib_iostream3_iostreamv3
+        PUBLIC ZLIB::ZLIB)
+
+    if(ZLIB_IOSTREAM3_BUILD_TESTING)
+        enable_testing()
+
+        add_executable(zlib_iostream3_test test.cc zfstream.h)
+
+        target_link_libraries(zlib_iostream3_test
+            PRIVATE zlib_iostream3_iostreamv3)
+
+        add_test(NAME zlib_iostream3_test COMMAND zlib_iostream3_test)
+
+        set_tests_properties(zlib_iostream3_test
+            PROPERTIES
+                FIXTURES_REQUIRED zlib_iostream3_cleanup)
+
+        if(MSVC
+           OR MSYS
+           OR MINGW
+           OR CYGWIN)
+            iostreamv3_findtestenv(zlib_iostream3_test)
+        endif(
+            MSVC
+            OR MSYS
+            OR MINGW
+            OR CYGWIN)
+    endif(ZLIB_IOSTREAM3_BUILD_TESTING)
+endif(ZLIB_IOSTREAM3_BUILD_SHARED)
+
+if(ZLIB_IOSTREAM3_BUILD_STATIC)
+    add_library(zlib_iostream3_iostreamv3Static STATIC
+                zfstream.cc
+                zfstream.h)
+
+    add_library(IOSTREAMV3::IOSTREAMV3STATIC
+        ALIAS zlib_iostream3_iostreamv3Static)
+
+    target_link_libraries(zlib_iostream3_iostreamv3Static
+        PUBLIC ZLIB::ZLIBSTATIC)
+
+    set_target_properties(zlib_iostream3_iostreamv3Static
+        PROPERTIES
+            EXPORT_NAME IOSTREAMV3STATIC
+            OUTPUT_NAME iostream3${zlib_IOStream3_static_suffix})
+
+    if(ZLIB_IOSTREAM3_BUILD_TESTING)
+        enable_testing()
+
+        add_executable(zlib_iostream3_testStatic test.cc zfstream.h)
+
+        target_link_libraries(zlib_iostream3_testStatic
+            PRIVATE zlib_iostream3_iostreamv3Static)
+
+        add_test(NAME zlib_iostream3_testStatic
+                 COMMAND zlib_iostream3_testStatic)
+
+        set_tests_properties(zlib_iostream3_testStatic
+            PROPERTIES
+                FIXTURES_REQUIRED zlib_iostream3_cleanup)
+    endif(ZLIB_IOSTREAM3_BUILD_TESTING)
+endif(ZLIB_IOSTREAM3_BUILD_STATIC)
+
+if(ZLIB_IOSTREAM3_BUILD_TESTING)
+    add_test(NAME zlib_iostream3_cleanup COMMAND ${CMAKE_COMMAND} -E rm
+        ${CMAKE_CURRENT_BINARY_DIR}/test1.txt.gz
+        ${CMAKE_CURRENT_BINARY_DIR}/test2.txt.gz)
+
+    set_tests_properties(zlib_iostream3_cleanup
+        PROPERTIES
+            FIXTURES_CLEANUP zlib_iostream3_cleanup)
+
+        add_subdirectory(test)
+endif(ZLIB_IOSTREAM3_BUILD_TESTING)
+
+if(ZLIB_IOSTREAM3_INSTALL)
+    if(ZLIB_IOSTREAM3_BUILD_SHARED)
+        install(
+            TARGETS zlib_iostream3_iostreamv3
+            COMPONENT Runtime
+            EXPORT zlibiostream3SharedExport
+            RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+            ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+        install(
+            EXPORT zlibiostream3SharedExport
+            FILE iostreamv3-shared.cmake
+            NAMESPACE IOSTREAMV3::
+            DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/iostreamv3)
+
+        if(MSVC)
+            install(
+                FILES $<TARGET_PDB_FILE:zlib_iostream3_iostreamv3>
+                COMPONENT Development
+                DESTINATION ${CMAKE_INSTALL_BINDIR}
+                CONFIGURATIONS Debug OR RelWithDebInfo
+                OPTIONAL)
+        endif(MSVC)
+    endif(ZLIB_IOSTREAM3_BUILD_SHARED)
+
+    if(ZLIB_IOSTREAM3_BUILD_STATIC)
+        install(
+            TARGETS zlib_iostream3_iostreamv3Static
+            COMPONENT Development
+            EXPORT iostream3StaticExport
+            ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+        install(
+            EXPORT iostream3StaticExport
+            FILE iostreamv3-static.cmake
+            NAMESPACE IOSTREAMV3::
+            DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/iostreamv3)
+    endif(ZLIB_IOSTREAM3_BUILD_STATIC)
+
+    configure_package_config_file(
+        ${iostreamV3_SOURCE_DIR}/iostream3Config.cmake.in
+        ${iostreamV3_BINARY_DIR}/iostreamv3Config.cmake
+        INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/iostreamv3)
+
+    write_basic_package_version_file(
+        "${iostreamV3_BINARY_DIR}/iostreamv3ConfigVersion.cmake"
+        VERSION "${iostream3_VERSION}"
+        COMPATIBILITY AnyNewerVersion)
+
+    install(FILES ${iostreamV3_BINARY_DIR}/iostreamv3Config.cmake
+                  ${iostreamV3_BINARY_DIR}/iostreamv3ConfigVersion.cmake
+            DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/iostreamv3)
+    install(
+        FILES zfstream.h
+        COMPONENT Development
+        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
+endif(ZLIB_IOSTREAM3_INSTALL)

package/deps/zlib/contrib/iostream3/README

@@ -0,0 +1,35 @@
+These classes provide a C++ stream interface to the zlib library. It allows you
+to do things like:
+
+  gzofstream outf("blah.gz");
+  outf << "These go into the gzip file " << 123 << endl;
+
+It does this by deriving a specialized stream buffer for gzipped files, which is
+the way Stroustrup would have done it. :->
+
+The gzifstream and gzofstream classes were originally written by Kevin Ruland
+and made available in the zlib contrib/iostream directory. The older version still
+compiles under gcc 2.xx, but not under gcc 3.xx, which sparked the development of
+this version.
+
+The new classes are as standard-compliant as possible, closely following the
+approach of the standard library's fstream classes. It compiles under gcc versions
+3.2 and 3.3, but not under gcc 2.xx. This is mainly due to changes in the standard
+library naming scheme. The new version of gzifstream/gzofstream/gzfilebuf differs
+from the previous one in the following respects:
+- added showmanyc
+- added setbuf, with support for unbuffered output via setbuf(0,0)
+- a few bug fixes of stream behavior
+- gzipped output file opened with default compression level instead of maximum level
+- setcompressionlevel()/strategy() members replaced by single setcompression()
+
+The code is provided "as is", with the permission to use, copy, modify, distribute
+and sell it for any purpose without fee.
+
+Ludwig Schwardt
+<schwardt@sun.ac.za>
+
+DSP Lab
+Electrical & Electronic Engineering Department
+University of Stellenbosch
+South Africa

package/deps/zlib/contrib/iostream3/TODO

@@ -0,0 +1,17 @@
+Possible upgrades to gzfilebuf:
+
+- The ability to do putback (e.g. putbackfail)
+
+- The ability to seek (zlib supports this, but could be slow/tricky)
+
+- Simultaneous read/write access (does it make sense?)
+
+- Support for ios_base::ate open mode
+
+- Locale support?
+
+- Check public interface to see which calls give problems
+  (due to dependence on library internals)
+
+- Override operator<<(ostream&, gzfilebuf*) to allow direct copying
+  of stream buffer to stream ( i.e. os << is.rdbuf(); )

package/deps/zlib/contrib/iostream3/iostream3Config.cmake.in

@@ -0,0 +1,23 @@
+@PACKAGE_INIT@
+
+set(_iostreamv3_supported_components "shared" "static")
+include(CMakeFindDependencyMacro)
+
+if(iostreamv3_FIND_COMPONENTS)
+    find_dependency(ZLIB CONFIG COMPONENTS ${iostreamv3_FIND_COMPONENTS})
+
+    foreach(_comp ${iostreamv3_FIND_COMPONENTS})
+        if(NOT _comp IN_LIST _iostreamv3_supported_components)
+            set(iostreamv3_FOUND False)
+            set(iostreamv3_NOT_FOUND_MESSAGE "Unsupported component: ${_comp}")
+        endif(NOT _comp IN_LIST _iostreamv3_supported_components)
+
+        include("${CMAKE_CURRENT_LIST_DIR}/iostreamv3-${_comp}.cmake")
+    endforeach(_comp ${iostreamv3_FIND_COMPONENTS})
+else(iostream3_FIND_COMPONENTS)
+    find_dependency(ZLIB CONFIG)
+
+    foreach(_component_config IN LISTS _iostreamv3_supported_components)
+        include("${CMAKE_CURRENT_LIST_DIR}/iostreamv3-${_component_config}.cmake")
+    endforeach(_component_config IN LISTS _iostreamv3_supported_components)
+endif(iostreamv3_FIND_COMPONENTS)