Compare commits
	
		
			5 Commits
		
	
	
		
			v9.8.5
			...
			feature/cp
		
	
	| Author | SHA1 | Date | |
|---|---|---|---|
| 
						 | 
					7ff12a36b9 | ||
| 
						 | 
					945c692227 | ||
| 
						 | 
					c16b64bcb2 | ||
| 
						 | 
					886b8f54bf | ||
| 
						 | 
					02810f9adf | 
							
								
								
									
										13
									
								
								.github/workflows/unittest_linux.yml
									
									
									
									
										vendored
									
									
								
							
							
						
						
									
										13
									
								
								.github/workflows/unittest_linux.yml
									
									
									
									
										vendored
									
									
								
							@@ -1,13 +0,0 @@
 | 
			
		||||
name: linux
 | 
			
		||||
on:
 | 
			
		||||
  push:
 | 
			
		||||
    paths-ignore:
 | 
			
		||||
    - 'docs/**'
 | 
			
		||||
 | 
			
		||||
jobs:
 | 
			
		||||
  linux:
 | 
			
		||||
    runs-on: ubuntu-latest
 | 
			
		||||
    steps:
 | 
			
		||||
    - uses: actions/checkout@v1
 | 
			
		||||
    - name: make test_make
 | 
			
		||||
      run: make test_make
 | 
			
		||||
							
								
								
									
										15
									
								
								.github/workflows/unittest_mac_tsan_mbedtls.yml
									
									
									
									
										vendored
									
									
								
							
							
						
						
									
										15
									
								
								.github/workflows/unittest_mac_tsan_mbedtls.yml
									
									
									
									
										vendored
									
									
								
							@@ -1,15 +0,0 @@
 | 
			
		||||
name: mac_tsan_mbedtls
 | 
			
		||||
on:
 | 
			
		||||
  push:
 | 
			
		||||
    paths-ignore:
 | 
			
		||||
    - 'docs/**'
 | 
			
		||||
 | 
			
		||||
jobs:
 | 
			
		||||
  mac_tsan_mbedtls:
 | 
			
		||||
    runs-on: macOS-latest
 | 
			
		||||
    steps:
 | 
			
		||||
    - uses: actions/checkout@v1
 | 
			
		||||
    - name: install mbedtls
 | 
			
		||||
      run: brew install mbedtls
 | 
			
		||||
    - name: make test
 | 
			
		||||
      run: make test_tsan_mbedtls
 | 
			
		||||
							
								
								
									
										15
									
								
								.github/workflows/unittest_mac_tsan_openssl.yml
									
									
									
									
										vendored
									
									
								
							
							
						
						
									
										15
									
								
								.github/workflows/unittest_mac_tsan_openssl.yml
									
									
									
									
										vendored
									
									
								
							@@ -1,15 +0,0 @@
 | 
			
		||||
name: mac_tsan_openssl
 | 
			
		||||
on:
 | 
			
		||||
  push:
 | 
			
		||||
    paths-ignore:
 | 
			
		||||
    - 'docs/**'
 | 
			
		||||
 | 
			
		||||
jobs:
 | 
			
		||||
  mac_tsan_openssl:
 | 
			
		||||
    runs-on: macOS-latest
 | 
			
		||||
    steps:
 | 
			
		||||
    - uses: actions/checkout@v1
 | 
			
		||||
    - name: install openssl
 | 
			
		||||
      run: brew install openssl@1.1
 | 
			
		||||
    - name: make test
 | 
			
		||||
      run: make test_tsan_openssl
 | 
			
		||||
@@ -1,13 +0,0 @@
 | 
			
		||||
name: mac_tsan_sectransport
 | 
			
		||||
on:
 | 
			
		||||
  push:
 | 
			
		||||
    paths-ignore:
 | 
			
		||||
    - 'docs/**'
 | 
			
		||||
 | 
			
		||||
jobs:
 | 
			
		||||
  mac_tsan_sectransport:
 | 
			
		||||
    runs-on: macOS-latest
 | 
			
		||||
    steps:
 | 
			
		||||
    - uses: actions/checkout@v1
 | 
			
		||||
    - name: make test_tsan
 | 
			
		||||
      run: make test_tsan
 | 
			
		||||
							
								
								
									
										40
									
								
								.github/workflows/unittest_uwp.yml
									
									
									
									
										vendored
									
									
								
							
							
						
						
									
										40
									
								
								.github/workflows/unittest_uwp.yml
									
									
									
									
										vendored
									
									
								
							@@ -1,40 +0,0 @@
 | 
			
		||||
name: uwp
 | 
			
		||||
on:
 | 
			
		||||
  push:
 | 
			
		||||
    paths-ignore:
 | 
			
		||||
    - 'docs/**'
 | 
			
		||||
 | 
			
		||||
jobs:
 | 
			
		||||
  uwp:
 | 
			
		||||
    runs-on: windows-latest
 | 
			
		||||
    steps:
 | 
			
		||||
    - uses: actions/checkout@v1
 | 
			
		||||
    - uses: seanmiddleditch/gha-setup-vsdevenv@master
 | 
			
		||||
    - run: |
 | 
			
		||||
        vcpkg install zlib:x64-uwp
 | 
			
		||||
    - run: |
 | 
			
		||||
        mkdir build
 | 
			
		||||
        cd build
 | 
			
		||||
        cmake -DCMAKE_TOOLCHAIN_FILE=c:/vcpkg/scripts/buildsystems/vcpkg.cmake -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION="10.0" -DCMAKE_CXX_COMPILER=cl.exe -DUSE_TEST=1 ..
 | 
			
		||||
    - run: cmake --build build
 | 
			
		||||
 | 
			
		||||
#
 | 
			
		||||
#   Windows with OpenSSL is working but disabled as it takes 13 minutes (10 for openssl) to build with vcpkg
 | 
			
		||||
#
 | 
			
		||||
#   windows_openssl:
 | 
			
		||||
#     runs-on: windows-latest
 | 
			
		||||
#     steps:
 | 
			
		||||
#     - uses: actions/checkout@v1
 | 
			
		||||
#     - uses: seanmiddleditch/gha-setup-vsdevenv@master
 | 
			
		||||
#     - run: |
 | 
			
		||||
#         vcpkg install zlib:x64-windows
 | 
			
		||||
#         vcpkg install openssl:x64-windows
 | 
			
		||||
#     - run: |
 | 
			
		||||
#         mkdir build
 | 
			
		||||
#         cd build
 | 
			
		||||
#         cmake -DCMAKE_TOOLCHAIN_FILE=c:/vcpkg/scripts/buildsystems/vcpkg.cmake -DCMAKE_CXX_COMPILER=cl.exe -DUSE_OPEN_SSL=1 -DUSE_TLS=1 -DUSE_WS=1 -DUSE_TEST=1 ..
 | 
			
		||||
#     - run: cmake --build build
 | 
			
		||||
# 
 | 
			
		||||
#     # Running the unittest does not work, the binary cannot be found
 | 
			
		||||
#     #- run: ../build/test/ixwebsocket_unittest.exe
 | 
			
		||||
#     # working-directory: test
 | 
			
		||||
							
								
								
									
										19
									
								
								.github/workflows/unittest_windows.yml
									
									
									
									
										vendored
									
									
								
							
							
						
						
									
										19
									
								
								.github/workflows/unittest_windows.yml
									
									
									
									
										vendored
									
									
								
							@@ -1,19 +0,0 @@
 | 
			
		||||
name: windows
 | 
			
		||||
on:
 | 
			
		||||
  push:
 | 
			
		||||
    paths-ignore:
 | 
			
		||||
    - 'docs/**'
 | 
			
		||||
 | 
			
		||||
jobs:
 | 
			
		||||
  windows:
 | 
			
		||||
    runs-on: windows-latest
 | 
			
		||||
    steps:
 | 
			
		||||
    - uses: actions/checkout@v1
 | 
			
		||||
    - uses: seanmiddleditch/gha-setup-vsdevenv@master
 | 
			
		||||
    - run: |
 | 
			
		||||
        vcpkg install zlib:x64-windows
 | 
			
		||||
    - run: |
 | 
			
		||||
        mkdir build
 | 
			
		||||
        cd build
 | 
			
		||||
        cmake -DCMAKE_TOOLCHAIN_FILE=c:/vcpkg/scripts/buildsystems/vcpkg.cmake -DCMAKE_CXX_COMPILER=cl.exe -DUSE_WS=1 -DUSE_TEST=1 ..
 | 
			
		||||
    - run: cmake --build build
 | 
			
		||||
							
								
								
									
										1
									
								
								.gitignore
									
									
									
									
										vendored
									
									
								
							
							
						
						
									
										1
									
								
								.gitignore
									
									
									
									
										vendored
									
									
								
							@@ -5,4 +5,3 @@ ixsnake/ixsnake/.certs/
 | 
			
		||||
site/
 | 
			
		||||
ws/.certs/
 | 
			
		||||
ws/.srl
 | 
			
		||||
ixhttpd
 | 
			
		||||
 
 | 
			
		||||
@@ -7,7 +7,7 @@ find_library(MBEDCRYPTO_LIBRARY mbedcrypto)
 | 
			
		||||
set(MBEDTLS_LIBRARIES "${MBEDTLS_LIBRARY}" "${MBEDX509_LIBRARY}" "${MBEDCRYPTO_LIBRARY}")
 | 
			
		||||
 | 
			
		||||
include(FindPackageHandleStandardArgs)
 | 
			
		||||
find_package_handle_standard_args(MbedTLS DEFAULT_MSG
 | 
			
		||||
find_package_handle_standard_args(MBEDTLS DEFAULT_MSG
 | 
			
		||||
    MBEDTLS_INCLUDE_DIRS MBEDTLS_LIBRARY MBEDX509_LIBRARY MBEDCRYPTO_LIBRARY)
 | 
			
		||||
 | 
			
		||||
mark_as_advanced(MBEDTLS_INCLUDE_DIRS MBEDTLS_LIBRARY MBEDX509_LIBRARY MBEDCRYPTO_LIBRARY)
 | 
			
		||||
 
 | 
			
		||||
@@ -180,8 +180,10 @@ if (USE_TLS)
 | 
			
		||||
      # set(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} /opt/local/include/openssl-1.0)
 | 
			
		||||
    endif()
 | 
			
		||||
 | 
			
		||||
    # Use OPENSSL_ROOT_DIR CMake variable if you need to use your own openssl
 | 
			
		||||
    # This OPENSSL_FOUND check is to help find a cmake manually configured OpenSSL
 | 
			
		||||
    if (NOT OPENSSL_FOUND)
 | 
			
		||||
      find_package(OpenSSL REQUIRED)
 | 
			
		||||
    endif()
 | 
			
		||||
    message(STATUS "OpenSSL: " ${OPENSSL_VERSION})
 | 
			
		||||
 | 
			
		||||
    add_definitions(${OPENSSL_DEFINITIONS})
 | 
			
		||||
@@ -199,10 +201,18 @@ if (USE_TLS)
 | 
			
		||||
  endif()
 | 
			
		||||
endif()
 | 
			
		||||
 | 
			
		||||
# Use ZLIB_ROOT CMake variable if you need to use your own zlib
 | 
			
		||||
find_package(ZLIB REQUIRED)
 | 
			
		||||
# This ZLIB_FOUND check is to help find a cmake manually configured zlib
 | 
			
		||||
if (NOT ZLIB_FOUND)
 | 
			
		||||
  find_package(ZLIB)
 | 
			
		||||
endif()
 | 
			
		||||
if (ZLIB_FOUND)
 | 
			
		||||
  include_directories(${ZLIB_INCLUDE_DIRS})
 | 
			
		||||
  target_link_libraries(ixwebsocket ${ZLIB_LIBRARIES})
 | 
			
		||||
else()
 | 
			
		||||
  include_directories(third_party/zlib ${CMAKE_CURRENT_BINARY_DIR}/third_party/zlib)
 | 
			
		||||
  add_subdirectory(third_party/zlib)
 | 
			
		||||
  target_link_libraries(ixwebsocket zlibstatic)
 | 
			
		||||
endif()
 | 
			
		||||
 | 
			
		||||
if (WIN32)
 | 
			
		||||
  target_link_libraries(ixwebsocket wsock32 ws2_32 shlwapi)
 | 
			
		||||
@@ -228,29 +238,19 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
 | 
			
		||||
    target_compile_options(ixwebsocket PRIVATE /MP)
 | 
			
		||||
endif()
 | 
			
		||||
 | 
			
		||||
target_include_directories(ixwebsocket PUBLIC
 | 
			
		||||
  $<BUILD_INTERFACE:${IXWEBSOCKET_INCLUDE_DIRS}/>
 | 
			
		||||
  $<INSTALL_INTERFACE:include/ixwebsocket>
 | 
			
		||||
)
 | 
			
		||||
target_include_directories(ixwebsocket PUBLIC ${IXWEBSOCKET_INCLUDE_DIRS})
 | 
			
		||||
 | 
			
		||||
set_target_properties(ixwebsocket PROPERTIES PUBLIC_HEADER "${IXWEBSOCKET_HEADERS}")
 | 
			
		||||
 | 
			
		||||
install(TARGETS ixwebsocket
 | 
			
		||||
        EXPORT ixwebsocket
 | 
			
		||||
        ARCHIVE DESTINATION lib
 | 
			
		||||
        PUBLIC_HEADER DESTINATION include/ixwebsocket/
 | 
			
		||||
        ARCHIVE DESTINATION ${CMAKE_INSTALL_PREFIX}/lib
 | 
			
		||||
        PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_PREFIX}/include/ixwebsocket/
 | 
			
		||||
)
 | 
			
		||||
 | 
			
		||||
install(EXPORT ixwebsocket
 | 
			
		||||
        FILE ixwebsocket-config.cmake
 | 
			
		||||
        NAMESPACE ixwebsocket::
 | 
			
		||||
        DESTINATION lib/cmake/ixwebsocket)
 | 
			
		||||
 | 
			
		||||
if (USE_WS OR USE_TEST)
 | 
			
		||||
  add_subdirectory(ixcore)
 | 
			
		||||
  add_subdirectory(ixcrypto)
 | 
			
		||||
  add_subdirectory(ixcobra)
 | 
			
		||||
  add_subdirectory(ixredis)
 | 
			
		||||
  add_subdirectory(ixsnake)
 | 
			
		||||
  add_subdirectory(ixsentry)
 | 
			
		||||
  add_subdirectory(ixbots)
 | 
			
		||||
 
 | 
			
		||||
@@ -1 +1 @@
 | 
			
		||||
docker/Dockerfile.alpine
 | 
			
		||||
docker/Dockerfile.centos7_httpd
 | 
			
		||||
@@ -81,7 +81,7 @@ If your company or project is using this library, feel free to open an issue or
 | 
			
		||||
 | 
			
		||||
- [Machine Zone](https://www.mz.com)
 | 
			
		||||
- [Tokio](https://gitlab.com/HCInk/tokio), a discord library focused on audio playback with node bindings.
 | 
			
		||||
- [libDiscordBot](https://github.com/tostc/libDiscordBot/tree/master), an easy to use Discord-bot framework.
 | 
			
		||||
- [libDiscordBot](https://github.com/tostc/libDiscordBot/tree/master), a work in progress discord library
 | 
			
		||||
- [gwebsocket](https://github.com/norrbotten/gwebsocket), a websocket (lua) module for Garry's Mod
 | 
			
		||||
- [DisCPP](https://github.com/DisCPP/DisCPP), a simple but feature rich Discord API wrapper
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -1,8 +1,8 @@
 | 
			
		||||
FROM alpine:3.12 as build
 | 
			
		||||
FROM alpine:3.11 as build
 | 
			
		||||
 | 
			
		||||
RUN apk add --no-cache \
 | 
			
		||||
    gcc g++ musl-dev linux-headers \
 | 
			
		||||
    cmake mbedtls-dev make zlib-dev python3-dev ninja
 | 
			
		||||
    cmake mbedtls-dev make zlib-dev ninja
 | 
			
		||||
 | 
			
		||||
RUN addgroup -S app && \
 | 
			
		||||
    adduser -S -G app app && \
 | 
			
		||||
@@ -18,9 +18,9 @@ USER app
 | 
			
		||||
RUN make ws_mbedtls_install && \
 | 
			
		||||
    sh tools/trim_repo_for_docker.sh
 | 
			
		||||
 | 
			
		||||
FROM alpine:3.12 as runtime
 | 
			
		||||
FROM alpine:3.11 as runtime
 | 
			
		||||
 | 
			
		||||
RUN apk add --no-cache libstdc++ mbedtls ca-certificates python3 && \
 | 
			
		||||
RUN apk add --no-cache libstdc++ mbedtls ca-certificates && \
 | 
			
		||||
    addgroup -S app && \
 | 
			
		||||
    adduser -S -G app app
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
							
								
								
									
										33
									
								
								docker/Dockerfile.centos7_httpd
									
									
									
									
									
										Normal file
									
								
							
							
						
						
									
										33
									
								
								docker/Dockerfile.centos7_httpd
									
									
									
									
									
										Normal file
									
								
							@@ -0,0 +1,33 @@
 | 
			
		||||
FROM centos:7 as build
 | 
			
		||||
 | 
			
		||||
RUN yum install -y gcc-c++ make zlib-devel redhat-rpm-config
 | 
			
		||||
 | 
			
		||||
RUN groupadd app && useradd -g app app
 | 
			
		||||
RUN chown -R app:app /opt
 | 
			
		||||
RUN chown -R app:app /usr/local
 | 
			
		||||
 | 
			
		||||
# There is a bug in CMake where we cannot build from the root top folder
 | 
			
		||||
# So we build from /opt
 | 
			
		||||
COPY --chown=app:app . /opt
 | 
			
		||||
WORKDIR /opt
 | 
			
		||||
 | 
			
		||||
USER app
 | 
			
		||||
RUN [ "make", "httpd_linux" ]
 | 
			
		||||
RUN [ "rm", "-rf", "build" ]
 | 
			
		||||
 | 
			
		||||
FROM centos:8 as runtime
 | 
			
		||||
 | 
			
		||||
RUN groupadd app && useradd -g app app
 | 
			
		||||
COPY --chown=app:app --from=build /usr/local/bin/ixhttpd /usr/local/bin/ixhttpd
 | 
			
		||||
RUN chmod +x /usr/local/bin/ixhttpd
 | 
			
		||||
RUN ldd /usr/local/bin/ixhttpd
 | 
			
		||||
 | 
			
		||||
# Copy source code for gcc
 | 
			
		||||
COPY --chown=app:app --from=build /opt /opt
 | 
			
		||||
 | 
			
		||||
# Now run in usermode
 | 
			
		||||
USER app
 | 
			
		||||
WORKDIR /home/app
 | 
			
		||||
 | 
			
		||||
ENTRYPOINT ["ixhttpd"]
 | 
			
		||||
EXPOSE 9999
 | 
			
		||||
@@ -1,78 +1,6 @@
 | 
			
		||||
# Changelog
 | 
			
		||||
All changes to this project will be documented in this file.
 | 
			
		||||
 | 
			
		||||
## [9.8.5] - 2020-07-06
 | 
			
		||||
 | 
			
		||||
(cobra python bots) remove the test which stop the bot when events do not follow cobra metrics system schema with an id and a device entry
 | 
			
		||||
 | 
			
		||||
## [9.8.4] - 2020-06-26
 | 
			
		||||
 | 
			
		||||
(cobra bots) remove bots which is not required now that we can use Python extensions
 | 
			
		||||
 | 
			
		||||
## [9.8.3] - 2020-06-25
 | 
			
		||||
 | 
			
		||||
(cmake) new python code is optional and enabled at cmake time with -DUSE_PYTHON=1
 | 
			
		||||
 | 
			
		||||
## [9.8.2] - 2020-06-24
 | 
			
		||||
 | 
			
		||||
(cobra bots) new cobra metrics bot to send data to statsd using Python for processing the message
 | 
			
		||||
 | 
			
		||||
## [9.8.1] - 2020-06-19
 | 
			
		||||
 | 
			
		||||
(cobra metrics to statsd bot) fps slow frame info : do not include os name
 | 
			
		||||
 | 
			
		||||
## [9.8.0] - 2020-06-19
 | 
			
		||||
 | 
			
		||||
(cobra metrics to statsd bot) send info about memory warnings
 | 
			
		||||
 | 
			
		||||
## [9.7.9] - 2020-06-18
 | 
			
		||||
 | 
			
		||||
(http client) fix deadlock when following redirects
 | 
			
		||||
 | 
			
		||||
## [9.7.8] - 2020-06-18
 | 
			
		||||
 | 
			
		||||
(cobra metrics to statsd bot) send info about net requests
 | 
			
		||||
 | 
			
		||||
## [9.7.7] - 2020-06-17
 | 
			
		||||
 | 
			
		||||
(cobra client and bots) add batch_size subscription option for retrieving multiple messages at once
 | 
			
		||||
 | 
			
		||||
## [9.7.6] - 2020-06-15
 | 
			
		||||
 | 
			
		||||
(websocket) WebSocketServer is not a final class, so that users can extend it (fix #215)
 | 
			
		||||
 | 
			
		||||
## [9.7.5] - 2020-06-15
 | 
			
		||||
 | 
			
		||||
(cobra bots) minor aesthetic change, in how we display http headers with a : then space as key value separator instead of :: with no space
 | 
			
		||||
 | 
			
		||||
## [9.7.4] - 2020-06-11
 | 
			
		||||
 | 
			
		||||
(cobra metrics to statsd bot) change from a statsd type of gauge to a timing one
 | 
			
		||||
 | 
			
		||||
## [9.7.3] - 2020-06-11
 | 
			
		||||
 | 
			
		||||
(redis cobra bots) capture most used devices in a zset
 | 
			
		||||
 | 
			
		||||
## [9.7.2] - 2020-06-11
 | 
			
		||||
 | 
			
		||||
(ws) add bare bone redis-cli like sub-command, with command line editing powered by libnoise
 | 
			
		||||
 | 
			
		||||
## [9.7.1] - 2020-06-11
 | 
			
		||||
 | 
			
		||||
(redis cobra bots) ws cobra metrics to redis / hostname invalid parsing
 | 
			
		||||
 | 
			
		||||
## [9.7.0] - 2020-06-11
 | 
			
		||||
 | 
			
		||||
(redis cobra bots) xadd with maxlen + fix bug in xadd client implementation and ws cobra metrics to redis command argument parsing
 | 
			
		||||
 | 
			
		||||
## [9.6.9] - 2020-06-10
 | 
			
		||||
 | 
			
		||||
(redis cobra bots) update the cobra to redis bot to use the bot framework, and change it to report fps metrics into redis streams.
 | 
			
		||||
 | 
			
		||||
## [9.6.6] - 2020-06-04
 | 
			
		||||
 | 
			
		||||
(statsd cobra bots) statsd improvement: prefix does not need a dot as a suffix, message size can be larger than 256 bytes, error handling was invalid, use core logger for logging instead of std::cerr
 | 
			
		||||
 | 
			
		||||
## [9.6.5] - 2020-05-29
 | 
			
		||||
 | 
			
		||||
(http server) support gzip compression
 | 
			
		||||
 
 | 
			
		||||
@@ -22,9 +22,8 @@ Options for building:
 | 
			
		||||
* `-DUSE_MBED_TLS=1` will use [mbedlts](https://tls.mbed.org/) for the TLS support
 | 
			
		||||
* `-DUSE_WS=1` will build the ws interactive command line tool
 | 
			
		||||
* `-DUSE_TEST=1` will build the unittest
 | 
			
		||||
* `-DUSE_PYTHON=1` will use Python3 for cobra bots, require Python3 to be installed.
 | 
			
		||||
 | 
			
		||||
If you are on Windows, look at the [appveyor](https://github.com/machinezone/IXWebSocket/blob/master/appveyor.yml) file (not maintained much though) or rather the [github actions](https://github.com/machinezone/IXWebSocket/blob/master/.github/workflows/unittest_windows.yml) which have instructions for building dependencies.
 | 
			
		||||
If you are on Windows, look at the [appveyor](https://github.com/machinezone/IXWebSocket/blob/master/appveyor.yml) file (not maintained much though) or rather the [github actions](https://github.com/machinezone/IXWebSocket/blob/master/.github/workflows/ccpp.yml#L40) which have instructions for building dependencies.
 | 
			
		||||
 | 
			
		||||
It is also possible to externally include the project, so that everything is fetched over the wire when you build like so:
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -6,7 +6,7 @@
 | 
			
		||||
 *  Buid with make httpd
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
#include <ixwebsocket/IXHttpServer.h>
 | 
			
		||||
#include "IXHttpServer.h"
 | 
			
		||||
#include <sstream>
 | 
			
		||||
#include <iostream>
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -8,8 +8,6 @@ set (IXBOTS_SOURCES
 | 
			
		||||
    ixbots/IXCobraToSentryBot.cpp
 | 
			
		||||
    ixbots/IXCobraToStatsdBot.cpp
 | 
			
		||||
    ixbots/IXCobraToStdoutBot.cpp
 | 
			
		||||
    ixbots/IXCobraMetricsToRedisBot.cpp
 | 
			
		||||
    ixbots/IXCobraToPythonBot.cpp
 | 
			
		||||
    ixbots/IXStatsdClient.cpp
 | 
			
		||||
)
 | 
			
		||||
 | 
			
		||||
@@ -19,8 +17,6 @@ set (IXBOTS_HEADERS
 | 
			
		||||
    ixbots/IXCobraToSentryBot.h
 | 
			
		||||
    ixbots/IXCobraToStatsdBot.h
 | 
			
		||||
    ixbots/IXCobraToStdoutBot.h
 | 
			
		||||
    ixbots/IXCobraMetricsToRedisBot.h
 | 
			
		||||
    ixbots/IXCobraToPythonBot.h
 | 
			
		||||
    ixbots/IXStatsdClient.h
 | 
			
		||||
)
 | 
			
		||||
 | 
			
		||||
@@ -34,24 +30,14 @@ if (NOT JSONCPP_FOUND)
 | 
			
		||||
  set(JSONCPP_INCLUDE_DIRS ../third_party/jsoncpp)
 | 
			
		||||
endif()
 | 
			
		||||
 | 
			
		||||
if (USE_PYTHON)
 | 
			
		||||
  target_compile_definitions(ixbots PUBLIC IXBOTS_USE_PYTHON)
 | 
			
		||||
  find_package(Python COMPONENTS Development)
 | 
			
		||||
endif()
 | 
			
		||||
 | 
			
		||||
set(IXBOTS_INCLUDE_DIRS
 | 
			
		||||
    .
 | 
			
		||||
    ..
 | 
			
		||||
    ../ixcore
 | 
			
		||||
    ../ixwebsocket
 | 
			
		||||
    ../ixcobra
 | 
			
		||||
    ../ixredis
 | 
			
		||||
    ../ixsentry
 | 
			
		||||
    ${JSONCPP_INCLUDE_DIRS}
 | 
			
		||||
    ${SPDLOG_INCLUDE_DIRS})
 | 
			
		||||
 | 
			
		||||
if (USE_PYTHON)
 | 
			
		||||
  set(IXBOTS_INCLUDE_DIRS ${IXBOTS_INCLUDE_DIRS} ${Python_INCLUDE_DIRS})
 | 
			
		||||
endif()
 | 
			
		||||
 | 
			
		||||
target_include_directories( ixbots PUBLIC ${IXBOTS_INCLUDE_DIRS} )
 | 
			
		||||
 
 | 
			
		||||
@@ -8,7 +8,6 @@
 | 
			
		||||
 | 
			
		||||
#include <ixcobra/IXCobraConnection.h>
 | 
			
		||||
#include <ixcore/utils/IXCoreLogger.h>
 | 
			
		||||
#include <ixwebsocket/IXSetThreadName.h>
 | 
			
		||||
 | 
			
		||||
#include <algorithm>
 | 
			
		||||
#include <chrono>
 | 
			
		||||
@@ -29,7 +28,6 @@ namespace ix
 | 
			
		||||
        auto runtime = botConfig.runtime;
 | 
			
		||||
        auto maxEventsPerMinute = botConfig.maxEventsPerMinute;
 | 
			
		||||
        auto limitReceivedEvents = botConfig.limitReceivedEvents;
 | 
			
		||||
        auto batchSize = botConfig.batchSize;
 | 
			
		||||
 | 
			
		||||
        ix::CobraConnection conn;
 | 
			
		||||
        conn.configure(config);
 | 
			
		||||
@@ -45,7 +43,6 @@ namespace ix
 | 
			
		||||
        std::atomic<bool> stop(false);
 | 
			
		||||
        std::atomic<bool> throttled(false);
 | 
			
		||||
        std::atomic<bool> fatalCobraError(false);
 | 
			
		||||
        std::atomic<bool> stalledConnection(false);
 | 
			
		||||
        int minuteCounter = 0;
 | 
			
		||||
 | 
			
		||||
        auto timer = [&sentCount,
 | 
			
		||||
@@ -56,9 +53,7 @@ namespace ix
 | 
			
		||||
                      &receivedCountPerSecs,
 | 
			
		||||
                      &receivedCountPerMinutes,
 | 
			
		||||
                      &minuteCounter,
 | 
			
		||||
                      &conn,
 | 
			
		||||
                      &stop] {
 | 
			
		||||
            setThreadName("Bot progress");
 | 
			
		||||
            while (!stop)
 | 
			
		||||
            {
 | 
			
		||||
                //
 | 
			
		||||
@@ -75,11 +70,7 @@ namespace ix
 | 
			
		||||
                   << sentCountPerSecs
 | 
			
		||||
                   << " "
 | 
			
		||||
                   << sentCountTotal;
 | 
			
		||||
 | 
			
		||||
                if (conn.isAuthenticated())
 | 
			
		||||
                {
 | 
			
		||||
                CoreLogger::info(ss.str());
 | 
			
		||||
                }
 | 
			
		||||
 | 
			
		||||
                receivedCountPerSecs = receivedCount - receivedCountTotal;
 | 
			
		||||
                sentCountPerSecs = sentCount - sentCountTotal;
 | 
			
		||||
@@ -102,14 +93,7 @@ namespace ix
 | 
			
		||||
 | 
			
		||||
        std::thread t1(timer);
 | 
			
		||||
 | 
			
		||||
        auto heartbeat = [&sentCount,
 | 
			
		||||
                          &receivedCount,
 | 
			
		||||
                          &stop,
 | 
			
		||||
                          &enableHeartbeat,
 | 
			
		||||
                          &heartBeatTimeout,
 | 
			
		||||
                          &stalledConnection]
 | 
			
		||||
        {
 | 
			
		||||
            setThreadName("Bot heartbeat");
 | 
			
		||||
        auto heartbeat = [&sentCount, &receivedCount, &stop, &enableHeartbeat, &heartBeatTimeout, &fatalCobraError] {
 | 
			
		||||
            std::string state("na");
 | 
			
		||||
 | 
			
		||||
            if (!enableHeartbeat) return;
 | 
			
		||||
@@ -124,12 +108,9 @@ namespace ix
 | 
			
		||||
 | 
			
		||||
                if (currentState == state)
 | 
			
		||||
                {
 | 
			
		||||
                    ss.str("");
 | 
			
		||||
                    ss << "no messages received or sent for "
 | 
			
		||||
                       << heartBeatTimeout << " seconds, reconnecting";
 | 
			
		||||
 | 
			
		||||
                    CoreLogger::error(ss.str());
 | 
			
		||||
                    stalledConnection = true;
 | 
			
		||||
                    CoreLogger::error("no messages received or sent for 1 minute, exiting");
 | 
			
		||||
                    fatalCobraError = true;
 | 
			
		||||
                    break;
 | 
			
		||||
                }
 | 
			
		||||
                state = currentState;
 | 
			
		||||
 | 
			
		||||
@@ -154,7 +135,6 @@ namespace ix
 | 
			
		||||
                               &receivedCountPerMinutes,
 | 
			
		||||
                               maxEventsPerMinute,
 | 
			
		||||
                               limitReceivedEvents,
 | 
			
		||||
                               batchSize,
 | 
			
		||||
                               &fatalCobraError,
 | 
			
		||||
                               &sentCount](const CobraEventPtr& event) {
 | 
			
		||||
            if (event->type == ix::CobraEventType::Open)
 | 
			
		||||
@@ -163,7 +143,7 @@ namespace ix
 | 
			
		||||
 | 
			
		||||
                for (auto&& it : event->headers)
 | 
			
		||||
                {
 | 
			
		||||
                    CoreLogger::info(it.first + ": " + it.second);
 | 
			
		||||
                    CoreLogger::info(it.first + "::" + it.second);
 | 
			
		||||
                }
 | 
			
		||||
            }
 | 
			
		||||
            else if (event->type == ix::CobraEventType::Closed)
 | 
			
		||||
@@ -176,7 +156,7 @@ namespace ix
 | 
			
		||||
                CoreLogger::info("Subscribing to " + channel);
 | 
			
		||||
                CoreLogger::info("Subscribing at position " + subscriptionPosition);
 | 
			
		||||
                CoreLogger::info("Subscribing with filter " + filter);
 | 
			
		||||
                conn.subscribe(channel, filter, subscriptionPosition, batchSize,
 | 
			
		||||
                conn.subscribe(channel, filter, subscriptionPosition,
 | 
			
		||||
                    [&sentCount, &receivedCountPerMinutes,
 | 
			
		||||
                     maxEventsPerMinute, limitReceivedEvents,
 | 
			
		||||
                     &throttled, &receivedCount,
 | 
			
		||||
@@ -251,13 +231,6 @@ namespace ix
 | 
			
		||||
                std::this_thread::sleep_for(duration);
 | 
			
		||||
 | 
			
		||||
                if (fatalCobraError) break;
 | 
			
		||||
 | 
			
		||||
                if (stalledConnection)
 | 
			
		||||
                {
 | 
			
		||||
                    conn.disconnect();
 | 
			
		||||
                    conn.connect();
 | 
			
		||||
                    stalledConnection = false;
 | 
			
		||||
                }
 | 
			
		||||
            }
 | 
			
		||||
        }
 | 
			
		||||
        // Run for a duration, used by unittesting now
 | 
			
		||||
@@ -269,13 +242,6 @@ namespace ix
 | 
			
		||||
                std::this_thread::sleep_for(duration);
 | 
			
		||||
 | 
			
		||||
                if (fatalCobraError) break;
 | 
			
		||||
 | 
			
		||||
                if (stalledConnection)
 | 
			
		||||
                {
 | 
			
		||||
                    conn.disconnect();
 | 
			
		||||
                    conn.connect();
 | 
			
		||||
                    stalledConnection = false;
 | 
			
		||||
                }
 | 
			
		||||
            }
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
@@ -299,22 +265,4 @@ namespace ix
 | 
			
		||||
    {
 | 
			
		||||
        _onBotMessageCallback = callback;
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    std::string CobraBot::getDeviceIdentifier(const Json::Value& msg)
 | 
			
		||||
    {
 | 
			
		||||
        std::string deviceId("na");
 | 
			
		||||
 | 
			
		||||
        auto osName = msg["device"]["os_name"];
 | 
			
		||||
        if (osName == "Android")
 | 
			
		||||
        {
 | 
			
		||||
            deviceId = msg["device"]["model"].asString();
 | 
			
		||||
        }
 | 
			
		||||
        else if (osName == "iOS")
 | 
			
		||||
        {
 | 
			
		||||
            deviceId = msg["device"]["hardware_model"].asString();
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        return deviceId;
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
} // namespace ix
 | 
			
		||||
 
 | 
			
		||||
@@ -28,8 +28,6 @@ namespace ix
 | 
			
		||||
        int64_t run(const CobraBotConfig& botConfig);
 | 
			
		||||
        void setOnBotMessageCallback(const OnBotMessageCallback& callback);
 | 
			
		||||
 | 
			
		||||
        std::string getDeviceIdentifier(const Json::Value& msg);
 | 
			
		||||
 | 
			
		||||
    private:
 | 
			
		||||
        OnBotMessageCallback _onBotMessageCallback;
 | 
			
		||||
    };
 | 
			
		||||
 
 | 
			
		||||
@@ -27,6 +27,5 @@ namespace ix
 | 
			
		||||
        int runtime = -1;
 | 
			
		||||
        int maxEventsPerMinute = std::numeric_limits<int>::max();
 | 
			
		||||
        bool limitReceivedEvents = false;
 | 
			
		||||
        int batchSize = 1;
 | 
			
		||||
    };
 | 
			
		||||
} // namespace ix
 | 
			
		||||
 
 | 
			
		||||
@@ -1,149 +0,0 @@
 | 
			
		||||
/*
 | 
			
		||||
 *  IXCobraMetricsToRedisBot.cpp
 | 
			
		||||
 *  Author: Benjamin Sergeant
 | 
			
		||||
 *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
#include "IXCobraMetricsToRedisBot.h"
 | 
			
		||||
 | 
			
		||||
#include "IXCobraBot.h"
 | 
			
		||||
#include "IXStatsdClient.h"
 | 
			
		||||
#include <chrono>
 | 
			
		||||
#include <ixcobra/IXCobraConnection.h>
 | 
			
		||||
#include <ixcore/utils/IXCoreLogger.h>
 | 
			
		||||
#include <sstream>
 | 
			
		||||
#include <vector>
 | 
			
		||||
#include <algorithm>
 | 
			
		||||
#include <map>
 | 
			
		||||
#include <cctype>
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
namespace
 | 
			
		||||
{
 | 
			
		||||
    std::string removeSpaces(const std::string& str)
 | 
			
		||||
    {
 | 
			
		||||
        std::string out(str);
 | 
			
		||||
        out.erase(
 | 
			
		||||
            std::remove_if(out.begin(), out.end(), [](unsigned char x) { return std::isspace(x); }),
 | 
			
		||||
            out.end());
 | 
			
		||||
 | 
			
		||||
        return out;
 | 
			
		||||
    }
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
namespace ix
 | 
			
		||||
{
 | 
			
		||||
    bool processPerfMetricsEventSlowFrames(const Json::Value& msg,
 | 
			
		||||
                                           RedisClient& redisClient,
 | 
			
		||||
                                           const std::string& deviceId)
 | 
			
		||||
    {
 | 
			
		||||
        auto frameRateHistogramCounts = msg["data"]["FrameRateHistogramCounts"];
 | 
			
		||||
 | 
			
		||||
        int slowFrames = 0;
 | 
			
		||||
        slowFrames += frameRateHistogramCounts[4].asInt();
 | 
			
		||||
        slowFrames += frameRateHistogramCounts[5].asInt();
 | 
			
		||||
        slowFrames += frameRateHistogramCounts[6].asInt();
 | 
			
		||||
        slowFrames += frameRateHistogramCounts[7].asInt();
 | 
			
		||||
 | 
			
		||||
        //
 | 
			
		||||
        // XADD without a device id
 | 
			
		||||
        //
 | 
			
		||||
        std::stringstream ss;
 | 
			
		||||
        ss << msg["id"].asString() << "_slow_frames" << "."
 | 
			
		||||
           << msg["device"]["game"].asString() << "."
 | 
			
		||||
           << msg["device"]["os_name"].asString() << "."
 | 
			
		||||
           << removeSpaces(msg["data"]["Tag"].asString());
 | 
			
		||||
 | 
			
		||||
        int maxLen;
 | 
			
		||||
        maxLen = 100000;
 | 
			
		||||
        std::string id = ss.str();
 | 
			
		||||
        std::string errMsg;
 | 
			
		||||
        if (redisClient.xadd(id, std::to_string(slowFrames), maxLen, errMsg).empty())
 | 
			
		||||
        {
 | 
			
		||||
            CoreLogger::info(std::string("redis XADD error: ") + errMsg);
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        //
 | 
			
		||||
        // XADD with a device id
 | 
			
		||||
        //
 | 
			
		||||
        ss.str(""); // reset the stringstream
 | 
			
		||||
        ss << msg["id"].asString() << "_slow_frames_by_device" << "."
 | 
			
		||||
           << deviceId << "."
 | 
			
		||||
           << msg["device"]["game"].asString() << "."
 | 
			
		||||
           << msg["device"]["os_name"].asString() << "."
 | 
			
		||||
           << removeSpaces(msg["data"]["Tag"].asString());
 | 
			
		||||
 | 
			
		||||
        id = ss.str();
 | 
			
		||||
        maxLen = 1000;
 | 
			
		||||
        if (redisClient.xadd(id, std::to_string(slowFrames), maxLen, errMsg).empty())
 | 
			
		||||
        {
 | 
			
		||||
            CoreLogger::info(std::string("redis XADD error: ") + errMsg);
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        //
 | 
			
		||||
        // Add device to the device zset, and increment the score
 | 
			
		||||
        // so that we know which devices are used more than others
 | 
			
		||||
        // ZINCRBY myzset 1 one
 | 
			
		||||
        //
 | 
			
		||||
        ss.str(""); // reset the stringstream
 | 
			
		||||
        ss << msg["id"].asString() << "_slow_frames_devices" << "."
 | 
			
		||||
           << msg["device"]["game"].asString();
 | 
			
		||||
 | 
			
		||||
        id = ss.str();
 | 
			
		||||
        std::vector<std::string> args = {
 | 
			
		||||
            "ZINCRBY", id, "1", deviceId
 | 
			
		||||
        };
 | 
			
		||||
        auto response = redisClient.send(args, errMsg);
 | 
			
		||||
        if (response.first == RespType::Error)
 | 
			
		||||
        {
 | 
			
		||||
            CoreLogger::info(std::string("redis ZINCRBY error: ") + errMsg);
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        return true;
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    int64_t cobra_metrics_to_redis_bot(const ix::CobraBotConfig& config,
 | 
			
		||||
                                       RedisClient& redisClient,
 | 
			
		||||
                                       bool verbose)
 | 
			
		||||
    {
 | 
			
		||||
        CobraBot bot;
 | 
			
		||||
 | 
			
		||||
        bot.setOnBotMessageCallback(
 | 
			
		||||
            [&redisClient, &verbose, &bot]
 | 
			
		||||
             (const Json::Value& msg,
 | 
			
		||||
              const std::string& /*position*/,
 | 
			
		||||
              std::atomic<bool>& /*throttled*/,
 | 
			
		||||
              std::atomic<bool>& /*fatalCobraError*/,
 | 
			
		||||
              std::atomic<uint64_t>& sentCount) -> void {
 | 
			
		||||
            if (msg["device"].isNull())
 | 
			
		||||
            {
 | 
			
		||||
                CoreLogger::info("no device entry, skipping event");
 | 
			
		||||
                return;
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            if (msg["id"].isNull())
 | 
			
		||||
            {
 | 
			
		||||
                CoreLogger::info("no id entry, skipping event");
 | 
			
		||||
                return;
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            //
 | 
			
		||||
            // Display full message with
 | 
			
		||||
            if (verbose)
 | 
			
		||||
            {
 | 
			
		||||
                CoreLogger::info(msg.toStyledString());
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            bool success = false;
 | 
			
		||||
            if (msg["id"].asString() == "engine_performance_metrics_id")
 | 
			
		||||
            {
 | 
			
		||||
                auto deviceId = bot.getDeviceIdentifier(msg);
 | 
			
		||||
                success = processPerfMetricsEventSlowFrames(msg, redisClient, deviceId);
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            if (success) sentCount++;
 | 
			
		||||
        });
 | 
			
		||||
 | 
			
		||||
        return bot.run(config);
 | 
			
		||||
    }
 | 
			
		||||
} // namespace ix
 | 
			
		||||
@@ -1,20 +0,0 @@
 | 
			
		||||
/*
 | 
			
		||||
 *  IXCobraMetricsToRedisBot.h
 | 
			
		||||
 *  Author: Benjamin Sergeant
 | 
			
		||||
 *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
 | 
			
		||||
 */
 | 
			
		||||
#pragma once
 | 
			
		||||
 | 
			
		||||
#include <cstdint>
 | 
			
		||||
#include <ixredis/IXRedisClient.h>
 | 
			
		||||
#include "IXCobraBotConfig.h"
 | 
			
		||||
#include <stddef.h>
 | 
			
		||||
#include <string>
 | 
			
		||||
 | 
			
		||||
namespace ix
 | 
			
		||||
{
 | 
			
		||||
    int64_t cobra_metrics_to_redis_bot(const ix::CobraBotConfig& config,
 | 
			
		||||
                                       RedisClient& redisClient,
 | 
			
		||||
                                       bool verbose);
 | 
			
		||||
} // namespace ix
 | 
			
		||||
 | 
			
		||||
@@ -1,332 +0,0 @@
 | 
			
		||||
/*
 | 
			
		||||
 *  IXCobraToPythonBot.cpp
 | 
			
		||||
 *  Author: Benjamin Sergeant
 | 
			
		||||
 *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
#include "IXCobraToPythonBot.h"
 | 
			
		||||
 | 
			
		||||
#include "IXCobraBot.h"
 | 
			
		||||
#include "IXStatsdClient.h"
 | 
			
		||||
#include <chrono>
 | 
			
		||||
#include <ixcobra/IXCobraConnection.h>
 | 
			
		||||
#include <ixcore/utils/IXCoreLogger.h>
 | 
			
		||||
#include <sstream>
 | 
			
		||||
#include <vector>
 | 
			
		||||
#include <algorithm>
 | 
			
		||||
#include <map>
 | 
			
		||||
#include <cctype>
 | 
			
		||||
 | 
			
		||||
//
 | 
			
		||||
// I cannot get Windows to easily build on CI (github action) so support
 | 
			
		||||
// is disabled for now. It should be a simple fix 
 | 
			
		||||
// (linking error about missing debug build)
 | 
			
		||||
//
 | 
			
		||||
 | 
			
		||||
#ifdef IXBOTS_USE_PYTHON
 | 
			
		||||
#define PY_SSIZE_T_CLEAN
 | 
			
		||||
#include <Python.h>
 | 
			
		||||
#endif
 | 
			
		||||
 | 
			
		||||
#ifdef IXBOTS_USE_PYTHON
 | 
			
		||||
namespace
 | 
			
		||||
{
 | 
			
		||||
    //
 | 
			
		||||
    // This function is unused at this point. It produce a correct output,
 | 
			
		||||
    // but triggers memory leaks when called repeateadly, as I cannot figure out how to
 | 
			
		||||
    // make the reference counting Python functions to work properly (Py_DECREF and friends)
 | 
			
		||||
    //
 | 
			
		||||
    PyObject* jsonToPythonObject(const Json::Value& val)
 | 
			
		||||
    {
 | 
			
		||||
        switch(val.type())
 | 
			
		||||
        {
 | 
			
		||||
            case Json::nullValue:
 | 
			
		||||
            {
 | 
			
		||||
                return Py_None;
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            case Json::intValue:
 | 
			
		||||
            {
 | 
			
		||||
                return PyLong_FromLong(val.asInt64());
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            case Json::uintValue:
 | 
			
		||||
            {
 | 
			
		||||
                return PyLong_FromLong(val.asUInt64());
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            case Json::realValue:
 | 
			
		||||
            {
 | 
			
		||||
                return PyFloat_FromDouble(val.asDouble());
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            case Json::stringValue:
 | 
			
		||||
            {
 | 
			
		||||
                return PyUnicode_FromString(val.asCString());
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            case Json::booleanValue:
 | 
			
		||||
            {
 | 
			
		||||
                return val.asBool() ? Py_True : Py_False;
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            case Json::arrayValue:
 | 
			
		||||
            {
 | 
			
		||||
                PyObject* list = PyList_New(val.size());
 | 
			
		||||
                Py_ssize_t i = 0;
 | 
			
		||||
                for (auto&& it = val.begin(); it != val.end(); ++it)
 | 
			
		||||
                {
 | 
			
		||||
                    PyList_SetItem(list, i++, jsonToPythonObject(*it));
 | 
			
		||||
                }
 | 
			
		||||
                return list;
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            case Json::objectValue:
 | 
			
		||||
            {
 | 
			
		||||
                PyObject* dict = PyDict_New();
 | 
			
		||||
                for (auto&& it = val.begin(); it != val.end(); ++it)
 | 
			
		||||
                {
 | 
			
		||||
                    PyObject* key = jsonToPythonObject(it.key());
 | 
			
		||||
                    PyObject* value = jsonToPythonObject(*it);
 | 
			
		||||
 | 
			
		||||
                    PyDict_SetItem(dict, key, value);
 | 
			
		||||
                }
 | 
			
		||||
                return dict;
 | 
			
		||||
            }
 | 
			
		||||
        }
 | 
			
		||||
    }
 | 
			
		||||
}
 | 
			
		||||
#endif
 | 
			
		||||
 | 
			
		||||
namespace ix
 | 
			
		||||
{
 | 
			
		||||
    int64_t cobra_to_python_bot(const ix::CobraBotConfig& config,
 | 
			
		||||
                                StatsdClient& statsdClient,
 | 
			
		||||
                                const std::string& scriptPath)
 | 
			
		||||
    {
 | 
			
		||||
#ifndef IXBOTS_USE_PYTHON
 | 
			
		||||
        CoreLogger::error("Command is disabled. "
 | 
			
		||||
                          "Needs to be configured with USE_PYTHON=1");
 | 
			
		||||
        return -1;
 | 
			
		||||
#else
 | 
			
		||||
        CobraBot bot;
 | 
			
		||||
        Py_InitializeEx(0); // 0 arg so that we do not install signal handlers 
 | 
			
		||||
                            // which prevent us from using Ctrl-C
 | 
			
		||||
 | 
			
		||||
        size_t lastIndex = scriptPath.find_last_of("."); 
 | 
			
		||||
        std::string modulePath = scriptPath.substr(0, lastIndex);
 | 
			
		||||
 | 
			
		||||
        PyObject* pyModuleName = PyUnicode_DecodeFSDefault(modulePath.c_str());
 | 
			
		||||
 | 
			
		||||
        if (pyModuleName == nullptr)
 | 
			
		||||
        {
 | 
			
		||||
            CoreLogger::error("Python error: Cannot decode file system path");
 | 
			
		||||
            PyErr_Print();
 | 
			
		||||
            return false;
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        // Import module
 | 
			
		||||
        PyObject* pyModule = PyImport_Import(pyModuleName);
 | 
			
		||||
        Py_DECREF(pyModuleName);
 | 
			
		||||
        if (pyModule == nullptr)
 | 
			
		||||
        {
 | 
			
		||||
            CoreLogger::error("Python error: Cannot import module.");
 | 
			
		||||
            CoreLogger::error("Module name cannot countain dash characters.");
 | 
			
		||||
            CoreLogger::error("Is PYTHONPATH set correctly ?");
 | 
			
		||||
            PyErr_Print();
 | 
			
		||||
            return false;
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        // module main funtion name is named 'run'
 | 
			
		||||
        const std::string entryPoint("run");
 | 
			
		||||
        PyObject* pyFunc = PyObject_GetAttrString(pyModule, entryPoint.c_str());
 | 
			
		||||
 | 
			
		||||
        if (!pyFunc)
 | 
			
		||||
        {
 | 
			
		||||
            CoreLogger::error("run symbol is missing from module.");
 | 
			
		||||
            PyErr_Print();
 | 
			
		||||
            return false;
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        if (!PyCallable_Check(pyFunc))
 | 
			
		||||
        {
 | 
			
		||||
            CoreLogger::error("run symbol is not a function.");
 | 
			
		||||
            PyErr_Print();
 | 
			
		||||
            return false;
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        bot.setOnBotMessageCallback(
 | 
			
		||||
            [&statsdClient, pyFunc]
 | 
			
		||||
                (const Json::Value& msg,
 | 
			
		||||
                 const std::string& /*position*/,
 | 
			
		||||
                 std::atomic<bool>& /*throttled*/,
 | 
			
		||||
                 std::atomic<bool>& fatalCobraError,
 | 
			
		||||
                 std::atomic<uint64_t>& sentCount) -> void {
 | 
			
		||||
            //
 | 
			
		||||
            // Invoke python script here. First build function parameters, a tuple
 | 
			
		||||
            //
 | 
			
		||||
            const int kVersion = 1; // We can bump this and let the interface evolve
 | 
			
		||||
 | 
			
		||||
            PyObject *pyArgs = PyTuple_New(2);
 | 
			
		||||
            PyTuple_SetItem(pyArgs, 0, PyLong_FromLong(kVersion)); // First argument
 | 
			
		||||
 | 
			
		||||
            //
 | 
			
		||||
            // It would be better to create a Python object (a dictionary) 
 | 
			
		||||
            // from the json msg, but it is simpler to serialize it to a string
 | 
			
		||||
            // and decode it on the Python side of the fence
 | 
			
		||||
            //
 | 
			
		||||
            PyObject* pySerializedJson = PyUnicode_FromString(msg.toStyledString().c_str());
 | 
			
		||||
            PyTuple_SetItem(pyArgs, 1, pySerializedJson); // Second argument
 | 
			
		||||
 | 
			
		||||
            // Invoke the python routine
 | 
			
		||||
            PyObject* pyList = PyObject_CallObject(pyFunc, pyArgs);
 | 
			
		||||
 | 
			
		||||
            // Error calling the function
 | 
			
		||||
            if (pyList == nullptr)
 | 
			
		||||
            {
 | 
			
		||||
                fatalCobraError = true;
 | 
			
		||||
                CoreLogger::error("run() function call failed. Input msg: ");
 | 
			
		||||
                auto serializedMsg = msg.toStyledString();
 | 
			
		||||
                CoreLogger::error(serializedMsg);
 | 
			
		||||
                PyErr_Print();
 | 
			
		||||
                CoreLogger::error("================");
 | 
			
		||||
                return;
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            // Invalid return type
 | 
			
		||||
            if (!PyList_Check(pyList))
 | 
			
		||||
            {
 | 
			
		||||
                fatalCobraError = true;
 | 
			
		||||
                CoreLogger::error("run() return type should be a list");
 | 
			
		||||
                return;
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            // The result is a list of dict containing sufficient info 
 | 
			
		||||
            // to send messages to statsd
 | 
			
		||||
            auto listSize = PyList_Size(pyList);
 | 
			
		||||
            
 | 
			
		||||
            for (Py_ssize_t i = 0 ; i < listSize; ++i)
 | 
			
		||||
            {
 | 
			
		||||
                PyObject* dict = PyList_GetItem(pyList, i);
 | 
			
		||||
 | 
			
		||||
                // Make sure this is a dict
 | 
			
		||||
                if (!PyDict_Check(dict))
 | 
			
		||||
                {
 | 
			
		||||
                    fatalCobraError = true;
 | 
			
		||||
                    CoreLogger::error("list element is not a dict");
 | 
			
		||||
                    continue;
 | 
			
		||||
                }
 | 
			
		||||
 | 
			
		||||
                //
 | 
			
		||||
                // Retrieve object kind
 | 
			
		||||
                //
 | 
			
		||||
                PyObject* pyKind = PyDict_GetItemString(dict, "kind");
 | 
			
		||||
                if (!PyUnicode_Check(pyKind))
 | 
			
		||||
                {
 | 
			
		||||
                    fatalCobraError = true;
 | 
			
		||||
                    CoreLogger::error("kind entry is not a string");
 | 
			
		||||
                    continue;
 | 
			
		||||
                }
 | 
			
		||||
                std::string kind(PyUnicode_AsUTF8(pyKind));
 | 
			
		||||
 | 
			
		||||
                bool counter = false;
 | 
			
		||||
                bool gauge = false;
 | 
			
		||||
                bool timing = false;
 | 
			
		||||
 | 
			
		||||
                if (kind == "counter")
 | 
			
		||||
                {
 | 
			
		||||
                    counter = true;
 | 
			
		||||
                }
 | 
			
		||||
                else if (kind == "gauge")
 | 
			
		||||
                {
 | 
			
		||||
                    gauge = true;
 | 
			
		||||
                }
 | 
			
		||||
                else if (kind == "timing")
 | 
			
		||||
                {
 | 
			
		||||
                    timing = true;
 | 
			
		||||
                }
 | 
			
		||||
                else
 | 
			
		||||
                {
 | 
			
		||||
                    fatalCobraError = true;
 | 
			
		||||
                    CoreLogger::error(std::string("invalid kind entry: ") + kind +
 | 
			
		||||
                                      ". Supported ones are counter, gauge, timing");
 | 
			
		||||
                    continue;
 | 
			
		||||
                }
 | 
			
		||||
 | 
			
		||||
                //
 | 
			
		||||
                // Retrieve object key
 | 
			
		||||
                //
 | 
			
		||||
                PyObject* pyKey = PyDict_GetItemString(dict, "key");
 | 
			
		||||
                if (!PyUnicode_Check(pyKey))
 | 
			
		||||
                {
 | 
			
		||||
                    fatalCobraError = true;
 | 
			
		||||
                    CoreLogger::error("key entry is not a string");
 | 
			
		||||
                    continue;
 | 
			
		||||
                }
 | 
			
		||||
                std::string key(PyUnicode_AsUTF8(pyKey));
 | 
			
		||||
 | 
			
		||||
                //
 | 
			
		||||
                // Retrieve object value and send data to statsd
 | 
			
		||||
                //
 | 
			
		||||
                PyObject* pyValue = PyDict_GetItemString(dict, "value");
 | 
			
		||||
 | 
			
		||||
                // Send data to statsd
 | 
			
		||||
                if (PyFloat_Check(pyValue))
 | 
			
		||||
                {
 | 
			
		||||
                    double value = PyFloat_AsDouble(pyValue);
 | 
			
		||||
 | 
			
		||||
                    if (counter)
 | 
			
		||||
                    {
 | 
			
		||||
                        statsdClient.count(key, value);
 | 
			
		||||
                    }
 | 
			
		||||
                    else if (gauge)
 | 
			
		||||
                    {
 | 
			
		||||
                        statsdClient.gauge(key, value);
 | 
			
		||||
                    }
 | 
			
		||||
                    else if (timing)
 | 
			
		||||
                    {
 | 
			
		||||
                        statsdClient.timing(key, value);
 | 
			
		||||
                    }
 | 
			
		||||
                }
 | 
			
		||||
                else if (PyLong_Check(pyValue))
 | 
			
		||||
                {
 | 
			
		||||
                    long value = PyLong_AsLong(pyValue);
 | 
			
		||||
 | 
			
		||||
                    if (counter)
 | 
			
		||||
                    {
 | 
			
		||||
                        statsdClient.count(key, value);
 | 
			
		||||
                    }
 | 
			
		||||
                    else if (gauge)
 | 
			
		||||
                    {
 | 
			
		||||
                        statsdClient.gauge(key, value);
 | 
			
		||||
                    }
 | 
			
		||||
                    else if (timing)
 | 
			
		||||
                    {
 | 
			
		||||
                        statsdClient.timing(key, value);
 | 
			
		||||
                    }
 | 
			
		||||
                }
 | 
			
		||||
                else
 | 
			
		||||
                {
 | 
			
		||||
                    fatalCobraError = true;
 | 
			
		||||
                    CoreLogger::error("value entry is neither an int or a float");
 | 
			
		||||
                    continue;
 | 
			
		||||
                }
 | 
			
		||||
 | 
			
		||||
                sentCount++; // should we update this for each statsd object sent ?
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            Py_DECREF(pyArgs);
 | 
			
		||||
            Py_DECREF(pyList);
 | 
			
		||||
        });
 | 
			
		||||
 | 
			
		||||
        bool status = bot.run(config);
 | 
			
		||||
 | 
			
		||||
        // Cleanup - we should do something similar in all exit case ...
 | 
			
		||||
        Py_DECREF(pyFunc);
 | 
			
		||||
        Py_DECREF(pyModule);
 | 
			
		||||
        Py_FinalizeEx();
 | 
			
		||||
 | 
			
		||||
        return status;
 | 
			
		||||
#endif
 | 
			
		||||
    }
 | 
			
		||||
}
 | 
			
		||||
@@ -1,19 +0,0 @@
 | 
			
		||||
/*
 | 
			
		||||
 *  IXCobraMetricsToStatsdBot.h
 | 
			
		||||
 *  Author: Benjamin Sergeant
 | 
			
		||||
 *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
 | 
			
		||||
 */
 | 
			
		||||
#pragma once
 | 
			
		||||
 | 
			
		||||
#include <cstdint>
 | 
			
		||||
#include <ixbots/IXStatsdClient.h>
 | 
			
		||||
#include "IXCobraBotConfig.h"
 | 
			
		||||
#include <stddef.h>
 | 
			
		||||
#include <string>
 | 
			
		||||
 | 
			
		||||
namespace ix
 | 
			
		||||
{
 | 
			
		||||
    int64_t cobra_to_python_bot(const ix::CobraBotConfig& config,
 | 
			
		||||
                                StatsdClient& statsdClient,
 | 
			
		||||
                                const std::string& scriptPath);
 | 
			
		||||
} // namespace ix
 | 
			
		||||
@@ -70,17 +70,11 @@ namespace ix
 | 
			
		||||
                                                     std::atomic<bool>& fatalCobraError,
 | 
			
		||||
                                                     std::atomic<uint64_t>& sentCount) -> void {
 | 
			
		||||
                std::string id;
 | 
			
		||||
                size_t idx = 0;
 | 
			
		||||
                for (auto&& attr : tokens)
 | 
			
		||||
                {
 | 
			
		||||
                    id += ".";
 | 
			
		||||
                    auto val = extractAttr(attr, msg);
 | 
			
		||||
                    id += val.asString();
 | 
			
		||||
 | 
			
		||||
                    // We add a dot separator unless we are processing the last token
 | 
			
		||||
                    if (idx++ != tokens.size() - 1)
 | 
			
		||||
                    {
 | 
			
		||||
                        id += ".";
 | 
			
		||||
                    }
 | 
			
		||||
                }
 | 
			
		||||
 | 
			
		||||
                if (gauge.empty() && timer.empty())
 | 
			
		||||
 
 | 
			
		||||
@@ -39,28 +39,21 @@
 | 
			
		||||
 | 
			
		||||
#include "IXStatsdClient.h"
 | 
			
		||||
 | 
			
		||||
#include <iostream>
 | 
			
		||||
#include <ixwebsocket/IXNetSystem.h>
 | 
			
		||||
#include <ixwebsocket/IXSetThreadName.h>
 | 
			
		||||
#include <ixcore/utils/IXCoreLogger.h>
 | 
			
		||||
#include <sstream>
 | 
			
		||||
#include <stdio.h>
 | 
			
		||||
#include <stdlib.h>
 | 
			
		||||
#include <string.h>
 | 
			
		||||
 | 
			
		||||
namespace ix
 | 
			
		||||
{
 | 
			
		||||
    StatsdClient::StatsdClient(const std::string& host,
 | 
			
		||||
                               int port,
 | 
			
		||||
                               const std::string& prefix,
 | 
			
		||||
                               bool verbose)
 | 
			
		||||
    StatsdClient::StatsdClient(const std::string& host, int port, const std::string& prefix)
 | 
			
		||||
        : _host(host)
 | 
			
		||||
        , _port(port)
 | 
			
		||||
        , _prefix(prefix)
 | 
			
		||||
        , _stop(false)
 | 
			
		||||
        , _verbose(verbose)
 | 
			
		||||
    {
 | 
			
		||||
        _thread = std::thread([this] {
 | 
			
		||||
            setThreadName("Statsd");
 | 
			
		||||
 | 
			
		||||
            while (!_stop)
 | 
			
		||||
            {
 | 
			
		||||
                flushQueue();
 | 
			
		||||
@@ -122,15 +115,11 @@ namespace ix
 | 
			
		||||
    {
 | 
			
		||||
        cleanup(key);
 | 
			
		||||
 | 
			
		||||
        std::stringstream ss;
 | 
			
		||||
        ss << _prefix << "." << key << ":" << value << "|" << type;
 | 
			
		||||
        char buf[256];
 | 
			
		||||
        snprintf(
 | 
			
		||||
            buf, sizeof(buf), "%s%s:%zd|%s\n", _prefix.c_str(), key.c_str(), value, type.c_str());
 | 
			
		||||
 | 
			
		||||
        if (_verbose)
 | 
			
		||||
        {
 | 
			
		||||
            CoreLogger::info(ss.str());
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        enqueue(ss.str() + "\n");
 | 
			
		||||
        enqueue(buf);
 | 
			
		||||
        return 0;
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
@@ -148,13 +137,10 @@ namespace ix
 | 
			
		||||
        {
 | 
			
		||||
            auto message = _queue.front();
 | 
			
		||||
            auto ret = _socket.sendto(message);
 | 
			
		||||
            if (ret == -1)
 | 
			
		||||
            if (ret != 0)
 | 
			
		||||
            {
 | 
			
		||||
                CoreLogger::error(std::string("statsd error: ") + strerror(UdpSocket::getErrno()));
 | 
			
		||||
                std::cerr << "error: " << strerror(UdpSocket::getErrno()) << std::endl;
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            // we always dequeue regardless of the ability to send the message
 | 
			
		||||
            // so that we keep our queue size under control
 | 
			
		||||
            _queue.pop_front();
 | 
			
		||||
        }
 | 
			
		||||
    }
 | 
			
		||||
 
 | 
			
		||||
@@ -20,8 +20,7 @@ namespace ix
 | 
			
		||||
    public:
 | 
			
		||||
        StatsdClient(const std::string& host = "127.0.0.1",
 | 
			
		||||
                     int port = 8125,
 | 
			
		||||
                     const std::string& prefix = "",
 | 
			
		||||
                     bool verbose = false);
 | 
			
		||||
                     const std::string& prefix = "");
 | 
			
		||||
        ~StatsdClient();
 | 
			
		||||
 | 
			
		||||
        bool init(std::string& errMsg);
 | 
			
		||||
@@ -53,7 +52,6 @@ namespace ix
 | 
			
		||||
        std::mutex _mutex; // for the queue
 | 
			
		||||
 | 
			
		||||
        std::deque<std::string> _queue;
 | 
			
		||||
        bool _verbose;
 | 
			
		||||
    };
 | 
			
		||||
 | 
			
		||||
} // end namespace ix
 | 
			
		||||
 
 | 
			
		||||
@@ -562,13 +562,11 @@ namespace ix
 | 
			
		||||
    void CobraConnection::subscribe(const std::string& channel,
 | 
			
		||||
                                    const std::string& filter,
 | 
			
		||||
                                    const std::string& position,
 | 
			
		||||
                                    int batchSize,
 | 
			
		||||
                                    SubscriptionCallback cb)
 | 
			
		||||
    {
 | 
			
		||||
        // Create and send a subscribe pdu
 | 
			
		||||
        Json::Value body;
 | 
			
		||||
        body["channel"] = channel;
 | 
			
		||||
        body["batch_size"] = batchSize;
 | 
			
		||||
 | 
			
		||||
        if (!filter.empty())
 | 
			
		||||
        {
 | 
			
		||||
 
 | 
			
		||||
@@ -88,7 +88,6 @@ namespace ix
 | 
			
		||||
        void subscribe(const std::string& channel,
 | 
			
		||||
                       const std::string& filter = std::string(),
 | 
			
		||||
                       const std::string& position = std::string(),
 | 
			
		||||
                       int batchSize = 1,
 | 
			
		||||
                       SubscriptionCallback cb = nullptr);
 | 
			
		||||
 | 
			
		||||
        /// Unsubscribe from a channel
 | 
			
		||||
 
 | 
			
		||||
@@ -1,27 +0,0 @@
 | 
			
		||||
#
 | 
			
		||||
# Author: Benjamin Sergeant
 | 
			
		||||
# Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
 | 
			
		||||
#
 | 
			
		||||
 | 
			
		||||
set (IXREDIS_SOURCES
 | 
			
		||||
    ixredis/IXRedisClient.cpp
 | 
			
		||||
    ixredis/IXRedisServer.cpp
 | 
			
		||||
)
 | 
			
		||||
 | 
			
		||||
set (IXREDIS_HEADERS
 | 
			
		||||
    ixredis/IXRedisClient.h
 | 
			
		||||
    ixredis/IXRedisServer.h
 | 
			
		||||
)
 | 
			
		||||
 | 
			
		||||
add_library(ixredis STATIC
 | 
			
		||||
    ${IXREDIS_SOURCES}
 | 
			
		||||
    ${IXREDIS_HEADERS}
 | 
			
		||||
)
 | 
			
		||||
 | 
			
		||||
set(IXREDIS_INCLUDE_DIRS
 | 
			
		||||
    .
 | 
			
		||||
    ..
 | 
			
		||||
    ../ixcore
 | 
			
		||||
    ../ixwebsocket)
 | 
			
		||||
 | 
			
		||||
target_include_directories( ixredis PUBLIC ${IXREDIS_INCLUDE_DIRS} )
 | 
			
		||||
@@ -7,12 +7,16 @@ set (IXSNAKE_SOURCES
 | 
			
		||||
    ixsnake/IXSnakeServer.cpp
 | 
			
		||||
    ixsnake/IXSnakeProtocol.cpp
 | 
			
		||||
    ixsnake/IXAppConfig.cpp
 | 
			
		||||
    ixsnake/IXRedisClient.cpp
 | 
			
		||||
    ixsnake/IXRedisServer.cpp
 | 
			
		||||
)
 | 
			
		||||
 | 
			
		||||
set (IXSNAKE_HEADERS
 | 
			
		||||
    ixsnake/IXSnakeServer.h
 | 
			
		||||
    ixsnake/IXSnakeProtocol.h
 | 
			
		||||
    ixsnake/IXAppConfig.h
 | 
			
		||||
    ixsnake/IXRedisClient.h
 | 
			
		||||
    ixsnake/IXRedisServer.h
 | 
			
		||||
)
 | 
			
		||||
 | 
			
		||||
add_library(ixsnake STATIC
 | 
			
		||||
@@ -26,7 +30,6 @@ set(IXSNAKE_INCLUDE_DIRS
 | 
			
		||||
    ../ixcore
 | 
			
		||||
    ../ixcrypto
 | 
			
		||||
    ../ixwebsocket
 | 
			
		||||
    ../ixredis
 | 
			
		||||
    ../third_party)
 | 
			
		||||
 | 
			
		||||
target_include_directories( ixsnake PUBLIC ${IXSNAKE_INCLUDE_DIRS} )
 | 
			
		||||
 
 | 
			
		||||
@@ -9,7 +9,6 @@
 | 
			
		||||
#include <cstring>
 | 
			
		||||
#include <iomanip>
 | 
			
		||||
#include <iostream>
 | 
			
		||||
#include <ixwebsocket/IXSocket.h>
 | 
			
		||||
#include <ixwebsocket/IXSocketFactory.h>
 | 
			
		||||
#include <ixwebsocket/IXSocketTLSOptions.h>
 | 
			
		||||
#include <sstream>
 | 
			
		||||
@@ -251,16 +250,12 @@ namespace ix
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    std::string RedisClient::prepareXaddCommand(const std::string& stream,
 | 
			
		||||
                                                const std::string& message,
 | 
			
		||||
                                                int maxLen)
 | 
			
		||||
                                                const std::string& message)
 | 
			
		||||
    {
 | 
			
		||||
        std::stringstream ss;
 | 
			
		||||
        ss << "*8\r\n";
 | 
			
		||||
        ss << "*5\r\n";
 | 
			
		||||
        ss << writeString("XADD");
 | 
			
		||||
        ss << writeString(stream);
 | 
			
		||||
        ss << writeString("MAXLEN");
 | 
			
		||||
        ss << writeString("~");
 | 
			
		||||
        ss << writeString(std::to_string(maxLen));
 | 
			
		||||
        ss << writeString("*");
 | 
			
		||||
        ss << writeString("field");
 | 
			
		||||
        ss << writeString(message);
 | 
			
		||||
@@ -270,7 +265,6 @@ namespace ix
 | 
			
		||||
 | 
			
		||||
    std::string RedisClient::xadd(const std::string& stream,
 | 
			
		||||
                                  const std::string& message,
 | 
			
		||||
                                  int maxLen,
 | 
			
		||||
                                  std::string& errMsg)
 | 
			
		||||
    {
 | 
			
		||||
        errMsg.clear();
 | 
			
		||||
@@ -281,7 +275,7 @@ namespace ix
 | 
			
		||||
            return std::string();
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        std::string command = prepareXaddCommand(stream, message, maxLen);
 | 
			
		||||
        std::string command = prepareXaddCommand(stream, message);
 | 
			
		||||
 | 
			
		||||
        bool sent = _socket->writeBytes(command, nullptr);
 | 
			
		||||
        if (!sent)
 | 
			
		||||
@@ -354,104 +348,4 @@ namespace ix
 | 
			
		||||
 | 
			
		||||
        return success;
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    std::pair<RespType, std::string> RedisClient::send(
 | 
			
		||||
        const std::vector<std::string>& args,
 | 
			
		||||
        std::string& errMsg)
 | 
			
		||||
    {
 | 
			
		||||
        std::stringstream ss;
 | 
			
		||||
        ss << "*";
 | 
			
		||||
        ss << std::to_string(args.size());
 | 
			
		||||
        ss << "\r\n";
 | 
			
		||||
 | 
			
		||||
        for (auto&& arg : args)
 | 
			
		||||
        {
 | 
			
		||||
            ss << writeString(arg);
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        bool sent = _socket->writeBytes(ss.str(), nullptr);
 | 
			
		||||
        if (!sent)
 | 
			
		||||
        {
 | 
			
		||||
            errMsg = "Cannot write bytes to socket";
 | 
			
		||||
            return std::make_pair(RespType::Error, "");
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        return readResponse(errMsg);
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    std::pair<RespType, std::string> RedisClient::readResponse(std::string& errMsg)
 | 
			
		||||
    {
 | 
			
		||||
        // Read result
 | 
			
		||||
        auto pollResult = _socket->isReadyToRead(-1);
 | 
			
		||||
        if (pollResult == PollResultType::Error)
 | 
			
		||||
        {
 | 
			
		||||
            errMsg = "Error while polling for result";
 | 
			
		||||
            return std::make_pair(RespType::Error, "");
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        // First line is the string length
 | 
			
		||||
        auto lineResult = _socket->readLine(nullptr);
 | 
			
		||||
        auto lineValid = lineResult.first;
 | 
			
		||||
        auto line = lineResult.second;
 | 
			
		||||
 | 
			
		||||
        if (!lineValid)
 | 
			
		||||
        {
 | 
			
		||||
            errMsg = "Error while polling for result";
 | 
			
		||||
            return std::make_pair(RespType::Error, "");
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        std::string response;
 | 
			
		||||
 | 
			
		||||
        if (line[0] == '+') // Simple string
 | 
			
		||||
        {
 | 
			
		||||
            std::stringstream ss;
 | 
			
		||||
            response = line.substr(1, line.size() - 3);
 | 
			
		||||
            return std::make_pair(RespType::String, response);
 | 
			
		||||
        }
 | 
			
		||||
        else if (line[0] == '-') // Errors
 | 
			
		||||
        {
 | 
			
		||||
            std::stringstream ss;
 | 
			
		||||
            response = line.substr(1, line.size() - 3);
 | 
			
		||||
            return std::make_pair(RespType::Error, response);
 | 
			
		||||
        }
 | 
			
		||||
        else if (line[0] == ':') // Integers
 | 
			
		||||
        {
 | 
			
		||||
            std::stringstream ss;
 | 
			
		||||
            response = line.substr(1, line.size() - 3);
 | 
			
		||||
            return std::make_pair(RespType::Integer, response);
 | 
			
		||||
        }
 | 
			
		||||
        else if (line[0] == '$') // Bulk strings
 | 
			
		||||
        {
 | 
			
		||||
            int stringSize;
 | 
			
		||||
            {
 | 
			
		||||
                std::stringstream ss;
 | 
			
		||||
                ss << line.substr(1, line.size() - 1);
 | 
			
		||||
                ss >> stringSize;
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            // Read the result, which is the stream id computed by the redis server
 | 
			
		||||
            lineResult = _socket->readLine(nullptr);
 | 
			
		||||
            lineValid = lineResult.first;
 | 
			
		||||
            line = lineResult.second;
 | 
			
		||||
 | 
			
		||||
            std::string str = line.substr(0, stringSize);
 | 
			
		||||
            return std::make_pair(RespType::String, str);
 | 
			
		||||
        }
 | 
			
		||||
        else
 | 
			
		||||
        {
 | 
			
		||||
            errMsg = "Unhandled response type";
 | 
			
		||||
            return std::make_pair(RespType::Unknown, std::string());
 | 
			
		||||
        }
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    std::string RedisClient::getRespTypeDescription(RespType respType)
 | 
			
		||||
    {
 | 
			
		||||
        switch (respType)
 | 
			
		||||
        {
 | 
			
		||||
            case RespType::Integer: return "integer";
 | 
			
		||||
            case RespType::Error: return "error";
 | 
			
		||||
            case RespType::String: return "string";
 | 
			
		||||
            default: return "unknown";
 | 
			
		||||
        }
 | 
			
		||||
    }
 | 
			
		||||
} // namespace ix
 | 
			
		||||
@@ -8,20 +8,12 @@
 | 
			
		||||
 | 
			
		||||
#include <atomic>
 | 
			
		||||
#include <functional>
 | 
			
		||||
#include <ixwebsocket/IXSocket.h>
 | 
			
		||||
#include <memory>
 | 
			
		||||
#include <string>
 | 
			
		||||
#include <ixwebsocket/IXSocket.h>
 | 
			
		||||
 | 
			
		||||
namespace ix
 | 
			
		||||
{
 | 
			
		||||
    enum class RespType : int
 | 
			
		||||
    {
 | 
			
		||||
        String = 0,
 | 
			
		||||
        Error = 1,
 | 
			
		||||
        Integer = 2,
 | 
			
		||||
        Unknown = 3
 | 
			
		||||
    };
 | 
			
		||||
 | 
			
		||||
    class RedisClient
 | 
			
		||||
    {
 | 
			
		||||
    public:
 | 
			
		||||
@@ -48,22 +40,13 @@ namespace ix
 | 
			
		||||
        // XADD
 | 
			
		||||
        std::string xadd(const std::string& channel,
 | 
			
		||||
                         const std::string& message,
 | 
			
		||||
                         int maxLen,
 | 
			
		||||
                         std::string& errMsg);
 | 
			
		||||
        std::string prepareXaddCommand(const std::string& stream,
 | 
			
		||||
                                       const std::string& message,
 | 
			
		||||
                                       int maxLen);
 | 
			
		||||
 | 
			
		||||
        std::string prepareXaddCommand(const std::string& stream, const std::string& message);
 | 
			
		||||
 | 
			
		||||
        std::string readXaddReply(std::string& errMsg);
 | 
			
		||||
        bool sendCommand(
 | 
			
		||||
            const std::string& commands, int commandsCount, std::string& errMsg);
 | 
			
		||||
 | 
			
		||||
        // Arbitrary commands
 | 
			
		||||
        std::pair<RespType, std::string> send(
 | 
			
		||||
            const std::vector<std::string>& args,
 | 
			
		||||
            std::string& errMsg);
 | 
			
		||||
        std::pair<RespType, std::string> readResponse(std::string& errMsg);
 | 
			
		||||
 | 
			
		||||
        std::string getRespTypeDescription(RespType respType);
 | 
			
		||||
        bool sendCommand(const std::string& commands, int commandsCount, std::string& errMsg);
 | 
			
		||||
 | 
			
		||||
        void stop();
 | 
			
		||||
 | 
			
		||||
@@ -112,7 +112,7 @@ namespace ix
 | 
			
		||||
            it.second.erase(socket.get());
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        for (auto&& it : _subscribers)
 | 
			
		||||
        for (auto it : _subscribers)
 | 
			
		||||
        {
 | 
			
		||||
            std::stringstream ss;
 | 
			
		||||
            ss << "Subscription id: " << it.first << " #subscribers: " << it.second.size();
 | 
			
		||||
@@ -6,8 +6,8 @@
 | 
			
		||||
 | 
			
		||||
#pragma once
 | 
			
		||||
 | 
			
		||||
#include <ixwebsocket/IXSocket.h>
 | 
			
		||||
#include <ixwebsocket/IXSocketServer.h>
 | 
			
		||||
#include "IXSocket.h"
 | 
			
		||||
#include "IXSocketServer.h"
 | 
			
		||||
#include <functional>
 | 
			
		||||
#include <map>
 | 
			
		||||
#include <memory>
 | 
			
		||||
@@ -6,7 +6,7 @@
 | 
			
		||||
 | 
			
		||||
#pragma once
 | 
			
		||||
 | 
			
		||||
#include <ixredis/IXRedisClient.h>
 | 
			
		||||
#include "IXRedisClient.h"
 | 
			
		||||
#include <future>
 | 
			
		||||
#include <ixwebsocket/IXConnectionState.h>
 | 
			
		||||
#include <string>
 | 
			
		||||
 
 | 
			
		||||
@@ -127,7 +127,7 @@ namespace ix
 | 
			
		||||
    {
 | 
			
		||||
        // We only have one socket connection, so we cannot
 | 
			
		||||
        // make multiple requests concurrently.
 | 
			
		||||
        std::lock_guard<std::recursive_mutex> lock(_mutex);
 | 
			
		||||
        std::lock_guard<std::mutex> lock(_mutex);
 | 
			
		||||
 | 
			
		||||
        uint64_t uploadSize = 0;
 | 
			
		||||
        uint64_t downloadSize = 0;
 | 
			
		||||
 
 | 
			
		||||
@@ -103,9 +103,7 @@ namespace ix
 | 
			
		||||
        std::thread _thread;
 | 
			
		||||
 | 
			
		||||
        std::unique_ptr<Socket> _socket;
 | 
			
		||||
        std::recursive_mutex _mutex; // to protect accessing the _socket (only one socket per client)
 | 
			
		||||
                                     // the mutex needs to be recursive as this function might
 | 
			
		||||
                                     // be called recursively to follow HTTP redirections
 | 
			
		||||
        std::mutex _mutex; // to protect accessing the _socket (only one socket per client)
 | 
			
		||||
 | 
			
		||||
        SocketTLSOptions _tlsOptions;
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -164,10 +164,9 @@ namespace ix
 | 
			
		||||
                std::string content = res.second;
 | 
			
		||||
 | 
			
		||||
                std::string acceptEncoding = request->headers["Accept-encoding"];
 | 
			
		||||
                if (acceptEncoding == "*" || acceptEncoding.find("gzip") != std::string::npos)
 | 
			
		||||
                if (acceptEncoding == "gzip" || acceptEncoding == "*")
 | 
			
		||||
                {
 | 
			
		||||
                    content = gzipCompress(content);
 | 
			
		||||
                    headers["Content-Encoding"] = "gzip";
 | 
			
		||||
                }
 | 
			
		||||
 | 
			
		||||
                // Log request
 | 
			
		||||
 
 | 
			
		||||
@@ -6,6 +6,7 @@
 | 
			
		||||
 | 
			
		||||
#include "IXSelectInterruptFactory.h"
 | 
			
		||||
 | 
			
		||||
#include "IXUniquePtr.h"
 | 
			
		||||
#if defined(__linux__) || defined(__APPLE__)
 | 
			
		||||
#include "IXSelectInterruptPipe.h"
 | 
			
		||||
#else
 | 
			
		||||
@@ -17,9 +18,9 @@ namespace ix
 | 
			
		||||
    SelectInterruptPtr createSelectInterrupt()
 | 
			
		||||
    {
 | 
			
		||||
#if defined(__linux__) || defined(__APPLE__)
 | 
			
		||||
        return std::make_unique<SelectInterruptPipe>();
 | 
			
		||||
        return ix::make_unique<SelectInterruptPipe>();
 | 
			
		||||
#else
 | 
			
		||||
        return std::make_unique<SelectInterrupt>();
 | 
			
		||||
        return ix::make_unique<SelectInterrupt>();
 | 
			
		||||
#endif
 | 
			
		||||
    }
 | 
			
		||||
} // namespace ix
 | 
			
		||||
 
 | 
			
		||||
@@ -10,6 +10,7 @@
 | 
			
		||||
#include "IXNetSystem.h"
 | 
			
		||||
#include "IXSelectInterrupt.h"
 | 
			
		||||
#include "IXSocket.h"
 | 
			
		||||
#include "IXUniquePtr.h"
 | 
			
		||||
#include <fcntl.h>
 | 
			
		||||
#include <string.h>
 | 
			
		||||
#include <sys/types.h>
 | 
			
		||||
@@ -65,7 +66,7 @@ namespace ix
 | 
			
		||||
 | 
			
		||||
            int timeoutMs = 10;
 | 
			
		||||
            bool readyToRead = false;
 | 
			
		||||
            auto selectInterrupt = std::make_unique<SelectInterrupt>();
 | 
			
		||||
            auto selectInterrupt = ix::make_unique<SelectInterrupt>();
 | 
			
		||||
            PollResultType pollResult = Socket::poll(readyToRead, timeoutMs, fd, selectInterrupt);
 | 
			
		||||
 | 
			
		||||
            if (pollResult == PollResultType::Timeout)
 | 
			
		||||
 
 | 
			
		||||
@@ -5,6 +5,7 @@
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
#include "IXSocketFactory.h"
 | 
			
		||||
#include "IXUniquePtr.h"
 | 
			
		||||
 | 
			
		||||
#ifdef IXWEBSOCKET_USE_TLS
 | 
			
		||||
 | 
			
		||||
@@ -35,17 +36,17 @@ namespace ix
 | 
			
		||||
 | 
			
		||||
        if (!tls)
 | 
			
		||||
        {
 | 
			
		||||
            socket = std::make_unique<Socket>(fd);
 | 
			
		||||
            socket = ix::make_unique<Socket>(fd);
 | 
			
		||||
        }
 | 
			
		||||
        else
 | 
			
		||||
        {
 | 
			
		||||
#ifdef IXWEBSOCKET_USE_TLS
 | 
			
		||||
#if defined(IXWEBSOCKET_USE_MBED_TLS)
 | 
			
		||||
            socket = std::make_unique<SocketMbedTLS>(tlsOptions, fd);
 | 
			
		||||
            socket = ix::make_unique<SocketMbedTLS>(tlsOptions, fd);
 | 
			
		||||
#elif defined(IXWEBSOCKET_USE_OPEN_SSL)
 | 
			
		||||
            socket = std::make_unique<SocketOpenSSL>(tlsOptions, fd);
 | 
			
		||||
            socket = ix::make_unique<SocketOpenSSL>(tlsOptions, fd);
 | 
			
		||||
#elif defined(__APPLE__)
 | 
			
		||||
            socket = std::make_unique<SocketAppleSSL>(tlsOptions, fd);
 | 
			
		||||
            socket = ix::make_unique<SocketAppleSSL>(tlsOptions, fd);
 | 
			
		||||
#endif
 | 
			
		||||
#else
 | 
			
		||||
            errorMsg = "TLS support is not enabled on this platform.";
 | 
			
		||||
 
 | 
			
		||||
@@ -12,6 +12,7 @@
 | 
			
		||||
#include "IXSocket.h"
 | 
			
		||||
#include "IXSocketConnect.h"
 | 
			
		||||
#include "IXSocketFactory.h"
 | 
			
		||||
#include "IXUniquePtr.h"
 | 
			
		||||
#include <assert.h>
 | 
			
		||||
#include <sstream>
 | 
			
		||||
#include <stdio.h>
 | 
			
		||||
@@ -258,7 +259,7 @@ namespace ix
 | 
			
		||||
            // Use poll to check whether a new connection is in progress
 | 
			
		||||
            int timeoutMs = 10;
 | 
			
		||||
            bool readyToRead = true;
 | 
			
		||||
            auto selectInterrupt = std::make_unique<SelectInterrupt>();
 | 
			
		||||
            auto selectInterrupt = ix::make_unique<SelectInterrupt>();
 | 
			
		||||
            PollResultType pollResult =
 | 
			
		||||
                Socket::poll(readyToRead, timeoutMs, _serverFd, selectInterrupt);
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
							
								
								
									
										18
									
								
								ixwebsocket/IXUniquePtr.h
									
									
									
									
									
										Normal file
									
								
							
							
						
						
									
										18
									
								
								ixwebsocket/IXUniquePtr.h
									
									
									
									
									
										Normal file
									
								
							@@ -0,0 +1,18 @@
 | 
			
		||||
/*
 | 
			
		||||
 *  IXUniquePtr.h
 | 
			
		||||
 *  Author: Benjamin Sergeant
 | 
			
		||||
 *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
#pragma once
 | 
			
		||||
 | 
			
		||||
#include <memory>
 | 
			
		||||
 | 
			
		||||
namespace ix
 | 
			
		||||
{
 | 
			
		||||
    template<typename T, typename... Args>
 | 
			
		||||
    std::unique_ptr<T> make_unique(Args&&... args)
 | 
			
		||||
    {
 | 
			
		||||
        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
 | 
			
		||||
    }
 | 
			
		||||
}
 | 
			
		||||
@@ -19,7 +19,7 @@
 | 
			
		||||
 | 
			
		||||
namespace ix
 | 
			
		||||
{
 | 
			
		||||
    class WebSocketServer : public SocketServer
 | 
			
		||||
    class WebSocketServer final : public SocketServer
 | 
			
		||||
    {
 | 
			
		||||
    public:
 | 
			
		||||
        using OnConnectionCallback =
 | 
			
		||||
 
 | 
			
		||||
@@ -6,4 +6,4 @@
 | 
			
		||||
 | 
			
		||||
#pragma once
 | 
			
		||||
 | 
			
		||||
#define IX_WEBSOCKET_VERSION "9.8.5"
 | 
			
		||||
#define IX_WEBSOCKET_VERSION "9.6.5"
 | 
			
		||||
 
 | 
			
		||||
							
								
								
									
										40
									
								
								makefile
									
									
									
									
									
								
							
							
						
						
									
										40
									
								
								makefile
									
									
									
									
									
								
							@@ -19,28 +19,26 @@ install: brew
 | 
			
		||||
#
 | 
			
		||||
# Release, Debug, MinSizeRel, RelWithDebInfo are the build types
 | 
			
		||||
#
 | 
			
		||||
# Default rule does not use python as that requires first time users to have Python3 installed
 | 
			
		||||
#
 | 
			
		||||
brew:
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 -DUSE_TEST=1 .. ; ninja install)
 | 
			
		||||
 | 
			
		||||
# Docker default target. We've had problems with OpenSSL and TLS 1.3 (on the
 | 
			
		||||
# Docker default target. We've add problem with OpenSSL and TLS 1.3 (on the
 | 
			
		||||
# server side ?) and I can't work-around it easily, so we're using mbedtls on
 | 
			
		||||
# Linux for the SSL backend, which works great.
 | 
			
		||||
ws_mbedtls_install:
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 -DUSE_MBED_TLS=1 .. ; ninja install)
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_TLS=1 -DUSE_WS=1 -DUSE_MBED_TLS=1 .. ; ninja install)
 | 
			
		||||
 | 
			
		||||
ws:
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 .. && ninja install)
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 .. ; ninja install)
 | 
			
		||||
 | 
			
		||||
ws_install:
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 .. && make -j 4 install)
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_TLS=1 -DUSE_WS=1 .. ; make -j 4 install)
 | 
			
		||||
 | 
			
		||||
ws_openssl:
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 -DUSE_OPEN_SSL=1 .. ; make -j 4)
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 -DUSE_OPEN_SSL=1 .. ; make -j 4)
 | 
			
		||||
 | 
			
		||||
ws_mbedtls:
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 -DUSE_MBED_TLS=1 .. ; make -j 4)
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 -DUSE_MBED_TLS=1 .. ; make -j 4)
 | 
			
		||||
 | 
			
		||||
ws_no_ssl:
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_WS=1 .. ; make -j 4)
 | 
			
		||||
@@ -109,16 +107,16 @@ test:
 | 
			
		||||
	(cd test ; python2.7 run.py -r)
 | 
			
		||||
 | 
			
		||||
test_make:
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 -DUSE_TEST=1 .. ; make -j 4)
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 -DUSE_TEST=1 .. ; make -j 4)
 | 
			
		||||
	(cd test ; python2.7 run.py -r)
 | 
			
		||||
 | 
			
		||||
test_tsan:
 | 
			
		||||
	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableThreadSanitizer YES)
 | 
			
		||||
	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_TEST=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableThreadSanitizer YES)
 | 
			
		||||
	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
 | 
			
		||||
	(cd test ; python2.7 run.py -r)
 | 
			
		||||
 | 
			
		||||
test_ubsan:
 | 
			
		||||
	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableUndefinedBehaviorSanitizer YES)
 | 
			
		||||
	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_TEST=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableUndefinedBehaviorSanitizer YES)
 | 
			
		||||
	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
 | 
			
		||||
	(cd test ; python2.7 run.py -r)
 | 
			
		||||
 | 
			
		||||
@@ -126,37 +124,37 @@ test_asan: build_test_asan
 | 
			
		||||
	(cd test ; python2.7 run.py -r)
 | 
			
		||||
 | 
			
		||||
build_test_asan:
 | 
			
		||||
	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableAddressSanitizer YES)
 | 
			
		||||
	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_TEST=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableAddressSanitizer YES)
 | 
			
		||||
	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
 | 
			
		||||
 | 
			
		||||
test_tsan_openssl:
 | 
			
		||||
	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_OPEN_SSL=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableThreadSanitizer YES)
 | 
			
		||||
	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_OPEN_SSL=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableThreadSanitizer YES)
 | 
			
		||||
	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
 | 
			
		||||
	(cd test ; python2.7 run.py -r)
 | 
			
		||||
 | 
			
		||||
test_ubsan_openssl:
 | 
			
		||||
	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_OPEN_SSL=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableUndefinedBehaviorSanitizer YES)
 | 
			
		||||
	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_OPEN_SSL=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableUndefinedBehaviorSanitizer YES)
 | 
			
		||||
	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
 | 
			
		||||
	(cd test ; python2.7 run.py -r)
 | 
			
		||||
 | 
			
		||||
test_tsan_openssl_release:
 | 
			
		||||
	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Release -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_OPEN_SSL=1 .. && xcodebuild -project ixwebsocket.xcodeproj -configuration Release -target ixwebsocket_unittest -enableThreadSanitizer YES)
 | 
			
		||||
	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Release -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_OPEN_SSL=1 .. && xcodebuild -project ixwebsocket.xcodeproj -configuration Release -target ixwebsocket_unittest -enableThreadSanitizer YES)
 | 
			
		||||
	(cd build/test ; ln -sf Release/ixwebsocket_unittest)
 | 
			
		||||
	(cd test ; python2.7 run.py -r)
 | 
			
		||||
 | 
			
		||||
test_tsan_mbedtls:
 | 
			
		||||
	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_MBED_TLS=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableThreadSanitizer YES)
 | 
			
		||||
	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_MBED_TLS=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableThreadSanitizer YES)
 | 
			
		||||
	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
 | 
			
		||||
	(cd test ; python2.7 run.py -r)
 | 
			
		||||
 | 
			
		||||
build_test_openssl:
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_OPEN_SSL=1 -DUSE_TEST=1 .. ; ninja install)
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_OPEN_SSL=1 -DUSE_TEST=1 .. ; ninja install)
 | 
			
		||||
 | 
			
		||||
test_openssl: build_test_openssl
 | 
			
		||||
	(cd test ; python2.7 run.py -r)
 | 
			
		||||
 | 
			
		||||
build_test_mbedtls:
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_MBED_TLS=1 -DUSE_TEST=1 .. ; make -j 4)
 | 
			
		||||
	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_MBED_TLS=1 -DUSE_TEST=1 .. ; make -j 4)
 | 
			
		||||
 | 
			
		||||
test_mbedtls: build_test_mbedtls
 | 
			
		||||
	(cd test ; python2.7 run.py -r)
 | 
			
		||||
@@ -172,7 +170,7 @@ autobahn_report:
 | 
			
		||||
	cp -rvf ~/sandbox/reports/clients/* ../bsergean.github.io/IXWebSocket/autobahn/
 | 
			
		||||
 | 
			
		||||
httpd:
 | 
			
		||||
	clang++ --std=c++14 --stdlib=libc++ httpd.cpp \
 | 
			
		||||
	clang++ --std=c++11 --stdlib=libc++ -Iixwebsocket httpd.cpp \
 | 
			
		||||
		ixwebsocket/IXSelectInterruptFactory.cpp \
 | 
			
		||||
		ixwebsocket/IXCancellationRequest.cpp \
 | 
			
		||||
		ixwebsocket/IXSocketTLSOptions.cpp \
 | 
			
		||||
@@ -225,7 +223,6 @@ rebase_upstream:
 | 
			
		||||
	git reset --hard upstream/master
 | 
			
		||||
	git push origin master --force
 | 
			
		||||
 | 
			
		||||
# Legacy target
 | 
			
		||||
install_cmake_for_linux:
 | 
			
		||||
	mkdir -p /tmp/cmake
 | 
			
		||||
	(cd /tmp/cmake ; curl -L -O https://github.com/Kitware/CMake/releases/download/v3.14.0/cmake-3.14.0-Linux-x86_64.tar.gz ; tar zxf cmake-3.14.0-Linux-x86_64.tar.gz)
 | 
			
		||||
@@ -236,9 +233,6 @@ install_cmake_for_linux:
 | 
			
		||||
doc:
 | 
			
		||||
	mkdocs gh-deploy
 | 
			
		||||
 | 
			
		||||
change:
 | 
			
		||||
	vim ixwebsocket/IXWebSocketVersion.h docs/CHANGELOG.md
 | 
			
		||||
 | 
			
		||||
.PHONY: test
 | 
			
		||||
.PHONY: build
 | 
			
		||||
.PHONY: ws
 | 
			
		||||
 
 | 
			
		||||
@@ -91,30 +91,15 @@ if (JSONCPP_FOUND)
 | 
			
		||||
  target_link_libraries(ixwebsocket_unittest ${JSONCPP_LIBRARIES})
 | 
			
		||||
endif()
 | 
			
		||||
 | 
			
		||||
if (USE_PYTHON)
 | 
			
		||||
  find_package(Python COMPONENTS Development)
 | 
			
		||||
  if (NOT Python_FOUND)
 | 
			
		||||
    message(FATAL_ERROR "Python3 not found")
 | 
			
		||||
  endif()
 | 
			
		||||
  message("Python_FOUND:${Python_FOUND}")
 | 
			
		||||
  message("Python_VERSION:${Python_VERSION}")
 | 
			
		||||
  message("Python_Development_FOUND:${Python_Development_FOUND}")
 | 
			
		||||
  message("Python_LIBRARIES:${Python_LIBRARIES}")
 | 
			
		||||
endif()
 | 
			
		||||
 | 
			
		||||
# library with the most dependencies come first
 | 
			
		||||
target_link_libraries(ixwebsocket_unittest ixbots)
 | 
			
		||||
target_link_libraries(ixwebsocket_unittest ixsnake)
 | 
			
		||||
target_link_libraries(ixwebsocket_unittest ixcobra)
 | 
			
		||||
target_link_libraries(ixwebsocket_unittest ixsentry)
 | 
			
		||||
target_link_libraries(ixwebsocket_unittest ixredis)
 | 
			
		||||
target_link_libraries(ixwebsocket_unittest ixwebsocket)
 | 
			
		||||
target_link_libraries(ixwebsocket_unittest ixcrypto)
 | 
			
		||||
target_link_libraries(ixwebsocket_unittest ixcore)
 | 
			
		||||
 | 
			
		||||
target_link_libraries(ixwebsocket_unittest spdlog)
 | 
			
		||||
if (USE_PYTHON)
 | 
			
		||||
  target_link_libraries(ixwebsocket_unittest ${Python_LIBRARIES})
 | 
			
		||||
endif()
 | 
			
		||||
 | 
			
		||||
install(TARGETS ixwebsocket_unittest DESTINATION bin)
 | 
			
		||||
 
 | 
			
		||||
@@ -10,7 +10,7 @@
 | 
			
		||||
#include <iostream>
 | 
			
		||||
#include <ixcobra/IXCobraConnection.h>
 | 
			
		||||
#include <ixcrypto/IXUuid.h>
 | 
			
		||||
#include <ixredis/IXRedisServer.h>
 | 
			
		||||
#include <ixsnake/IXRedisServer.h>
 | 
			
		||||
#include <ixsnake/IXSnakeServer.h>
 | 
			
		||||
 | 
			
		||||
using namespace ix;
 | 
			
		||||
@@ -125,12 +125,10 @@ namespace
 | 
			
		||||
    {
 | 
			
		||||
        std::string filter;
 | 
			
		||||
        std::string position("$");
 | 
			
		||||
        int batchSize = 1;
 | 
			
		||||
 | 
			
		||||
        _conn.subscribe(channel,
 | 
			
		||||
                        filter,
 | 
			
		||||
                        position,
 | 
			
		||||
                        batchSize,
 | 
			
		||||
                        [this](const Json::Value& msg, const std::string& /*position*/) {
 | 
			
		||||
                            spdlog::info("receive {}", msg.toStyledString());
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -8,7 +8,7 @@
 | 
			
		||||
#include <iostream>
 | 
			
		||||
#include <ixcobra/IXCobraMetricsPublisher.h>
 | 
			
		||||
#include <ixcrypto/IXUuid.h>
 | 
			
		||||
#include <ixredis/IXRedisServer.h>
 | 
			
		||||
#include <ixsnake/IXRedisServer.h>
 | 
			
		||||
#include <ixsnake/IXSnakeServer.h>
 | 
			
		||||
#include <set>
 | 
			
		||||
 | 
			
		||||
@@ -76,12 +76,10 @@ namespace
 | 
			
		||||
                log("Subscriber authenticated");
 | 
			
		||||
                std::string filter;
 | 
			
		||||
                std::string position("$");
 | 
			
		||||
                int batchSize = 1;
 | 
			
		||||
 | 
			
		||||
                conn.subscribe(channel,
 | 
			
		||||
                               filter,
 | 
			
		||||
                               position,
 | 
			
		||||
                               batchSize,
 | 
			
		||||
                               [](const Json::Value& msg, const std::string& /*position*/) {
 | 
			
		||||
                                   log(msg.toStyledString());
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -13,7 +13,7 @@
 | 
			
		||||
#include <ixcobra/IXCobraMetricsPublisher.h>
 | 
			
		||||
#include <ixcrypto/IXUuid.h>
 | 
			
		||||
#include <ixsentry/IXSentryClient.h>
 | 
			
		||||
#include <ixredis/IXRedisServer.h>
 | 
			
		||||
#include <ixsnake/IXRedisServer.h>
 | 
			
		||||
#include <ixsnake/IXSnakeServer.h>
 | 
			
		||||
#include <ixwebsocket/IXHttpServer.h>
 | 
			
		||||
#include <ixwebsocket/IXUserAgent.h>
 | 
			
		||||
 
 | 
			
		||||
@@ -13,7 +13,7 @@
 | 
			
		||||
#include <ixcobra/IXCobraMetricsPublisher.h>
 | 
			
		||||
#include <ixcrypto/IXUuid.h>
 | 
			
		||||
#include <ixsentry/IXSentryClient.h>
 | 
			
		||||
#include <ixredis/IXRedisServer.h>
 | 
			
		||||
#include <ixsnake/IXRedisServer.h>
 | 
			
		||||
#include <ixsnake/IXSnakeServer.h>
 | 
			
		||||
#include <ixwebsocket/IXHttpServer.h>
 | 
			
		||||
#include <ixwebsocket/IXUserAgent.h>
 | 
			
		||||
 
 | 
			
		||||
@@ -13,7 +13,7 @@
 | 
			
		||||
#include <ixcobra/IXCobraMetricsPublisher.h>
 | 
			
		||||
#include <ixcrypto/IXUuid.h>
 | 
			
		||||
#include <ixsentry/IXSentryClient.h>
 | 
			
		||||
#include <ixredis/IXRedisServer.h>
 | 
			
		||||
#include <ixsnake/IXRedisServer.h>
 | 
			
		||||
#include <ixsnake/IXSnakeServer.h>
 | 
			
		||||
#include <ixwebsocket/IXHttpServer.h>
 | 
			
		||||
#include <ixwebsocket/IXUserAgent.h>
 | 
			
		||||
 
 | 
			
		||||
@@ -67,7 +67,7 @@ TEST_CASE("http server", "[httpd]")
 | 
			
		||||
 | 
			
		||||
TEST_CASE("http server redirection", "[httpd_redirect]")
 | 
			
		||||
{
 | 
			
		||||
    SECTION("Connect to a local HTTP server, with redirection enabled, but we do not follow redirects")
 | 
			
		||||
    SECTION("Connect to a local HTTP server, with redirection enabled")
 | 
			
		||||
    {
 | 
			
		||||
        int port = getFreePort();
 | 
			
		||||
        ix::HttpServer server(port, "127.0.0.1");
 | 
			
		||||
@@ -117,54 +117,4 @@ TEST_CASE("http server redirection", "[httpd_redirect]")
 | 
			
		||||
 | 
			
		||||
        server.stop();
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    SECTION("Connect to a local HTTP server, with redirection enabled, but we do follow redirects")
 | 
			
		||||
    {
 | 
			
		||||
        int port = getFreePort();
 | 
			
		||||
        ix::HttpServer server(port, "127.0.0.1");
 | 
			
		||||
        server.makeRedirectServer("http://www.google.com");
 | 
			
		||||
 | 
			
		||||
        auto res = server.listen();
 | 
			
		||||
        REQUIRE(res.first);
 | 
			
		||||
        server.start();
 | 
			
		||||
 | 
			
		||||
        HttpClient httpClient;
 | 
			
		||||
        WebSocketHttpHeaders headers;
 | 
			
		||||
 | 
			
		||||
        std::string url("http://127.0.0.1:");
 | 
			
		||||
        url += std::to_string(port);
 | 
			
		||||
        url += "/data/foo.txt";
 | 
			
		||||
        auto args = httpClient.createRequest(url);
 | 
			
		||||
 | 
			
		||||
        args->extraHeaders = headers;
 | 
			
		||||
        args->connectTimeout = 60;
 | 
			
		||||
        args->transferTimeout = 60;
 | 
			
		||||
        args->followRedirects = true;
 | 
			
		||||
        args->maxRedirects = 10;
 | 
			
		||||
        args->verbose = true;
 | 
			
		||||
        args->compress = true;
 | 
			
		||||
        args->logger = [](const std::string& msg) { std::cout << msg; };
 | 
			
		||||
        args->onProgressCallback = [](int current, int total) -> bool {
 | 
			
		||||
            std::cerr << "\r"
 | 
			
		||||
                      << "Downloaded " << current << " bytes out of " << total;
 | 
			
		||||
            return true;
 | 
			
		||||
        };
 | 
			
		||||
 | 
			
		||||
        auto response = httpClient.get(url, args);
 | 
			
		||||
 | 
			
		||||
        for (auto it : response->headers)
 | 
			
		||||
        {
 | 
			
		||||
            std::cerr << it.first << ": " << it.second << std::endl;
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        std::cerr << "Upload size: " << response->uploadSize << std::endl;
 | 
			
		||||
        std::cerr << "Download size: " << response->downloadSize << std::endl;
 | 
			
		||||
        std::cerr << "Status: " << response->statusCode << std::endl;
 | 
			
		||||
        std::cerr << "Error message: " << response->errorMsg << std::endl;
 | 
			
		||||
 | 
			
		||||
        REQUIRE(response->errorCode == HttpErrorCode::Ok);
 | 
			
		||||
        REQUIRE(response->statusCode == 200);
 | 
			
		||||
 | 
			
		||||
        server.stop();
 | 
			
		||||
    }
 | 
			
		||||
}
 | 
			
		||||
 
 | 
			
		||||
@@ -19,7 +19,7 @@ namespace
 | 
			
		||||
    class WebSocketClient
 | 
			
		||||
    {
 | 
			
		||||
    public:
 | 
			
		||||
        WebSocketClient(int port);
 | 
			
		||||
        WebSocketClient(int port, bool useHeartBeatMethod);
 | 
			
		||||
 | 
			
		||||
        void start();
 | 
			
		||||
        void stop();
 | 
			
		||||
@@ -29,10 +29,12 @@ namespace
 | 
			
		||||
    private:
 | 
			
		||||
        ix::WebSocket _webSocket;
 | 
			
		||||
        int _port;
 | 
			
		||||
        bool _useHeartBeatMethod;
 | 
			
		||||
    };
 | 
			
		||||
 | 
			
		||||
    WebSocketClient::WebSocketClient(int port)
 | 
			
		||||
    WebSocketClient::WebSocketClient(int port, bool useHeartBeatMethod)
 | 
			
		||||
        : _port(port)
 | 
			
		||||
        , _useHeartBeatMethod(useHeartBeatMethod)
 | 
			
		||||
    {
 | 
			
		||||
        ;
 | 
			
		||||
    }
 | 
			
		||||
@@ -61,37 +63,49 @@ namespace
 | 
			
		||||
 | 
			
		||||
        // The important bit for this test.
 | 
			
		||||
        // Set a 1 second heartbeat with the setter method to test
 | 
			
		||||
        if (_useHeartBeatMethod)
 | 
			
		||||
        {
 | 
			
		||||
            _webSocket.setPingInterval(1);
 | 
			
		||||
        }
 | 
			
		||||
        else
 | 
			
		||||
        {
 | 
			
		||||
            _webSocket.setPingInterval(1);
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        std::stringstream ss;
 | 
			
		||||
        log(std::string("Connecting to url: ") + url);
 | 
			
		||||
 | 
			
		||||
        _webSocket.setOnMessageCallback([](const ix::WebSocketMessagePtr& msg) {
 | 
			
		||||
        _webSocket.setOnMessageCallback([](ix::WebSocketMessageType messageType,
 | 
			
		||||
                                           const std::string& str,
 | 
			
		||||
                                           size_t wireSize,
 | 
			
		||||
                                           const ix::WebSocketErrorInfo& error,
 | 
			
		||||
                                           const ix::WebSocketOpenInfo& openInfo,
 | 
			
		||||
                                           const ix::WebSocketCloseInfo& closeInfo) {
 | 
			
		||||
            std::stringstream ss;
 | 
			
		||||
            if (msg->type == ix::WebSocketMessageType::Open)
 | 
			
		||||
            if (messageType == ix::WebSocketMessageType::Open)
 | 
			
		||||
            {
 | 
			
		||||
                log("client connected");
 | 
			
		||||
            }
 | 
			
		||||
            else if (msg->type == ix::WebSocketMessageType::Close)
 | 
			
		||||
            else if (messageType == ix::WebSocketMessageType::Close)
 | 
			
		||||
            {
 | 
			
		||||
                log("client disconnected");
 | 
			
		||||
            }
 | 
			
		||||
            else if (msg->type == ix::WebSocketMessageType::Error)
 | 
			
		||||
            else if (messageType == ix::WebSocketMessageType::Error)
 | 
			
		||||
            {
 | 
			
		||||
                ss << "Error ! " << msg->errorInfo.reason;
 | 
			
		||||
                ss << "Error ! " << error.reason;
 | 
			
		||||
                log(ss.str());
 | 
			
		||||
            }
 | 
			
		||||
            else if (msg->type == ix::WebSocketMessageType::Pong)
 | 
			
		||||
            else if (messageType == ix::WebSocketMessageType::Pong)
 | 
			
		||||
            {
 | 
			
		||||
                ss << "Received pong message " << msg->str;
 | 
			
		||||
                ss << "Received pong message " << str;
 | 
			
		||||
                log(ss.str());
 | 
			
		||||
            }
 | 
			
		||||
            else if (msg->type == ix::WebSocketMessageType::Ping)
 | 
			
		||||
            else if (messageType == ix::WebSocketMessageType::Ping)
 | 
			
		||||
            {
 | 
			
		||||
                ss << "Received ping message " << msg->str;
 | 
			
		||||
                ss << "Received ping message " << str;
 | 
			
		||||
                log(ss.str());
 | 
			
		||||
            }
 | 
			
		||||
            else if (msg->type == ix::WebSocketMessageType::Message)
 | 
			
		||||
            else if (messageType == ix::WebSocketMessageType::Message)
 | 
			
		||||
            {
 | 
			
		||||
                // too many messages to log
 | 
			
		||||
            }
 | 
			
		||||
@@ -118,28 +132,33 @@ namespace
 | 
			
		||||
                                             std::shared_ptr<ConnectionState> connectionState) {
 | 
			
		||||
                webSocket->setOnMessageCallback(
 | 
			
		||||
                    [webSocket, connectionState, &server, &receivedPingMessages](
 | 
			
		||||
                        const ix::WebSocketMessagePtr& msg) {
 | 
			
		||||
                        if (msg->type == ix::WebSocketMessageType::Open)
 | 
			
		||||
                        ix::WebSocketMessageType messageType,
 | 
			
		||||
                        const std::string& str,
 | 
			
		||||
                        size_t wireSize,
 | 
			
		||||
                        const ix::WebSocketErrorInfo& error,
 | 
			
		||||
                        const ix::WebSocketOpenInfo& openInfo,
 | 
			
		||||
                        const ix::WebSocketCloseInfo& closeInfo) {
 | 
			
		||||
                        if (messageType == ix::WebSocketMessageType::Open)
 | 
			
		||||
                        {
 | 
			
		||||
                            TLogger() << "New server connection";
 | 
			
		||||
                            TLogger() << "id: " << connectionState->getId();
 | 
			
		||||
                            TLogger() << "Uri: " << msg->openInfo.uri;
 | 
			
		||||
                            TLogger() << "Uri: " << openInfo.uri;
 | 
			
		||||
                            TLogger() << "Headers:";
 | 
			
		||||
                            for (auto it : msg->openInfo.headers)
 | 
			
		||||
                            for (auto it : openInfo.headers)
 | 
			
		||||
                            {
 | 
			
		||||
                                TLogger() << it.first << ": " << it.second;
 | 
			
		||||
                            }
 | 
			
		||||
                        }
 | 
			
		||||
                        else if (msg->type == ix::WebSocketMessageType::Close)
 | 
			
		||||
                        else if (messageType == ix::WebSocketMessageType::Close)
 | 
			
		||||
                        {
 | 
			
		||||
                            log("Server closed connection");
 | 
			
		||||
                        }
 | 
			
		||||
                        else if (msg->type == ix::WebSocketMessageType::Ping)
 | 
			
		||||
                        else if (messageType == ix::WebSocketMessageType::Ping)
 | 
			
		||||
                        {
 | 
			
		||||
                            log("Server received a ping");
 | 
			
		||||
                            receivedPingMessages++;
 | 
			
		||||
                        }
 | 
			
		||||
                        else if (msg->type == ix::WebSocketMessageType::Message)
 | 
			
		||||
                        else if (messageType == ix::WebSocketMessageType::Message)
 | 
			
		||||
                        {
 | 
			
		||||
                            // to many messages to log
 | 
			
		||||
                            for (auto client : server.getClients())
 | 
			
		||||
@@ -174,7 +193,8 @@ TEST_CASE("Websocket_ping_no_data_sent_setPingInterval", "[setPingInterval]")
 | 
			
		||||
        REQUIRE(startServer(server, serverReceivedPingMessages));
 | 
			
		||||
 | 
			
		||||
        std::string session = ix::generateSessionId();
 | 
			
		||||
        WebSocketClient webSocketClient(port);
 | 
			
		||||
        bool useSetHeartBeatPeriodMethod = false; // so use setPingInterval
 | 
			
		||||
        WebSocketClient webSocketClient(port, useSetHeartBeatPeriodMethod);
 | 
			
		||||
 | 
			
		||||
        webSocketClient.start();
 | 
			
		||||
 | 
			
		||||
@@ -216,7 +236,8 @@ TEST_CASE("Websocket_ping_data_sent_setPingInterval", "[setPingInterval]")
 | 
			
		||||
        REQUIRE(startServer(server, serverReceivedPingMessages));
 | 
			
		||||
 | 
			
		||||
        std::string session = ix::generateSessionId();
 | 
			
		||||
        WebSocketClient webSocketClient(port);
 | 
			
		||||
        bool useSetHeartBeatPeriodMethod = false; // so use setPingInterval
 | 
			
		||||
        WebSocketClient webSocketClient(port, useSetHeartBeatPeriodMethod);
 | 
			
		||||
 | 
			
		||||
        webSocketClient.start();
 | 
			
		||||
 | 
			
		||||
@@ -240,7 +261,7 @@ TEST_CASE("Websocket_ping_data_sent_setPingInterval", "[setPingInterval]")
 | 
			
		||||
        // Here we test ping interval
 | 
			
		||||
        // client has sent data, but ping should have been sent no matter what
 | 
			
		||||
        // -> expected ping messages == 3 as 900+900+1300 = 3100 seconds, 1 ping sent every second
 | 
			
		||||
        REQUIRE(serverReceivedPingMessages >= 2);
 | 
			
		||||
        REQUIRE(serverReceivedPingMessages == 3);
 | 
			
		||||
 | 
			
		||||
        // Give us 1000ms for the server to notice that clients went away
 | 
			
		||||
        ix::msleep(1000);
 | 
			
		||||
@@ -263,7 +284,8 @@ TEST_CASE("Websocket_ping_data_sent_setPingInterval_half_full", "[setPingInterva
 | 
			
		||||
        REQUIRE(startServer(server, serverReceivedPingMessages));
 | 
			
		||||
 | 
			
		||||
        std::string session = ix::generateSessionId();
 | 
			
		||||
        WebSocketClient webSocketClient(port);
 | 
			
		||||
        bool useSetHeartBeatPeriodMethod = false; // so use setPingInterval
 | 
			
		||||
        WebSocketClient webSocketClient(port, useSetHeartBeatPeriodMethod);
 | 
			
		||||
 | 
			
		||||
        webSocketClient.start();
 | 
			
		||||
 | 
			
		||||
@@ -316,7 +338,8 @@ TEST_CASE("Websocket_ping_data_sent_setPingInterval_full", "[setPingInterval]")
 | 
			
		||||
        REQUIRE(startServer(server, serverReceivedPingMessages));
 | 
			
		||||
 | 
			
		||||
        std::string session = ix::generateSessionId();
 | 
			
		||||
        WebSocketClient webSocketClient(port);
 | 
			
		||||
        bool useSetHeartBeatPeriodMethod = false; // so use setPingInterval
 | 
			
		||||
        WebSocketClient webSocketClient(port, useSetHeartBeatPeriodMethod);
 | 
			
		||||
 | 
			
		||||
        webSocketClient.start();
 | 
			
		||||
 | 
			
		||||
@@ -340,9 +363,8 @@ TEST_CASE("Websocket_ping_data_sent_setPingInterval_full", "[setPingInterval]")
 | 
			
		||||
 | 
			
		||||
        // Here we test ping interval
 | 
			
		||||
        // client has sent data, but ping should have been sent no matter what
 | 
			
		||||
        // -> expected ping messages == 2, 1 ping sent every second
 | 
			
		||||
        // The first ping is sent right away on connect
 | 
			
		||||
        REQUIRE(serverReceivedPingMessages == 2);
 | 
			
		||||
        // -> expected ping messages == 1, 1 ping sent every second
 | 
			
		||||
        REQUIRE(serverReceivedPingMessages == 1);
 | 
			
		||||
 | 
			
		||||
        ix::msleep(100);
 | 
			
		||||
 | 
			
		||||
@@ -370,7 +392,8 @@ TEST_CASE("Websocket_ping_no_data_sent_setHeartBeatPeriod", "[setPingInterval]")
 | 
			
		||||
        REQUIRE(startServer(server, serverReceivedPingMessages));
 | 
			
		||||
 | 
			
		||||
        std::string session = ix::generateSessionId();
 | 
			
		||||
        WebSocketClient webSocketClient(port);
 | 
			
		||||
        bool useSetHeartBeatPeriodMethod = true;
 | 
			
		||||
        WebSocketClient webSocketClient(port, useSetHeartBeatPeriodMethod);
 | 
			
		||||
 | 
			
		||||
        webSocketClient.start();
 | 
			
		||||
 | 
			
		||||
@@ -383,13 +406,14 @@ TEST_CASE("Websocket_ping_no_data_sent_setHeartBeatPeriod", "[setPingInterval]")
 | 
			
		||||
 | 
			
		||||
        REQUIRE(server.getClients().size() == 1);
 | 
			
		||||
 | 
			
		||||
        ix::msleep(2100);
 | 
			
		||||
        ix::msleep(1900);
 | 
			
		||||
 | 
			
		||||
        webSocketClient.stop();
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
        // Here we test ping interval
 | 
			
		||||
        // -> expected ping messages == 2 as 2100 seconds, 1 ping sent every second
 | 
			
		||||
        REQUIRE(serverReceivedPingMessages == 2);
 | 
			
		||||
        // -> expected ping messages == 1 as 1900 seconds, 1 ping sent every second
 | 
			
		||||
        REQUIRE(serverReceivedPingMessages == 1);
 | 
			
		||||
 | 
			
		||||
        // Give us 1000ms for the server to notice that clients went away
 | 
			
		||||
        ix::msleep(1000);
 | 
			
		||||
@@ -412,7 +436,8 @@ TEST_CASE("Websocket_ping_data_sent_setHeartBeatPeriod", "[setPingInterval]")
 | 
			
		||||
        REQUIRE(startServer(server, serverReceivedPingMessages));
 | 
			
		||||
 | 
			
		||||
        std::string session = ix::generateSessionId();
 | 
			
		||||
        WebSocketClient webSocketClient(port);
 | 
			
		||||
        bool useSetHeartBeatPeriodMethod = true;
 | 
			
		||||
        WebSocketClient webSocketClient(port, useSetHeartBeatPeriodMethod);
 | 
			
		||||
 | 
			
		||||
        webSocketClient.start();
 | 
			
		||||
 | 
			
		||||
@@ -439,7 +464,7 @@ TEST_CASE("Websocket_ping_data_sent_setHeartBeatPeriod", "[setPingInterval]")
 | 
			
		||||
        // Here we test ping interval
 | 
			
		||||
        // client has sent data, but ping should have been sent no matter what
 | 
			
		||||
        // -> expected ping messages == 2 as 900+900+1100 = 2900 seconds, 1 ping sent every second
 | 
			
		||||
        REQUIRE(serverReceivedPingMessages >= 2);
 | 
			
		||||
        REQUIRE(serverReceivedPingMessages == 2);
 | 
			
		||||
 | 
			
		||||
        // Give us 1000ms for the server to notice that clients went away
 | 
			
		||||
        ix::msleep(1000);
 | 
			
		||||
 
 | 
			
		||||
							
								
								
									
										2428
									
								
								third_party/cpp-linenoise/linenoise.cpp
									
									
									
									
										vendored
									
									
								
							
							
						
						
									
										2428
									
								
								third_party/cpp-linenoise/linenoise.cpp
									
									
									
									
										vendored
									
									
								
							
										
											
												File diff suppressed because it is too large
												Load Diff
											
										
									
								
							
							
								
								
									
										2298
									
								
								third_party/cpp-linenoise/linenoise.hpp
									
									
									
									
										vendored
									
									
								
							
							
						
						
									
										2298
									
								
								third_party/cpp-linenoise/linenoise.hpp
									
									
									
									
										vendored
									
									
								
							
										
											
												File diff suppressed because it is too large
												Load Diff
											
										
									
								
							
							
								
								
									
										26
									
								
								third_party/zlib/.gitignore
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										26
									
								
								third_party/zlib/.gitignore
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,26 @@
 | 
			
		||||
*.diff
 | 
			
		||||
*.patch
 | 
			
		||||
*.orig
 | 
			
		||||
*.rej
 | 
			
		||||
 | 
			
		||||
*~
 | 
			
		||||
*.a
 | 
			
		||||
*.lo
 | 
			
		||||
*.o
 | 
			
		||||
*.dylib
 | 
			
		||||
 | 
			
		||||
*.gcda
 | 
			
		||||
*.gcno
 | 
			
		||||
*.gcov
 | 
			
		||||
 | 
			
		||||
/example
 | 
			
		||||
/example64
 | 
			
		||||
/examplesh
 | 
			
		||||
/libz.so*
 | 
			
		||||
/minigzip
 | 
			
		||||
/minigzip64
 | 
			
		||||
/minigzipsh
 | 
			
		||||
/zlib.pc
 | 
			
		||||
/configure.log
 | 
			
		||||
 | 
			
		||||
.DS_Store
 | 
			
		||||
							
								
								
									
										227
									
								
								third_party/zlib/CMakeLists.txt
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										227
									
								
								third_party/zlib/CMakeLists.txt
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,227 @@
 | 
			
		||||
cmake_minimum_required(VERSION 2.4.4)
 | 
			
		||||
set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS ON)
 | 
			
		||||
 | 
			
		||||
project(zlib C)
 | 
			
		||||
 | 
			
		||||
set(VERSION "1.2.11")
 | 
			
		||||
 | 
			
		||||
option(ASM686 "Enable building i686 assembly implementation")
 | 
			
		||||
option(AMD64 "Enable building amd64 assembly implementation")
 | 
			
		||||
 | 
			
		||||
set(INSTALL_BIN_DIR "${CMAKE_INSTALL_PREFIX}/bin" CACHE PATH "Installation directory for executables")
 | 
			
		||||
set(INSTALL_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib" CACHE PATH "Installation directory for libraries")
 | 
			
		||||
set(INSTALL_INC_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE PATH "Installation directory for headers")
 | 
			
		||||
set(INSTALL_MAN_DIR "${CMAKE_INSTALL_PREFIX}/share/man" CACHE PATH "Installation directory for manual pages")
 | 
			
		||||
set(INSTALL_PKGCONFIG_DIR "${CMAKE_INSTALL_PREFIX}/share/pkgconfig" CACHE PATH "Installation directory for pkgconfig (.pc) files")
 | 
			
		||||
 | 
			
		||||
include(CheckTypeSize)
 | 
			
		||||
include(CheckFunctionExists)
 | 
			
		||||
include(CheckIncludeFile)
 | 
			
		||||
include(CheckCSourceCompiles)
 | 
			
		||||
enable_testing()
 | 
			
		||||
 | 
			
		||||
check_include_file(sys/types.h HAVE_SYS_TYPES_H)
 | 
			
		||||
check_include_file(stdint.h    HAVE_STDINT_H)
 | 
			
		||||
check_include_file(stddef.h    HAVE_STDDEF_H)
 | 
			
		||||
 | 
			
		||||
#
 | 
			
		||||
# Check to see if we have large file support
 | 
			
		||||
#
 | 
			
		||||
set(CMAKE_REQUIRED_DEFINITIONS -D_LARGEFILE64_SOURCE=1)
 | 
			
		||||
# We add these other definitions here because CheckTypeSize.cmake
 | 
			
		||||
# in CMake 2.4.x does not automatically do so and we want
 | 
			
		||||
# compatibility with CMake 2.4.x.
 | 
			
		||||
if(HAVE_SYS_TYPES_H)
 | 
			
		||||
    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_SYS_TYPES_H)
 | 
			
		||||
endif()
 | 
			
		||||
if(HAVE_STDINT_H)
 | 
			
		||||
    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDINT_H)
 | 
			
		||||
endif()
 | 
			
		||||
if(HAVE_STDDEF_H)
 | 
			
		||||
    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDDEF_H)
 | 
			
		||||
endif()
 | 
			
		||||
check_type_size(off64_t OFF64_T)
 | 
			
		||||
if(HAVE_OFF64_T)
 | 
			
		||||
   add_definitions(-D_LARGEFILE64_SOURCE=1)
 | 
			
		||||
endif()
 | 
			
		||||
set(CMAKE_REQUIRED_DEFINITIONS) # clear variable
 | 
			
		||||
 | 
			
		||||
#
 | 
			
		||||
# Check for fseeko
 | 
			
		||||
#
 | 
			
		||||
check_function_exists(fseeko HAVE_FSEEKO)
 | 
			
		||||
if(NOT HAVE_FSEEKO)
 | 
			
		||||
    add_definitions(-DNO_FSEEKO)
 | 
			
		||||
endif()
 | 
			
		||||
 | 
			
		||||
#
 | 
			
		||||
# Check for unistd.h
 | 
			
		||||
#
 | 
			
		||||
check_include_file(unistd.h Z_HAVE_UNISTD_H)
 | 
			
		||||
 | 
			
		||||
if(MSVC)
 | 
			
		||||
    set(CMAKE_DEBUG_POSTFIX "d")
 | 
			
		||||
    add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
 | 
			
		||||
    add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE)
 | 
			
		||||
    include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 | 
			
		||||
endif()
 | 
			
		||||
 | 
			
		||||
if(NOT CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR)
 | 
			
		||||
    # If we're doing an out of source build and the user has a zconf.h
 | 
			
		||||
    # in their source tree...
 | 
			
		||||
    if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h)
 | 
			
		||||
        message(STATUS "Renaming")
 | 
			
		||||
        message(STATUS "    ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h")
 | 
			
		||||
        message(STATUS "to 'zconf.h.included' because this file is included with zlib")
 | 
			
		||||
        message(STATUS "but CMake generates it automatically in the build directory.")
 | 
			
		||||
        file(RENAME ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.included)
 | 
			
		||||
  endif()
 | 
			
		||||
endif()
 | 
			
		||||
 | 
			
		||||
set(ZLIB_PC ${CMAKE_CURRENT_BINARY_DIR}/zlib.pc)
 | 
			
		||||
configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/zlib.pc.cmakein
 | 
			
		||||
		${ZLIB_PC} @ONLY)
 | 
			
		||||
configure_file(	${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.cmakein
 | 
			
		||||
		${CMAKE_CURRENT_BINARY_DIR}/zconf.h @ONLY)
 | 
			
		||||
include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_SOURCE_DIR})
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
#============================================================================
 | 
			
		||||
# zlib
 | 
			
		||||
#============================================================================
 | 
			
		||||
 | 
			
		||||
set(ZLIB_PUBLIC_HDRS
 | 
			
		||||
    ${CMAKE_CURRENT_BINARY_DIR}/zconf.h
 | 
			
		||||
    zlib.h
 | 
			
		||||
)
 | 
			
		||||
set(ZLIB_PRIVATE_HDRS
 | 
			
		||||
    crc32.h
 | 
			
		||||
    deflate.h
 | 
			
		||||
    gzguts.h
 | 
			
		||||
    inffast.h
 | 
			
		||||
    inffixed.h
 | 
			
		||||
    inflate.h
 | 
			
		||||
    inftrees.h
 | 
			
		||||
    trees.h
 | 
			
		||||
    zutil.h
 | 
			
		||||
)
 | 
			
		||||
set(ZLIB_SRCS
 | 
			
		||||
    adler32.c
 | 
			
		||||
    compress.c
 | 
			
		||||
    crc32.c
 | 
			
		||||
    deflate.c
 | 
			
		||||
    gzclose.c
 | 
			
		||||
    gzlib.c
 | 
			
		||||
    gzread.c
 | 
			
		||||
    gzwrite.c
 | 
			
		||||
    inflate.c
 | 
			
		||||
    infback.c
 | 
			
		||||
    inftrees.c
 | 
			
		||||
    inffast.c
 | 
			
		||||
    trees.c
 | 
			
		||||
    uncompr.c
 | 
			
		||||
    zutil.c
 | 
			
		||||
)
 | 
			
		||||
 | 
			
		||||
if(NOT MINGW)
 | 
			
		||||
    set(ZLIB_DLL_SRCS
 | 
			
		||||
        win32/zlib1.rc # If present will override custom build rule below.
 | 
			
		||||
    )
 | 
			
		||||
endif()
 | 
			
		||||
 | 
			
		||||
if(CMAKE_COMPILER_IS_GNUCC)
 | 
			
		||||
    if(ASM686)
 | 
			
		||||
        set(ZLIB_ASMS contrib/asm686/match.S)
 | 
			
		||||
    elseif (AMD64)
 | 
			
		||||
        set(ZLIB_ASMS contrib/amd64/amd64-match.S)
 | 
			
		||||
    endif ()
 | 
			
		||||
 | 
			
		||||
	if(ZLIB_ASMS)
 | 
			
		||||
		add_definitions(-DASMV)
 | 
			
		||||
		set_source_files_properties(${ZLIB_ASMS} PROPERTIES LANGUAGE C COMPILE_FLAGS -DNO_UNDERLINE)
 | 
			
		||||
	endif()
 | 
			
		||||
endif()
 | 
			
		||||
 | 
			
		||||
if(MSVC)
 | 
			
		||||
    if(ASM686)
 | 
			
		||||
		ENABLE_LANGUAGE(ASM_MASM)
 | 
			
		||||
        set(ZLIB_ASMS
 | 
			
		||||
			contrib/masmx86/inffas32.asm
 | 
			
		||||
			contrib/masmx86/match686.asm
 | 
			
		||||
		)
 | 
			
		||||
    elseif (AMD64)
 | 
			
		||||
		ENABLE_LANGUAGE(ASM_MASM)
 | 
			
		||||
        set(ZLIB_ASMS
 | 
			
		||||
			contrib/masmx64/gvmat64.asm
 | 
			
		||||
			contrib/masmx64/inffasx64.asm
 | 
			
		||||
		)
 | 
			
		||||
    endif()
 | 
			
		||||
 | 
			
		||||
	if(ZLIB_ASMS)
 | 
			
		||||
		add_definitions(-DASMV -DASMINF)
 | 
			
		||||
	endif()
 | 
			
		||||
endif()
 | 
			
		||||
 | 
			
		||||
# parse the full version number from zlib.h and include in ZLIB_FULL_VERSION
 | 
			
		||||
file(READ ${CMAKE_CURRENT_SOURCE_DIR}/zlib.h _zlib_h_contents)
 | 
			
		||||
string(REGEX REPLACE ".*#define[ \t]+ZLIB_VERSION[ \t]+\"([-0-9A-Za-z.]+)\".*"
 | 
			
		||||
    "\\1" ZLIB_FULL_VERSION ${_zlib_h_contents})
 | 
			
		||||
 | 
			
		||||
if(MINGW)
 | 
			
		||||
    # This gets us DLL resource information when compiling on MinGW.
 | 
			
		||||
    if(NOT CMAKE_RC_COMPILER)
 | 
			
		||||
        set(CMAKE_RC_COMPILER windres.exe)
 | 
			
		||||
    endif()
 | 
			
		||||
 | 
			
		||||
    add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj
 | 
			
		||||
                       COMMAND ${CMAKE_RC_COMPILER}
 | 
			
		||||
                            -D GCC_WINDRES
 | 
			
		||||
                            -I ${CMAKE_CURRENT_SOURCE_DIR}
 | 
			
		||||
                            -I ${CMAKE_CURRENT_BINARY_DIR}
 | 
			
		||||
                            -o ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj
 | 
			
		||||
                            -i ${CMAKE_CURRENT_SOURCE_DIR}/win32/zlib1.rc)
 | 
			
		||||
    set(ZLIB_DLL_SRCS ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj)
 | 
			
		||||
endif(MINGW)
 | 
			
		||||
 | 
			
		||||
add_library(zlib SHARED ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_DLL_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
 | 
			
		||||
add_library(zlibstatic STATIC ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
 | 
			
		||||
set_target_properties(zlib PROPERTIES DEFINE_SYMBOL ZLIB_DLL)
 | 
			
		||||
set_target_properties(zlib PROPERTIES SOVERSION 1)
 | 
			
		||||
 | 
			
		||||
if(NOT CYGWIN)
 | 
			
		||||
    # This property causes shared libraries on Linux to have the full version
 | 
			
		||||
    # encoded into their final filename.  We disable this on Cygwin because
 | 
			
		||||
    # it causes cygz-${ZLIB_FULL_VERSION}.dll to be created when cygz.dll
 | 
			
		||||
    # seems to be the default.
 | 
			
		||||
    #
 | 
			
		||||
    # This has no effect with MSVC, on that platform the version info for
 | 
			
		||||
    # the DLL comes from the resource file win32/zlib1.rc
 | 
			
		||||
    set_target_properties(zlib PROPERTIES VERSION ${ZLIB_FULL_VERSION})
 | 
			
		||||
endif()
 | 
			
		||||
 | 
			
		||||
if(UNIX)
 | 
			
		||||
    # On unix-like platforms the library is almost always called libz
 | 
			
		||||
   set_target_properties(zlib zlibstatic PROPERTIES OUTPUT_NAME z)
 | 
			
		||||
   if(NOT APPLE)
 | 
			
		||||
     set_target_properties(zlib PROPERTIES LINK_FLAGS "-Wl,--version-script,\"${CMAKE_CURRENT_SOURCE_DIR}/zlib.map\"")
 | 
			
		||||
   endif()
 | 
			
		||||
elseif(BUILD_SHARED_LIBS AND WIN32)
 | 
			
		||||
    # Creates zlib1.dll when building shared library version
 | 
			
		||||
    set_target_properties(zlib PROPERTIES SUFFIX "1.dll")
 | 
			
		||||
endif()
 | 
			
		||||
 | 
			
		||||
if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
 | 
			
		||||
    install(TARGETS zlib zlibstatic
 | 
			
		||||
        RUNTIME DESTINATION "${INSTALL_BIN_DIR}"
 | 
			
		||||
        ARCHIVE DESTINATION "${INSTALL_LIB_DIR}"
 | 
			
		||||
        LIBRARY DESTINATION "${INSTALL_LIB_DIR}" )
 | 
			
		||||
endif()
 | 
			
		||||
if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL )
 | 
			
		||||
    install(FILES ${ZLIB_PUBLIC_HDRS} DESTINATION "${INSTALL_INC_DIR}")
 | 
			
		||||
endif()
 | 
			
		||||
if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
 | 
			
		||||
    install(FILES zlib.3 DESTINATION "${INSTALL_MAN_DIR}/man3")
 | 
			
		||||
endif()
 | 
			
		||||
if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
 | 
			
		||||
    install(FILES ${ZLIB_PC} DESTINATION "${INSTALL_PKGCONFIG_DIR}")
 | 
			
		||||
endif()
 | 
			
		||||
							
								
								
									
										1515
									
								
								third_party/zlib/ChangeLog
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										1515
									
								
								third_party/zlib/ChangeLog
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
										
											
												File diff suppressed because it is too large
												Load Diff
											
										
									
								
							
							
								
								
									
										368
									
								
								third_party/zlib/FAQ
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										368
									
								
								third_party/zlib/FAQ
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,368 @@
 | 
			
		||||
 | 
			
		||||
                Frequently Asked Questions about zlib
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
If your question is not there, please check the zlib home page
 | 
			
		||||
http://zlib.net/ which may have more recent information.
 | 
			
		||||
The lastest zlib FAQ is at http://zlib.net/zlib_faq.html
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 1. Is zlib Y2K-compliant?
 | 
			
		||||
 | 
			
		||||
    Yes. zlib doesn't handle dates.
 | 
			
		||||
 | 
			
		||||
 2. Where can I get a Windows DLL version?
 | 
			
		||||
 | 
			
		||||
    The zlib sources can be compiled without change to produce a DLL.  See the
 | 
			
		||||
    file win32/DLL_FAQ.txt in the zlib distribution.  Pointers to the
 | 
			
		||||
    precompiled DLL are found in the zlib web site at http://zlib.net/ .
 | 
			
		||||
 | 
			
		||||
 3. Where can I get a Visual Basic interface to zlib?
 | 
			
		||||
 | 
			
		||||
    See
 | 
			
		||||
        * http://marknelson.us/1997/01/01/zlib-engine/
 | 
			
		||||
        * win32/DLL_FAQ.txt in the zlib distribution
 | 
			
		||||
 | 
			
		||||
 4. compress() returns Z_BUF_ERROR.
 | 
			
		||||
 | 
			
		||||
    Make sure that before the call of compress(), the length of the compressed
 | 
			
		||||
    buffer is equal to the available size of the compressed buffer and not
 | 
			
		||||
    zero.  For Visual Basic, check that this parameter is passed by reference
 | 
			
		||||
    ("as any"), not by value ("as long").
 | 
			
		||||
 | 
			
		||||
 5. deflate() or inflate() returns Z_BUF_ERROR.
 | 
			
		||||
 | 
			
		||||
    Before making the call, make sure that avail_in and avail_out are not zero.
 | 
			
		||||
    When setting the parameter flush equal to Z_FINISH, also make sure that
 | 
			
		||||
    avail_out is big enough to allow processing all pending input.  Note that a
 | 
			
		||||
    Z_BUF_ERROR is not fatal--another call to deflate() or inflate() can be
 | 
			
		||||
    made with more input or output space.  A Z_BUF_ERROR may in fact be
 | 
			
		||||
    unavoidable depending on how the functions are used, since it is not
 | 
			
		||||
    possible to tell whether or not there is more output pending when
 | 
			
		||||
    strm.avail_out returns with zero.  See http://zlib.net/zlib_how.html for a
 | 
			
		||||
    heavily annotated example.
 | 
			
		||||
 | 
			
		||||
 6. Where's the zlib documentation (man pages, etc.)?
 | 
			
		||||
 | 
			
		||||
    It's in zlib.h .  Examples of zlib usage are in the files test/example.c
 | 
			
		||||
    and test/minigzip.c, with more in examples/ .
 | 
			
		||||
 | 
			
		||||
 7. Why don't you use GNU autoconf or libtool or ...?
 | 
			
		||||
 | 
			
		||||
    Because we would like to keep zlib as a very small and simple package.
 | 
			
		||||
    zlib is rather portable and doesn't need much configuration.
 | 
			
		||||
 | 
			
		||||
 8. I found a bug in zlib.
 | 
			
		||||
 | 
			
		||||
    Most of the time, such problems are due to an incorrect usage of zlib.
 | 
			
		||||
    Please try to reproduce the problem with a small program and send the
 | 
			
		||||
    corresponding source to us at zlib@gzip.org .  Do not send multi-megabyte
 | 
			
		||||
    data files without prior agreement.
 | 
			
		||||
 | 
			
		||||
 9. Why do I get "undefined reference to gzputc"?
 | 
			
		||||
 | 
			
		||||
    If "make test" produces something like
 | 
			
		||||
 | 
			
		||||
       example.o(.text+0x154): undefined reference to `gzputc'
 | 
			
		||||
 | 
			
		||||
    check that you don't have old files libz.* in /usr/lib, /usr/local/lib or
 | 
			
		||||
    /usr/X11R6/lib. Remove any old versions, then do "make install".
 | 
			
		||||
 | 
			
		||||
10. I need a Delphi interface to zlib.
 | 
			
		||||
 | 
			
		||||
    See the contrib/delphi directory in the zlib distribution.
 | 
			
		||||
 | 
			
		||||
11. Can zlib handle .zip archives?
 | 
			
		||||
 | 
			
		||||
    Not by itself, no.  See the directory contrib/minizip in the zlib
 | 
			
		||||
    distribution.
 | 
			
		||||
 | 
			
		||||
12. Can zlib handle .Z files?
 | 
			
		||||
 | 
			
		||||
    No, sorry.  You have to spawn an uncompress or gunzip subprocess, or adapt
 | 
			
		||||
    the code of uncompress on your own.
 | 
			
		||||
 | 
			
		||||
13. How can I make a Unix shared library?
 | 
			
		||||
 | 
			
		||||
    By default a shared (and a static) library is built for Unix.  So:
 | 
			
		||||
 | 
			
		||||
    make distclean
 | 
			
		||||
    ./configure
 | 
			
		||||
    make
 | 
			
		||||
 | 
			
		||||
14. How do I install a shared zlib library on Unix?
 | 
			
		||||
 | 
			
		||||
    After the above, then:
 | 
			
		||||
 | 
			
		||||
    make install
 | 
			
		||||
 | 
			
		||||
    However, many flavors of Unix come with a shared zlib already installed.
 | 
			
		||||
    Before going to the trouble of compiling a shared version of zlib and
 | 
			
		||||
    trying to install it, you may want to check if it's already there!  If you
 | 
			
		||||
    can #include <zlib.h>, it's there.  The -lz option will probably link to
 | 
			
		||||
    it.  You can check the version at the top of zlib.h or with the
 | 
			
		||||
    ZLIB_VERSION symbol defined in zlib.h .
 | 
			
		||||
 | 
			
		||||
15. I have a question about OttoPDF.
 | 
			
		||||
 | 
			
		||||
    We are not the authors of OttoPDF. The real author is on the OttoPDF web
 | 
			
		||||
    site: Joel Hainley, jhainley@myndkryme.com.
 | 
			
		||||
 | 
			
		||||
16. Can zlib decode Flate data in an Adobe PDF file?
 | 
			
		||||
 | 
			
		||||
    Yes. See http://www.pdflib.com/ . To modify PDF forms, see
 | 
			
		||||
    http://sourceforge.net/projects/acroformtool/ .
 | 
			
		||||
 | 
			
		||||
17. Why am I getting this "register_frame_info not found" error on Solaris?
 | 
			
		||||
 | 
			
		||||
    After installing zlib 1.1.4 on Solaris 2.6, running applications using zlib
 | 
			
		||||
    generates an error such as:
 | 
			
		||||
 | 
			
		||||
        ld.so.1: rpm: fatal: relocation error: file /usr/local/lib/libz.so:
 | 
			
		||||
        symbol __register_frame_info: referenced symbol not found
 | 
			
		||||
 | 
			
		||||
    The symbol __register_frame_info is not part of zlib, it is generated by
 | 
			
		||||
    the C compiler (cc or gcc).  You must recompile applications using zlib
 | 
			
		||||
    which have this problem.  This problem is specific to Solaris.  See
 | 
			
		||||
    http://www.sunfreeware.com for Solaris versions of zlib and applications
 | 
			
		||||
    using zlib.
 | 
			
		||||
 | 
			
		||||
18. Why does gzip give an error on a file I make with compress/deflate?
 | 
			
		||||
 | 
			
		||||
    The compress and deflate functions produce data in the zlib format, which
 | 
			
		||||
    is different and incompatible with the gzip format.  The gz* functions in
 | 
			
		||||
    zlib on the other hand use the gzip format.  Both the zlib and gzip formats
 | 
			
		||||
    use the same compressed data format internally, but have different headers
 | 
			
		||||
    and trailers around the compressed data.
 | 
			
		||||
 | 
			
		||||
19. Ok, so why are there two different formats?
 | 
			
		||||
 | 
			
		||||
    The gzip format was designed to retain the directory information about a
 | 
			
		||||
    single file, such as the name and last modification date.  The zlib format
 | 
			
		||||
    on the other hand was designed for in-memory and communication channel
 | 
			
		||||
    applications, and has a much more compact header and trailer and uses a
 | 
			
		||||
    faster integrity check than gzip.
 | 
			
		||||
 | 
			
		||||
20. Well that's nice, but how do I make a gzip file in memory?
 | 
			
		||||
 | 
			
		||||
    You can request that deflate write the gzip format instead of the zlib
 | 
			
		||||
    format using deflateInit2().  You can also request that inflate decode the
 | 
			
		||||
    gzip format using inflateInit2().  Read zlib.h for more details.
 | 
			
		||||
 | 
			
		||||
21. Is zlib thread-safe?
 | 
			
		||||
 | 
			
		||||
    Yes.  However any library routines that zlib uses and any application-
 | 
			
		||||
    provided memory allocation routines must also be thread-safe.  zlib's gz*
 | 
			
		||||
    functions use stdio library routines, and most of zlib's functions use the
 | 
			
		||||
    library memory allocation routines by default.  zlib's *Init* functions
 | 
			
		||||
    allow for the application to provide custom memory allocation routines.
 | 
			
		||||
 | 
			
		||||
    Of course, you should only operate on any given zlib or gzip stream from a
 | 
			
		||||
    single thread at a time.
 | 
			
		||||
 | 
			
		||||
22. Can I use zlib in my commercial application?
 | 
			
		||||
 | 
			
		||||
    Yes.  Please read the license in zlib.h.
 | 
			
		||||
 | 
			
		||||
23. Is zlib under the GNU license?
 | 
			
		||||
 | 
			
		||||
    No.  Please read the license in zlib.h.
 | 
			
		||||
 | 
			
		||||
24. The license says that altered source versions must be "plainly marked". So
 | 
			
		||||
    what exactly do I need to do to meet that requirement?
 | 
			
		||||
 | 
			
		||||
    You need to change the ZLIB_VERSION and ZLIB_VERNUM #defines in zlib.h.  In
 | 
			
		||||
    particular, the final version number needs to be changed to "f", and an
 | 
			
		||||
    identification string should be appended to ZLIB_VERSION.  Version numbers
 | 
			
		||||
    x.x.x.f are reserved for modifications to zlib by others than the zlib
 | 
			
		||||
    maintainers.  For example, if the version of the base zlib you are altering
 | 
			
		||||
    is "1.2.3.4", then in zlib.h you should change ZLIB_VERNUM to 0x123f, and
 | 
			
		||||
    ZLIB_VERSION to something like "1.2.3.f-zachary-mods-v3".  You can also
 | 
			
		||||
    update the version strings in deflate.c and inftrees.c.
 | 
			
		||||
 | 
			
		||||
    For altered source distributions, you should also note the origin and
 | 
			
		||||
    nature of the changes in zlib.h, as well as in ChangeLog and README, along
 | 
			
		||||
    with the dates of the alterations.  The origin should include at least your
 | 
			
		||||
    name (or your company's name), and an email address to contact for help or
 | 
			
		||||
    issues with the library.
 | 
			
		||||
 | 
			
		||||
    Note that distributing a compiled zlib library along with zlib.h and
 | 
			
		||||
    zconf.h is also a source distribution, and so you should change
 | 
			
		||||
    ZLIB_VERSION and ZLIB_VERNUM and note the origin and nature of the changes
 | 
			
		||||
    in zlib.h as you would for a full source distribution.
 | 
			
		||||
 | 
			
		||||
25. Will zlib work on a big-endian or little-endian architecture, and can I
 | 
			
		||||
    exchange compressed data between them?
 | 
			
		||||
 | 
			
		||||
    Yes and yes.
 | 
			
		||||
 | 
			
		||||
26. Will zlib work on a 64-bit machine?
 | 
			
		||||
 | 
			
		||||
    Yes.  It has been tested on 64-bit machines, and has no dependence on any
 | 
			
		||||
    data types being limited to 32-bits in length.  If you have any
 | 
			
		||||
    difficulties, please provide a complete problem report to zlib@gzip.org
 | 
			
		||||
 | 
			
		||||
27. Will zlib decompress data from the PKWare Data Compression Library?
 | 
			
		||||
 | 
			
		||||
    No.  The PKWare DCL uses a completely different compressed data format than
 | 
			
		||||
    does PKZIP and zlib.  However, you can look in zlib's contrib/blast
 | 
			
		||||
    directory for a possible solution to your problem.
 | 
			
		||||
 | 
			
		||||
28. Can I access data randomly in a compressed stream?
 | 
			
		||||
 | 
			
		||||
    No, not without some preparation.  If when compressing you periodically use
 | 
			
		||||
    Z_FULL_FLUSH, carefully write all the pending data at those points, and
 | 
			
		||||
    keep an index of those locations, then you can start decompression at those
 | 
			
		||||
    points.  You have to be careful to not use Z_FULL_FLUSH too often, since it
 | 
			
		||||
    can significantly degrade compression.  Alternatively, you can scan a
 | 
			
		||||
    deflate stream once to generate an index, and then use that index for
 | 
			
		||||
    random access.  See examples/zran.c .
 | 
			
		||||
 | 
			
		||||
29. Does zlib work on MVS, OS/390, CICS, etc.?
 | 
			
		||||
 | 
			
		||||
    It has in the past, but we have not heard of any recent evidence.  There
 | 
			
		||||
    were working ports of zlib 1.1.4 to MVS, but those links no longer work.
 | 
			
		||||
    If you know of recent, successful applications of zlib on these operating
 | 
			
		||||
    systems, please let us know.  Thanks.
 | 
			
		||||
 | 
			
		||||
30. Is there some simpler, easier to read version of inflate I can look at to
 | 
			
		||||
    understand the deflate format?
 | 
			
		||||
 | 
			
		||||
    First off, you should read RFC 1951.  Second, yes.  Look in zlib's
 | 
			
		||||
    contrib/puff directory.
 | 
			
		||||
 | 
			
		||||
31. Does zlib infringe on any patents?
 | 
			
		||||
 | 
			
		||||
    As far as we know, no.  In fact, that was originally the whole point behind
 | 
			
		||||
    zlib.  Look here for some more information:
 | 
			
		||||
 | 
			
		||||
    http://www.gzip.org/#faq11
 | 
			
		||||
 | 
			
		||||
32. Can zlib work with greater than 4 GB of data?
 | 
			
		||||
 | 
			
		||||
    Yes.  inflate() and deflate() will process any amount of data correctly.
 | 
			
		||||
    Each call of inflate() or deflate() is limited to input and output chunks
 | 
			
		||||
    of the maximum value that can be stored in the compiler's "unsigned int"
 | 
			
		||||
    type, but there is no limit to the number of chunks.  Note however that the
 | 
			
		||||
    strm.total_in and strm_total_out counters may be limited to 4 GB.  These
 | 
			
		||||
    counters are provided as a convenience and are not used internally by
 | 
			
		||||
    inflate() or deflate().  The application can easily set up its own counters
 | 
			
		||||
    updated after each call of inflate() or deflate() to count beyond 4 GB.
 | 
			
		||||
    compress() and uncompress() may be limited to 4 GB, since they operate in a
 | 
			
		||||
    single call.  gzseek() and gztell() may be limited to 4 GB depending on how
 | 
			
		||||
    zlib is compiled.  See the zlibCompileFlags() function in zlib.h.
 | 
			
		||||
 | 
			
		||||
    The word "may" appears several times above since there is a 4 GB limit only
 | 
			
		||||
    if the compiler's "long" type is 32 bits.  If the compiler's "long" type is
 | 
			
		||||
    64 bits, then the limit is 16 exabytes.
 | 
			
		||||
 | 
			
		||||
33. Does zlib have any security vulnerabilities?
 | 
			
		||||
 | 
			
		||||
    The only one that we are aware of is potentially in gzprintf().  If zlib is
 | 
			
		||||
    compiled to use sprintf() or vsprintf(), then there is no protection
 | 
			
		||||
    against a buffer overflow of an 8K string space (or other value as set by
 | 
			
		||||
    gzbuffer()), other than the caller of gzprintf() assuring that the output
 | 
			
		||||
    will not exceed 8K.  On the other hand, if zlib is compiled to use
 | 
			
		||||
    snprintf() or vsnprintf(), which should normally be the case, then there is
 | 
			
		||||
    no vulnerability.  The ./configure script will display warnings if an
 | 
			
		||||
    insecure variation of sprintf() will be used by gzprintf().  Also the
 | 
			
		||||
    zlibCompileFlags() function will return information on what variant of
 | 
			
		||||
    sprintf() is used by gzprintf().
 | 
			
		||||
 | 
			
		||||
    If you don't have snprintf() or vsnprintf() and would like one, you can
 | 
			
		||||
    find a portable implementation here:
 | 
			
		||||
 | 
			
		||||
        http://www.ijs.si/software/snprintf/
 | 
			
		||||
 | 
			
		||||
    Note that you should be using the most recent version of zlib.  Versions
 | 
			
		||||
    1.1.3 and before were subject to a double-free vulnerability, and versions
 | 
			
		||||
    1.2.1 and 1.2.2 were subject to an access exception when decompressing
 | 
			
		||||
    invalid compressed data.
 | 
			
		||||
 | 
			
		||||
34. Is there a Java version of zlib?
 | 
			
		||||
 | 
			
		||||
    Probably what you want is to use zlib in Java. zlib is already included
 | 
			
		||||
    as part of the Java SDK in the java.util.zip package. If you really want
 | 
			
		||||
    a version of zlib written in the Java language, look on the zlib home
 | 
			
		||||
    page for links: http://zlib.net/ .
 | 
			
		||||
 | 
			
		||||
35. I get this or that compiler or source-code scanner warning when I crank it
 | 
			
		||||
    up to maximally-pedantic. Can't you guys write proper code?
 | 
			
		||||
 | 
			
		||||
    Many years ago, we gave up attempting to avoid warnings on every compiler
 | 
			
		||||
    in the universe.  It just got to be a waste of time, and some compilers
 | 
			
		||||
    were downright silly as well as contradicted each other.  So now, we simply
 | 
			
		||||
    make sure that the code always works.
 | 
			
		||||
 | 
			
		||||
36. Valgrind (or some similar memory access checker) says that deflate is
 | 
			
		||||
    performing a conditional jump that depends on an uninitialized value.
 | 
			
		||||
    Isn't that a bug?
 | 
			
		||||
 | 
			
		||||
    No.  That is intentional for performance reasons, and the output of deflate
 | 
			
		||||
    is not affected.  This only started showing up recently since zlib 1.2.x
 | 
			
		||||
    uses malloc() by default for allocations, whereas earlier versions used
 | 
			
		||||
    calloc(), which zeros out the allocated memory.  Even though the code was
 | 
			
		||||
    correct, versions 1.2.4 and later was changed to not stimulate these
 | 
			
		||||
    checkers.
 | 
			
		||||
 | 
			
		||||
37. Will zlib read the (insert any ancient or arcane format here) compressed
 | 
			
		||||
    data format?
 | 
			
		||||
 | 
			
		||||
    Probably not. Look in the comp.compression FAQ for pointers to various
 | 
			
		||||
    formats and associated software.
 | 
			
		||||
 | 
			
		||||
38. How can I encrypt/decrypt zip files with zlib?
 | 
			
		||||
 | 
			
		||||
    zlib doesn't support encryption.  The original PKZIP encryption is very
 | 
			
		||||
    weak and can be broken with freely available programs.  To get strong
 | 
			
		||||
    encryption, use GnuPG, http://www.gnupg.org/ , which already includes zlib
 | 
			
		||||
    compression.  For PKZIP compatible "encryption", look at
 | 
			
		||||
    http://www.info-zip.org/
 | 
			
		||||
 | 
			
		||||
39. What's the difference between the "gzip" and "deflate" HTTP 1.1 encodings?
 | 
			
		||||
 | 
			
		||||
    "gzip" is the gzip format, and "deflate" is the zlib format.  They should
 | 
			
		||||
    probably have called the second one "zlib" instead to avoid confusion with
 | 
			
		||||
    the raw deflate compressed data format.  While the HTTP 1.1 RFC 2616
 | 
			
		||||
    correctly points to the zlib specification in RFC 1950 for the "deflate"
 | 
			
		||||
    transfer encoding, there have been reports of servers and browsers that
 | 
			
		||||
    incorrectly produce or expect raw deflate data per the deflate
 | 
			
		||||
    specification in RFC 1951, most notably Microsoft.  So even though the
 | 
			
		||||
    "deflate" transfer encoding using the zlib format would be the more
 | 
			
		||||
    efficient approach (and in fact exactly what the zlib format was designed
 | 
			
		||||
    for), using the "gzip" transfer encoding is probably more reliable due to
 | 
			
		||||
    an unfortunate choice of name on the part of the HTTP 1.1 authors.
 | 
			
		||||
 | 
			
		||||
    Bottom line: use the gzip format for HTTP 1.1 encoding.
 | 
			
		||||
 | 
			
		||||
40. Does zlib support the new "Deflate64" format introduced by PKWare?
 | 
			
		||||
 | 
			
		||||
    No.  PKWare has apparently decided to keep that format proprietary, since
 | 
			
		||||
    they have not documented it as they have previous compression formats.  In
 | 
			
		||||
    any case, the compression improvements are so modest compared to other more
 | 
			
		||||
    modern approaches, that it's not worth the effort to implement.
 | 
			
		||||
 | 
			
		||||
41. I'm having a problem with the zip functions in zlib, can you help?
 | 
			
		||||
 | 
			
		||||
    There are no zip functions in zlib.  You are probably using minizip by
 | 
			
		||||
    Giles Vollant, which is found in the contrib directory of zlib.  It is not
 | 
			
		||||
    part of zlib.  In fact none of the stuff in contrib is part of zlib.  The
 | 
			
		||||
    files in there are not supported by the zlib authors.  You need to contact
 | 
			
		||||
    the authors of the respective contribution for help.
 | 
			
		||||
 | 
			
		||||
42. The match.asm code in contrib is under the GNU General Public License.
 | 
			
		||||
    Since it's part of zlib, doesn't that mean that all of zlib falls under the
 | 
			
		||||
    GNU GPL?
 | 
			
		||||
 | 
			
		||||
    No.  The files in contrib are not part of zlib.  They were contributed by
 | 
			
		||||
    other authors and are provided as a convenience to the user within the zlib
 | 
			
		||||
    distribution.  Each item in contrib has its own license.
 | 
			
		||||
 | 
			
		||||
43. Is zlib subject to export controls?  What is its ECCN?
 | 
			
		||||
 | 
			
		||||
    zlib is not subject to export controls, and so is classified as EAR99.
 | 
			
		||||
 | 
			
		||||
44. Can you please sign these lengthy legal documents and fax them back to us
 | 
			
		||||
    so that we can use your software in our product?
 | 
			
		||||
 | 
			
		||||
    No. Go away. Shoo.
 | 
			
		||||
							
								
								
									
										68
									
								
								third_party/zlib/INDEX
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										68
									
								
								third_party/zlib/INDEX
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,68 @@
 | 
			
		||||
CMakeLists.txt  cmake build file
 | 
			
		||||
ChangeLog       history of changes
 | 
			
		||||
FAQ             Frequently Asked Questions about zlib
 | 
			
		||||
INDEX           this file
 | 
			
		||||
Makefile        dummy Makefile that tells you to ./configure
 | 
			
		||||
Makefile.in     template for Unix Makefile
 | 
			
		||||
README          guess what
 | 
			
		||||
configure       configure script for Unix
 | 
			
		||||
make_vms.com    makefile for VMS
 | 
			
		||||
test/example.c  zlib usages examples for build testing
 | 
			
		||||
test/minigzip.c minimal gzip-like functionality for build testing
 | 
			
		||||
test/infcover.c inf*.c code coverage for build coverage testing
 | 
			
		||||
treebuild.xml   XML description of source file dependencies
 | 
			
		||||
zconf.h.cmakein zconf.h template for cmake
 | 
			
		||||
zconf.h.in      zconf.h template for configure
 | 
			
		||||
zlib.3          Man page for zlib
 | 
			
		||||
zlib.3.pdf      Man page in PDF format
 | 
			
		||||
zlib.map        Linux symbol information
 | 
			
		||||
zlib.pc.in      Template for pkg-config descriptor
 | 
			
		||||
zlib.pc.cmakein zlib.pc template for cmake
 | 
			
		||||
zlib2ansi       perl script to convert source files for C++ compilation
 | 
			
		||||
 | 
			
		||||
amiga/          makefiles for Amiga SAS C
 | 
			
		||||
as400/          makefiles for AS/400
 | 
			
		||||
doc/            documentation for formats and algorithms
 | 
			
		||||
msdos/          makefiles for MSDOS
 | 
			
		||||
nintendods/     makefile for Nintendo DS
 | 
			
		||||
old/            makefiles for various architectures and zlib documentation
 | 
			
		||||
                files that have not yet been updated for zlib 1.2.x
 | 
			
		||||
qnx/            makefiles for QNX
 | 
			
		||||
watcom/         makefiles for OpenWatcom
 | 
			
		||||
win32/          makefiles for Windows
 | 
			
		||||
 | 
			
		||||
                zlib public header files (required for library use):
 | 
			
		||||
zconf.h
 | 
			
		||||
zlib.h
 | 
			
		||||
 | 
			
		||||
                private source files used to build the zlib library:
 | 
			
		||||
adler32.c
 | 
			
		||||
compress.c
 | 
			
		||||
crc32.c
 | 
			
		||||
crc32.h
 | 
			
		||||
deflate.c
 | 
			
		||||
deflate.h
 | 
			
		||||
gzclose.c
 | 
			
		||||
gzguts.h
 | 
			
		||||
gzlib.c
 | 
			
		||||
gzread.c
 | 
			
		||||
gzwrite.c
 | 
			
		||||
infback.c
 | 
			
		||||
inffast.c
 | 
			
		||||
inffast.h
 | 
			
		||||
inffixed.h
 | 
			
		||||
inflate.c
 | 
			
		||||
inflate.h
 | 
			
		||||
inftrees.c
 | 
			
		||||
inftrees.h
 | 
			
		||||
trees.c
 | 
			
		||||
trees.h
 | 
			
		||||
uncompr.c
 | 
			
		||||
zutil.c
 | 
			
		||||
zutil.h
 | 
			
		||||
 | 
			
		||||
                source files for sample programs
 | 
			
		||||
See examples/README.examples
 | 
			
		||||
 | 
			
		||||
                unsupported contributions by third parties
 | 
			
		||||
See contrib/README.contrib
 | 
			
		||||
							
								
								
									
										5
									
								
								third_party/zlib/Makefile
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										5
									
								
								third_party/zlib/Makefile
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,5 @@
 | 
			
		||||
all:
 | 
			
		||||
	-@echo "Please use ./configure first.  Thank you."
 | 
			
		||||
 | 
			
		||||
distclean:
 | 
			
		||||
	make -f Makefile.in distclean
 | 
			
		||||
							
								
								
									
										410
									
								
								third_party/zlib/Makefile.in
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										410
									
								
								third_party/zlib/Makefile.in
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,410 @@
 | 
			
		||||
# Makefile for zlib
 | 
			
		||||
# Copyright (C) 1995-2017 Jean-loup Gailly, Mark Adler
 | 
			
		||||
# For conditions of distribution and use, see copyright notice in zlib.h
 | 
			
		||||
 | 
			
		||||
# To compile and test, type:
 | 
			
		||||
#    ./configure; make test
 | 
			
		||||
# Normally configure builds both a static and a shared library.
 | 
			
		||||
# If you want to build just a static library, use: ./configure --static
 | 
			
		||||
 | 
			
		||||
# To use the asm code, type:
 | 
			
		||||
#    cp contrib/asm?86/match.S ./match.S
 | 
			
		||||
#    make LOC=-DASMV OBJA=match.o
 | 
			
		||||
 | 
			
		||||
# To install /usr/local/lib/libz.* and /usr/local/include/zlib.h, type:
 | 
			
		||||
#    make install
 | 
			
		||||
# To install in $HOME instead of /usr/local, use:
 | 
			
		||||
#    make install prefix=$HOME
 | 
			
		||||
 | 
			
		||||
CC=cc
 | 
			
		||||
 | 
			
		||||
CFLAGS=-O
 | 
			
		||||
#CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7
 | 
			
		||||
#CFLAGS=-g -DZLIB_DEBUG
 | 
			
		||||
#CFLAGS=-O3 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \
 | 
			
		||||
#           -Wstrict-prototypes -Wmissing-prototypes
 | 
			
		||||
 | 
			
		||||
SFLAGS=-O
 | 
			
		||||
LDFLAGS=
 | 
			
		||||
TEST_LDFLAGS=-L. libz.a
 | 
			
		||||
LDSHARED=$(CC)
 | 
			
		||||
CPP=$(CC) -E
 | 
			
		||||
 | 
			
		||||
STATICLIB=libz.a
 | 
			
		||||
SHAREDLIB=libz.so
 | 
			
		||||
SHAREDLIBV=libz.so.1.2.11
 | 
			
		||||
SHAREDLIBM=libz.so.1
 | 
			
		||||
LIBS=$(STATICLIB) $(SHAREDLIBV)
 | 
			
		||||
 | 
			
		||||
AR=ar
 | 
			
		||||
ARFLAGS=rc
 | 
			
		||||
RANLIB=ranlib
 | 
			
		||||
LDCONFIG=ldconfig
 | 
			
		||||
LDSHAREDLIBC=-lc
 | 
			
		||||
TAR=tar
 | 
			
		||||
SHELL=/bin/sh
 | 
			
		||||
EXE=
 | 
			
		||||
 | 
			
		||||
prefix = /usr/local
 | 
			
		||||
exec_prefix = ${prefix}
 | 
			
		||||
libdir = ${exec_prefix}/lib
 | 
			
		||||
sharedlibdir = ${libdir}
 | 
			
		||||
includedir = ${prefix}/include
 | 
			
		||||
mandir = ${prefix}/share/man
 | 
			
		||||
man3dir = ${mandir}/man3
 | 
			
		||||
pkgconfigdir = ${libdir}/pkgconfig
 | 
			
		||||
SRCDIR=
 | 
			
		||||
ZINC=
 | 
			
		||||
ZINCOUT=-I.
 | 
			
		||||
 | 
			
		||||
OBJZ = adler32.o crc32.o deflate.o infback.o inffast.o inflate.o inftrees.o trees.o zutil.o
 | 
			
		||||
OBJG = compress.o uncompr.o gzclose.o gzlib.o gzread.o gzwrite.o
 | 
			
		||||
OBJC = $(OBJZ) $(OBJG)
 | 
			
		||||
 | 
			
		||||
PIC_OBJZ = adler32.lo crc32.lo deflate.lo infback.lo inffast.lo inflate.lo inftrees.lo trees.lo zutil.lo
 | 
			
		||||
PIC_OBJG = compress.lo uncompr.lo gzclose.lo gzlib.lo gzread.lo gzwrite.lo
 | 
			
		||||
PIC_OBJC = $(PIC_OBJZ) $(PIC_OBJG)
 | 
			
		||||
 | 
			
		||||
# to use the asm code: make OBJA=match.o, PIC_OBJA=match.lo
 | 
			
		||||
OBJA =
 | 
			
		||||
PIC_OBJA =
 | 
			
		||||
 | 
			
		||||
OBJS = $(OBJC) $(OBJA)
 | 
			
		||||
 | 
			
		||||
PIC_OBJS = $(PIC_OBJC) $(PIC_OBJA)
 | 
			
		||||
 | 
			
		||||
all: static shared
 | 
			
		||||
 | 
			
		||||
static: example$(EXE) minigzip$(EXE)
 | 
			
		||||
 | 
			
		||||
shared: examplesh$(EXE) minigzipsh$(EXE)
 | 
			
		||||
 | 
			
		||||
all64: example64$(EXE) minigzip64$(EXE)
 | 
			
		||||
 | 
			
		||||
check: test
 | 
			
		||||
 | 
			
		||||
test: all teststatic testshared
 | 
			
		||||
 | 
			
		||||
teststatic: static
 | 
			
		||||
	@TMPST=tmpst_$$; \
 | 
			
		||||
	if echo hello world | ./minigzip | ./minigzip -d && ./example $$TMPST ; then \
 | 
			
		||||
	  echo '		*** zlib test OK ***'; \
 | 
			
		||||
	else \
 | 
			
		||||
	  echo '		*** zlib test FAILED ***'; false; \
 | 
			
		||||
	fi; \
 | 
			
		||||
	rm -f $$TMPST
 | 
			
		||||
 | 
			
		||||
testshared: shared
 | 
			
		||||
	@LD_LIBRARY_PATH=`pwd`:$(LD_LIBRARY_PATH) ; export LD_LIBRARY_PATH; \
 | 
			
		||||
	LD_LIBRARYN32_PATH=`pwd`:$(LD_LIBRARYN32_PATH) ; export LD_LIBRARYN32_PATH; \
 | 
			
		||||
	DYLD_LIBRARY_PATH=`pwd`:$(DYLD_LIBRARY_PATH) ; export DYLD_LIBRARY_PATH; \
 | 
			
		||||
	SHLIB_PATH=`pwd`:$(SHLIB_PATH) ; export SHLIB_PATH; \
 | 
			
		||||
	TMPSH=tmpsh_$$; \
 | 
			
		||||
	if echo hello world | ./minigzipsh | ./minigzipsh -d && ./examplesh $$TMPSH; then \
 | 
			
		||||
	  echo '		*** zlib shared test OK ***'; \
 | 
			
		||||
	else \
 | 
			
		||||
	  echo '		*** zlib shared test FAILED ***'; false; \
 | 
			
		||||
	fi; \
 | 
			
		||||
	rm -f $$TMPSH
 | 
			
		||||
 | 
			
		||||
test64: all64
 | 
			
		||||
	@TMP64=tmp64_$$; \
 | 
			
		||||
	if echo hello world | ./minigzip64 | ./minigzip64 -d && ./example64 $$TMP64; then \
 | 
			
		||||
	  echo '		*** zlib 64-bit test OK ***'; \
 | 
			
		||||
	else \
 | 
			
		||||
	  echo '		*** zlib 64-bit test FAILED ***'; false; \
 | 
			
		||||
	fi; \
 | 
			
		||||
	rm -f $$TMP64
 | 
			
		||||
 | 
			
		||||
infcover.o: $(SRCDIR)test/infcover.c $(SRCDIR)zlib.h zconf.h
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/infcover.c
 | 
			
		||||
 | 
			
		||||
infcover: infcover.o libz.a
 | 
			
		||||
	$(CC) $(CFLAGS) -o $@ infcover.o libz.a
 | 
			
		||||
 | 
			
		||||
cover: infcover
 | 
			
		||||
	rm -f *.gcda
 | 
			
		||||
	./infcover
 | 
			
		||||
	gcov inf*.c
 | 
			
		||||
 | 
			
		||||
libz.a: $(OBJS)
 | 
			
		||||
	$(AR) $(ARFLAGS) $@ $(OBJS)
 | 
			
		||||
	-@ ($(RANLIB) $@ || true) >/dev/null 2>&1
 | 
			
		||||
 | 
			
		||||
match.o: match.S
 | 
			
		||||
	$(CPP) match.S > _match.s
 | 
			
		||||
	$(CC) -c _match.s
 | 
			
		||||
	mv _match.o match.o
 | 
			
		||||
	rm -f _match.s
 | 
			
		||||
 | 
			
		||||
match.lo: match.S
 | 
			
		||||
	$(CPP) match.S > _match.s
 | 
			
		||||
	$(CC) -c -fPIC _match.s
 | 
			
		||||
	mv _match.o match.lo
 | 
			
		||||
	rm -f _match.s
 | 
			
		||||
 | 
			
		||||
example.o: $(SRCDIR)test/example.c $(SRCDIR)zlib.h zconf.h
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/example.c
 | 
			
		||||
 | 
			
		||||
minigzip.o: $(SRCDIR)test/minigzip.c $(SRCDIR)zlib.h zconf.h
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/minigzip.c
 | 
			
		||||
 | 
			
		||||
example64.o: $(SRCDIR)test/example.c $(SRCDIR)zlib.h zconf.h
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINCOUT) -D_FILE_OFFSET_BITS=64 -c -o $@ $(SRCDIR)test/example.c
 | 
			
		||||
 | 
			
		||||
minigzip64.o: $(SRCDIR)test/minigzip.c $(SRCDIR)zlib.h zconf.h
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINCOUT) -D_FILE_OFFSET_BITS=64 -c -o $@ $(SRCDIR)test/minigzip.c
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
adler32.o: $(SRCDIR)adler32.c
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)adler32.c
 | 
			
		||||
 | 
			
		||||
crc32.o: $(SRCDIR)crc32.c
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)crc32.c
 | 
			
		||||
 | 
			
		||||
deflate.o: $(SRCDIR)deflate.c
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)deflate.c
 | 
			
		||||
 | 
			
		||||
infback.o: $(SRCDIR)infback.c
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)infback.c
 | 
			
		||||
 | 
			
		||||
inffast.o: $(SRCDIR)inffast.c
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)inffast.c
 | 
			
		||||
 | 
			
		||||
inflate.o: $(SRCDIR)inflate.c
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)inflate.c
 | 
			
		||||
 | 
			
		||||
inftrees.o: $(SRCDIR)inftrees.c
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)inftrees.c
 | 
			
		||||
 | 
			
		||||
trees.o: $(SRCDIR)trees.c
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)trees.c
 | 
			
		||||
 | 
			
		||||
zutil.o: $(SRCDIR)zutil.c
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)zutil.c
 | 
			
		||||
 | 
			
		||||
compress.o: $(SRCDIR)compress.c
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)compress.c
 | 
			
		||||
 | 
			
		||||
uncompr.o: $(SRCDIR)uncompr.c
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)uncompr.c
 | 
			
		||||
 | 
			
		||||
gzclose.o: $(SRCDIR)gzclose.c
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzclose.c
 | 
			
		||||
 | 
			
		||||
gzlib.o: $(SRCDIR)gzlib.c
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzlib.c
 | 
			
		||||
 | 
			
		||||
gzread.o: $(SRCDIR)gzread.c
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzread.c
 | 
			
		||||
 | 
			
		||||
gzwrite.o: $(SRCDIR)gzwrite.c
 | 
			
		||||
	$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzwrite.c
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
adler32.lo: $(SRCDIR)adler32.c
 | 
			
		||||
	-@mkdir objs 2>/dev/null || test -d objs
 | 
			
		||||
	$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/adler32.o $(SRCDIR)adler32.c
 | 
			
		||||
	-@mv objs/adler32.o $@
 | 
			
		||||
 | 
			
		||||
crc32.lo: $(SRCDIR)crc32.c
 | 
			
		||||
	-@mkdir objs 2>/dev/null || test -d objs
 | 
			
		||||
	$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/crc32.o $(SRCDIR)crc32.c
 | 
			
		||||
	-@mv objs/crc32.o $@
 | 
			
		||||
 | 
			
		||||
deflate.lo: $(SRCDIR)deflate.c
 | 
			
		||||
	-@mkdir objs 2>/dev/null || test -d objs
 | 
			
		||||
	$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/deflate.o $(SRCDIR)deflate.c
 | 
			
		||||
	-@mv objs/deflate.o $@
 | 
			
		||||
 | 
			
		||||
infback.lo: $(SRCDIR)infback.c
 | 
			
		||||
	-@mkdir objs 2>/dev/null || test -d objs
 | 
			
		||||
	$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/infback.o $(SRCDIR)infback.c
 | 
			
		||||
	-@mv objs/infback.o $@
 | 
			
		||||
 | 
			
		||||
inffast.lo: $(SRCDIR)inffast.c
 | 
			
		||||
	-@mkdir objs 2>/dev/null || test -d objs
 | 
			
		||||
	$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/inffast.o $(SRCDIR)inffast.c
 | 
			
		||||
	-@mv objs/inffast.o $@
 | 
			
		||||
 | 
			
		||||
inflate.lo: $(SRCDIR)inflate.c
 | 
			
		||||
	-@mkdir objs 2>/dev/null || test -d objs
 | 
			
		||||
	$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/inflate.o $(SRCDIR)inflate.c
 | 
			
		||||
	-@mv objs/inflate.o $@
 | 
			
		||||
 | 
			
		||||
inftrees.lo: $(SRCDIR)inftrees.c
 | 
			
		||||
	-@mkdir objs 2>/dev/null || test -d objs
 | 
			
		||||
	$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/inftrees.o $(SRCDIR)inftrees.c
 | 
			
		||||
	-@mv objs/inftrees.o $@
 | 
			
		||||
 | 
			
		||||
trees.lo: $(SRCDIR)trees.c
 | 
			
		||||
	-@mkdir objs 2>/dev/null || test -d objs
 | 
			
		||||
	$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/trees.o $(SRCDIR)trees.c
 | 
			
		||||
	-@mv objs/trees.o $@
 | 
			
		||||
 | 
			
		||||
zutil.lo: $(SRCDIR)zutil.c
 | 
			
		||||
	-@mkdir objs 2>/dev/null || test -d objs
 | 
			
		||||
	$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/zutil.o $(SRCDIR)zutil.c
 | 
			
		||||
	-@mv objs/zutil.o $@
 | 
			
		||||
 | 
			
		||||
compress.lo: $(SRCDIR)compress.c
 | 
			
		||||
	-@mkdir objs 2>/dev/null || test -d objs
 | 
			
		||||
	$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/compress.o $(SRCDIR)compress.c
 | 
			
		||||
	-@mv objs/compress.o $@
 | 
			
		||||
 | 
			
		||||
uncompr.lo: $(SRCDIR)uncompr.c
 | 
			
		||||
	-@mkdir objs 2>/dev/null || test -d objs
 | 
			
		||||
	$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/uncompr.o $(SRCDIR)uncompr.c
 | 
			
		||||
	-@mv objs/uncompr.o $@
 | 
			
		||||
 | 
			
		||||
gzclose.lo: $(SRCDIR)gzclose.c
 | 
			
		||||
	-@mkdir objs 2>/dev/null || test -d objs
 | 
			
		||||
	$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzclose.o $(SRCDIR)gzclose.c
 | 
			
		||||
	-@mv objs/gzclose.o $@
 | 
			
		||||
 | 
			
		||||
gzlib.lo: $(SRCDIR)gzlib.c
 | 
			
		||||
	-@mkdir objs 2>/dev/null || test -d objs
 | 
			
		||||
	$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzlib.o $(SRCDIR)gzlib.c
 | 
			
		||||
	-@mv objs/gzlib.o $@
 | 
			
		||||
 | 
			
		||||
gzread.lo: $(SRCDIR)gzread.c
 | 
			
		||||
	-@mkdir objs 2>/dev/null || test -d objs
 | 
			
		||||
	$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzread.o $(SRCDIR)gzread.c
 | 
			
		||||
	-@mv objs/gzread.o $@
 | 
			
		||||
 | 
			
		||||
gzwrite.lo: $(SRCDIR)gzwrite.c
 | 
			
		||||
	-@mkdir objs 2>/dev/null || test -d objs
 | 
			
		||||
	$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzwrite.o $(SRCDIR)gzwrite.c
 | 
			
		||||
	-@mv objs/gzwrite.o $@
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
placebo $(SHAREDLIBV): $(PIC_OBJS) libz.a
 | 
			
		||||
	$(LDSHARED) $(SFLAGS) -o $@ $(PIC_OBJS) $(LDSHAREDLIBC) $(LDFLAGS)
 | 
			
		||||
	rm -f $(SHAREDLIB) $(SHAREDLIBM)
 | 
			
		||||
	ln -s $@ $(SHAREDLIB)
 | 
			
		||||
	ln -s $@ $(SHAREDLIBM)
 | 
			
		||||
	-@rmdir objs
 | 
			
		||||
 | 
			
		||||
example$(EXE): example.o $(STATICLIB)
 | 
			
		||||
	$(CC) $(CFLAGS) -o $@ example.o $(TEST_LDFLAGS)
 | 
			
		||||
 | 
			
		||||
minigzip$(EXE): minigzip.o $(STATICLIB)
 | 
			
		||||
	$(CC) $(CFLAGS) -o $@ minigzip.o $(TEST_LDFLAGS)
 | 
			
		||||
 | 
			
		||||
examplesh$(EXE): example.o $(SHAREDLIBV)
 | 
			
		||||
	$(CC) $(CFLAGS) -o $@ example.o -L. $(SHAREDLIBV)
 | 
			
		||||
 | 
			
		||||
minigzipsh$(EXE): minigzip.o $(SHAREDLIBV)
 | 
			
		||||
	$(CC) $(CFLAGS) -o $@ minigzip.o -L. $(SHAREDLIBV)
 | 
			
		||||
 | 
			
		||||
example64$(EXE): example64.o $(STATICLIB)
 | 
			
		||||
	$(CC) $(CFLAGS) -o $@ example64.o $(TEST_LDFLAGS)
 | 
			
		||||
 | 
			
		||||
minigzip64$(EXE): minigzip64.o $(STATICLIB)
 | 
			
		||||
	$(CC) $(CFLAGS) -o $@ minigzip64.o $(TEST_LDFLAGS)
 | 
			
		||||
 | 
			
		||||
install-libs: $(LIBS)
 | 
			
		||||
	-@if [ ! -d $(DESTDIR)$(exec_prefix)  ]; then mkdir -p $(DESTDIR)$(exec_prefix); fi
 | 
			
		||||
	-@if [ ! -d $(DESTDIR)$(libdir)       ]; then mkdir -p $(DESTDIR)$(libdir); fi
 | 
			
		||||
	-@if [ ! -d $(DESTDIR)$(sharedlibdir) ]; then mkdir -p $(DESTDIR)$(sharedlibdir); fi
 | 
			
		||||
	-@if [ ! -d $(DESTDIR)$(man3dir)      ]; then mkdir -p $(DESTDIR)$(man3dir); fi
 | 
			
		||||
	-@if [ ! -d $(DESTDIR)$(pkgconfigdir) ]; then mkdir -p $(DESTDIR)$(pkgconfigdir); fi
 | 
			
		||||
	rm -f $(DESTDIR)$(libdir)/$(STATICLIB)
 | 
			
		||||
	cp $(STATICLIB) $(DESTDIR)$(libdir)
 | 
			
		||||
	chmod 644 $(DESTDIR)$(libdir)/$(STATICLIB)
 | 
			
		||||
	-@($(RANLIB) $(DESTDIR)$(libdir)/libz.a || true) >/dev/null 2>&1
 | 
			
		||||
	-@if test -n "$(SHAREDLIBV)"; then \
 | 
			
		||||
	  rm -f $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBV); \
 | 
			
		||||
	  cp $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir); \
 | 
			
		||||
	  echo "cp $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)"; \
 | 
			
		||||
	  chmod 755 $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBV); \
 | 
			
		||||
	  echo "chmod 755 $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBV)"; \
 | 
			
		||||
	  rm -f $(DESTDIR)$(sharedlibdir)/$(SHAREDLIB) $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBM); \
 | 
			
		||||
	  ln -s $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)/$(SHAREDLIB); \
 | 
			
		||||
	  ln -s $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBM); \
 | 
			
		||||
	  ($(LDCONFIG) || true)  >/dev/null 2>&1; \
 | 
			
		||||
	fi
 | 
			
		||||
	rm -f $(DESTDIR)$(man3dir)/zlib.3
 | 
			
		||||
	cp $(SRCDIR)zlib.3 $(DESTDIR)$(man3dir)
 | 
			
		||||
	chmod 644 $(DESTDIR)$(man3dir)/zlib.3
 | 
			
		||||
	rm -f $(DESTDIR)$(pkgconfigdir)/zlib.pc
 | 
			
		||||
	cp zlib.pc $(DESTDIR)$(pkgconfigdir)
 | 
			
		||||
	chmod 644 $(DESTDIR)$(pkgconfigdir)/zlib.pc
 | 
			
		||||
# The ranlib in install is needed on NeXTSTEP which checks file times
 | 
			
		||||
# ldconfig is for Linux
 | 
			
		||||
 | 
			
		||||
install: install-libs
 | 
			
		||||
	-@if [ ! -d $(DESTDIR)$(includedir)   ]; then mkdir -p $(DESTDIR)$(includedir); fi
 | 
			
		||||
	rm -f $(DESTDIR)$(includedir)/zlib.h $(DESTDIR)$(includedir)/zconf.h
 | 
			
		||||
	cp $(SRCDIR)zlib.h zconf.h $(DESTDIR)$(includedir)
 | 
			
		||||
	chmod 644 $(DESTDIR)$(includedir)/zlib.h $(DESTDIR)$(includedir)/zconf.h
 | 
			
		||||
 | 
			
		||||
uninstall:
 | 
			
		||||
	cd $(DESTDIR)$(includedir) && rm -f zlib.h zconf.h
 | 
			
		||||
	cd $(DESTDIR)$(libdir) && rm -f libz.a; \
 | 
			
		||||
	if test -n "$(SHAREDLIBV)" -a -f $(SHAREDLIBV); then \
 | 
			
		||||
	  rm -f $(SHAREDLIBV) $(SHAREDLIB) $(SHAREDLIBM); \
 | 
			
		||||
	fi
 | 
			
		||||
	cd $(DESTDIR)$(man3dir) && rm -f zlib.3
 | 
			
		||||
	cd $(DESTDIR)$(pkgconfigdir) && rm -f zlib.pc
 | 
			
		||||
 | 
			
		||||
docs: zlib.3.pdf
 | 
			
		||||
 | 
			
		||||
zlib.3.pdf: $(SRCDIR)zlib.3
 | 
			
		||||
	groff -mandoc -f H -T ps $(SRCDIR)zlib.3 | ps2pdf - $@
 | 
			
		||||
 | 
			
		||||
zconf.h.cmakein: $(SRCDIR)zconf.h.in
 | 
			
		||||
	-@ TEMPFILE=zconfh_$$; \
 | 
			
		||||
	echo "/#define ZCONF_H/ a\\\\\n#cmakedefine Z_PREFIX\\\\\n#cmakedefine Z_HAVE_UNISTD_H\n" >> $$TEMPFILE &&\
 | 
			
		||||
	sed -f $$TEMPFILE $(SRCDIR)zconf.h.in > $@ &&\
 | 
			
		||||
	touch -r $(SRCDIR)zconf.h.in $@ &&\
 | 
			
		||||
	rm $$TEMPFILE
 | 
			
		||||
 | 
			
		||||
zconf: $(SRCDIR)zconf.h.in
 | 
			
		||||
	cp -p $(SRCDIR)zconf.h.in zconf.h
 | 
			
		||||
 | 
			
		||||
mostlyclean: clean
 | 
			
		||||
clean:
 | 
			
		||||
	rm -f *.o *.lo *~ \
 | 
			
		||||
	   example$(EXE) minigzip$(EXE) examplesh$(EXE) minigzipsh$(EXE) \
 | 
			
		||||
	   example64$(EXE) minigzip64$(EXE) \
 | 
			
		||||
	   infcover \
 | 
			
		||||
	   libz.* foo.gz so_locations \
 | 
			
		||||
	   _match.s maketree contrib/infback9/*.o
 | 
			
		||||
	rm -rf objs
 | 
			
		||||
	rm -f *.gcda *.gcno *.gcov
 | 
			
		||||
	rm -f contrib/infback9/*.gcda contrib/infback9/*.gcno contrib/infback9/*.gcov
 | 
			
		||||
 | 
			
		||||
maintainer-clean: distclean
 | 
			
		||||
distclean: clean zconf zconf.h.cmakein docs
 | 
			
		||||
	rm -f Makefile zlib.pc configure.log
 | 
			
		||||
	-@rm -f .DS_Store
 | 
			
		||||
	@if [ -f Makefile.in ]; then \
 | 
			
		||||
	printf 'all:\n\t-@echo "Please use ./configure first.  Thank you."\n' > Makefile ; \
 | 
			
		||||
	printf '\ndistclean:\n\tmake -f Makefile.in distclean\n' >> Makefile ; \
 | 
			
		||||
	touch -r $(SRCDIR)Makefile.in Makefile ; fi
 | 
			
		||||
	@if [ ! -f zconf.h.in ]; then rm -f zconf.h zconf.h.cmakein ; fi
 | 
			
		||||
	@if [ ! -f zlib.3 ]; then rm -f zlib.3.pdf ; fi
 | 
			
		||||
 | 
			
		||||
tags:
 | 
			
		||||
	etags $(SRCDIR)*.[ch]
 | 
			
		||||
 | 
			
		||||
adler32.o zutil.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
 | 
			
		||||
gzclose.o gzlib.o gzread.o gzwrite.o: $(SRCDIR)zlib.h zconf.h $(SRCDIR)gzguts.h
 | 
			
		||||
compress.o example.o minigzip.o uncompr.o: $(SRCDIR)zlib.h zconf.h
 | 
			
		||||
crc32.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)crc32.h
 | 
			
		||||
deflate.o: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
 | 
			
		||||
infback.o inflate.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h $(SRCDIR)inffixed.h
 | 
			
		||||
inffast.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h
 | 
			
		||||
inftrees.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h
 | 
			
		||||
trees.o: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)trees.h
 | 
			
		||||
 | 
			
		||||
adler32.lo zutil.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
 | 
			
		||||
gzclose.lo gzlib.lo gzread.lo gzwrite.lo: $(SRCDIR)zlib.h zconf.h $(SRCDIR)gzguts.h
 | 
			
		||||
compress.lo example.lo minigzip.lo uncompr.lo: $(SRCDIR)zlib.h zconf.h
 | 
			
		||||
crc32.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)crc32.h
 | 
			
		||||
deflate.lo: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
 | 
			
		||||
infback.lo inflate.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h $(SRCDIR)inffixed.h
 | 
			
		||||
inffast.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h
 | 
			
		||||
inftrees.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h
 | 
			
		||||
trees.lo: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)trees.h
 | 
			
		||||
							
								
								
									
										115
									
								
								third_party/zlib/README
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										115
									
								
								third_party/zlib/README
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,115 @@
 | 
			
		||||
ZLIB DATA COMPRESSION LIBRARY
 | 
			
		||||
 | 
			
		||||
zlib 1.2.11 is a general purpose data compression library.  All the code is
 | 
			
		||||
thread safe.  The data format used by the zlib library is described by RFCs
 | 
			
		||||
(Request for Comments) 1950 to 1952 in the files
 | 
			
		||||
http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and
 | 
			
		||||
rfc1952 (gzip format).
 | 
			
		||||
 | 
			
		||||
All functions of the compression library are documented in the file zlib.h
 | 
			
		||||
(volunteer to write man pages welcome, contact zlib@gzip.org).  A usage example
 | 
			
		||||
of the library is given in the file test/example.c which also tests that
 | 
			
		||||
the library is working correctly.  Another example is given in the file
 | 
			
		||||
test/minigzip.c.  The compression library itself is composed of all source
 | 
			
		||||
files in the root directory.
 | 
			
		||||
 | 
			
		||||
To compile all files and run the test program, follow the instructions given at
 | 
			
		||||
the top of Makefile.in.  In short "./configure; make test", and if that goes
 | 
			
		||||
well, "make install" should work for most flavors of Unix.  For Windows, use
 | 
			
		||||
one of the special makefiles in win32/ or contrib/vstudio/ .  For VMS, use
 | 
			
		||||
make_vms.com.
 | 
			
		||||
 | 
			
		||||
Questions about zlib should be sent to <zlib@gzip.org>, or to Gilles Vollant
 | 
			
		||||
<info@winimage.com> for the Windows DLL version.  The zlib home page is
 | 
			
		||||
http://zlib.net/ .  Before reporting a problem, please check this site to
 | 
			
		||||
verify that you have the latest version of zlib; otherwise get the latest
 | 
			
		||||
version and check whether the problem still exists or not.
 | 
			
		||||
 | 
			
		||||
PLEASE read the zlib FAQ http://zlib.net/zlib_faq.html before asking for help.
 | 
			
		||||
 | 
			
		||||
Mark Nelson <markn@ieee.org> wrote an article about zlib for the Jan.  1997
 | 
			
		||||
issue of Dr.  Dobb's Journal; a copy of the article is available at
 | 
			
		||||
http://marknelson.us/1997/01/01/zlib-engine/ .
 | 
			
		||||
 | 
			
		||||
The changes made in version 1.2.11 are documented in the file ChangeLog.
 | 
			
		||||
 | 
			
		||||
Unsupported third party contributions are provided in directory contrib/ .
 | 
			
		||||
 | 
			
		||||
zlib is available in Java using the java.util.zip package, documented at
 | 
			
		||||
http://java.sun.com/developer/technicalArticles/Programming/compression/ .
 | 
			
		||||
 | 
			
		||||
A Perl interface to zlib written by Paul Marquess <pmqs@cpan.org> is available
 | 
			
		||||
at CPAN (Comprehensive Perl Archive Network) sites, including
 | 
			
		||||
http://search.cpan.org/~pmqs/IO-Compress-Zlib/ .
 | 
			
		||||
 | 
			
		||||
A Python interface to zlib written by A.M. Kuchling <amk@amk.ca> is
 | 
			
		||||
available in Python 1.5 and later versions, see
 | 
			
		||||
http://docs.python.org/library/zlib.html .
 | 
			
		||||
 | 
			
		||||
zlib is built into tcl: http://wiki.tcl.tk/4610 .
 | 
			
		||||
 | 
			
		||||
An experimental package to read and write files in .zip format, written on top
 | 
			
		||||
of zlib by Gilles Vollant <info@winimage.com>, is available in the
 | 
			
		||||
contrib/minizip directory of zlib.
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
Notes for some targets:
 | 
			
		||||
 | 
			
		||||
- For Windows DLL versions, please see win32/DLL_FAQ.txt
 | 
			
		||||
 | 
			
		||||
- For 64-bit Irix, deflate.c must be compiled without any optimization. With
 | 
			
		||||
  -O, one libpng test fails. The test works in 32 bit mode (with the -n32
 | 
			
		||||
  compiler flag). The compiler bug has been reported to SGI.
 | 
			
		||||
 | 
			
		||||
- zlib doesn't work with gcc 2.6.3 on a DEC 3000/300LX under OSF/1 2.1 it works
 | 
			
		||||
  when compiled with cc.
 | 
			
		||||
 | 
			
		||||
- On Digital Unix 4.0D (formely OSF/1) on AlphaServer, the cc option -std1 is
 | 
			
		||||
  necessary to get gzprintf working correctly. This is done by configure.
 | 
			
		||||
 | 
			
		||||
- zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works with
 | 
			
		||||
  other compilers. Use "make test" to check your compiler.
 | 
			
		||||
 | 
			
		||||
- gzdopen is not supported on RISCOS or BEOS.
 | 
			
		||||
 | 
			
		||||
- For PalmOs, see http://palmzlib.sourceforge.net/
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
Acknowledgments:
 | 
			
		||||
 | 
			
		||||
  The deflate format used by zlib was defined by Phil Katz.  The deflate and
 | 
			
		||||
  zlib specifications were written by L.  Peter Deutsch.  Thanks to all the
 | 
			
		||||
  people who reported problems and suggested various improvements in zlib; they
 | 
			
		||||
  are too numerous to cite here.
 | 
			
		||||
 | 
			
		||||
Copyright notice:
 | 
			
		||||
 | 
			
		||||
 (C) 1995-2017 Jean-loup Gailly and Mark Adler
 | 
			
		||||
 | 
			
		||||
  This software is provided 'as-is', without any express or implied
 | 
			
		||||
  warranty.  In no event will the authors be held liable for any damages
 | 
			
		||||
  arising from the use of this software.
 | 
			
		||||
 | 
			
		||||
  Permission is granted to anyone to use this software for any purpose,
 | 
			
		||||
  including commercial applications, and to alter it and redistribute it
 | 
			
		||||
  freely, subject to the following restrictions:
 | 
			
		||||
 | 
			
		||||
  1. The origin of this software must not be misrepresented; you must not
 | 
			
		||||
     claim that you wrote the original software. If you use this software
 | 
			
		||||
     in a product, an acknowledgment in the product documentation would be
 | 
			
		||||
     appreciated but is not required.
 | 
			
		||||
  2. Altered source versions must be plainly marked as such, and must not be
 | 
			
		||||
     misrepresented as being the original software.
 | 
			
		||||
  3. This notice may not be removed or altered from any source distribution.
 | 
			
		||||
 | 
			
		||||
  Jean-loup Gailly        Mark Adler
 | 
			
		||||
  jloup@gzip.org          madler@alumni.caltech.edu
 | 
			
		||||
 | 
			
		||||
If you use the zlib library in a product, we would appreciate *not* receiving
 | 
			
		||||
lengthy legal documents to sign.  The sources are provided for free but without
 | 
			
		||||
warranty of any kind.  The library has been entirely written by Jean-loup
 | 
			
		||||
Gailly and Mark Adler; it does not include third-party code.
 | 
			
		||||
 | 
			
		||||
If you redistribute modified sources, we would appreciate that you include in
 | 
			
		||||
the file ChangeLog history information documenting your changes.  Please read
 | 
			
		||||
the FAQ for more information on the distribution of modified source versions.
 | 
			
		||||
							
								
								
									
										186
									
								
								third_party/zlib/adler32.c
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										186
									
								
								third_party/zlib/adler32.c
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,186 @@
 | 
			
		||||
/* adler32.c -- compute the Adler-32 checksum of a data stream
 | 
			
		||||
 * Copyright (C) 1995-2011, 2016 Mark Adler
 | 
			
		||||
 * For conditions of distribution and use, see copyright notice in zlib.h
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
/* @(#) $Id$ */
 | 
			
		||||
 | 
			
		||||
#include "zutil.h"
 | 
			
		||||
 | 
			
		||||
local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
 | 
			
		||||
 | 
			
		||||
#define BASE 65521U     /* largest prime smaller than 65536 */
 | 
			
		||||
#define NMAX 5552
 | 
			
		||||
/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
 | 
			
		||||
 | 
			
		||||
#define DO1(buf,i)  {adler += (buf)[i]; sum2 += adler;}
 | 
			
		||||
#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
 | 
			
		||||
#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
 | 
			
		||||
#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
 | 
			
		||||
#define DO16(buf)   DO8(buf,0); DO8(buf,8);
 | 
			
		||||
 | 
			
		||||
/* use NO_DIVIDE if your processor does not do division in hardware --
 | 
			
		||||
   try it both ways to see which is faster */
 | 
			
		||||
#ifdef NO_DIVIDE
 | 
			
		||||
/* note that this assumes BASE is 65521, where 65536 % 65521 == 15
 | 
			
		||||
   (thank you to John Reiser for pointing this out) */
 | 
			
		||||
#  define CHOP(a) \
 | 
			
		||||
    do { \
 | 
			
		||||
        unsigned long tmp = a >> 16; \
 | 
			
		||||
        a &= 0xffffUL; \
 | 
			
		||||
        a += (tmp << 4) - tmp; \
 | 
			
		||||
    } while (0)
 | 
			
		||||
#  define MOD28(a) \
 | 
			
		||||
    do { \
 | 
			
		||||
        CHOP(a); \
 | 
			
		||||
        if (a >= BASE) a -= BASE; \
 | 
			
		||||
    } while (0)
 | 
			
		||||
#  define MOD(a) \
 | 
			
		||||
    do { \
 | 
			
		||||
        CHOP(a); \
 | 
			
		||||
        MOD28(a); \
 | 
			
		||||
    } while (0)
 | 
			
		||||
#  define MOD63(a) \
 | 
			
		||||
    do { /* this assumes a is not negative */ \
 | 
			
		||||
        z_off64_t tmp = a >> 32; \
 | 
			
		||||
        a &= 0xffffffffL; \
 | 
			
		||||
        a += (tmp << 8) - (tmp << 5) + tmp; \
 | 
			
		||||
        tmp = a >> 16; \
 | 
			
		||||
        a &= 0xffffL; \
 | 
			
		||||
        a += (tmp << 4) - tmp; \
 | 
			
		||||
        tmp = a >> 16; \
 | 
			
		||||
        a &= 0xffffL; \
 | 
			
		||||
        a += (tmp << 4) - tmp; \
 | 
			
		||||
        if (a >= BASE) a -= BASE; \
 | 
			
		||||
    } while (0)
 | 
			
		||||
#else
 | 
			
		||||
#  define MOD(a) a %= BASE
 | 
			
		||||
#  define MOD28(a) a %= BASE
 | 
			
		||||
#  define MOD63(a) a %= BASE
 | 
			
		||||
#endif
 | 
			
		||||
 | 
			
		||||
/* ========================================================================= */
 | 
			
		||||
uLong ZEXPORT adler32_z(adler, buf, len)
 | 
			
		||||
    uLong adler;
 | 
			
		||||
    const Bytef *buf;
 | 
			
		||||
    z_size_t len;
 | 
			
		||||
{
 | 
			
		||||
    unsigned long sum2;
 | 
			
		||||
    unsigned n;
 | 
			
		||||
 | 
			
		||||
    /* split Adler-32 into component sums */
 | 
			
		||||
    sum2 = (adler >> 16) & 0xffff;
 | 
			
		||||
    adler &= 0xffff;
 | 
			
		||||
 | 
			
		||||
    /* in case user likes doing a byte at a time, keep it fast */
 | 
			
		||||
    if (len == 1) {
 | 
			
		||||
        adler += buf[0];
 | 
			
		||||
        if (adler >= BASE)
 | 
			
		||||
            adler -= BASE;
 | 
			
		||||
        sum2 += adler;
 | 
			
		||||
        if (sum2 >= BASE)
 | 
			
		||||
            sum2 -= BASE;
 | 
			
		||||
        return adler | (sum2 << 16);
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    /* initial Adler-32 value (deferred check for len == 1 speed) */
 | 
			
		||||
    if (buf == Z_NULL)
 | 
			
		||||
        return 1L;
 | 
			
		||||
 | 
			
		||||
    /* in case short lengths are provided, keep it somewhat fast */
 | 
			
		||||
    if (len < 16) {
 | 
			
		||||
        while (len--) {
 | 
			
		||||
            adler += *buf++;
 | 
			
		||||
            sum2 += adler;
 | 
			
		||||
        }
 | 
			
		||||
        if (adler >= BASE)
 | 
			
		||||
            adler -= BASE;
 | 
			
		||||
        MOD28(sum2);            /* only added so many BASE's */
 | 
			
		||||
        return adler | (sum2 << 16);
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    /* do length NMAX blocks -- requires just one modulo operation */
 | 
			
		||||
    while (len >= NMAX) {
 | 
			
		||||
        len -= NMAX;
 | 
			
		||||
        n = NMAX / 16;          /* NMAX is divisible by 16 */
 | 
			
		||||
        do {
 | 
			
		||||
            DO16(buf);          /* 16 sums unrolled */
 | 
			
		||||
            buf += 16;
 | 
			
		||||
        } while (--n);
 | 
			
		||||
        MOD(adler);
 | 
			
		||||
        MOD(sum2);
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    /* do remaining bytes (less than NMAX, still just one modulo) */
 | 
			
		||||
    if (len) {                  /* avoid modulos if none remaining */
 | 
			
		||||
        while (len >= 16) {
 | 
			
		||||
            len -= 16;
 | 
			
		||||
            DO16(buf);
 | 
			
		||||
            buf += 16;
 | 
			
		||||
        }
 | 
			
		||||
        while (len--) {
 | 
			
		||||
            adler += *buf++;
 | 
			
		||||
            sum2 += adler;
 | 
			
		||||
        }
 | 
			
		||||
        MOD(adler);
 | 
			
		||||
        MOD(sum2);
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    /* return recombined sums */
 | 
			
		||||
    return adler | (sum2 << 16);
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/* ========================================================================= */
 | 
			
		||||
uLong ZEXPORT adler32(adler, buf, len)
 | 
			
		||||
    uLong adler;
 | 
			
		||||
    const Bytef *buf;
 | 
			
		||||
    uInt len;
 | 
			
		||||
{
 | 
			
		||||
    return adler32_z(adler, buf, len);
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/* ========================================================================= */
 | 
			
		||||
local uLong adler32_combine_(adler1, adler2, len2)
 | 
			
		||||
    uLong adler1;
 | 
			
		||||
    uLong adler2;
 | 
			
		||||
    z_off64_t len2;
 | 
			
		||||
{
 | 
			
		||||
    unsigned long sum1;
 | 
			
		||||
    unsigned long sum2;
 | 
			
		||||
    unsigned rem;
 | 
			
		||||
 | 
			
		||||
    /* for negative len, return invalid adler32 as a clue for debugging */
 | 
			
		||||
    if (len2 < 0)
 | 
			
		||||
        return 0xffffffffUL;
 | 
			
		||||
 | 
			
		||||
    /* the derivation of this formula is left as an exercise for the reader */
 | 
			
		||||
    MOD63(len2);                /* assumes len2 >= 0 */
 | 
			
		||||
    rem = (unsigned)len2;
 | 
			
		||||
    sum1 = adler1 & 0xffff;
 | 
			
		||||
    sum2 = rem * sum1;
 | 
			
		||||
    MOD(sum2);
 | 
			
		||||
    sum1 += (adler2 & 0xffff) + BASE - 1;
 | 
			
		||||
    sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
 | 
			
		||||
    if (sum1 >= BASE) sum1 -= BASE;
 | 
			
		||||
    if (sum1 >= BASE) sum1 -= BASE;
 | 
			
		||||
    if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);
 | 
			
		||||
    if (sum2 >= BASE) sum2 -= BASE;
 | 
			
		||||
    return sum1 | (sum2 << 16);
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/* ========================================================================= */
 | 
			
		||||
uLong ZEXPORT adler32_combine(adler1, adler2, len2)
 | 
			
		||||
    uLong adler1;
 | 
			
		||||
    uLong adler2;
 | 
			
		||||
    z_off_t len2;
 | 
			
		||||
{
 | 
			
		||||
    return adler32_combine_(adler1, adler2, len2);
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
uLong ZEXPORT adler32_combine64(adler1, adler2, len2)
 | 
			
		||||
    uLong adler1;
 | 
			
		||||
    uLong adler2;
 | 
			
		||||
    z_off64_t len2;
 | 
			
		||||
{
 | 
			
		||||
    return adler32_combine_(adler1, adler2, len2);
 | 
			
		||||
}
 | 
			
		||||
							
								
								
									
										69
									
								
								third_party/zlib/amiga/Makefile.pup
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										69
									
								
								third_party/zlib/amiga/Makefile.pup
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,69 @@
 | 
			
		||||
# Amiga powerUP (TM) Makefile
 | 
			
		||||
# makefile for libpng and SAS C V6.58/7.00 PPC compiler
 | 
			
		||||
# Copyright (C) 1998 by Andreas R. Kleinert
 | 
			
		||||
 | 
			
		||||
LIBNAME	= libzip.a
 | 
			
		||||
 | 
			
		||||
CC	= scppc
 | 
			
		||||
CFLAGS	= NOSTKCHK NOSINT OPTIMIZE OPTGO OPTPEEP OPTINLOCAL OPTINL \
 | 
			
		||||
	  OPTLOOP OPTRDEP=8 OPTDEP=8 OPTCOMP=8 NOVER
 | 
			
		||||
AR	= ppc-amigaos-ar cr
 | 
			
		||||
RANLIB	= ppc-amigaos-ranlib
 | 
			
		||||
LD	= ppc-amigaos-ld -r
 | 
			
		||||
LDFLAGS	= -o
 | 
			
		||||
LDLIBS	= LIB:scppc.a LIB:end.o
 | 
			
		||||
RM	= delete quiet
 | 
			
		||||
 | 
			
		||||
OBJS = adler32.o compress.o crc32.o gzclose.o gzlib.o gzread.o gzwrite.o \
 | 
			
		||||
       uncompr.o deflate.o trees.o zutil.o inflate.o infback.o inftrees.o inffast.o
 | 
			
		||||
 | 
			
		||||
TEST_OBJS = example.o minigzip.o
 | 
			
		||||
 | 
			
		||||
all: example minigzip
 | 
			
		||||
 | 
			
		||||
check: test
 | 
			
		||||
test: all
 | 
			
		||||
	example
 | 
			
		||||
	echo hello world | minigzip | minigzip -d
 | 
			
		||||
 | 
			
		||||
$(LIBNAME): $(OBJS)
 | 
			
		||||
	$(AR) $@ $(OBJS)
 | 
			
		||||
	-$(RANLIB) $@
 | 
			
		||||
 | 
			
		||||
example: example.o $(LIBNAME)
 | 
			
		||||
	$(LD) $(LDFLAGS) $@ LIB:c_ppc.o $@.o $(LIBNAME) $(LDLIBS)
 | 
			
		||||
 | 
			
		||||
minigzip: minigzip.o $(LIBNAME)
 | 
			
		||||
	$(LD) $(LDFLAGS) $@ LIB:c_ppc.o $@.o $(LIBNAME) $(LDLIBS)
 | 
			
		||||
 | 
			
		||||
mostlyclean: clean
 | 
			
		||||
clean:
 | 
			
		||||
	$(RM) *.o example minigzip $(LIBNAME) foo.gz
 | 
			
		||||
 | 
			
		||||
zip:
 | 
			
		||||
	zip -ul9 zlib README ChangeLog Makefile Make????.??? Makefile.?? \
 | 
			
		||||
	  descrip.mms *.[ch]
 | 
			
		||||
 | 
			
		||||
tgz:
 | 
			
		||||
	cd ..; tar cfz zlib/zlib.tgz zlib/README zlib/ChangeLog zlib/Makefile \
 | 
			
		||||
	  zlib/Make????.??? zlib/Makefile.?? zlib/descrip.mms zlib/*.[ch]
 | 
			
		||||
 | 
			
		||||
# DO NOT DELETE THIS LINE -- make depend depends on it.
 | 
			
		||||
 | 
			
		||||
adler32.o: zlib.h zconf.h
 | 
			
		||||
compress.o: zlib.h zconf.h
 | 
			
		||||
crc32.o: crc32.h zlib.h zconf.h
 | 
			
		||||
deflate.o: deflate.h zutil.h zlib.h zconf.h
 | 
			
		||||
example.o: zlib.h zconf.h
 | 
			
		||||
gzclose.o: zlib.h zconf.h gzguts.h
 | 
			
		||||
gzlib.o: zlib.h zconf.h gzguts.h
 | 
			
		||||
gzread.o: zlib.h zconf.h gzguts.h
 | 
			
		||||
gzwrite.o: zlib.h zconf.h gzguts.h
 | 
			
		||||
inffast.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
 | 
			
		||||
inflate.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
 | 
			
		||||
infback.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
 | 
			
		||||
inftrees.o: zutil.h zlib.h zconf.h inftrees.h
 | 
			
		||||
minigzip.o: zlib.h zconf.h
 | 
			
		||||
trees.o: deflate.h zutil.h zlib.h zconf.h trees.h
 | 
			
		||||
uncompr.o: zlib.h zconf.h
 | 
			
		||||
zutil.o: zutil.h zlib.h zconf.h
 | 
			
		||||
							
								
								
									
										68
									
								
								third_party/zlib/amiga/Makefile.sas
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										68
									
								
								third_party/zlib/amiga/Makefile.sas
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,68 @@
 | 
			
		||||
# SMakefile for zlib
 | 
			
		||||
# Modified from the standard UNIX Makefile Copyright Jean-loup Gailly
 | 
			
		||||
# Osma Ahvenlampi <Osma.Ahvenlampi@hut.fi>
 | 
			
		||||
# Amiga, SAS/C 6.56 & Smake
 | 
			
		||||
 | 
			
		||||
CC=sc
 | 
			
		||||
CFLAGS=OPT
 | 
			
		||||
#CFLAGS=OPT CPU=68030
 | 
			
		||||
#CFLAGS=DEBUG=LINE
 | 
			
		||||
LDFLAGS=LIB z.lib
 | 
			
		||||
 | 
			
		||||
SCOPTIONS=OPTSCHED OPTINLINE OPTALIAS OPTTIME OPTINLOCAL STRMERGE \
 | 
			
		||||
       NOICONS PARMS=BOTH NOSTACKCHECK UTILLIB NOVERSION ERRORREXX \
 | 
			
		||||
       DEF=POSTINC
 | 
			
		||||
 | 
			
		||||
OBJS = adler32.o compress.o crc32.o gzclose.o gzlib.o gzread.o gzwrite.o \
 | 
			
		||||
       uncompr.o deflate.o trees.o zutil.o inflate.o infback.o inftrees.o inffast.o
 | 
			
		||||
 | 
			
		||||
TEST_OBJS = example.o minigzip.o
 | 
			
		||||
 | 
			
		||||
all: SCOPTIONS example minigzip
 | 
			
		||||
 | 
			
		||||
check: test
 | 
			
		||||
test: all
 | 
			
		||||
	example
 | 
			
		||||
	echo hello world | minigzip | minigzip -d
 | 
			
		||||
 | 
			
		||||
install: z.lib
 | 
			
		||||
	copy clone zlib.h zconf.h INCLUDE:
 | 
			
		||||
	copy clone z.lib LIB:
 | 
			
		||||
 | 
			
		||||
z.lib: $(OBJS)
 | 
			
		||||
	oml z.lib r $(OBJS)
 | 
			
		||||
 | 
			
		||||
example: example.o z.lib
 | 
			
		||||
	$(CC) $(CFLAGS) LINK TO $@ example.o $(LDFLAGS)
 | 
			
		||||
 | 
			
		||||
minigzip: minigzip.o z.lib
 | 
			
		||||
	$(CC) $(CFLAGS) LINK TO $@ minigzip.o $(LDFLAGS)
 | 
			
		||||
 | 
			
		||||
mostlyclean: clean
 | 
			
		||||
clean:
 | 
			
		||||
	-delete force quiet example minigzip *.o z.lib foo.gz *.lnk SCOPTIONS
 | 
			
		||||
 | 
			
		||||
SCOPTIONS: Makefile.sas
 | 
			
		||||
	copy to $@ <from <
 | 
			
		||||
$(SCOPTIONS)
 | 
			
		||||
<
 | 
			
		||||
 | 
			
		||||
# DO NOT DELETE THIS LINE -- make depend depends on it.
 | 
			
		||||
 | 
			
		||||
adler32.o: zlib.h zconf.h
 | 
			
		||||
compress.o: zlib.h zconf.h
 | 
			
		||||
crc32.o: crc32.h zlib.h zconf.h
 | 
			
		||||
deflate.o: deflate.h zutil.h zlib.h zconf.h
 | 
			
		||||
example.o: zlib.h zconf.h
 | 
			
		||||
gzclose.o: zlib.h zconf.h gzguts.h
 | 
			
		||||
gzlib.o: zlib.h zconf.h gzguts.h
 | 
			
		||||
gzread.o: zlib.h zconf.h gzguts.h
 | 
			
		||||
gzwrite.o: zlib.h zconf.h gzguts.h
 | 
			
		||||
inffast.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
 | 
			
		||||
inflate.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
 | 
			
		||||
infback.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
 | 
			
		||||
inftrees.o: zutil.h zlib.h zconf.h inftrees.h
 | 
			
		||||
minigzip.o: zlib.h zconf.h
 | 
			
		||||
trees.o: deflate.h zutil.h zlib.h zconf.h trees.h
 | 
			
		||||
uncompr.o: zlib.h zconf.h
 | 
			
		||||
zutil.o: zutil.h zlib.h zconf.h
 | 
			
		||||
							
								
								
									
										86
									
								
								third_party/zlib/compress.c
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										86
									
								
								third_party/zlib/compress.c
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,86 @@
 | 
			
		||||
/* compress.c -- compress a memory buffer
 | 
			
		||||
 * Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler
 | 
			
		||||
 * For conditions of distribution and use, see copyright notice in zlib.h
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
/* @(#) $Id$ */
 | 
			
		||||
 | 
			
		||||
#define ZLIB_INTERNAL
 | 
			
		||||
#include "zlib.h"
 | 
			
		||||
 | 
			
		||||
/* ===========================================================================
 | 
			
		||||
     Compresses the source buffer into the destination buffer. The level
 | 
			
		||||
   parameter has the same meaning as in deflateInit.  sourceLen is the byte
 | 
			
		||||
   length of the source buffer. Upon entry, destLen is the total size of the
 | 
			
		||||
   destination buffer, which must be at least 0.1% larger than sourceLen plus
 | 
			
		||||
   12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
 | 
			
		||||
 | 
			
		||||
     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
 | 
			
		||||
   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
 | 
			
		||||
   Z_STREAM_ERROR if the level parameter is invalid.
 | 
			
		||||
*/
 | 
			
		||||
int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
 | 
			
		||||
    Bytef *dest;
 | 
			
		||||
    uLongf *destLen;
 | 
			
		||||
    const Bytef *source;
 | 
			
		||||
    uLong sourceLen;
 | 
			
		||||
    int level;
 | 
			
		||||
{
 | 
			
		||||
    z_stream stream;
 | 
			
		||||
    int err;
 | 
			
		||||
    const uInt max = (uInt)-1;
 | 
			
		||||
    uLong left;
 | 
			
		||||
 | 
			
		||||
    left = *destLen;
 | 
			
		||||
    *destLen = 0;
 | 
			
		||||
 | 
			
		||||
    stream.zalloc = (alloc_func)0;
 | 
			
		||||
    stream.zfree = (free_func)0;
 | 
			
		||||
    stream.opaque = (voidpf)0;
 | 
			
		||||
 | 
			
		||||
    err = deflateInit(&stream, level);
 | 
			
		||||
    if (err != Z_OK) return err;
 | 
			
		||||
 | 
			
		||||
    stream.next_out = dest;
 | 
			
		||||
    stream.avail_out = 0;
 | 
			
		||||
    stream.next_in = (z_const Bytef *)source;
 | 
			
		||||
    stream.avail_in = 0;
 | 
			
		||||
 | 
			
		||||
    do {
 | 
			
		||||
        if (stream.avail_out == 0) {
 | 
			
		||||
            stream.avail_out = left > (uLong)max ? max : (uInt)left;
 | 
			
		||||
            left -= stream.avail_out;
 | 
			
		||||
        }
 | 
			
		||||
        if (stream.avail_in == 0) {
 | 
			
		||||
            stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen;
 | 
			
		||||
            sourceLen -= stream.avail_in;
 | 
			
		||||
        }
 | 
			
		||||
        err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH);
 | 
			
		||||
    } while (err == Z_OK);
 | 
			
		||||
 | 
			
		||||
    *destLen = stream.total_out;
 | 
			
		||||
    deflateEnd(&stream);
 | 
			
		||||
    return err == Z_STREAM_END ? Z_OK : err;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/* ===========================================================================
 | 
			
		||||
 */
 | 
			
		||||
int ZEXPORT compress (dest, destLen, source, sourceLen)
 | 
			
		||||
    Bytef *dest;
 | 
			
		||||
    uLongf *destLen;
 | 
			
		||||
    const Bytef *source;
 | 
			
		||||
    uLong sourceLen;
 | 
			
		||||
{
 | 
			
		||||
    return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/* ===========================================================================
 | 
			
		||||
     If the default memLevel or windowBits for deflateInit() is changed, then
 | 
			
		||||
   this function needs to be updated.
 | 
			
		||||
 */
 | 
			
		||||
uLong ZEXPORT compressBound (sourceLen)
 | 
			
		||||
    uLong sourceLen;
 | 
			
		||||
{
 | 
			
		||||
    return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
 | 
			
		||||
           (sourceLen >> 25) + 13;
 | 
			
		||||
}
 | 
			
		||||
							
								
								
									
										921
									
								
								third_party/zlib/configure
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										921
									
								
								third_party/zlib/configure
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,921 @@
 | 
			
		||||
#!/bin/sh
 | 
			
		||||
# configure script for zlib.
 | 
			
		||||
#
 | 
			
		||||
# Normally configure builds both a static and a shared library.
 | 
			
		||||
# If you want to build just a static library, use: ./configure --static
 | 
			
		||||
#
 | 
			
		||||
# To impose specific compiler or flags or install directory, use for example:
 | 
			
		||||
#    prefix=$HOME CC=cc CFLAGS="-O4" ./configure
 | 
			
		||||
# or for csh/tcsh users:
 | 
			
		||||
#    (setenv prefix $HOME; setenv CC cc; setenv CFLAGS "-O4"; ./configure)
 | 
			
		||||
 | 
			
		||||
# Incorrect settings of CC or CFLAGS may prevent creating a shared library.
 | 
			
		||||
# If you have problems, try without defining CC and CFLAGS before reporting
 | 
			
		||||
# an error.
 | 
			
		||||
 | 
			
		||||
# start off configure.log
 | 
			
		||||
echo -------------------- >> configure.log
 | 
			
		||||
echo $0 $* >> configure.log
 | 
			
		||||
date >> configure.log
 | 
			
		||||
 | 
			
		||||
# get source directory
 | 
			
		||||
SRCDIR=`dirname $0`
 | 
			
		||||
if test $SRCDIR = "."; then
 | 
			
		||||
    ZINC=""
 | 
			
		||||
    ZINCOUT="-I."
 | 
			
		||||
    SRCDIR=""
 | 
			
		||||
else
 | 
			
		||||
    ZINC='-include zconf.h'
 | 
			
		||||
    ZINCOUT='-I. -I$(SRCDIR)'
 | 
			
		||||
    SRCDIR="$SRCDIR/"
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
# set command prefix for cross-compilation
 | 
			
		||||
if [ -n "${CHOST}" ]; then
 | 
			
		||||
    uname="`echo "${CHOST}" | sed -e 's/^[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)-.*$/\1/'`"
 | 
			
		||||
    CROSS_PREFIX="${CHOST}-"
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
# destination name for static library
 | 
			
		||||
STATICLIB=libz.a
 | 
			
		||||
 | 
			
		||||
# extract zlib version numbers from zlib.h
 | 
			
		||||
VER=`sed -n -e '/VERSION "/s/.*"\(.*\)".*/\1/p' < ${SRCDIR}zlib.h`
 | 
			
		||||
VER3=`sed -n -e '/VERSION "/s/.*"\([0-9]*\\.[0-9]*\\.[0-9]*\).*/\1/p' < ${SRCDIR}zlib.h`
 | 
			
		||||
VER2=`sed -n -e '/VERSION "/s/.*"\([0-9]*\\.[0-9]*\)\\..*/\1/p' < ${SRCDIR}zlib.h`
 | 
			
		||||
VER1=`sed -n -e '/VERSION "/s/.*"\([0-9]*\)\\..*/\1/p' < ${SRCDIR}zlib.h`
 | 
			
		||||
 | 
			
		||||
# establish commands for library building
 | 
			
		||||
if "${CROSS_PREFIX}ar" --version >/dev/null 2>/dev/null || test $? -lt 126; then
 | 
			
		||||
    AR=${AR-"${CROSS_PREFIX}ar"}
 | 
			
		||||
    test -n "${CROSS_PREFIX}" && echo Using ${AR} | tee -a configure.log
 | 
			
		||||
else
 | 
			
		||||
    AR=${AR-"ar"}
 | 
			
		||||
    test -n "${CROSS_PREFIX}" && echo Using ${AR} | tee -a configure.log
 | 
			
		||||
fi
 | 
			
		||||
ARFLAGS=${ARFLAGS-"rc"}
 | 
			
		||||
if "${CROSS_PREFIX}ranlib" --version >/dev/null 2>/dev/null || test $? -lt 126; then
 | 
			
		||||
    RANLIB=${RANLIB-"${CROSS_PREFIX}ranlib"}
 | 
			
		||||
    test -n "${CROSS_PREFIX}" && echo Using ${RANLIB} | tee -a configure.log
 | 
			
		||||
else
 | 
			
		||||
    RANLIB=${RANLIB-"ranlib"}
 | 
			
		||||
fi
 | 
			
		||||
if "${CROSS_PREFIX}nm" --version >/dev/null 2>/dev/null || test $? -lt 126; then
 | 
			
		||||
    NM=${NM-"${CROSS_PREFIX}nm"}
 | 
			
		||||
    test -n "${CROSS_PREFIX}" && echo Using ${NM} | tee -a configure.log
 | 
			
		||||
else
 | 
			
		||||
    NM=${NM-"nm"}
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
# set defaults before processing command line options
 | 
			
		||||
LDCONFIG=${LDCONFIG-"ldconfig"}
 | 
			
		||||
LDSHAREDLIBC="${LDSHAREDLIBC--lc}"
 | 
			
		||||
ARCHS=
 | 
			
		||||
prefix=${prefix-/usr/local}
 | 
			
		||||
exec_prefix=${exec_prefix-'${prefix}'}
 | 
			
		||||
libdir=${libdir-'${exec_prefix}/lib'}
 | 
			
		||||
sharedlibdir=${sharedlibdir-'${libdir}'}
 | 
			
		||||
includedir=${includedir-'${prefix}/include'}
 | 
			
		||||
mandir=${mandir-'${prefix}/share/man'}
 | 
			
		||||
shared_ext='.so'
 | 
			
		||||
shared=1
 | 
			
		||||
solo=0
 | 
			
		||||
cover=0
 | 
			
		||||
zprefix=0
 | 
			
		||||
zconst=0
 | 
			
		||||
build64=0
 | 
			
		||||
gcc=0
 | 
			
		||||
warn=0
 | 
			
		||||
debug=0
 | 
			
		||||
old_cc="$CC"
 | 
			
		||||
old_cflags="$CFLAGS"
 | 
			
		||||
OBJC='$(OBJZ) $(OBJG)'
 | 
			
		||||
PIC_OBJC='$(PIC_OBJZ) $(PIC_OBJG)'
 | 
			
		||||
 | 
			
		||||
# leave this script, optionally in a bad way
 | 
			
		||||
leave()
 | 
			
		||||
{
 | 
			
		||||
  if test "$*" != "0"; then
 | 
			
		||||
    echo "** $0 aborting." | tee -a configure.log
 | 
			
		||||
  fi
 | 
			
		||||
  rm -f $test.[co] $test $test$shared_ext $test.gcno ./--version
 | 
			
		||||
  echo -------------------- >> configure.log
 | 
			
		||||
  echo >> configure.log
 | 
			
		||||
  echo >> configure.log
 | 
			
		||||
  exit $1
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
# process command line options
 | 
			
		||||
while test $# -ge 1
 | 
			
		||||
do
 | 
			
		||||
case "$1" in
 | 
			
		||||
    -h* | --help)
 | 
			
		||||
      echo 'usage:' | tee -a configure.log
 | 
			
		||||
      echo '  configure [--const] [--zprefix] [--prefix=PREFIX]  [--eprefix=EXPREFIX]' | tee -a configure.log
 | 
			
		||||
      echo '    [--static] [--64] [--libdir=LIBDIR] [--sharedlibdir=LIBDIR]' | tee -a configure.log
 | 
			
		||||
      echo '    [--includedir=INCLUDEDIR] [--archs="-arch i386 -arch x86_64"]' | tee -a configure.log
 | 
			
		||||
        exit 0 ;;
 | 
			
		||||
    -p*=* | --prefix=*) prefix=`echo $1 | sed 's/.*=//'`; shift ;;
 | 
			
		||||
    -e*=* | --eprefix=*) exec_prefix=`echo $1 | sed 's/.*=//'`; shift ;;
 | 
			
		||||
    -l*=* | --libdir=*) libdir=`echo $1 | sed 's/.*=//'`; shift ;;
 | 
			
		||||
    --sharedlibdir=*) sharedlibdir=`echo $1 | sed 's/.*=//'`; shift ;;
 | 
			
		||||
    -i*=* | --includedir=*) includedir=`echo $1 | sed 's/.*=//'`;shift ;;
 | 
			
		||||
    -u*=* | --uname=*) uname=`echo $1 | sed 's/.*=//'`;shift ;;
 | 
			
		||||
    -p* | --prefix) prefix="$2"; shift; shift ;;
 | 
			
		||||
    -e* | --eprefix) exec_prefix="$2"; shift; shift ;;
 | 
			
		||||
    -l* | --libdir) libdir="$2"; shift; shift ;;
 | 
			
		||||
    -i* | --includedir) includedir="$2"; shift; shift ;;
 | 
			
		||||
    -s* | --shared | --enable-shared) shared=1; shift ;;
 | 
			
		||||
    -t | --static) shared=0; shift ;;
 | 
			
		||||
    --solo) solo=1; shift ;;
 | 
			
		||||
    --cover) cover=1; shift ;;
 | 
			
		||||
    -z* | --zprefix) zprefix=1; shift ;;
 | 
			
		||||
    -6* | --64) build64=1; shift ;;
 | 
			
		||||
    -a*=* | --archs=*) ARCHS=`echo $1 | sed 's/.*=//'`; shift ;;
 | 
			
		||||
    --sysconfdir=*) echo "ignored option: --sysconfdir" | tee -a configure.log; shift ;;
 | 
			
		||||
    --localstatedir=*) echo "ignored option: --localstatedir" | tee -a configure.log; shift ;;
 | 
			
		||||
    -c* | --const) zconst=1; shift ;;
 | 
			
		||||
    -w* | --warn) warn=1; shift ;;
 | 
			
		||||
    -d* | --debug) debug=1; shift ;;
 | 
			
		||||
    *)
 | 
			
		||||
      echo "unknown option: $1" | tee -a configure.log
 | 
			
		||||
      echo "$0 --help for help" | tee -a configure.log
 | 
			
		||||
      leave 1;;
 | 
			
		||||
    esac
 | 
			
		||||
done
 | 
			
		||||
 | 
			
		||||
# temporary file name
 | 
			
		||||
test=ztest$$
 | 
			
		||||
 | 
			
		||||
# put arguments in log, also put test file in log if used in arguments
 | 
			
		||||
show()
 | 
			
		||||
{
 | 
			
		||||
  case "$*" in
 | 
			
		||||
    *$test.c*)
 | 
			
		||||
      echo === $test.c === >> configure.log
 | 
			
		||||
      cat $test.c >> configure.log
 | 
			
		||||
      echo === >> configure.log;;
 | 
			
		||||
  esac
 | 
			
		||||
  echo $* >> configure.log
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
# check for gcc vs. cc and set compile and link flags based on the system identified by uname
 | 
			
		||||
cat > $test.c <<EOF
 | 
			
		||||
extern int getchar();
 | 
			
		||||
int hello() {return getchar();}
 | 
			
		||||
EOF
 | 
			
		||||
 | 
			
		||||
test -z "$CC" && echo Checking for ${CROSS_PREFIX}gcc... | tee -a configure.log
 | 
			
		||||
cc=${CC-${CROSS_PREFIX}gcc}
 | 
			
		||||
cflags=${CFLAGS-"-O3"}
 | 
			
		||||
# to force the asm version use: CFLAGS="-O3 -DASMV" ./configure
 | 
			
		||||
case "$cc" in
 | 
			
		||||
  *gcc*) gcc=1 ;;
 | 
			
		||||
  *clang*) gcc=1 ;;
 | 
			
		||||
esac
 | 
			
		||||
case `$cc -v 2>&1` in
 | 
			
		||||
  *gcc*) gcc=1 ;;
 | 
			
		||||
  *clang*) gcc=1 ;;
 | 
			
		||||
esac
 | 
			
		||||
 | 
			
		||||
show $cc -c $test.c
 | 
			
		||||
if test "$gcc" -eq 1 && ($cc -c $test.c) >> configure.log 2>&1; then
 | 
			
		||||
  echo ... using gcc >> configure.log
 | 
			
		||||
  CC="$cc"
 | 
			
		||||
  CFLAGS="${CFLAGS--O3}"
 | 
			
		||||
  SFLAGS="${CFLAGS--O3} -fPIC"
 | 
			
		||||
  if test "$ARCHS"; then
 | 
			
		||||
    CFLAGS="${CFLAGS} ${ARCHS}"
 | 
			
		||||
    LDFLAGS="${LDFLAGS} ${ARCHS}"
 | 
			
		||||
  fi
 | 
			
		||||
  if test $build64 -eq 1; then
 | 
			
		||||
    CFLAGS="${CFLAGS} -m64"
 | 
			
		||||
    SFLAGS="${SFLAGS} -m64"
 | 
			
		||||
  fi
 | 
			
		||||
  if test "$warn" -eq 1; then
 | 
			
		||||
    if test "$zconst" -eq 1; then
 | 
			
		||||
      CFLAGS="${CFLAGS} -Wall -Wextra -Wcast-qual -pedantic -DZLIB_CONST"
 | 
			
		||||
    else
 | 
			
		||||
      CFLAGS="${CFLAGS} -Wall -Wextra -pedantic"
 | 
			
		||||
    fi
 | 
			
		||||
  fi
 | 
			
		||||
  if test $debug -eq 1; then
 | 
			
		||||
    CFLAGS="${CFLAGS} -DZLIB_DEBUG"
 | 
			
		||||
    SFLAGS="${SFLAGS} -DZLIB_DEBUG"
 | 
			
		||||
  fi
 | 
			
		||||
  if test -z "$uname"; then
 | 
			
		||||
    uname=`(uname -s || echo unknown) 2>/dev/null`
 | 
			
		||||
  fi
 | 
			
		||||
  case "$uname" in
 | 
			
		||||
  Linux* | linux* | GNU | GNU/* | solaris*)
 | 
			
		||||
        LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,${SRCDIR}zlib.map"} ;;
 | 
			
		||||
  *BSD | *bsd* | DragonFly)
 | 
			
		||||
        LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,${SRCDIR}zlib.map"}
 | 
			
		||||
        LDCONFIG="ldconfig -m" ;;
 | 
			
		||||
  CYGWIN* | Cygwin* | cygwin* | OS/2*)
 | 
			
		||||
        EXE='.exe' ;;
 | 
			
		||||
  MINGW* | mingw*)
 | 
			
		||||
# temporary bypass
 | 
			
		||||
        rm -f $test.[co] $test $test$shared_ext
 | 
			
		||||
        echo "Please use win32/Makefile.gcc instead." | tee -a configure.log
 | 
			
		||||
        leave 1
 | 
			
		||||
        LDSHARED=${LDSHARED-"$cc -shared"}
 | 
			
		||||
        LDSHAREDLIBC=""
 | 
			
		||||
        EXE='.exe' ;;
 | 
			
		||||
  QNX*)  # This is for QNX6. I suppose that the QNX rule below is for QNX2,QNX4
 | 
			
		||||
         # (alain.bonnefoy@icbt.com)
 | 
			
		||||
                 LDSHARED=${LDSHARED-"$cc -shared -Wl,-hlibz.so.1"} ;;
 | 
			
		||||
  HP-UX*)
 | 
			
		||||
         LDSHARED=${LDSHARED-"$cc -shared $SFLAGS"}
 | 
			
		||||
         case `(uname -m || echo unknown) 2>/dev/null` in
 | 
			
		||||
         ia64)
 | 
			
		||||
                 shared_ext='.so'
 | 
			
		||||
                 SHAREDLIB='libz.so' ;;
 | 
			
		||||
         *)
 | 
			
		||||
                 shared_ext='.sl'
 | 
			
		||||
                 SHAREDLIB='libz.sl' ;;
 | 
			
		||||
         esac ;;
 | 
			
		||||
  Darwin* | darwin*)
 | 
			
		||||
             shared_ext='.dylib'
 | 
			
		||||
             SHAREDLIB=libz$shared_ext
 | 
			
		||||
             SHAREDLIBV=libz.$VER$shared_ext
 | 
			
		||||
             SHAREDLIBM=libz.$VER1$shared_ext
 | 
			
		||||
             LDSHARED=${LDSHARED-"$cc -dynamiclib -install_name $libdir/$SHAREDLIBM -compatibility_version $VER1 -current_version $VER3"}
 | 
			
		||||
             if libtool -V 2>&1 | grep Apple > /dev/null; then
 | 
			
		||||
                 AR="libtool"
 | 
			
		||||
             else
 | 
			
		||||
                 AR="/usr/bin/libtool"
 | 
			
		||||
             fi
 | 
			
		||||
             ARFLAGS="-o" ;;
 | 
			
		||||
  *)             LDSHARED=${LDSHARED-"$cc -shared"} ;;
 | 
			
		||||
  esac
 | 
			
		||||
else
 | 
			
		||||
  # find system name and corresponding cc options
 | 
			
		||||
  CC=${CC-cc}
 | 
			
		||||
  gcc=0
 | 
			
		||||
  echo ... using $CC >> configure.log
 | 
			
		||||
  if test -z "$uname"; then
 | 
			
		||||
    uname=`(uname -sr || echo unknown) 2>/dev/null`
 | 
			
		||||
  fi
 | 
			
		||||
  case "$uname" in
 | 
			
		||||
  HP-UX*)    SFLAGS=${CFLAGS-"-O +z"}
 | 
			
		||||
             CFLAGS=${CFLAGS-"-O"}
 | 
			
		||||
#            LDSHARED=${LDSHARED-"ld -b +vnocompatwarnings"}
 | 
			
		||||
             LDSHARED=${LDSHARED-"ld -b"}
 | 
			
		||||
         case `(uname -m || echo unknown) 2>/dev/null` in
 | 
			
		||||
         ia64)
 | 
			
		||||
             shared_ext='.so'
 | 
			
		||||
             SHAREDLIB='libz.so' ;;
 | 
			
		||||
         *)
 | 
			
		||||
             shared_ext='.sl'
 | 
			
		||||
             SHAREDLIB='libz.sl' ;;
 | 
			
		||||
         esac ;;
 | 
			
		||||
  IRIX*)     SFLAGS=${CFLAGS-"-ansi -O2 -rpath ."}
 | 
			
		||||
             CFLAGS=${CFLAGS-"-ansi -O2"}
 | 
			
		||||
             LDSHARED=${LDSHARED-"cc -shared -Wl,-soname,libz.so.1"} ;;
 | 
			
		||||
  OSF1\ V4*) SFLAGS=${CFLAGS-"-O -std1"}
 | 
			
		||||
             CFLAGS=${CFLAGS-"-O -std1"}
 | 
			
		||||
             LDFLAGS="${LDFLAGS} -Wl,-rpath,."
 | 
			
		||||
             LDSHARED=${LDSHARED-"cc -shared  -Wl,-soname,libz.so -Wl,-msym -Wl,-rpath,$(libdir) -Wl,-set_version,${VER}:1.0"} ;;
 | 
			
		||||
  OSF1*)     SFLAGS=${CFLAGS-"-O -std1"}
 | 
			
		||||
             CFLAGS=${CFLAGS-"-O -std1"}
 | 
			
		||||
             LDSHARED=${LDSHARED-"cc -shared -Wl,-soname,libz.so.1"} ;;
 | 
			
		||||
  QNX*)      SFLAGS=${CFLAGS-"-4 -O"}
 | 
			
		||||
             CFLAGS=${CFLAGS-"-4 -O"}
 | 
			
		||||
             LDSHARED=${LDSHARED-"cc"}
 | 
			
		||||
             RANLIB=${RANLIB-"true"}
 | 
			
		||||
             AR="cc"
 | 
			
		||||
             ARFLAGS="-A" ;;
 | 
			
		||||
  SCO_SV\ 3.2*) SFLAGS=${CFLAGS-"-O3 -dy -KPIC "}
 | 
			
		||||
             CFLAGS=${CFLAGS-"-O3"}
 | 
			
		||||
             LDSHARED=${LDSHARED-"cc -dy -KPIC -G"} ;;
 | 
			
		||||
  SunOS\ 5* | solaris*)
 | 
			
		||||
         LDSHARED=${LDSHARED-"cc -G -h libz$shared_ext.$VER1"}
 | 
			
		||||
         SFLAGS=${CFLAGS-"-fast -KPIC"}
 | 
			
		||||
         CFLAGS=${CFLAGS-"-fast"}
 | 
			
		||||
         if test $build64 -eq 1; then
 | 
			
		||||
             # old versions of SunPRO/Workshop/Studio don't support -m64,
 | 
			
		||||
             # but newer ones do.  Check for it.
 | 
			
		||||
             flag64=`$CC -flags | egrep -- '^-m64'`
 | 
			
		||||
             if test x"$flag64" != x"" ; then
 | 
			
		||||
                 CFLAGS="${CFLAGS} -m64"
 | 
			
		||||
                 SFLAGS="${SFLAGS} -m64"
 | 
			
		||||
             else
 | 
			
		||||
                 case `(uname -m || echo unknown) 2>/dev/null` in
 | 
			
		||||
                   i86*)
 | 
			
		||||
                     SFLAGS="$SFLAGS -xarch=amd64"
 | 
			
		||||
                     CFLAGS="$CFLAGS -xarch=amd64" ;;
 | 
			
		||||
                   *)
 | 
			
		||||
                     SFLAGS="$SFLAGS -xarch=v9"
 | 
			
		||||
                     CFLAGS="$CFLAGS -xarch=v9" ;;
 | 
			
		||||
                 esac
 | 
			
		||||
             fi
 | 
			
		||||
         fi
 | 
			
		||||
         if test -n "$ZINC"; then
 | 
			
		||||
             ZINC='-I- -I. -I$(SRCDIR)'
 | 
			
		||||
         fi
 | 
			
		||||
         ;;
 | 
			
		||||
  SunOS\ 4*) SFLAGS=${CFLAGS-"-O2 -PIC"}
 | 
			
		||||
             CFLAGS=${CFLAGS-"-O2"}
 | 
			
		||||
             LDSHARED=${LDSHARED-"ld"} ;;
 | 
			
		||||
  SunStudio\ 9*) SFLAGS=${CFLAGS-"-fast -xcode=pic32 -xtarget=ultra3 -xarch=v9b"}
 | 
			
		||||
             CFLAGS=${CFLAGS-"-fast -xtarget=ultra3 -xarch=v9b"}
 | 
			
		||||
             LDSHARED=${LDSHARED-"cc -xarch=v9b"} ;;
 | 
			
		||||
  UNIX_System_V\ 4.2.0)
 | 
			
		||||
             SFLAGS=${CFLAGS-"-KPIC -O"}
 | 
			
		||||
             CFLAGS=${CFLAGS-"-O"}
 | 
			
		||||
             LDSHARED=${LDSHARED-"cc -G"} ;;
 | 
			
		||||
  UNIX_SV\ 4.2MP)
 | 
			
		||||
             SFLAGS=${CFLAGS-"-Kconform_pic -O"}
 | 
			
		||||
             CFLAGS=${CFLAGS-"-O"}
 | 
			
		||||
             LDSHARED=${LDSHARED-"cc -G"} ;;
 | 
			
		||||
  OpenUNIX\ 5)
 | 
			
		||||
             SFLAGS=${CFLAGS-"-KPIC -O"}
 | 
			
		||||
             CFLAGS=${CFLAGS-"-O"}
 | 
			
		||||
             LDSHARED=${LDSHARED-"cc -G"} ;;
 | 
			
		||||
  AIX*)  # Courtesy of dbakker@arrayasolutions.com
 | 
			
		||||
             SFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
 | 
			
		||||
             CFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
 | 
			
		||||
             LDSHARED=${LDSHARED-"xlc -G"} ;;
 | 
			
		||||
  # send working options for other systems to zlib@gzip.org
 | 
			
		||||
  *)         SFLAGS=${CFLAGS-"-O"}
 | 
			
		||||
             CFLAGS=${CFLAGS-"-O"}
 | 
			
		||||
             LDSHARED=${LDSHARED-"cc -shared"} ;;
 | 
			
		||||
  esac
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
# destination names for shared library if not defined above
 | 
			
		||||
SHAREDLIB=${SHAREDLIB-"libz$shared_ext"}
 | 
			
		||||
SHAREDLIBV=${SHAREDLIBV-"libz$shared_ext.$VER"}
 | 
			
		||||
SHAREDLIBM=${SHAREDLIBM-"libz$shared_ext.$VER1"}
 | 
			
		||||
 | 
			
		||||
echo >> configure.log
 | 
			
		||||
 | 
			
		||||
# define functions for testing compiler and library characteristics and logging the results
 | 
			
		||||
 | 
			
		||||
cat > $test.c <<EOF
 | 
			
		||||
#error error
 | 
			
		||||
EOF
 | 
			
		||||
if ($CC -c $CFLAGS $test.c) 2>/dev/null; then
 | 
			
		||||
  try()
 | 
			
		||||
  {
 | 
			
		||||
    show $*
 | 
			
		||||
    test "`( $* ) 2>&1 | tee -a configure.log`" = ""
 | 
			
		||||
  }
 | 
			
		||||
  echo - using any output from compiler to indicate an error >> configure.log
 | 
			
		||||
else
 | 
			
		||||
  try()
 | 
			
		||||
  {
 | 
			
		||||
    show $*
 | 
			
		||||
    ( $* ) >> configure.log 2>&1
 | 
			
		||||
    ret=$?
 | 
			
		||||
    if test $ret -ne 0; then
 | 
			
		||||
      echo "(exit code "$ret")" >> configure.log
 | 
			
		||||
    fi
 | 
			
		||||
    return $ret
 | 
			
		||||
  }
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
tryboth()
 | 
			
		||||
{
 | 
			
		||||
  show $*
 | 
			
		||||
  got=`( $* ) 2>&1`
 | 
			
		||||
  ret=$?
 | 
			
		||||
  printf %s "$got" >> configure.log
 | 
			
		||||
  if test $ret -ne 0; then
 | 
			
		||||
    return $ret
 | 
			
		||||
  fi
 | 
			
		||||
  test "$got" = ""
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
cat > $test.c << EOF
 | 
			
		||||
int foo() { return 0; }
 | 
			
		||||
EOF
 | 
			
		||||
echo "Checking for obsessive-compulsive compiler options..." >> configure.log
 | 
			
		||||
if try $CC -c $CFLAGS $test.c; then
 | 
			
		||||
  :
 | 
			
		||||
else
 | 
			
		||||
  echo "Compiler error reporting is too harsh for $0 (perhaps remove -Werror)." | tee -a configure.log
 | 
			
		||||
  leave 1
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
echo >> configure.log
 | 
			
		||||
 | 
			
		||||
# see if shared library build supported
 | 
			
		||||
cat > $test.c <<EOF
 | 
			
		||||
extern int getchar();
 | 
			
		||||
int hello() {return getchar();}
 | 
			
		||||
EOF
 | 
			
		||||
if test $shared -eq 1; then
 | 
			
		||||
  echo Checking for shared library support... | tee -a configure.log
 | 
			
		||||
  # we must test in two steps (cc then ld), required at least on SunOS 4.x
 | 
			
		||||
  if try $CC -w -c $SFLAGS $test.c &&
 | 
			
		||||
     try $LDSHARED $SFLAGS -o $test$shared_ext $test.o; then
 | 
			
		||||
    echo Building shared library $SHAREDLIBV with $CC. | tee -a configure.log
 | 
			
		||||
  elif test -z "$old_cc" -a -z "$old_cflags"; then
 | 
			
		||||
    echo No shared library support. | tee -a configure.log
 | 
			
		||||
    shared=0;
 | 
			
		||||
  else
 | 
			
		||||
    echo 'No shared library support; try without defining CC and CFLAGS' | tee -a configure.log
 | 
			
		||||
    shared=0;
 | 
			
		||||
  fi
 | 
			
		||||
fi
 | 
			
		||||
if test $shared -eq 0; then
 | 
			
		||||
  LDSHARED="$CC"
 | 
			
		||||
  ALL="static"
 | 
			
		||||
  TEST="all teststatic"
 | 
			
		||||
  SHAREDLIB=""
 | 
			
		||||
  SHAREDLIBV=""
 | 
			
		||||
  SHAREDLIBM=""
 | 
			
		||||
  echo Building static library $STATICLIB version $VER with $CC. | tee -a configure.log
 | 
			
		||||
else
 | 
			
		||||
  ALL="static shared"
 | 
			
		||||
  TEST="all teststatic testshared"
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
# check for underscores in external names for use by assembler code
 | 
			
		||||
CPP=${CPP-"$CC -E"}
 | 
			
		||||
case $CFLAGS in
 | 
			
		||||
  *ASMV*)
 | 
			
		||||
    echo >> configure.log
 | 
			
		||||
    show "$NM $test.o | grep _hello"
 | 
			
		||||
    if test "`$NM $test.o | grep _hello | tee -a configure.log`" = ""; then
 | 
			
		||||
      CPP="$CPP -DNO_UNDERLINE"
 | 
			
		||||
      echo Checking for underline in external names... No. | tee -a configure.log
 | 
			
		||||
    else
 | 
			
		||||
      echo Checking for underline in external names... Yes. | tee -a configure.log
 | 
			
		||||
    fi ;;
 | 
			
		||||
esac
 | 
			
		||||
 | 
			
		||||
echo >> configure.log
 | 
			
		||||
 | 
			
		||||
# check for size_t
 | 
			
		||||
cat > $test.c <<EOF
 | 
			
		||||
#include <stdio.h>
 | 
			
		||||
#include <stdlib.h>
 | 
			
		||||
size_t dummy = 0;
 | 
			
		||||
EOF
 | 
			
		||||
if try $CC -c $CFLAGS $test.c; then
 | 
			
		||||
  echo "Checking for size_t... Yes." | tee -a configure.log
 | 
			
		||||
  need_sizet=0
 | 
			
		||||
else
 | 
			
		||||
  echo "Checking for size_t... No." | tee -a configure.log
 | 
			
		||||
  need_sizet=1
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
echo >> configure.log
 | 
			
		||||
 | 
			
		||||
# find the size_t integer type, if needed
 | 
			
		||||
if test $need_sizet -eq 1; then
 | 
			
		||||
  cat > $test.c <<EOF
 | 
			
		||||
long long dummy = 0;
 | 
			
		||||
EOF
 | 
			
		||||
  if try $CC -c $CFLAGS $test.c; then
 | 
			
		||||
    echo "Checking for long long... Yes." | tee -a configure.log
 | 
			
		||||
    cat > $test.c <<EOF
 | 
			
		||||
#include <stdio.h>
 | 
			
		||||
int main(void) {
 | 
			
		||||
    if (sizeof(void *) <= sizeof(int)) puts("int");
 | 
			
		||||
    else if (sizeof(void *) <= sizeof(long)) puts("long");
 | 
			
		||||
    else puts("z_longlong");
 | 
			
		||||
    return 0;
 | 
			
		||||
}
 | 
			
		||||
EOF
 | 
			
		||||
  else
 | 
			
		||||
    echo "Checking for long long... No." | tee -a configure.log
 | 
			
		||||
    cat > $test.c <<EOF
 | 
			
		||||
#include <stdio.h>
 | 
			
		||||
int main(void) {
 | 
			
		||||
    if (sizeof(void *) <= sizeof(int)) puts("int");
 | 
			
		||||
    else puts("long");
 | 
			
		||||
    return 0;
 | 
			
		||||
}
 | 
			
		||||
EOF
 | 
			
		||||
  fi
 | 
			
		||||
  if try $CC $CFLAGS -o $test $test.c; then
 | 
			
		||||
    sizet=`./$test`
 | 
			
		||||
    echo "Checking for a pointer-size integer type..." $sizet"." | tee -a configure.log
 | 
			
		||||
  else
 | 
			
		||||
    echo "Failed to find a pointer-size integer type." | tee -a configure.log
 | 
			
		||||
    leave 1
 | 
			
		||||
  fi
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
if test $need_sizet -eq 1; then
 | 
			
		||||
  CFLAGS="${CFLAGS} -DNO_SIZE_T=${sizet}"
 | 
			
		||||
  SFLAGS="${SFLAGS} -DNO_SIZE_T=${sizet}"
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
echo >> configure.log
 | 
			
		||||
 | 
			
		||||
# check for large file support, and if none, check for fseeko()
 | 
			
		||||
cat > $test.c <<EOF
 | 
			
		||||
#include <sys/types.h>
 | 
			
		||||
off64_t dummy = 0;
 | 
			
		||||
EOF
 | 
			
		||||
if try $CC -c $CFLAGS -D_LARGEFILE64_SOURCE=1 $test.c; then
 | 
			
		||||
  CFLAGS="${CFLAGS} -D_LARGEFILE64_SOURCE=1"
 | 
			
		||||
  SFLAGS="${SFLAGS} -D_LARGEFILE64_SOURCE=1"
 | 
			
		||||
  ALL="${ALL} all64"
 | 
			
		||||
  TEST="${TEST} test64"
 | 
			
		||||
  echo "Checking for off64_t... Yes." | tee -a configure.log
 | 
			
		||||
  echo "Checking for fseeko... Yes." | tee -a configure.log
 | 
			
		||||
else
 | 
			
		||||
  echo "Checking for off64_t... No." | tee -a configure.log
 | 
			
		||||
  echo >> configure.log
 | 
			
		||||
  cat > $test.c <<EOF
 | 
			
		||||
#include <stdio.h>
 | 
			
		||||
int main(void) {
 | 
			
		||||
  fseeko(NULL, 0, 0);
 | 
			
		||||
  return 0;
 | 
			
		||||
}
 | 
			
		||||
EOF
 | 
			
		||||
  if try $CC $CFLAGS -o $test $test.c; then
 | 
			
		||||
    echo "Checking for fseeko... Yes." | tee -a configure.log
 | 
			
		||||
  else
 | 
			
		||||
    CFLAGS="${CFLAGS} -DNO_FSEEKO"
 | 
			
		||||
    SFLAGS="${SFLAGS} -DNO_FSEEKO"
 | 
			
		||||
    echo "Checking for fseeko... No." | tee -a configure.log
 | 
			
		||||
  fi
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
echo >> configure.log
 | 
			
		||||
 | 
			
		||||
# check for strerror() for use by gz* functions
 | 
			
		||||
cat > $test.c <<EOF
 | 
			
		||||
#include <string.h>
 | 
			
		||||
#include <errno.h>
 | 
			
		||||
int main() { return strlen(strerror(errno)); }
 | 
			
		||||
EOF
 | 
			
		||||
if try $CC $CFLAGS -o $test $test.c; then
 | 
			
		||||
  echo "Checking for strerror... Yes." | tee -a configure.log
 | 
			
		||||
else
 | 
			
		||||
  CFLAGS="${CFLAGS} -DNO_STRERROR"
 | 
			
		||||
  SFLAGS="${SFLAGS} -DNO_STRERROR"
 | 
			
		||||
  echo "Checking for strerror... No." | tee -a configure.log
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
# copy clean zconf.h for subsequent edits
 | 
			
		||||
cp -p ${SRCDIR}zconf.h.in zconf.h
 | 
			
		||||
 | 
			
		||||
echo >> configure.log
 | 
			
		||||
 | 
			
		||||
# check for unistd.h and save result in zconf.h
 | 
			
		||||
cat > $test.c <<EOF
 | 
			
		||||
#include <unistd.h>
 | 
			
		||||
int main() { return 0; }
 | 
			
		||||
EOF
 | 
			
		||||
if try $CC -c $CFLAGS $test.c; then
 | 
			
		||||
  sed < zconf.h "/^#ifdef HAVE_UNISTD_H.* may be/s/def HAVE_UNISTD_H\(.*\) may be/ 1\1 was/" > zconf.temp.h
 | 
			
		||||
  mv zconf.temp.h zconf.h
 | 
			
		||||
  echo "Checking for unistd.h... Yes." | tee -a configure.log
 | 
			
		||||
else
 | 
			
		||||
  echo "Checking for unistd.h... No." | tee -a configure.log
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
echo >> configure.log
 | 
			
		||||
 | 
			
		||||
# check for stdarg.h and save result in zconf.h
 | 
			
		||||
cat > $test.c <<EOF
 | 
			
		||||
#include <stdarg.h>
 | 
			
		||||
int main() { return 0; }
 | 
			
		||||
EOF
 | 
			
		||||
if try $CC -c $CFLAGS $test.c; then
 | 
			
		||||
  sed < zconf.h "/^#ifdef HAVE_STDARG_H.* may be/s/def HAVE_STDARG_H\(.*\) may be/ 1\1 was/" > zconf.temp.h
 | 
			
		||||
  mv zconf.temp.h zconf.h
 | 
			
		||||
  echo "Checking for stdarg.h... Yes." | tee -a configure.log
 | 
			
		||||
else
 | 
			
		||||
  echo "Checking for stdarg.h... No." | tee -a configure.log
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
# if the z_ prefix was requested, save that in zconf.h
 | 
			
		||||
if test $zprefix -eq 1; then
 | 
			
		||||
  sed < zconf.h "/#ifdef Z_PREFIX.* may be/s/def Z_PREFIX\(.*\) may be/ 1\1 was/" > zconf.temp.h
 | 
			
		||||
  mv zconf.temp.h zconf.h
 | 
			
		||||
  echo >> configure.log
 | 
			
		||||
  echo "Using z_ prefix on all symbols." | tee -a configure.log
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
# if --solo compilation was requested, save that in zconf.h and remove gz stuff from object lists
 | 
			
		||||
if test $solo -eq 1; then
 | 
			
		||||
  sed '/#define ZCONF_H/a\
 | 
			
		||||
#define Z_SOLO
 | 
			
		||||
 | 
			
		||||
' < zconf.h > zconf.temp.h
 | 
			
		||||
  mv zconf.temp.h zconf.h
 | 
			
		||||
OBJC='$(OBJZ)'
 | 
			
		||||
PIC_OBJC='$(PIC_OBJZ)'
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
# if code coverage testing was requested, use older gcc if defined, e.g. "gcc-4.2" on Mac OS X
 | 
			
		||||
if test $cover -eq 1; then
 | 
			
		||||
  CFLAGS="${CFLAGS} -fprofile-arcs -ftest-coverage"
 | 
			
		||||
  if test -n "$GCC_CLASSIC"; then
 | 
			
		||||
    CC=$GCC_CLASSIC
 | 
			
		||||
  fi
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
echo >> configure.log
 | 
			
		||||
 | 
			
		||||
# conduct a series of tests to resolve eight possible cases of using "vs" or "s" printf functions
 | 
			
		||||
# (using stdarg or not), with or without "n" (proving size of buffer), and with or without a
 | 
			
		||||
# return value.  The most secure result is vsnprintf() with a return value.  snprintf() with a
 | 
			
		||||
# return value is secure as well, but then gzprintf() will be limited to 20 arguments.
 | 
			
		||||
cat > $test.c <<EOF
 | 
			
		||||
#include <stdio.h>
 | 
			
		||||
#include <stdarg.h>
 | 
			
		||||
#include "zconf.h"
 | 
			
		||||
int main()
 | 
			
		||||
{
 | 
			
		||||
#ifndef STDC
 | 
			
		||||
  choke me
 | 
			
		||||
#endif
 | 
			
		||||
  return 0;
 | 
			
		||||
}
 | 
			
		||||
EOF
 | 
			
		||||
if try $CC -c $CFLAGS $test.c; then
 | 
			
		||||
  echo "Checking whether to use vs[n]printf() or s[n]printf()... using vs[n]printf()." | tee -a configure.log
 | 
			
		||||
 | 
			
		||||
  echo >> configure.log
 | 
			
		||||
  cat > $test.c <<EOF
 | 
			
		||||
#include <stdio.h>
 | 
			
		||||
#include <stdarg.h>
 | 
			
		||||
int mytest(const char *fmt, ...)
 | 
			
		||||
{
 | 
			
		||||
  char buf[20];
 | 
			
		||||
  va_list ap;
 | 
			
		||||
  va_start(ap, fmt);
 | 
			
		||||
  vsnprintf(buf, sizeof(buf), fmt, ap);
 | 
			
		||||
  va_end(ap);
 | 
			
		||||
  return 0;
 | 
			
		||||
}
 | 
			
		||||
int main()
 | 
			
		||||
{
 | 
			
		||||
  return (mytest("Hello%d\n", 1));
 | 
			
		||||
}
 | 
			
		||||
EOF
 | 
			
		||||
  if try $CC $CFLAGS -o $test $test.c; then
 | 
			
		||||
    echo "Checking for vsnprintf() in stdio.h... Yes." | tee -a configure.log
 | 
			
		||||
 | 
			
		||||
    echo >> configure.log
 | 
			
		||||
    cat >$test.c <<EOF
 | 
			
		||||
#include <stdio.h>
 | 
			
		||||
#include <stdarg.h>
 | 
			
		||||
int mytest(const char *fmt, ...)
 | 
			
		||||
{
 | 
			
		||||
  int n;
 | 
			
		||||
  char buf[20];
 | 
			
		||||
  va_list ap;
 | 
			
		||||
  va_start(ap, fmt);
 | 
			
		||||
  n = vsnprintf(buf, sizeof(buf), fmt, ap);
 | 
			
		||||
  va_end(ap);
 | 
			
		||||
  return n;
 | 
			
		||||
}
 | 
			
		||||
int main()
 | 
			
		||||
{
 | 
			
		||||
  return (mytest("Hello%d\n", 1));
 | 
			
		||||
}
 | 
			
		||||
EOF
 | 
			
		||||
 | 
			
		||||
    if try $CC -c $CFLAGS $test.c; then
 | 
			
		||||
      echo "Checking for return value of vsnprintf()... Yes." | tee -a configure.log
 | 
			
		||||
    else
 | 
			
		||||
      CFLAGS="$CFLAGS -DHAS_vsnprintf_void"
 | 
			
		||||
      SFLAGS="$SFLAGS -DHAS_vsnprintf_void"
 | 
			
		||||
      echo "Checking for return value of vsnprintf()... No." | tee -a configure.log
 | 
			
		||||
      echo "  WARNING: apparently vsnprintf() does not return a value. zlib" | tee -a configure.log
 | 
			
		||||
      echo "  can build but will be open to possible string-format security" | tee -a configure.log
 | 
			
		||||
      echo "  vulnerabilities." | tee -a configure.log
 | 
			
		||||
    fi
 | 
			
		||||
  else
 | 
			
		||||
    CFLAGS="$CFLAGS -DNO_vsnprintf"
 | 
			
		||||
    SFLAGS="$SFLAGS -DNO_vsnprintf"
 | 
			
		||||
    echo "Checking for vsnprintf() in stdio.h... No." | tee -a configure.log
 | 
			
		||||
    echo "  WARNING: vsnprintf() not found, falling back to vsprintf(). zlib" | tee -a configure.log
 | 
			
		||||
    echo "  can build but will be open to possible buffer-overflow security" | tee -a configure.log
 | 
			
		||||
    echo "  vulnerabilities." | tee -a configure.log
 | 
			
		||||
 | 
			
		||||
    echo >> configure.log
 | 
			
		||||
    cat >$test.c <<EOF
 | 
			
		||||
#include <stdio.h>
 | 
			
		||||
#include <stdarg.h>
 | 
			
		||||
int mytest(const char *fmt, ...)
 | 
			
		||||
{
 | 
			
		||||
  int n;
 | 
			
		||||
  char buf[20];
 | 
			
		||||
  va_list ap;
 | 
			
		||||
  va_start(ap, fmt);
 | 
			
		||||
  n = vsprintf(buf, fmt, ap);
 | 
			
		||||
  va_end(ap);
 | 
			
		||||
  return n;
 | 
			
		||||
}
 | 
			
		||||
int main()
 | 
			
		||||
{
 | 
			
		||||
  return (mytest("Hello%d\n", 1));
 | 
			
		||||
}
 | 
			
		||||
EOF
 | 
			
		||||
 | 
			
		||||
    if try $CC -c $CFLAGS $test.c; then
 | 
			
		||||
      echo "Checking for return value of vsprintf()... Yes." | tee -a configure.log
 | 
			
		||||
    else
 | 
			
		||||
      CFLAGS="$CFLAGS -DHAS_vsprintf_void"
 | 
			
		||||
      SFLAGS="$SFLAGS -DHAS_vsprintf_void"
 | 
			
		||||
      echo "Checking for return value of vsprintf()... No." | tee -a configure.log
 | 
			
		||||
      echo "  WARNING: apparently vsprintf() does not return a value. zlib" | tee -a configure.log
 | 
			
		||||
      echo "  can build but will be open to possible string-format security" | tee -a configure.log
 | 
			
		||||
      echo "  vulnerabilities." | tee -a configure.log
 | 
			
		||||
    fi
 | 
			
		||||
  fi
 | 
			
		||||
else
 | 
			
		||||
  echo "Checking whether to use vs[n]printf() or s[n]printf()... using s[n]printf()." | tee -a configure.log
 | 
			
		||||
 | 
			
		||||
  echo >> configure.log
 | 
			
		||||
  cat >$test.c <<EOF
 | 
			
		||||
#include <stdio.h>
 | 
			
		||||
int mytest()
 | 
			
		||||
{
 | 
			
		||||
  char buf[20];
 | 
			
		||||
  snprintf(buf, sizeof(buf), "%s", "foo");
 | 
			
		||||
  return 0;
 | 
			
		||||
}
 | 
			
		||||
int main()
 | 
			
		||||
{
 | 
			
		||||
  return (mytest());
 | 
			
		||||
}
 | 
			
		||||
EOF
 | 
			
		||||
 | 
			
		||||
  if try $CC $CFLAGS -o $test $test.c; then
 | 
			
		||||
    echo "Checking for snprintf() in stdio.h... Yes." | tee -a configure.log
 | 
			
		||||
 | 
			
		||||
    echo >> configure.log
 | 
			
		||||
    cat >$test.c <<EOF
 | 
			
		||||
#include <stdio.h>
 | 
			
		||||
int mytest()
 | 
			
		||||
{
 | 
			
		||||
  char buf[20];
 | 
			
		||||
  return snprintf(buf, sizeof(buf), "%s", "foo");
 | 
			
		||||
}
 | 
			
		||||
int main()
 | 
			
		||||
{
 | 
			
		||||
  return (mytest());
 | 
			
		||||
}
 | 
			
		||||
EOF
 | 
			
		||||
 | 
			
		||||
    if try $CC -c $CFLAGS $test.c; then
 | 
			
		||||
      echo "Checking for return value of snprintf()... Yes." | tee -a configure.log
 | 
			
		||||
    else
 | 
			
		||||
      CFLAGS="$CFLAGS -DHAS_snprintf_void"
 | 
			
		||||
      SFLAGS="$SFLAGS -DHAS_snprintf_void"
 | 
			
		||||
      echo "Checking for return value of snprintf()... No." | tee -a configure.log
 | 
			
		||||
      echo "  WARNING: apparently snprintf() does not return a value. zlib" | tee -a configure.log
 | 
			
		||||
      echo "  can build but will be open to possible string-format security" | tee -a configure.log
 | 
			
		||||
      echo "  vulnerabilities." | tee -a configure.log
 | 
			
		||||
    fi
 | 
			
		||||
  else
 | 
			
		||||
    CFLAGS="$CFLAGS -DNO_snprintf"
 | 
			
		||||
    SFLAGS="$SFLAGS -DNO_snprintf"
 | 
			
		||||
    echo "Checking for snprintf() in stdio.h... No." | tee -a configure.log
 | 
			
		||||
    echo "  WARNING: snprintf() not found, falling back to sprintf(). zlib" | tee -a configure.log
 | 
			
		||||
    echo "  can build but will be open to possible buffer-overflow security" | tee -a configure.log
 | 
			
		||||
    echo "  vulnerabilities." | tee -a configure.log
 | 
			
		||||
 | 
			
		||||
    echo >> configure.log
 | 
			
		||||
    cat >$test.c <<EOF
 | 
			
		||||
#include <stdio.h>
 | 
			
		||||
int mytest()
 | 
			
		||||
{
 | 
			
		||||
  char buf[20];
 | 
			
		||||
  return sprintf(buf, "%s", "foo");
 | 
			
		||||
}
 | 
			
		||||
int main()
 | 
			
		||||
{
 | 
			
		||||
  return (mytest());
 | 
			
		||||
}
 | 
			
		||||
EOF
 | 
			
		||||
 | 
			
		||||
    if try $CC -c $CFLAGS $test.c; then
 | 
			
		||||
      echo "Checking for return value of sprintf()... Yes." | tee -a configure.log
 | 
			
		||||
    else
 | 
			
		||||
      CFLAGS="$CFLAGS -DHAS_sprintf_void"
 | 
			
		||||
      SFLAGS="$SFLAGS -DHAS_sprintf_void"
 | 
			
		||||
      echo "Checking for return value of sprintf()... No." | tee -a configure.log
 | 
			
		||||
      echo "  WARNING: apparently sprintf() does not return a value. zlib" | tee -a configure.log
 | 
			
		||||
      echo "  can build but will be open to possible string-format security" | tee -a configure.log
 | 
			
		||||
      echo "  vulnerabilities." | tee -a configure.log
 | 
			
		||||
    fi
 | 
			
		||||
  fi
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
# see if we can hide zlib internal symbols that are linked between separate source files
 | 
			
		||||
if test "$gcc" -eq 1; then
 | 
			
		||||
  echo >> configure.log
 | 
			
		||||
  cat > $test.c <<EOF
 | 
			
		||||
#define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
 | 
			
		||||
int ZLIB_INTERNAL foo;
 | 
			
		||||
int main()
 | 
			
		||||
{
 | 
			
		||||
  return 0;
 | 
			
		||||
}
 | 
			
		||||
EOF
 | 
			
		||||
  if tryboth $CC -c $CFLAGS $test.c; then
 | 
			
		||||
    CFLAGS="$CFLAGS -DHAVE_HIDDEN"
 | 
			
		||||
    SFLAGS="$SFLAGS -DHAVE_HIDDEN"
 | 
			
		||||
    echo "Checking for attribute(visibility) support... Yes." | tee -a configure.log
 | 
			
		||||
  else
 | 
			
		||||
    echo "Checking for attribute(visibility) support... No." | tee -a configure.log
 | 
			
		||||
  fi
 | 
			
		||||
fi
 | 
			
		||||
 | 
			
		||||
# show the results in the log
 | 
			
		||||
echo >> configure.log
 | 
			
		||||
echo ALL = $ALL >> configure.log
 | 
			
		||||
echo AR = $AR >> configure.log
 | 
			
		||||
echo ARFLAGS = $ARFLAGS >> configure.log
 | 
			
		||||
echo CC = $CC >> configure.log
 | 
			
		||||
echo CFLAGS = $CFLAGS >> configure.log
 | 
			
		||||
echo CPP = $CPP >> configure.log
 | 
			
		||||
echo EXE = $EXE >> configure.log
 | 
			
		||||
echo LDCONFIG = $LDCONFIG >> configure.log
 | 
			
		||||
echo LDFLAGS = $LDFLAGS >> configure.log
 | 
			
		||||
echo LDSHARED = $LDSHARED >> configure.log
 | 
			
		||||
echo LDSHAREDLIBC = $LDSHAREDLIBC >> configure.log
 | 
			
		||||
echo OBJC = $OBJC >> configure.log
 | 
			
		||||
echo PIC_OBJC = $PIC_OBJC >> configure.log
 | 
			
		||||
echo RANLIB = $RANLIB >> configure.log
 | 
			
		||||
echo SFLAGS = $SFLAGS >> configure.log
 | 
			
		||||
echo SHAREDLIB = $SHAREDLIB >> configure.log
 | 
			
		||||
echo SHAREDLIBM = $SHAREDLIBM >> configure.log
 | 
			
		||||
echo SHAREDLIBV = $SHAREDLIBV >> configure.log
 | 
			
		||||
echo STATICLIB = $STATICLIB >> configure.log
 | 
			
		||||
echo TEST = $TEST >> configure.log
 | 
			
		||||
echo VER = $VER >> configure.log
 | 
			
		||||
echo Z_U4 = $Z_U4 >> configure.log
 | 
			
		||||
echo SRCDIR = $SRCDIR >> configure.log
 | 
			
		||||
echo exec_prefix = $exec_prefix >> configure.log
 | 
			
		||||
echo includedir = $includedir >> configure.log
 | 
			
		||||
echo libdir = $libdir >> configure.log
 | 
			
		||||
echo mandir = $mandir >> configure.log
 | 
			
		||||
echo prefix = $prefix >> configure.log
 | 
			
		||||
echo sharedlibdir = $sharedlibdir >> configure.log
 | 
			
		||||
echo uname = $uname >> configure.log
 | 
			
		||||
 | 
			
		||||
# udpate Makefile with the configure results
 | 
			
		||||
sed < ${SRCDIR}Makefile.in "
 | 
			
		||||
/^CC *=/s#=.*#=$CC#
 | 
			
		||||
/^CFLAGS *=/s#=.*#=$CFLAGS#
 | 
			
		||||
/^SFLAGS *=/s#=.*#=$SFLAGS#
 | 
			
		||||
/^LDFLAGS *=/s#=.*#=$LDFLAGS#
 | 
			
		||||
/^LDSHARED *=/s#=.*#=$LDSHARED#
 | 
			
		||||
/^CPP *=/s#=.*#=$CPP#
 | 
			
		||||
/^STATICLIB *=/s#=.*#=$STATICLIB#
 | 
			
		||||
/^SHAREDLIB *=/s#=.*#=$SHAREDLIB#
 | 
			
		||||
/^SHAREDLIBV *=/s#=.*#=$SHAREDLIBV#
 | 
			
		||||
/^SHAREDLIBM *=/s#=.*#=$SHAREDLIBM#
 | 
			
		||||
/^AR *=/s#=.*#=$AR#
 | 
			
		||||
/^ARFLAGS *=/s#=.*#=$ARFLAGS#
 | 
			
		||||
/^RANLIB *=/s#=.*#=$RANLIB#
 | 
			
		||||
/^LDCONFIG *=/s#=.*#=$LDCONFIG#
 | 
			
		||||
/^LDSHAREDLIBC *=/s#=.*#=$LDSHAREDLIBC#
 | 
			
		||||
/^EXE *=/s#=.*#=$EXE#
 | 
			
		||||
/^SRCDIR *=/s#=.*#=$SRCDIR#
 | 
			
		||||
/^ZINC *=/s#=.*#=$ZINC#
 | 
			
		||||
/^ZINCOUT *=/s#=.*#=$ZINCOUT#
 | 
			
		||||
/^prefix *=/s#=.*#=$prefix#
 | 
			
		||||
/^exec_prefix *=/s#=.*#=$exec_prefix#
 | 
			
		||||
/^libdir *=/s#=.*#=$libdir#
 | 
			
		||||
/^sharedlibdir *=/s#=.*#=$sharedlibdir#
 | 
			
		||||
/^includedir *=/s#=.*#=$includedir#
 | 
			
		||||
/^mandir *=/s#=.*#=$mandir#
 | 
			
		||||
/^OBJC *=/s#=.*#= $OBJC#
 | 
			
		||||
/^PIC_OBJC *=/s#=.*#= $PIC_OBJC#
 | 
			
		||||
/^all: */s#:.*#: $ALL#
 | 
			
		||||
/^test: */s#:.*#: $TEST#
 | 
			
		||||
" > Makefile
 | 
			
		||||
 | 
			
		||||
# create zlib.pc with the configure results
 | 
			
		||||
sed < ${SRCDIR}zlib.pc.in "
 | 
			
		||||
/^CC *=/s#=.*#=$CC#
 | 
			
		||||
/^CFLAGS *=/s#=.*#=$CFLAGS#
 | 
			
		||||
/^CPP *=/s#=.*#=$CPP#
 | 
			
		||||
/^LDSHARED *=/s#=.*#=$LDSHARED#
 | 
			
		||||
/^STATICLIB *=/s#=.*#=$STATICLIB#
 | 
			
		||||
/^SHAREDLIB *=/s#=.*#=$SHAREDLIB#
 | 
			
		||||
/^SHAREDLIBV *=/s#=.*#=$SHAREDLIBV#
 | 
			
		||||
/^SHAREDLIBM *=/s#=.*#=$SHAREDLIBM#
 | 
			
		||||
/^AR *=/s#=.*#=$AR#
 | 
			
		||||
/^ARFLAGS *=/s#=.*#=$ARFLAGS#
 | 
			
		||||
/^RANLIB *=/s#=.*#=$RANLIB#
 | 
			
		||||
/^EXE *=/s#=.*#=$EXE#
 | 
			
		||||
/^prefix *=/s#=.*#=$prefix#
 | 
			
		||||
/^exec_prefix *=/s#=.*#=$exec_prefix#
 | 
			
		||||
/^libdir *=/s#=.*#=$libdir#
 | 
			
		||||
/^sharedlibdir *=/s#=.*#=$sharedlibdir#
 | 
			
		||||
/^includedir *=/s#=.*#=$includedir#
 | 
			
		||||
/^mandir *=/s#=.*#=$mandir#
 | 
			
		||||
/^LDFLAGS *=/s#=.*#=$LDFLAGS#
 | 
			
		||||
" | sed -e "
 | 
			
		||||
s/\@VERSION\@/$VER/g;
 | 
			
		||||
" > zlib.pc
 | 
			
		||||
 | 
			
		||||
# done
 | 
			
		||||
leave 0
 | 
			
		||||
							
								
								
									
										78
									
								
								third_party/zlib/contrib/README.contrib
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										78
									
								
								third_party/zlib/contrib/README.contrib
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,78 @@
 | 
			
		||||
All files under this contrib directory are UNSUPPORTED. There were
 | 
			
		||||
provided by users of zlib and were not tested by the authors of zlib.
 | 
			
		||||
Use at your own risk. Please contact the authors of the contributions
 | 
			
		||||
for help about these, not the zlib authors. Thanks.
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
ada/        by Dmitriy Anisimkov <anisimkov@yahoo.com>
 | 
			
		||||
        Support for Ada
 | 
			
		||||
        See http://zlib-ada.sourceforge.net/
 | 
			
		||||
 | 
			
		||||
amd64/      by Mikhail Teterin <mi@ALDAN.algebra.com>
 | 
			
		||||
        asm code for AMD64
 | 
			
		||||
        See patch at http://www.freebsd.org/cgi/query-pr.cgi?pr=bin/96393
 | 
			
		||||
 | 
			
		||||
asm686/     by Brian Raiter <breadbox@muppetlabs.com>
 | 
			
		||||
        asm code for Pentium and PPro/PII, using the AT&T (GNU as) syntax
 | 
			
		||||
        See http://www.muppetlabs.com/~breadbox/software/assembly.html
 | 
			
		||||
 | 
			
		||||
blast/      by Mark Adler <madler@alumni.caltech.edu>
 | 
			
		||||
        Decompressor for output of PKWare Data Compression Library (DCL)
 | 
			
		||||
 | 
			
		||||
delphi/     by Cosmin Truta <cosmint@cs.ubbcluj.ro>
 | 
			
		||||
        Support for Delphi and C++ Builder
 | 
			
		||||
 | 
			
		||||
dotzlib/    by Henrik Ravn <henrik@ravn.com>
 | 
			
		||||
        Support for Microsoft .Net and Visual C++ .Net
 | 
			
		||||
 | 
			
		||||
gcc_gvmat64/by Gilles Vollant <info@winimage.com>
 | 
			
		||||
        GCC Version of x86 64-bit (AMD64 and Intel EM64t) code for x64
 | 
			
		||||
        assembler to replace longest_match() and inflate_fast()
 | 
			
		||||
 | 
			
		||||
infback9/   by Mark Adler <madler@alumni.caltech.edu>
 | 
			
		||||
        Unsupported diffs to infback to decode the deflate64 format
 | 
			
		||||
 | 
			
		||||
inflate86/  by Chris Anderson <christop@charm.net>
 | 
			
		||||
        Tuned x86 gcc asm code to replace inflate_fast()
 | 
			
		||||
 | 
			
		||||
iostream/   by Kevin Ruland <kevin@rodin.wustl.edu>
 | 
			
		||||
        A C++ I/O streams interface to the zlib gz* functions
 | 
			
		||||
 | 
			
		||||
iostream2/  by Tyge Løvset <Tyge.Lovset@cmr.no>
 | 
			
		||||
        Another C++ I/O streams interface
 | 
			
		||||
 | 
			
		||||
iostream3/  by Ludwig Schwardt <schwardt@sun.ac.za>
 | 
			
		||||
            and Kevin Ruland <kevin@rodin.wustl.edu>
 | 
			
		||||
        Yet another C++ I/O streams interface
 | 
			
		||||
 | 
			
		||||
masmx64/    by Gilles Vollant <info@winimage.com>
 | 
			
		||||
        x86 64-bit (AMD64 and Intel EM64t) code for x64 assembler to
 | 
			
		||||
        replace longest_match() and inflate_fast(),  also masm x86
 | 
			
		||||
        64-bits translation of Chris Anderson inflate_fast()
 | 
			
		||||
 | 
			
		||||
masmx86/    by Gilles Vollant <info@winimage.com>
 | 
			
		||||
        x86 asm code to replace longest_match() and inflate_fast(),
 | 
			
		||||
        for Visual C++ and MASM (32 bits).
 | 
			
		||||
        Based on Brian Raiter (asm686) and Chris Anderson (inflate86)
 | 
			
		||||
 | 
			
		||||
minizip/    by Gilles Vollant <info@winimage.com>
 | 
			
		||||
        Mini zip and unzip based on zlib
 | 
			
		||||
        Includes Zip64 support by Mathias Svensson <mathias@result42.com>
 | 
			
		||||
        See http://www.winimage.com/zLibDll/minizip.html
 | 
			
		||||
 | 
			
		||||
pascal/     by Bob Dellaca <bobdl@xtra.co.nz> et al.
 | 
			
		||||
        Support for Pascal
 | 
			
		||||
 | 
			
		||||
puff/       by Mark Adler <madler@alumni.caltech.edu>
 | 
			
		||||
        Small, low memory usage inflate.  Also serves to provide an
 | 
			
		||||
        unambiguous description of the deflate format.
 | 
			
		||||
 | 
			
		||||
testzlib/   by Gilles Vollant <info@winimage.com>
 | 
			
		||||
        Example of the use of zlib
 | 
			
		||||
 | 
			
		||||
untgz/      by Pedro A. Aranda Gutierrez <paag@tid.es>
 | 
			
		||||
        A very simple tar.gz file extractor using zlib
 | 
			
		||||
 | 
			
		||||
vstudio/    by Gilles Vollant <info@winimage.com>
 | 
			
		||||
        Building a minizip-enhanced zlib with Microsoft Visual Studio
 | 
			
		||||
        Includes vc11 from kreuzerkrieg and vc12 from davispuh
 | 
			
		||||
							
								
								
									
										106
									
								
								third_party/zlib/contrib/ada/buffer_demo.adb
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										106
									
								
								third_party/zlib/contrib/ada/buffer_demo.adb
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,106 @@
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
--  ZLib for Ada thick binding.                               --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Copyright (C) 2002-2004 Dmitriy Anisimkov                 --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Open source license information is in the zlib.ads file.  --
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
--
 | 
			
		||||
--  $Id: buffer_demo.adb,v 1.3 2004/09/06 06:55:35 vagul Exp $
 | 
			
		||||
 | 
			
		||||
--  This demo program provided by Dr Steve Sangwine <sjs@essex.ac.uk>
 | 
			
		||||
--
 | 
			
		||||
--  Demonstration of a problem with Zlib-Ada (already fixed) when a buffer
 | 
			
		||||
--  of exactly the correct size is used for decompressed data, and the last
 | 
			
		||||
--  few bytes passed in to Zlib are checksum bytes.
 | 
			
		||||
 | 
			
		||||
--  This program compresses a string of text, and then decompresses the
 | 
			
		||||
--  compressed text into a buffer of the same size as the original text.
 | 
			
		||||
 | 
			
		||||
with Ada.Streams; use Ada.Streams;
 | 
			
		||||
with Ada.Text_IO;
 | 
			
		||||
 | 
			
		||||
with ZLib; use ZLib;
 | 
			
		||||
 | 
			
		||||
procedure Buffer_Demo is
 | 
			
		||||
   EOL  : Character renames ASCII.LF;
 | 
			
		||||
   Text : constant String
 | 
			
		||||
     := "Four score and seven years ago our fathers brought forth," & EOL &
 | 
			
		||||
        "upon this continent, a new nation, conceived in liberty," & EOL &
 | 
			
		||||
        "and dedicated to the proposition that `all men are created equal'.";
 | 
			
		||||
 | 
			
		||||
   Source : Stream_Element_Array (1 .. Text'Length);
 | 
			
		||||
   for Source'Address use Text'Address;
 | 
			
		||||
 | 
			
		||||
begin
 | 
			
		||||
   Ada.Text_IO.Put (Text);
 | 
			
		||||
   Ada.Text_IO.New_Line;
 | 
			
		||||
   Ada.Text_IO.Put_Line
 | 
			
		||||
     ("Uncompressed size : " & Positive'Image (Text'Length) & " bytes");
 | 
			
		||||
 | 
			
		||||
   declare
 | 
			
		||||
      Compressed_Data : Stream_Element_Array (1 .. Text'Length);
 | 
			
		||||
      L               : Stream_Element_Offset;
 | 
			
		||||
   begin
 | 
			
		||||
      Compress : declare
 | 
			
		||||
         Compressor : Filter_Type;
 | 
			
		||||
         I : Stream_Element_Offset;
 | 
			
		||||
      begin
 | 
			
		||||
         Deflate_Init (Compressor);
 | 
			
		||||
 | 
			
		||||
         --  Compress the whole of T at once.
 | 
			
		||||
 | 
			
		||||
         Translate (Compressor, Source, I, Compressed_Data, L, Finish);
 | 
			
		||||
         pragma Assert (I = Source'Last);
 | 
			
		||||
 | 
			
		||||
         Close (Compressor);
 | 
			
		||||
 | 
			
		||||
         Ada.Text_IO.Put_Line
 | 
			
		||||
           ("Compressed size :   "
 | 
			
		||||
            & Stream_Element_Offset'Image (L) & " bytes");
 | 
			
		||||
      end Compress;
 | 
			
		||||
 | 
			
		||||
      --  Now we decompress the data, passing short blocks of data to Zlib
 | 
			
		||||
      --  (because this demonstrates the problem - the last block passed will
 | 
			
		||||
      --  contain checksum information and there will be no output, only a
 | 
			
		||||
      --  check inside Zlib that the checksum is correct).
 | 
			
		||||
 | 
			
		||||
      Decompress : declare
 | 
			
		||||
         Decompressor : Filter_Type;
 | 
			
		||||
 | 
			
		||||
         Uncompressed_Data : Stream_Element_Array (1 .. Text'Length);
 | 
			
		||||
 | 
			
		||||
         Block_Size : constant := 4;
 | 
			
		||||
         --  This makes sure that the last block contains
 | 
			
		||||
         --  only Adler checksum data.
 | 
			
		||||
 | 
			
		||||
         P : Stream_Element_Offset := Compressed_Data'First - 1;
 | 
			
		||||
         O : Stream_Element_Offset;
 | 
			
		||||
      begin
 | 
			
		||||
         Inflate_Init (Decompressor);
 | 
			
		||||
 | 
			
		||||
         loop
 | 
			
		||||
            Translate
 | 
			
		||||
              (Decompressor,
 | 
			
		||||
               Compressed_Data
 | 
			
		||||
                 (P + 1 .. Stream_Element_Offset'Min (P + Block_Size, L)),
 | 
			
		||||
               P,
 | 
			
		||||
               Uncompressed_Data
 | 
			
		||||
                 (Total_Out (Decompressor) + 1 .. Uncompressed_Data'Last),
 | 
			
		||||
               O,
 | 
			
		||||
               No_Flush);
 | 
			
		||||
 | 
			
		||||
               Ada.Text_IO.Put_Line
 | 
			
		||||
                 ("Total in : " & Count'Image (Total_In (Decompressor)) &
 | 
			
		||||
                  ", out : " & Count'Image (Total_Out (Decompressor)));
 | 
			
		||||
 | 
			
		||||
               exit when P = L;
 | 
			
		||||
         end loop;
 | 
			
		||||
 | 
			
		||||
         Ada.Text_IO.New_Line;
 | 
			
		||||
         Ada.Text_IO.Put_Line
 | 
			
		||||
           ("Decompressed text matches original text : "
 | 
			
		||||
             & Boolean'Image (Uncompressed_Data = Source));
 | 
			
		||||
      end Decompress;
 | 
			
		||||
   end;
 | 
			
		||||
end Buffer_Demo;
 | 
			
		||||
							
								
								
									
										156
									
								
								third_party/zlib/contrib/ada/mtest.adb
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										156
									
								
								third_party/zlib/contrib/ada/mtest.adb
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,156 @@
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
--  ZLib for Ada thick binding.                               --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Copyright (C) 2002-2003 Dmitriy Anisimkov                 --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Open source license information is in the zlib.ads file.  --
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
--  Continuous test for ZLib multithreading. If the test would fail
 | 
			
		||||
--  we should provide thread safe allocation routines for the Z_Stream.
 | 
			
		||||
--
 | 
			
		||||
--  $Id: mtest.adb,v 1.4 2004/07/23 07:49:54 vagul Exp $
 | 
			
		||||
 | 
			
		||||
with ZLib;
 | 
			
		||||
with Ada.Streams;
 | 
			
		||||
with Ada.Numerics.Discrete_Random;
 | 
			
		||||
with Ada.Text_IO;
 | 
			
		||||
with Ada.Exceptions;
 | 
			
		||||
with Ada.Task_Identification;
 | 
			
		||||
 | 
			
		||||
procedure MTest is
 | 
			
		||||
   use Ada.Streams;
 | 
			
		||||
   use ZLib;
 | 
			
		||||
 | 
			
		||||
   Stop : Boolean := False;
 | 
			
		||||
 | 
			
		||||
   pragma Atomic (Stop);
 | 
			
		||||
 | 
			
		||||
   subtype Visible_Symbols is Stream_Element range 16#20# .. 16#7E#;
 | 
			
		||||
 | 
			
		||||
   package Random_Elements is
 | 
			
		||||
      new Ada.Numerics.Discrete_Random (Visible_Symbols);
 | 
			
		||||
 | 
			
		||||
   task type Test_Task;
 | 
			
		||||
 | 
			
		||||
   task body Test_Task is
 | 
			
		||||
      Buffer : Stream_Element_Array (1 .. 100_000);
 | 
			
		||||
      Gen : Random_Elements.Generator;
 | 
			
		||||
 | 
			
		||||
      Buffer_First  : Stream_Element_Offset;
 | 
			
		||||
      Compare_First : Stream_Element_Offset;
 | 
			
		||||
 | 
			
		||||
      Deflate : Filter_Type;
 | 
			
		||||
      Inflate : Filter_Type;
 | 
			
		||||
 | 
			
		||||
      procedure Further (Item : in Stream_Element_Array);
 | 
			
		||||
 | 
			
		||||
      procedure Read_Buffer
 | 
			
		||||
        (Item : out Ada.Streams.Stream_Element_Array;
 | 
			
		||||
         Last : out Ada.Streams.Stream_Element_Offset);
 | 
			
		||||
 | 
			
		||||
      -------------
 | 
			
		||||
      -- Further --
 | 
			
		||||
      -------------
 | 
			
		||||
 | 
			
		||||
      procedure Further (Item : in Stream_Element_Array) is
 | 
			
		||||
 | 
			
		||||
         procedure Compare (Item : in Stream_Element_Array);
 | 
			
		||||
 | 
			
		||||
         -------------
 | 
			
		||||
         -- Compare --
 | 
			
		||||
         -------------
 | 
			
		||||
 | 
			
		||||
         procedure Compare (Item : in Stream_Element_Array) is
 | 
			
		||||
            Next_First : Stream_Element_Offset := Compare_First + Item'Length;
 | 
			
		||||
         begin
 | 
			
		||||
            if Buffer (Compare_First .. Next_First - 1) /= Item then
 | 
			
		||||
               raise Program_Error;
 | 
			
		||||
            end if;
 | 
			
		||||
 | 
			
		||||
            Compare_First := Next_First;
 | 
			
		||||
         end Compare;
 | 
			
		||||
 | 
			
		||||
         procedure Compare_Write is new ZLib.Write (Write => Compare);
 | 
			
		||||
      begin
 | 
			
		||||
         Compare_Write (Inflate, Item, No_Flush);
 | 
			
		||||
      end Further;
 | 
			
		||||
 | 
			
		||||
      -----------------
 | 
			
		||||
      -- Read_Buffer --
 | 
			
		||||
      -----------------
 | 
			
		||||
 | 
			
		||||
      procedure Read_Buffer
 | 
			
		||||
        (Item : out Ada.Streams.Stream_Element_Array;
 | 
			
		||||
         Last : out Ada.Streams.Stream_Element_Offset)
 | 
			
		||||
      is
 | 
			
		||||
         Buff_Diff   : Stream_Element_Offset := Buffer'Last - Buffer_First;
 | 
			
		||||
         Next_First : Stream_Element_Offset;
 | 
			
		||||
      begin
 | 
			
		||||
         if Item'Length <= Buff_Diff then
 | 
			
		||||
            Last := Item'Last;
 | 
			
		||||
 | 
			
		||||
            Next_First := Buffer_First + Item'Length;
 | 
			
		||||
 | 
			
		||||
            Item := Buffer (Buffer_First .. Next_First - 1);
 | 
			
		||||
 | 
			
		||||
            Buffer_First := Next_First;
 | 
			
		||||
         else
 | 
			
		||||
            Last := Item'First + Buff_Diff;
 | 
			
		||||
            Item (Item'First .. Last) := Buffer (Buffer_First .. Buffer'Last);
 | 
			
		||||
            Buffer_First := Buffer'Last + 1;
 | 
			
		||||
         end if;
 | 
			
		||||
      end Read_Buffer;
 | 
			
		||||
 | 
			
		||||
      procedure Translate is new Generic_Translate
 | 
			
		||||
                                   (Data_In  => Read_Buffer,
 | 
			
		||||
                                    Data_Out => Further);
 | 
			
		||||
 | 
			
		||||
   begin
 | 
			
		||||
      Random_Elements.Reset (Gen);
 | 
			
		||||
 | 
			
		||||
      Buffer := (others => 20);
 | 
			
		||||
 | 
			
		||||
      Main : loop
 | 
			
		||||
         for J in Buffer'Range loop
 | 
			
		||||
            Buffer (J) := Random_Elements.Random (Gen);
 | 
			
		||||
 | 
			
		||||
            Deflate_Init (Deflate);
 | 
			
		||||
            Inflate_Init (Inflate);
 | 
			
		||||
 | 
			
		||||
            Buffer_First  := Buffer'First;
 | 
			
		||||
            Compare_First := Buffer'First;
 | 
			
		||||
 | 
			
		||||
            Translate (Deflate);
 | 
			
		||||
 | 
			
		||||
            if Compare_First /= Buffer'Last + 1 then
 | 
			
		||||
               raise Program_Error;
 | 
			
		||||
            end if;
 | 
			
		||||
 | 
			
		||||
            Ada.Text_IO.Put_Line
 | 
			
		||||
              (Ada.Task_Identification.Image
 | 
			
		||||
                 (Ada.Task_Identification.Current_Task)
 | 
			
		||||
               & Stream_Element_Offset'Image (J)
 | 
			
		||||
               & ZLib.Count'Image (Total_Out (Deflate)));
 | 
			
		||||
 | 
			
		||||
            Close (Deflate);
 | 
			
		||||
            Close (Inflate);
 | 
			
		||||
 | 
			
		||||
            exit Main when Stop;
 | 
			
		||||
         end loop;
 | 
			
		||||
      end loop Main;
 | 
			
		||||
   exception
 | 
			
		||||
      when E : others =>
 | 
			
		||||
         Ada.Text_IO.Put_Line (Ada.Exceptions.Exception_Information (E));
 | 
			
		||||
         Stop := True;
 | 
			
		||||
   end Test_Task;
 | 
			
		||||
 | 
			
		||||
   Test : array (1 .. 4) of Test_Task;
 | 
			
		||||
 | 
			
		||||
   pragma Unreferenced (Test);
 | 
			
		||||
 | 
			
		||||
   Dummy : Character;
 | 
			
		||||
 | 
			
		||||
begin
 | 
			
		||||
   Ada.Text_IO.Get_Immediate (Dummy);
 | 
			
		||||
   Stop := True;
 | 
			
		||||
end MTest;
 | 
			
		||||
							
								
								
									
										156
									
								
								third_party/zlib/contrib/ada/read.adb
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										156
									
								
								third_party/zlib/contrib/ada/read.adb
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,156 @@
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
--  ZLib for Ada thick binding.                               --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Copyright (C) 2002-2003 Dmitriy Anisimkov                 --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Open source license information is in the zlib.ads file.  --
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
 | 
			
		||||
--  $Id: read.adb,v 1.8 2004/05/31 10:53:40 vagul Exp $
 | 
			
		||||
 | 
			
		||||
--  Test/demo program for the generic read interface.
 | 
			
		||||
 | 
			
		||||
with Ada.Numerics.Discrete_Random;
 | 
			
		||||
with Ada.Streams;
 | 
			
		||||
with Ada.Text_IO;
 | 
			
		||||
 | 
			
		||||
with ZLib;
 | 
			
		||||
 | 
			
		||||
procedure Read is
 | 
			
		||||
 | 
			
		||||
   use Ada.Streams;
 | 
			
		||||
 | 
			
		||||
   ------------------------------------
 | 
			
		||||
   --  Test configuration parameters --
 | 
			
		||||
   ------------------------------------
 | 
			
		||||
 | 
			
		||||
   File_Size   : Stream_Element_Offset := 100_000;
 | 
			
		||||
 | 
			
		||||
   Continuous  : constant Boolean          := False;
 | 
			
		||||
   --  If this constant is True, the test would be repeated again and again,
 | 
			
		||||
   --  with increment File_Size for every iteration.
 | 
			
		||||
 | 
			
		||||
   Header      : constant ZLib.Header_Type := ZLib.Default;
 | 
			
		||||
   --  Do not use Header other than Default in ZLib versions 1.1.4 and older.
 | 
			
		||||
 | 
			
		||||
   Init_Random : constant := 8;
 | 
			
		||||
   --  We are using the same random sequence, in case of we catch bug,
 | 
			
		||||
   --  so we would be able to reproduce it.
 | 
			
		||||
 | 
			
		||||
   -- End --
 | 
			
		||||
 | 
			
		||||
   Pack_Size : Stream_Element_Offset;
 | 
			
		||||
   Offset    : Stream_Element_Offset;
 | 
			
		||||
 | 
			
		||||
   Filter     : ZLib.Filter_Type;
 | 
			
		||||
 | 
			
		||||
   subtype Visible_Symbols
 | 
			
		||||
      is Stream_Element range 16#20# .. 16#7E#;
 | 
			
		||||
 | 
			
		||||
   package Random_Elements is new
 | 
			
		||||
      Ada.Numerics.Discrete_Random (Visible_Symbols);
 | 
			
		||||
 | 
			
		||||
   Gen : Random_Elements.Generator;
 | 
			
		||||
   Period  : constant Stream_Element_Offset := 200;
 | 
			
		||||
   --  Period constant variable for random generator not to be very random.
 | 
			
		||||
   --  Bigger period, harder random.
 | 
			
		||||
 | 
			
		||||
   Read_Buffer : Stream_Element_Array (1 .. 2048);
 | 
			
		||||
   Read_First  : Stream_Element_Offset;
 | 
			
		||||
   Read_Last   : Stream_Element_Offset;
 | 
			
		||||
 | 
			
		||||
   procedure Reset;
 | 
			
		||||
 | 
			
		||||
   procedure Read
 | 
			
		||||
     (Item : out Stream_Element_Array;
 | 
			
		||||
      Last : out Stream_Element_Offset);
 | 
			
		||||
   --  this procedure is for generic instantiation of
 | 
			
		||||
   --  ZLib.Read
 | 
			
		||||
   --  reading data from the File_In.
 | 
			
		||||
 | 
			
		||||
   procedure Read is new ZLib.Read
 | 
			
		||||
                           (Read,
 | 
			
		||||
                            Read_Buffer,
 | 
			
		||||
                            Rest_First => Read_First,
 | 
			
		||||
                            Rest_Last  => Read_Last);
 | 
			
		||||
 | 
			
		||||
   ----------
 | 
			
		||||
   -- Read --
 | 
			
		||||
   ----------
 | 
			
		||||
 | 
			
		||||
   procedure Read
 | 
			
		||||
     (Item : out Stream_Element_Array;
 | 
			
		||||
      Last : out Stream_Element_Offset) is
 | 
			
		||||
   begin
 | 
			
		||||
      Last := Stream_Element_Offset'Min
 | 
			
		||||
               (Item'Last,
 | 
			
		||||
                Item'First + File_Size - Offset);
 | 
			
		||||
 | 
			
		||||
      for J in Item'First .. Last loop
 | 
			
		||||
         if J < Item'First + Period then
 | 
			
		||||
            Item (J) := Random_Elements.Random (Gen);
 | 
			
		||||
         else
 | 
			
		||||
            Item (J) := Item (J - Period);
 | 
			
		||||
         end if;
 | 
			
		||||
 | 
			
		||||
         Offset   := Offset + 1;
 | 
			
		||||
      end loop;
 | 
			
		||||
   end Read;
 | 
			
		||||
 | 
			
		||||
   -----------
 | 
			
		||||
   -- Reset --
 | 
			
		||||
   -----------
 | 
			
		||||
 | 
			
		||||
   procedure Reset is
 | 
			
		||||
   begin
 | 
			
		||||
      Random_Elements.Reset (Gen, Init_Random);
 | 
			
		||||
      Pack_Size := 0;
 | 
			
		||||
      Offset := 1;
 | 
			
		||||
      Read_First := Read_Buffer'Last + 1;
 | 
			
		||||
      Read_Last  := Read_Buffer'Last;
 | 
			
		||||
   end Reset;
 | 
			
		||||
 | 
			
		||||
begin
 | 
			
		||||
   Ada.Text_IO.Put_Line ("ZLib " & ZLib.Version);
 | 
			
		||||
 | 
			
		||||
   loop
 | 
			
		||||
      for Level in ZLib.Compression_Level'Range loop
 | 
			
		||||
 | 
			
		||||
         Ada.Text_IO.Put ("Level ="
 | 
			
		||||
            & ZLib.Compression_Level'Image (Level));
 | 
			
		||||
 | 
			
		||||
         --  Deflate using generic instantiation.
 | 
			
		||||
 | 
			
		||||
         ZLib.Deflate_Init
 | 
			
		||||
               (Filter,
 | 
			
		||||
                Level,
 | 
			
		||||
                Header => Header);
 | 
			
		||||
 | 
			
		||||
         Reset;
 | 
			
		||||
 | 
			
		||||
         Ada.Text_IO.Put
 | 
			
		||||
           (Stream_Element_Offset'Image (File_Size) & " ->");
 | 
			
		||||
 | 
			
		||||
         loop
 | 
			
		||||
            declare
 | 
			
		||||
               Buffer : Stream_Element_Array (1 .. 1024);
 | 
			
		||||
               Last   : Stream_Element_Offset;
 | 
			
		||||
            begin
 | 
			
		||||
               Read (Filter, Buffer, Last);
 | 
			
		||||
 | 
			
		||||
               Pack_Size := Pack_Size + Last - Buffer'First + 1;
 | 
			
		||||
 | 
			
		||||
               exit when Last < Buffer'Last;
 | 
			
		||||
            end;
 | 
			
		||||
         end loop;
 | 
			
		||||
 | 
			
		||||
         Ada.Text_IO.Put_Line (Stream_Element_Offset'Image (Pack_Size));
 | 
			
		||||
 | 
			
		||||
         ZLib.Close (Filter);
 | 
			
		||||
      end loop;
 | 
			
		||||
 | 
			
		||||
      exit when not Continuous;
 | 
			
		||||
 | 
			
		||||
      File_Size := File_Size + 1;
 | 
			
		||||
   end loop;
 | 
			
		||||
end Read;
 | 
			
		||||
							
								
								
									
										65
									
								
								third_party/zlib/contrib/ada/readme.txt
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										65
									
								
								third_party/zlib/contrib/ada/readme.txt
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,65 @@
 | 
			
		||||
                        ZLib for Ada thick binding (ZLib.Ada)
 | 
			
		||||
                        Release 1.3
 | 
			
		||||
 | 
			
		||||
ZLib.Ada is a thick binding interface to the popular ZLib data
 | 
			
		||||
compression library, available at http://www.gzip.org/zlib/.
 | 
			
		||||
It provides Ada-style access to the ZLib C library.
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
        Here are the main changes since ZLib.Ada 1.2:
 | 
			
		||||
 | 
			
		||||
- Attension: ZLib.Read generic routine have a initialization requirement
 | 
			
		||||
  for Read_Last parameter now. It is a bit incompartible with previous version,
 | 
			
		||||
  but extends functionality, we could use new parameters Allow_Read_Some and
 | 
			
		||||
  Flush now.
 | 
			
		||||
 | 
			
		||||
- Added Is_Open routines to ZLib and ZLib.Streams packages.
 | 
			
		||||
 | 
			
		||||
- Add pragma Assert to check Stream_Element is 8 bit.
 | 
			
		||||
 | 
			
		||||
- Fix extraction to buffer with exact known decompressed size. Error reported by
 | 
			
		||||
  Steve Sangwine.
 | 
			
		||||
 | 
			
		||||
- Fix definition of ULong (changed to unsigned_long), fix regression on 64 bits
 | 
			
		||||
  computers. Patch provided by Pascal Obry.
 | 
			
		||||
 | 
			
		||||
- Add Status_Error exception definition.
 | 
			
		||||
 | 
			
		||||
- Add pragma Assertion that Ada.Streams.Stream_Element size is 8 bit.
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
        How to build ZLib.Ada under GNAT
 | 
			
		||||
 | 
			
		||||
You should have the ZLib library already build on your computer, before
 | 
			
		||||
building ZLib.Ada. Make the directory of ZLib.Ada sources current and
 | 
			
		||||
issue the command:
 | 
			
		||||
 | 
			
		||||
  gnatmake test -largs -L<directory where libz.a is> -lz
 | 
			
		||||
 | 
			
		||||
Or use the GNAT project file build for GNAT 3.15 or later:
 | 
			
		||||
 | 
			
		||||
  gnatmake -Pzlib.gpr -L<directory where libz.a is>
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
        How to build ZLib.Ada under Aonix ObjectAda for Win32 7.2.2
 | 
			
		||||
 | 
			
		||||
1. Make a project with all *.ads and *.adb files from the distribution.
 | 
			
		||||
2. Build the libz.a library from the ZLib C sources.
 | 
			
		||||
3. Rename libz.a to z.lib.
 | 
			
		||||
4. Add the library z.lib to the project.
 | 
			
		||||
5. Add the libc.lib library from the ObjectAda distribution to the project.
 | 
			
		||||
6. Build the executable using test.adb as a main procedure.
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
        How to use ZLib.Ada
 | 
			
		||||
 | 
			
		||||
The source files test.adb and read.adb are small demo programs that show
 | 
			
		||||
the main functionality of ZLib.Ada.
 | 
			
		||||
 | 
			
		||||
The routines from the package specifications are commented.
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
Homepage: http://zlib-ada.sourceforge.net/
 | 
			
		||||
Author: Dmitriy Anisimkov <anisimkov@yahoo.com>
 | 
			
		||||
 | 
			
		||||
Contributors: Pascal Obry <pascal@obry.org>, Steve Sangwine <sjs@essex.ac.uk>
 | 
			
		||||
							
								
								
									
										463
									
								
								third_party/zlib/contrib/ada/test.adb
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										463
									
								
								third_party/zlib/contrib/ada/test.adb
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,463 @@
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
--  ZLib for Ada thick binding.                               --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Copyright (C) 2002-2003 Dmitriy Anisimkov                 --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Open source license information is in the zlib.ads file.  --
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
 | 
			
		||||
--  $Id: test.adb,v 1.17 2003/08/12 12:13:30 vagul Exp $
 | 
			
		||||
 | 
			
		||||
--  The program has a few aims.
 | 
			
		||||
--  1. Test ZLib.Ada95 thick binding functionality.
 | 
			
		||||
--  2. Show the example of use main functionality of the ZLib.Ada95 binding.
 | 
			
		||||
--  3. Build this program automatically compile all ZLib.Ada95 packages under
 | 
			
		||||
--     GNAT Ada95 compiler.
 | 
			
		||||
 | 
			
		||||
with ZLib.Streams;
 | 
			
		||||
with Ada.Streams.Stream_IO;
 | 
			
		||||
with Ada.Numerics.Discrete_Random;
 | 
			
		||||
 | 
			
		||||
with Ada.Text_IO;
 | 
			
		||||
 | 
			
		||||
with Ada.Calendar;
 | 
			
		||||
 | 
			
		||||
procedure Test is
 | 
			
		||||
 | 
			
		||||
   use Ada.Streams;
 | 
			
		||||
   use Stream_IO;
 | 
			
		||||
 | 
			
		||||
   ------------------------------------
 | 
			
		||||
   --  Test configuration parameters --
 | 
			
		||||
   ------------------------------------
 | 
			
		||||
 | 
			
		||||
   File_Size   : Count   := 100_000;
 | 
			
		||||
   Continuous  : constant Boolean := False;
 | 
			
		||||
 | 
			
		||||
   Header      : constant ZLib.Header_Type := ZLib.Default;
 | 
			
		||||
                                              --  ZLib.None;
 | 
			
		||||
                                              --  ZLib.Auto;
 | 
			
		||||
                                              --  ZLib.GZip;
 | 
			
		||||
   --  Do not use Header other then Default in ZLib versions 1.1.4
 | 
			
		||||
   --  and older.
 | 
			
		||||
 | 
			
		||||
   Strategy    : constant ZLib.Strategy_Type := ZLib.Default_Strategy;
 | 
			
		||||
   Init_Random : constant := 10;
 | 
			
		||||
 | 
			
		||||
   -- End --
 | 
			
		||||
 | 
			
		||||
   In_File_Name  : constant String := "testzlib.in";
 | 
			
		||||
   --  Name of the input file
 | 
			
		||||
 | 
			
		||||
   Z_File_Name   : constant String := "testzlib.zlb";
 | 
			
		||||
   --  Name of the compressed file.
 | 
			
		||||
 | 
			
		||||
   Out_File_Name : constant String := "testzlib.out";
 | 
			
		||||
   --  Name of the decompressed file.
 | 
			
		||||
 | 
			
		||||
   File_In   : File_Type;
 | 
			
		||||
   File_Out  : File_Type;
 | 
			
		||||
   File_Back : File_Type;
 | 
			
		||||
   File_Z    : ZLib.Streams.Stream_Type;
 | 
			
		||||
 | 
			
		||||
   Filter : ZLib.Filter_Type;
 | 
			
		||||
 | 
			
		||||
   Time_Stamp : Ada.Calendar.Time;
 | 
			
		||||
 | 
			
		||||
   procedure Generate_File;
 | 
			
		||||
   --  Generate file of spetsified size with some random data.
 | 
			
		||||
   --  The random data is repeatable, for the good compression.
 | 
			
		||||
 | 
			
		||||
   procedure Compare_Streams
 | 
			
		||||
     (Left, Right : in out Root_Stream_Type'Class);
 | 
			
		||||
   --  The procedure compearing data in 2 streams.
 | 
			
		||||
   --  It is for compare data before and after compression/decompression.
 | 
			
		||||
 | 
			
		||||
   procedure Compare_Files (Left, Right : String);
 | 
			
		||||
   --  Compare files. Based on the Compare_Streams.
 | 
			
		||||
 | 
			
		||||
   procedure Copy_Streams
 | 
			
		||||
     (Source, Target : in out Root_Stream_Type'Class;
 | 
			
		||||
      Buffer_Size    : in     Stream_Element_Offset := 1024);
 | 
			
		||||
   --  Copying data from one stream to another. It is for test stream
 | 
			
		||||
   --  interface of the library.
 | 
			
		||||
 | 
			
		||||
   procedure Data_In
 | 
			
		||||
     (Item : out Stream_Element_Array;
 | 
			
		||||
      Last : out Stream_Element_Offset);
 | 
			
		||||
   --  this procedure is for generic instantiation of
 | 
			
		||||
   --  ZLib.Generic_Translate.
 | 
			
		||||
   --  reading data from the File_In.
 | 
			
		||||
 | 
			
		||||
   procedure Data_Out (Item : in Stream_Element_Array);
 | 
			
		||||
   --  this procedure is for generic instantiation of
 | 
			
		||||
   --  ZLib.Generic_Translate.
 | 
			
		||||
   --  writing data to the File_Out.
 | 
			
		||||
 | 
			
		||||
   procedure Stamp;
 | 
			
		||||
   --  Store the timestamp to the local variable.
 | 
			
		||||
 | 
			
		||||
   procedure Print_Statistic (Msg : String; Data_Size : ZLib.Count);
 | 
			
		||||
   --  Print the time statistic with the message.
 | 
			
		||||
 | 
			
		||||
   procedure Translate is new ZLib.Generic_Translate
 | 
			
		||||
                                (Data_In  => Data_In,
 | 
			
		||||
                                 Data_Out => Data_Out);
 | 
			
		||||
   --  This procedure is moving data from File_In to File_Out
 | 
			
		||||
   --  with compression or decompression, depend on initialization of
 | 
			
		||||
   --  Filter parameter.
 | 
			
		||||
 | 
			
		||||
   -------------------
 | 
			
		||||
   -- Compare_Files --
 | 
			
		||||
   -------------------
 | 
			
		||||
 | 
			
		||||
   procedure Compare_Files (Left, Right : String) is
 | 
			
		||||
      Left_File, Right_File : File_Type;
 | 
			
		||||
   begin
 | 
			
		||||
      Open (Left_File, In_File, Left);
 | 
			
		||||
      Open (Right_File, In_File, Right);
 | 
			
		||||
      Compare_Streams (Stream (Left_File).all, Stream (Right_File).all);
 | 
			
		||||
      Close (Left_File);
 | 
			
		||||
      Close (Right_File);
 | 
			
		||||
   end Compare_Files;
 | 
			
		||||
 | 
			
		||||
   ---------------------
 | 
			
		||||
   -- Compare_Streams --
 | 
			
		||||
   ---------------------
 | 
			
		||||
 | 
			
		||||
   procedure Compare_Streams
 | 
			
		||||
     (Left, Right : in out Ada.Streams.Root_Stream_Type'Class)
 | 
			
		||||
   is
 | 
			
		||||
      Left_Buffer, Right_Buffer : Stream_Element_Array (0 .. 16#FFF#);
 | 
			
		||||
      Left_Last, Right_Last : Stream_Element_Offset;
 | 
			
		||||
   begin
 | 
			
		||||
      loop
 | 
			
		||||
         Read (Left, Left_Buffer, Left_Last);
 | 
			
		||||
         Read (Right, Right_Buffer, Right_Last);
 | 
			
		||||
 | 
			
		||||
         if Left_Last /= Right_Last then
 | 
			
		||||
            Ada.Text_IO.Put_Line ("Compare error :"
 | 
			
		||||
              & Stream_Element_Offset'Image (Left_Last)
 | 
			
		||||
              & " /= "
 | 
			
		||||
              & Stream_Element_Offset'Image (Right_Last));
 | 
			
		||||
 | 
			
		||||
            raise Constraint_Error;
 | 
			
		||||
 | 
			
		||||
         elsif Left_Buffer (0 .. Left_Last)
 | 
			
		||||
               /= Right_Buffer (0 .. Right_Last)
 | 
			
		||||
         then
 | 
			
		||||
            Ada.Text_IO.Put_Line ("ERROR: IN and OUT files is not equal.");
 | 
			
		||||
            raise Constraint_Error;
 | 
			
		||||
 | 
			
		||||
         end if;
 | 
			
		||||
 | 
			
		||||
         exit when Left_Last < Left_Buffer'Last;
 | 
			
		||||
      end loop;
 | 
			
		||||
   end Compare_Streams;
 | 
			
		||||
 | 
			
		||||
   ------------------
 | 
			
		||||
   -- Copy_Streams --
 | 
			
		||||
   ------------------
 | 
			
		||||
 | 
			
		||||
   procedure Copy_Streams
 | 
			
		||||
     (Source, Target : in out Ada.Streams.Root_Stream_Type'Class;
 | 
			
		||||
      Buffer_Size    : in     Stream_Element_Offset := 1024)
 | 
			
		||||
   is
 | 
			
		||||
      Buffer : Stream_Element_Array (1 .. Buffer_Size);
 | 
			
		||||
      Last   : Stream_Element_Offset;
 | 
			
		||||
   begin
 | 
			
		||||
      loop
 | 
			
		||||
         Read  (Source, Buffer, Last);
 | 
			
		||||
         Write (Target, Buffer (1 .. Last));
 | 
			
		||||
 | 
			
		||||
         exit when Last < Buffer'Last;
 | 
			
		||||
      end loop;
 | 
			
		||||
   end Copy_Streams;
 | 
			
		||||
 | 
			
		||||
   -------------
 | 
			
		||||
   -- Data_In --
 | 
			
		||||
   -------------
 | 
			
		||||
 | 
			
		||||
   procedure Data_In
 | 
			
		||||
     (Item : out Stream_Element_Array;
 | 
			
		||||
      Last : out Stream_Element_Offset) is
 | 
			
		||||
   begin
 | 
			
		||||
      Read (File_In, Item, Last);
 | 
			
		||||
   end Data_In;
 | 
			
		||||
 | 
			
		||||
   --------------
 | 
			
		||||
   -- Data_Out --
 | 
			
		||||
   --------------
 | 
			
		||||
 | 
			
		||||
   procedure Data_Out (Item : in Stream_Element_Array) is
 | 
			
		||||
   begin
 | 
			
		||||
      Write (File_Out, Item);
 | 
			
		||||
   end Data_Out;
 | 
			
		||||
 | 
			
		||||
   -------------------
 | 
			
		||||
   -- Generate_File --
 | 
			
		||||
   -------------------
 | 
			
		||||
 | 
			
		||||
   procedure Generate_File is
 | 
			
		||||
      subtype Visible_Symbols is Stream_Element range 16#20# .. 16#7E#;
 | 
			
		||||
 | 
			
		||||
      package Random_Elements is
 | 
			
		||||
         new Ada.Numerics.Discrete_Random (Visible_Symbols);
 | 
			
		||||
 | 
			
		||||
      Gen    : Random_Elements.Generator;
 | 
			
		||||
      Buffer : Stream_Element_Array := (1 .. 77 => 16#20#) & 10;
 | 
			
		||||
 | 
			
		||||
      Buffer_Count : constant Count := File_Size / Buffer'Length;
 | 
			
		||||
      --  Number of same buffers in the packet.
 | 
			
		||||
 | 
			
		||||
      Density : constant Count := 30; --  from 0 to Buffer'Length - 2;
 | 
			
		||||
 | 
			
		||||
      procedure Fill_Buffer (J, D : in Count);
 | 
			
		||||
      --  Change the part of the buffer.
 | 
			
		||||
 | 
			
		||||
      -----------------
 | 
			
		||||
      -- Fill_Buffer --
 | 
			
		||||
      -----------------
 | 
			
		||||
 | 
			
		||||
      procedure Fill_Buffer (J, D : in Count) is
 | 
			
		||||
      begin
 | 
			
		||||
         for K in 0 .. D loop
 | 
			
		||||
            Buffer
 | 
			
		||||
              (Stream_Element_Offset ((J + K) mod (Buffer'Length - 1) + 1))
 | 
			
		||||
             := Random_Elements.Random (Gen);
 | 
			
		||||
 | 
			
		||||
         end loop;
 | 
			
		||||
      end Fill_Buffer;
 | 
			
		||||
 | 
			
		||||
   begin
 | 
			
		||||
      Random_Elements.Reset (Gen, Init_Random);
 | 
			
		||||
 | 
			
		||||
      Create (File_In, Out_File, In_File_Name);
 | 
			
		||||
 | 
			
		||||
      Fill_Buffer (1, Buffer'Length - 2);
 | 
			
		||||
 | 
			
		||||
      for J in 1 .. Buffer_Count loop
 | 
			
		||||
         Write (File_In, Buffer);
 | 
			
		||||
 | 
			
		||||
         Fill_Buffer (J, Density);
 | 
			
		||||
      end loop;
 | 
			
		||||
 | 
			
		||||
      --  fill remain size.
 | 
			
		||||
 | 
			
		||||
      Write
 | 
			
		||||
        (File_In,
 | 
			
		||||
         Buffer
 | 
			
		||||
           (1 .. Stream_Element_Offset
 | 
			
		||||
                   (File_Size - Buffer'Length * Buffer_Count)));
 | 
			
		||||
 | 
			
		||||
      Flush (File_In);
 | 
			
		||||
      Close (File_In);
 | 
			
		||||
   end Generate_File;
 | 
			
		||||
 | 
			
		||||
   ---------------------
 | 
			
		||||
   -- Print_Statistic --
 | 
			
		||||
   ---------------------
 | 
			
		||||
 | 
			
		||||
   procedure Print_Statistic (Msg : String; Data_Size : ZLib.Count) is
 | 
			
		||||
      use Ada.Calendar;
 | 
			
		||||
      use Ada.Text_IO;
 | 
			
		||||
 | 
			
		||||
      package Count_IO is new Integer_IO (ZLib.Count);
 | 
			
		||||
 | 
			
		||||
      Curr_Dur : Duration := Clock - Time_Stamp;
 | 
			
		||||
   begin
 | 
			
		||||
      Put (Msg);
 | 
			
		||||
 | 
			
		||||
      Set_Col (20);
 | 
			
		||||
      Ada.Text_IO.Put ("size =");
 | 
			
		||||
 | 
			
		||||
      Count_IO.Put
 | 
			
		||||
        (Data_Size,
 | 
			
		||||
         Width => Stream_IO.Count'Image (File_Size)'Length);
 | 
			
		||||
 | 
			
		||||
      Put_Line (" duration =" & Duration'Image (Curr_Dur));
 | 
			
		||||
   end Print_Statistic;
 | 
			
		||||
 | 
			
		||||
   -----------
 | 
			
		||||
   -- Stamp --
 | 
			
		||||
   -----------
 | 
			
		||||
 | 
			
		||||
   procedure Stamp is
 | 
			
		||||
   begin
 | 
			
		||||
      Time_Stamp := Ada.Calendar.Clock;
 | 
			
		||||
   end Stamp;
 | 
			
		||||
 | 
			
		||||
begin
 | 
			
		||||
   Ada.Text_IO.Put_Line ("ZLib " & ZLib.Version);
 | 
			
		||||
 | 
			
		||||
   loop
 | 
			
		||||
      Generate_File;
 | 
			
		||||
 | 
			
		||||
      for Level in ZLib.Compression_Level'Range loop
 | 
			
		||||
 | 
			
		||||
         Ada.Text_IO.Put_Line ("Level ="
 | 
			
		||||
            & ZLib.Compression_Level'Image (Level));
 | 
			
		||||
 | 
			
		||||
         --  Test generic interface.
 | 
			
		||||
         Open   (File_In, In_File, In_File_Name);
 | 
			
		||||
         Create (File_Out, Out_File, Z_File_Name);
 | 
			
		||||
 | 
			
		||||
         Stamp;
 | 
			
		||||
 | 
			
		||||
         --  Deflate using generic instantiation.
 | 
			
		||||
 | 
			
		||||
         ZLib.Deflate_Init
 | 
			
		||||
               (Filter   => Filter,
 | 
			
		||||
                Level    => Level,
 | 
			
		||||
                Strategy => Strategy,
 | 
			
		||||
                Header   => Header);
 | 
			
		||||
 | 
			
		||||
         Translate (Filter);
 | 
			
		||||
         Print_Statistic ("Generic compress", ZLib.Total_Out (Filter));
 | 
			
		||||
         ZLib.Close (Filter);
 | 
			
		||||
 | 
			
		||||
         Close (File_In);
 | 
			
		||||
         Close (File_Out);
 | 
			
		||||
 | 
			
		||||
         Open   (File_In, In_File, Z_File_Name);
 | 
			
		||||
         Create (File_Out, Out_File, Out_File_Name);
 | 
			
		||||
 | 
			
		||||
         Stamp;
 | 
			
		||||
 | 
			
		||||
         --  Inflate using generic instantiation.
 | 
			
		||||
 | 
			
		||||
         ZLib.Inflate_Init (Filter, Header => Header);
 | 
			
		||||
 | 
			
		||||
         Translate (Filter);
 | 
			
		||||
         Print_Statistic ("Generic decompress", ZLib.Total_Out (Filter));
 | 
			
		||||
 | 
			
		||||
         ZLib.Close (Filter);
 | 
			
		||||
 | 
			
		||||
         Close (File_In);
 | 
			
		||||
         Close (File_Out);
 | 
			
		||||
 | 
			
		||||
         Compare_Files (In_File_Name, Out_File_Name);
 | 
			
		||||
 | 
			
		||||
         --  Test stream interface.
 | 
			
		||||
 | 
			
		||||
         --  Compress to the back stream.
 | 
			
		||||
 | 
			
		||||
         Open   (File_In, In_File, In_File_Name);
 | 
			
		||||
         Create (File_Back, Out_File, Z_File_Name);
 | 
			
		||||
 | 
			
		||||
         Stamp;
 | 
			
		||||
 | 
			
		||||
         ZLib.Streams.Create
 | 
			
		||||
           (Stream          => File_Z,
 | 
			
		||||
            Mode            => ZLib.Streams.Out_Stream,
 | 
			
		||||
            Back            => ZLib.Streams.Stream_Access
 | 
			
		||||
                                 (Stream (File_Back)),
 | 
			
		||||
            Back_Compressed => True,
 | 
			
		||||
            Level           => Level,
 | 
			
		||||
            Strategy        => Strategy,
 | 
			
		||||
            Header          => Header);
 | 
			
		||||
 | 
			
		||||
         Copy_Streams
 | 
			
		||||
           (Source => Stream (File_In).all,
 | 
			
		||||
            Target => File_Z);
 | 
			
		||||
 | 
			
		||||
         --  Flushing internal buffers to the back stream.
 | 
			
		||||
 | 
			
		||||
         ZLib.Streams.Flush (File_Z, ZLib.Finish);
 | 
			
		||||
 | 
			
		||||
         Print_Statistic ("Write compress",
 | 
			
		||||
                          ZLib.Streams.Write_Total_Out (File_Z));
 | 
			
		||||
 | 
			
		||||
         ZLib.Streams.Close (File_Z);
 | 
			
		||||
 | 
			
		||||
         Close (File_In);
 | 
			
		||||
         Close (File_Back);
 | 
			
		||||
 | 
			
		||||
         --  Compare reading from original file and from
 | 
			
		||||
         --  decompression stream.
 | 
			
		||||
 | 
			
		||||
         Open (File_In,   In_File, In_File_Name);
 | 
			
		||||
         Open (File_Back, In_File, Z_File_Name);
 | 
			
		||||
 | 
			
		||||
         ZLib.Streams.Create
 | 
			
		||||
           (Stream          => File_Z,
 | 
			
		||||
            Mode            => ZLib.Streams.In_Stream,
 | 
			
		||||
            Back            => ZLib.Streams.Stream_Access
 | 
			
		||||
                                 (Stream (File_Back)),
 | 
			
		||||
            Back_Compressed => True,
 | 
			
		||||
            Header          => Header);
 | 
			
		||||
 | 
			
		||||
         Stamp;
 | 
			
		||||
         Compare_Streams (Stream (File_In).all, File_Z);
 | 
			
		||||
 | 
			
		||||
         Print_Statistic ("Read decompress",
 | 
			
		||||
                          ZLib.Streams.Read_Total_Out (File_Z));
 | 
			
		||||
 | 
			
		||||
         ZLib.Streams.Close (File_Z);
 | 
			
		||||
         Close (File_In);
 | 
			
		||||
         Close (File_Back);
 | 
			
		||||
 | 
			
		||||
         --  Compress by reading from compression stream.
 | 
			
		||||
 | 
			
		||||
         Open (File_Back, In_File, In_File_Name);
 | 
			
		||||
         Create (File_Out, Out_File, Z_File_Name);
 | 
			
		||||
 | 
			
		||||
         ZLib.Streams.Create
 | 
			
		||||
           (Stream          => File_Z,
 | 
			
		||||
            Mode            => ZLib.Streams.In_Stream,
 | 
			
		||||
            Back            => ZLib.Streams.Stream_Access
 | 
			
		||||
                                 (Stream (File_Back)),
 | 
			
		||||
            Back_Compressed => False,
 | 
			
		||||
            Level           => Level,
 | 
			
		||||
            Strategy        => Strategy,
 | 
			
		||||
            Header          => Header);
 | 
			
		||||
 | 
			
		||||
         Stamp;
 | 
			
		||||
         Copy_Streams
 | 
			
		||||
           (Source => File_Z,
 | 
			
		||||
            Target => Stream (File_Out).all);
 | 
			
		||||
 | 
			
		||||
         Print_Statistic ("Read compress",
 | 
			
		||||
                          ZLib.Streams.Read_Total_Out (File_Z));
 | 
			
		||||
 | 
			
		||||
         ZLib.Streams.Close (File_Z);
 | 
			
		||||
 | 
			
		||||
         Close (File_Out);
 | 
			
		||||
         Close (File_Back);
 | 
			
		||||
 | 
			
		||||
         --  Decompress to decompression stream.
 | 
			
		||||
 | 
			
		||||
         Open   (File_In,   In_File, Z_File_Name);
 | 
			
		||||
         Create (File_Back, Out_File, Out_File_Name);
 | 
			
		||||
 | 
			
		||||
         ZLib.Streams.Create
 | 
			
		||||
           (Stream          => File_Z,
 | 
			
		||||
            Mode            => ZLib.Streams.Out_Stream,
 | 
			
		||||
            Back            => ZLib.Streams.Stream_Access
 | 
			
		||||
                                 (Stream (File_Back)),
 | 
			
		||||
            Back_Compressed => False,
 | 
			
		||||
            Header          => Header);
 | 
			
		||||
 | 
			
		||||
         Stamp;
 | 
			
		||||
 | 
			
		||||
         Copy_Streams
 | 
			
		||||
           (Source => Stream (File_In).all,
 | 
			
		||||
            Target => File_Z);
 | 
			
		||||
 | 
			
		||||
         Print_Statistic ("Write decompress",
 | 
			
		||||
                          ZLib.Streams.Write_Total_Out (File_Z));
 | 
			
		||||
 | 
			
		||||
         ZLib.Streams.Close (File_Z);
 | 
			
		||||
         Close (File_In);
 | 
			
		||||
         Close (File_Back);
 | 
			
		||||
 | 
			
		||||
         Compare_Files (In_File_Name, Out_File_Name);
 | 
			
		||||
      end loop;
 | 
			
		||||
 | 
			
		||||
      Ada.Text_IO.Put_Line (Count'Image (File_Size) & " Ok.");
 | 
			
		||||
 | 
			
		||||
      exit when not Continuous;
 | 
			
		||||
 | 
			
		||||
      File_Size := File_Size + 1;
 | 
			
		||||
   end loop;
 | 
			
		||||
end Test;
 | 
			
		||||
							
								
								
									
										225
									
								
								third_party/zlib/contrib/ada/zlib-streams.adb
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										225
									
								
								third_party/zlib/contrib/ada/zlib-streams.adb
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,225 @@
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
--  ZLib for Ada thick binding.                               --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Copyright (C) 2002-2003 Dmitriy Anisimkov                 --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Open source license information is in the zlib.ads file.  --
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
 | 
			
		||||
--  $Id: zlib-streams.adb,v 1.10 2004/05/31 10:53:40 vagul Exp $
 | 
			
		||||
 | 
			
		||||
with Ada.Unchecked_Deallocation;
 | 
			
		||||
 | 
			
		||||
package body ZLib.Streams is
 | 
			
		||||
 | 
			
		||||
   -----------
 | 
			
		||||
   -- Close --
 | 
			
		||||
   -----------
 | 
			
		||||
 | 
			
		||||
   procedure Close (Stream : in out Stream_Type) is
 | 
			
		||||
      procedure Free is new Ada.Unchecked_Deallocation
 | 
			
		||||
         (Stream_Element_Array, Buffer_Access);
 | 
			
		||||
   begin
 | 
			
		||||
      if Stream.Mode = Out_Stream or Stream.Mode = Duplex then
 | 
			
		||||
         --  We should flush the data written by the writer.
 | 
			
		||||
 | 
			
		||||
         Flush (Stream, Finish);
 | 
			
		||||
 | 
			
		||||
         Close (Stream.Writer);
 | 
			
		||||
      end if;
 | 
			
		||||
 | 
			
		||||
      if Stream.Mode = In_Stream or Stream.Mode = Duplex then
 | 
			
		||||
         Close (Stream.Reader);
 | 
			
		||||
         Free (Stream.Buffer);
 | 
			
		||||
      end if;
 | 
			
		||||
   end Close;
 | 
			
		||||
 | 
			
		||||
   ------------
 | 
			
		||||
   -- Create --
 | 
			
		||||
   ------------
 | 
			
		||||
 | 
			
		||||
   procedure Create
 | 
			
		||||
     (Stream            :    out Stream_Type;
 | 
			
		||||
      Mode              : in     Stream_Mode;
 | 
			
		||||
      Back              : in     Stream_Access;
 | 
			
		||||
      Back_Compressed   : in     Boolean;
 | 
			
		||||
      Level             : in     Compression_Level := Default_Compression;
 | 
			
		||||
      Strategy          : in     Strategy_Type     := Default_Strategy;
 | 
			
		||||
      Header            : in     Header_Type       := Default;
 | 
			
		||||
      Read_Buffer_Size  : in     Ada.Streams.Stream_Element_Offset
 | 
			
		||||
                                    := Default_Buffer_Size;
 | 
			
		||||
      Write_Buffer_Size : in     Ada.Streams.Stream_Element_Offset
 | 
			
		||||
                                    := Default_Buffer_Size)
 | 
			
		||||
   is
 | 
			
		||||
 | 
			
		||||
      subtype Buffer_Subtype is Stream_Element_Array (1 .. Read_Buffer_Size);
 | 
			
		||||
 | 
			
		||||
      procedure Init_Filter
 | 
			
		||||
         (Filter   : in out Filter_Type;
 | 
			
		||||
          Compress : in     Boolean);
 | 
			
		||||
 | 
			
		||||
      -----------------
 | 
			
		||||
      -- Init_Filter --
 | 
			
		||||
      -----------------
 | 
			
		||||
 | 
			
		||||
      procedure Init_Filter
 | 
			
		||||
         (Filter   : in out Filter_Type;
 | 
			
		||||
          Compress : in     Boolean) is
 | 
			
		||||
      begin
 | 
			
		||||
         if Compress then
 | 
			
		||||
            Deflate_Init
 | 
			
		||||
              (Filter, Level, Strategy, Header => Header);
 | 
			
		||||
         else
 | 
			
		||||
            Inflate_Init (Filter, Header => Header);
 | 
			
		||||
         end if;
 | 
			
		||||
      end Init_Filter;
 | 
			
		||||
 | 
			
		||||
   begin
 | 
			
		||||
      Stream.Back := Back;
 | 
			
		||||
      Stream.Mode := Mode;
 | 
			
		||||
 | 
			
		||||
      if Mode = Out_Stream or Mode = Duplex then
 | 
			
		||||
         Init_Filter (Stream.Writer, Back_Compressed);
 | 
			
		||||
         Stream.Buffer_Size := Write_Buffer_Size;
 | 
			
		||||
      else
 | 
			
		||||
         Stream.Buffer_Size := 0;
 | 
			
		||||
      end if;
 | 
			
		||||
 | 
			
		||||
      if Mode = In_Stream or Mode = Duplex then
 | 
			
		||||
         Init_Filter (Stream.Reader, not Back_Compressed);
 | 
			
		||||
 | 
			
		||||
         Stream.Buffer     := new Buffer_Subtype;
 | 
			
		||||
         Stream.Rest_First := Stream.Buffer'Last + 1;
 | 
			
		||||
         Stream.Rest_Last  := Stream.Buffer'Last;
 | 
			
		||||
      end if;
 | 
			
		||||
   end Create;
 | 
			
		||||
 | 
			
		||||
   -----------
 | 
			
		||||
   -- Flush --
 | 
			
		||||
   -----------
 | 
			
		||||
 | 
			
		||||
   procedure Flush
 | 
			
		||||
     (Stream : in out Stream_Type;
 | 
			
		||||
      Mode   : in     Flush_Mode := Sync_Flush)
 | 
			
		||||
   is
 | 
			
		||||
      Buffer : Stream_Element_Array (1 .. Stream.Buffer_Size);
 | 
			
		||||
      Last   : Stream_Element_Offset;
 | 
			
		||||
   begin
 | 
			
		||||
      loop
 | 
			
		||||
         Flush (Stream.Writer, Buffer, Last, Mode);
 | 
			
		||||
 | 
			
		||||
         Ada.Streams.Write (Stream.Back.all, Buffer (1 .. Last));
 | 
			
		||||
 | 
			
		||||
         exit when Last < Buffer'Last;
 | 
			
		||||
      end loop;
 | 
			
		||||
   end Flush;
 | 
			
		||||
 | 
			
		||||
   -------------
 | 
			
		||||
   -- Is_Open --
 | 
			
		||||
   -------------
 | 
			
		||||
 | 
			
		||||
   function Is_Open (Stream : Stream_Type) return Boolean is
 | 
			
		||||
   begin
 | 
			
		||||
      return Is_Open (Stream.Reader) or else Is_Open (Stream.Writer);
 | 
			
		||||
   end Is_Open;
 | 
			
		||||
 | 
			
		||||
   ----------
 | 
			
		||||
   -- Read --
 | 
			
		||||
   ----------
 | 
			
		||||
 | 
			
		||||
   procedure Read
 | 
			
		||||
     (Stream : in out Stream_Type;
 | 
			
		||||
      Item   :    out Stream_Element_Array;
 | 
			
		||||
      Last   :    out Stream_Element_Offset)
 | 
			
		||||
   is
 | 
			
		||||
 | 
			
		||||
      procedure Read
 | 
			
		||||
        (Item : out Stream_Element_Array;
 | 
			
		||||
         Last : out Stream_Element_Offset);
 | 
			
		||||
 | 
			
		||||
      ----------
 | 
			
		||||
      -- Read --
 | 
			
		||||
      ----------
 | 
			
		||||
 | 
			
		||||
      procedure Read
 | 
			
		||||
        (Item : out Stream_Element_Array;
 | 
			
		||||
         Last : out Stream_Element_Offset) is
 | 
			
		||||
      begin
 | 
			
		||||
         Ada.Streams.Read (Stream.Back.all, Item, Last);
 | 
			
		||||
      end Read;
 | 
			
		||||
 | 
			
		||||
      procedure Read is new ZLib.Read
 | 
			
		||||
         (Read       => Read,
 | 
			
		||||
          Buffer     => Stream.Buffer.all,
 | 
			
		||||
          Rest_First => Stream.Rest_First,
 | 
			
		||||
          Rest_Last  => Stream.Rest_Last);
 | 
			
		||||
 | 
			
		||||
   begin
 | 
			
		||||
      Read (Stream.Reader, Item, Last);
 | 
			
		||||
   end Read;
 | 
			
		||||
 | 
			
		||||
   -------------------
 | 
			
		||||
   -- Read_Total_In --
 | 
			
		||||
   -------------------
 | 
			
		||||
 | 
			
		||||
   function Read_Total_In (Stream : in Stream_Type) return Count is
 | 
			
		||||
   begin
 | 
			
		||||
      return Total_In (Stream.Reader);
 | 
			
		||||
   end Read_Total_In;
 | 
			
		||||
 | 
			
		||||
   --------------------
 | 
			
		||||
   -- Read_Total_Out --
 | 
			
		||||
   --------------------
 | 
			
		||||
 | 
			
		||||
   function Read_Total_Out (Stream : in Stream_Type) return Count is
 | 
			
		||||
   begin
 | 
			
		||||
      return Total_Out (Stream.Reader);
 | 
			
		||||
   end Read_Total_Out;
 | 
			
		||||
 | 
			
		||||
   -----------
 | 
			
		||||
   -- Write --
 | 
			
		||||
   -----------
 | 
			
		||||
 | 
			
		||||
   procedure Write
 | 
			
		||||
     (Stream : in out Stream_Type;
 | 
			
		||||
      Item   : in     Stream_Element_Array)
 | 
			
		||||
   is
 | 
			
		||||
 | 
			
		||||
      procedure Write (Item : in Stream_Element_Array);
 | 
			
		||||
 | 
			
		||||
      -----------
 | 
			
		||||
      -- Write --
 | 
			
		||||
      -----------
 | 
			
		||||
 | 
			
		||||
      procedure Write (Item : in Stream_Element_Array) is
 | 
			
		||||
      begin
 | 
			
		||||
         Ada.Streams.Write (Stream.Back.all, Item);
 | 
			
		||||
      end Write;
 | 
			
		||||
 | 
			
		||||
      procedure Write is new ZLib.Write
 | 
			
		||||
         (Write       => Write,
 | 
			
		||||
          Buffer_Size => Stream.Buffer_Size);
 | 
			
		||||
 | 
			
		||||
   begin
 | 
			
		||||
      Write (Stream.Writer, Item, No_Flush);
 | 
			
		||||
   end Write;
 | 
			
		||||
 | 
			
		||||
   --------------------
 | 
			
		||||
   -- Write_Total_In --
 | 
			
		||||
   --------------------
 | 
			
		||||
 | 
			
		||||
   function Write_Total_In (Stream : in Stream_Type) return Count is
 | 
			
		||||
   begin
 | 
			
		||||
      return Total_In (Stream.Writer);
 | 
			
		||||
   end Write_Total_In;
 | 
			
		||||
 | 
			
		||||
   ---------------------
 | 
			
		||||
   -- Write_Total_Out --
 | 
			
		||||
   ---------------------
 | 
			
		||||
 | 
			
		||||
   function Write_Total_Out (Stream : in Stream_Type) return Count is
 | 
			
		||||
   begin
 | 
			
		||||
      return Total_Out (Stream.Writer);
 | 
			
		||||
   end Write_Total_Out;
 | 
			
		||||
 | 
			
		||||
end ZLib.Streams;
 | 
			
		||||
							
								
								
									
										114
									
								
								third_party/zlib/contrib/ada/zlib-streams.ads
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										114
									
								
								third_party/zlib/contrib/ada/zlib-streams.ads
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,114 @@
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
--  ZLib for Ada thick binding.                               --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Copyright (C) 2002-2003 Dmitriy Anisimkov                 --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Open source license information is in the zlib.ads file.  --
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
 | 
			
		||||
--  $Id: zlib-streams.ads,v 1.12 2004/05/31 10:53:40 vagul Exp $
 | 
			
		||||
 | 
			
		||||
package ZLib.Streams is
 | 
			
		||||
 | 
			
		||||
   type Stream_Mode is (In_Stream, Out_Stream, Duplex);
 | 
			
		||||
 | 
			
		||||
   type Stream_Access is access all Ada.Streams.Root_Stream_Type'Class;
 | 
			
		||||
 | 
			
		||||
   type Stream_Type is
 | 
			
		||||
      new Ada.Streams.Root_Stream_Type with private;
 | 
			
		||||
 | 
			
		||||
   procedure Read
 | 
			
		||||
     (Stream : in out Stream_Type;
 | 
			
		||||
      Item   :    out Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      Last   :    out Ada.Streams.Stream_Element_Offset);
 | 
			
		||||
 | 
			
		||||
   procedure Write
 | 
			
		||||
     (Stream : in out Stream_Type;
 | 
			
		||||
      Item   : in     Ada.Streams.Stream_Element_Array);
 | 
			
		||||
 | 
			
		||||
   procedure Flush
 | 
			
		||||
     (Stream : in out Stream_Type;
 | 
			
		||||
      Mode   : in     Flush_Mode := Sync_Flush);
 | 
			
		||||
   --  Flush the written data to the back stream,
 | 
			
		||||
   --  all data placed to the compressor is flushing to the Back stream.
 | 
			
		||||
   --  Should not be used until necessary, because it is decreasing
 | 
			
		||||
   --  compression.
 | 
			
		||||
 | 
			
		||||
   function Read_Total_In (Stream : in Stream_Type) return Count;
 | 
			
		||||
   pragma Inline (Read_Total_In);
 | 
			
		||||
   --  Return total number of bytes read from back stream so far.
 | 
			
		||||
 | 
			
		||||
   function Read_Total_Out (Stream : in Stream_Type) return Count;
 | 
			
		||||
   pragma Inline (Read_Total_Out);
 | 
			
		||||
   --  Return total number of bytes read so far.
 | 
			
		||||
 | 
			
		||||
   function Write_Total_In (Stream : in Stream_Type) return Count;
 | 
			
		||||
   pragma Inline (Write_Total_In);
 | 
			
		||||
   --  Return total number of bytes written so far.
 | 
			
		||||
 | 
			
		||||
   function Write_Total_Out (Stream : in Stream_Type) return Count;
 | 
			
		||||
   pragma Inline (Write_Total_Out);
 | 
			
		||||
   --  Return total number of bytes written to the back stream.
 | 
			
		||||
 | 
			
		||||
   procedure Create
 | 
			
		||||
     (Stream            :    out Stream_Type;
 | 
			
		||||
      Mode              : in     Stream_Mode;
 | 
			
		||||
      Back              : in     Stream_Access;
 | 
			
		||||
      Back_Compressed   : in     Boolean;
 | 
			
		||||
      Level             : in     Compression_Level := Default_Compression;
 | 
			
		||||
      Strategy          : in     Strategy_Type     := Default_Strategy;
 | 
			
		||||
      Header            : in     Header_Type       := Default;
 | 
			
		||||
      Read_Buffer_Size  : in     Ada.Streams.Stream_Element_Offset
 | 
			
		||||
                                    := Default_Buffer_Size;
 | 
			
		||||
      Write_Buffer_Size : in     Ada.Streams.Stream_Element_Offset
 | 
			
		||||
                                    := Default_Buffer_Size);
 | 
			
		||||
   --  Create the Comression/Decompression stream.
 | 
			
		||||
   --  If mode is In_Stream then Write operation is disabled.
 | 
			
		||||
   --  If mode is Out_Stream then Read operation is disabled.
 | 
			
		||||
 | 
			
		||||
   --  If Back_Compressed is true then
 | 
			
		||||
   --  Data written to the Stream is compressing to the Back stream
 | 
			
		||||
   --  and data read from the Stream is decompressed data from the Back stream.
 | 
			
		||||
 | 
			
		||||
   --  If Back_Compressed is false then
 | 
			
		||||
   --  Data written to the Stream is decompressing to the Back stream
 | 
			
		||||
   --  and data read from the Stream is compressed data from the Back stream.
 | 
			
		||||
 | 
			
		||||
   --  !!! When the Need_Header is False ZLib-Ada is using undocumented
 | 
			
		||||
   --  ZLib 1.1.4 functionality to do not create/wait for ZLib headers.
 | 
			
		||||
 | 
			
		||||
   function Is_Open (Stream : Stream_Type) return Boolean;
 | 
			
		||||
 | 
			
		||||
   procedure Close (Stream : in out Stream_Type);
 | 
			
		||||
 | 
			
		||||
private
 | 
			
		||||
 | 
			
		||||
   use Ada.Streams;
 | 
			
		||||
 | 
			
		||||
   type Buffer_Access is access all Stream_Element_Array;
 | 
			
		||||
 | 
			
		||||
   type Stream_Type
 | 
			
		||||
     is new Root_Stream_Type with
 | 
			
		||||
   record
 | 
			
		||||
      Mode       : Stream_Mode;
 | 
			
		||||
 | 
			
		||||
      Buffer     : Buffer_Access;
 | 
			
		||||
      Rest_First : Stream_Element_Offset;
 | 
			
		||||
      Rest_Last  : Stream_Element_Offset;
 | 
			
		||||
      --  Buffer for Read operation.
 | 
			
		||||
      --  We need to have this buffer in the record
 | 
			
		||||
      --  because not all read data from back stream
 | 
			
		||||
      --  could be processed during the read operation.
 | 
			
		||||
 | 
			
		||||
      Buffer_Size : Stream_Element_Offset;
 | 
			
		||||
      --  Buffer size for write operation.
 | 
			
		||||
      --  We do not need to have this buffer
 | 
			
		||||
      --  in the record because all data could be
 | 
			
		||||
      --  processed in the write operation.
 | 
			
		||||
 | 
			
		||||
      Back       : Stream_Access;
 | 
			
		||||
      Reader     : Filter_Type;
 | 
			
		||||
      Writer     : Filter_Type;
 | 
			
		||||
   end record;
 | 
			
		||||
 | 
			
		||||
end ZLib.Streams;
 | 
			
		||||
							
								
								
									
										141
									
								
								third_party/zlib/contrib/ada/zlib-thin.adb
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										141
									
								
								third_party/zlib/contrib/ada/zlib-thin.adb
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,141 @@
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
--  ZLib for Ada thick binding.                               --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Copyright (C) 2002-2003 Dmitriy Anisimkov                 --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Open source license information is in the zlib.ads file.  --
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
 | 
			
		||||
--  $Id: zlib-thin.adb,v 1.8 2003/12/14 18:27:31 vagul Exp $
 | 
			
		||||
 | 
			
		||||
package body ZLib.Thin is
 | 
			
		||||
 | 
			
		||||
   ZLIB_VERSION  : constant Chars_Ptr := zlibVersion;
 | 
			
		||||
 | 
			
		||||
   Z_Stream_Size : constant Int := Z_Stream'Size / System.Storage_Unit;
 | 
			
		||||
 | 
			
		||||
   --------------
 | 
			
		||||
   -- Avail_In --
 | 
			
		||||
   --------------
 | 
			
		||||
 | 
			
		||||
   function Avail_In (Strm : in Z_Stream) return UInt is
 | 
			
		||||
   begin
 | 
			
		||||
      return Strm.Avail_In;
 | 
			
		||||
   end Avail_In;
 | 
			
		||||
 | 
			
		||||
   ---------------
 | 
			
		||||
   -- Avail_Out --
 | 
			
		||||
   ---------------
 | 
			
		||||
 | 
			
		||||
   function Avail_Out (Strm : in Z_Stream) return UInt is
 | 
			
		||||
   begin
 | 
			
		||||
      return Strm.Avail_Out;
 | 
			
		||||
   end Avail_Out;
 | 
			
		||||
 | 
			
		||||
   ------------------
 | 
			
		||||
   -- Deflate_Init --
 | 
			
		||||
   ------------------
 | 
			
		||||
 | 
			
		||||
   function Deflate_Init
 | 
			
		||||
     (strm       : Z_Streamp;
 | 
			
		||||
      level      : Int;
 | 
			
		||||
      method     : Int;
 | 
			
		||||
      windowBits : Int;
 | 
			
		||||
      memLevel   : Int;
 | 
			
		||||
      strategy   : Int)
 | 
			
		||||
      return       Int is
 | 
			
		||||
   begin
 | 
			
		||||
      return deflateInit2
 | 
			
		||||
               (strm,
 | 
			
		||||
                level,
 | 
			
		||||
                method,
 | 
			
		||||
                windowBits,
 | 
			
		||||
                memLevel,
 | 
			
		||||
                strategy,
 | 
			
		||||
                ZLIB_VERSION,
 | 
			
		||||
                Z_Stream_Size);
 | 
			
		||||
   end Deflate_Init;
 | 
			
		||||
 | 
			
		||||
   ------------------
 | 
			
		||||
   -- Inflate_Init --
 | 
			
		||||
   ------------------
 | 
			
		||||
 | 
			
		||||
   function Inflate_Init (strm : Z_Streamp; windowBits : Int) return Int is
 | 
			
		||||
   begin
 | 
			
		||||
      return inflateInit2 (strm, windowBits, ZLIB_VERSION, Z_Stream_Size);
 | 
			
		||||
   end Inflate_Init;
 | 
			
		||||
 | 
			
		||||
   ------------------------
 | 
			
		||||
   -- Last_Error_Message --
 | 
			
		||||
   ------------------------
 | 
			
		||||
 | 
			
		||||
   function Last_Error_Message (Strm : in Z_Stream) return String is
 | 
			
		||||
      use Interfaces.C.Strings;
 | 
			
		||||
   begin
 | 
			
		||||
      if Strm.msg = Null_Ptr then
 | 
			
		||||
         return "";
 | 
			
		||||
      else
 | 
			
		||||
         return Value (Strm.msg);
 | 
			
		||||
      end if;
 | 
			
		||||
   end Last_Error_Message;
 | 
			
		||||
 | 
			
		||||
   ------------
 | 
			
		||||
   -- Set_In --
 | 
			
		||||
   ------------
 | 
			
		||||
 | 
			
		||||
   procedure Set_In
 | 
			
		||||
     (Strm   : in out Z_Stream;
 | 
			
		||||
      Buffer : in     Voidp;
 | 
			
		||||
      Size   : in     UInt) is
 | 
			
		||||
   begin
 | 
			
		||||
      Strm.Next_In  := Buffer;
 | 
			
		||||
      Strm.Avail_In := Size;
 | 
			
		||||
   end Set_In;
 | 
			
		||||
 | 
			
		||||
   ------------------
 | 
			
		||||
   -- Set_Mem_Func --
 | 
			
		||||
   ------------------
 | 
			
		||||
 | 
			
		||||
   procedure Set_Mem_Func
 | 
			
		||||
     (Strm   : in out Z_Stream;
 | 
			
		||||
      Opaque : in     Voidp;
 | 
			
		||||
      Alloc  : in     alloc_func;
 | 
			
		||||
      Free   : in     free_func) is
 | 
			
		||||
   begin
 | 
			
		||||
      Strm.opaque := Opaque;
 | 
			
		||||
      Strm.zalloc := Alloc;
 | 
			
		||||
      Strm.zfree  := Free;
 | 
			
		||||
   end Set_Mem_Func;
 | 
			
		||||
 | 
			
		||||
   -------------
 | 
			
		||||
   -- Set_Out --
 | 
			
		||||
   -------------
 | 
			
		||||
 | 
			
		||||
   procedure Set_Out
 | 
			
		||||
     (Strm   : in out Z_Stream;
 | 
			
		||||
      Buffer : in     Voidp;
 | 
			
		||||
      Size   : in     UInt) is
 | 
			
		||||
   begin
 | 
			
		||||
      Strm.Next_Out  := Buffer;
 | 
			
		||||
      Strm.Avail_Out := Size;
 | 
			
		||||
   end Set_Out;
 | 
			
		||||
 | 
			
		||||
   --------------
 | 
			
		||||
   -- Total_In --
 | 
			
		||||
   --------------
 | 
			
		||||
 | 
			
		||||
   function Total_In (Strm : in Z_Stream) return ULong is
 | 
			
		||||
   begin
 | 
			
		||||
      return Strm.Total_In;
 | 
			
		||||
   end Total_In;
 | 
			
		||||
 | 
			
		||||
   ---------------
 | 
			
		||||
   -- Total_Out --
 | 
			
		||||
   ---------------
 | 
			
		||||
 | 
			
		||||
   function Total_Out (Strm : in Z_Stream) return ULong is
 | 
			
		||||
   begin
 | 
			
		||||
      return Strm.Total_Out;
 | 
			
		||||
   end Total_Out;
 | 
			
		||||
 | 
			
		||||
end ZLib.Thin;
 | 
			
		||||
							
								
								
									
										450
									
								
								third_party/zlib/contrib/ada/zlib-thin.ads
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										450
									
								
								third_party/zlib/contrib/ada/zlib-thin.ads
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,450 @@
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
--  ZLib for Ada thick binding.                               --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Copyright (C) 2002-2003 Dmitriy Anisimkov                 --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Open source license information is in the zlib.ads file.  --
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
 | 
			
		||||
--  $Id: zlib-thin.ads,v 1.11 2004/07/23 06:33:11 vagul Exp $
 | 
			
		||||
 | 
			
		||||
with Interfaces.C.Strings;
 | 
			
		||||
 | 
			
		||||
with System;
 | 
			
		||||
 | 
			
		||||
private package ZLib.Thin is
 | 
			
		||||
 | 
			
		||||
   --  From zconf.h
 | 
			
		||||
 | 
			
		||||
   MAX_MEM_LEVEL : constant := 9;         --  zconf.h:105
 | 
			
		||||
                                          --  zconf.h:105
 | 
			
		||||
   MAX_WBITS : constant := 15;      --  zconf.h:115
 | 
			
		||||
                                    --  32K LZ77 window
 | 
			
		||||
                                    --  zconf.h:115
 | 
			
		||||
   SEEK_SET : constant := 8#0000#;  --  zconf.h:244
 | 
			
		||||
                                    --  Seek from beginning of file.
 | 
			
		||||
                                    --  zconf.h:244
 | 
			
		||||
   SEEK_CUR : constant := 1;        --  zconf.h:245
 | 
			
		||||
                                    --  Seek from current position.
 | 
			
		||||
                                    --  zconf.h:245
 | 
			
		||||
   SEEK_END : constant := 2;        --  zconf.h:246
 | 
			
		||||
                                    --  Set file pointer to EOF plus "offset"
 | 
			
		||||
                                    --  zconf.h:246
 | 
			
		||||
 | 
			
		||||
   type Byte is new Interfaces.C.unsigned_char; --  8 bits
 | 
			
		||||
                                                --  zconf.h:214
 | 
			
		||||
   type UInt is new Interfaces.C.unsigned;      --  16 bits or more
 | 
			
		||||
                                                --  zconf.h:216
 | 
			
		||||
   type Int is new Interfaces.C.int;
 | 
			
		||||
 | 
			
		||||
   type ULong is new Interfaces.C.unsigned_long;     --  32 bits or more
 | 
			
		||||
                                                     --  zconf.h:217
 | 
			
		||||
   subtype Chars_Ptr is Interfaces.C.Strings.chars_ptr;
 | 
			
		||||
 | 
			
		||||
   type ULong_Access is access ULong;
 | 
			
		||||
   type Int_Access is access Int;
 | 
			
		||||
 | 
			
		||||
   subtype Voidp is System.Address;            --  zconf.h:232
 | 
			
		||||
 | 
			
		||||
   subtype Byte_Access is Voidp;
 | 
			
		||||
 | 
			
		||||
   Nul : constant Voidp := System.Null_Address;
 | 
			
		||||
   --  end from zconf
 | 
			
		||||
 | 
			
		||||
   Z_NO_FLUSH : constant := 8#0000#;   --  zlib.h:125
 | 
			
		||||
                                       --  zlib.h:125
 | 
			
		||||
   Z_PARTIAL_FLUSH : constant := 1;       --  zlib.h:126
 | 
			
		||||
                                          --  will be removed, use
 | 
			
		||||
                                          --  Z_SYNC_FLUSH instead
 | 
			
		||||
                                          --  zlib.h:126
 | 
			
		||||
   Z_SYNC_FLUSH : constant := 2;       --  zlib.h:127
 | 
			
		||||
                                       --  zlib.h:127
 | 
			
		||||
   Z_FULL_FLUSH : constant := 3;       --  zlib.h:128
 | 
			
		||||
                                       --  zlib.h:128
 | 
			
		||||
   Z_FINISH : constant := 4;        --  zlib.h:129
 | 
			
		||||
                                    --  zlib.h:129
 | 
			
		||||
   Z_OK : constant := 8#0000#;   --  zlib.h:132
 | 
			
		||||
                                 --  zlib.h:132
 | 
			
		||||
   Z_STREAM_END : constant := 1;       --  zlib.h:133
 | 
			
		||||
                                       --  zlib.h:133
 | 
			
		||||
   Z_NEED_DICT : constant := 2;        --  zlib.h:134
 | 
			
		||||
                                       --  zlib.h:134
 | 
			
		||||
   Z_ERRNO : constant := -1;        --  zlib.h:135
 | 
			
		||||
                                    --  zlib.h:135
 | 
			
		||||
   Z_STREAM_ERROR : constant := -2;       --  zlib.h:136
 | 
			
		||||
                                          --  zlib.h:136
 | 
			
		||||
   Z_DATA_ERROR : constant := -3;      --  zlib.h:137
 | 
			
		||||
                                       --  zlib.h:137
 | 
			
		||||
   Z_MEM_ERROR : constant := -4;       --  zlib.h:138
 | 
			
		||||
                                       --  zlib.h:138
 | 
			
		||||
   Z_BUF_ERROR : constant := -5;       --  zlib.h:139
 | 
			
		||||
                                       --  zlib.h:139
 | 
			
		||||
   Z_VERSION_ERROR : constant := -6;      --  zlib.h:140
 | 
			
		||||
                                          --  zlib.h:140
 | 
			
		||||
   Z_NO_COMPRESSION : constant := 8#0000#;   --  zlib.h:145
 | 
			
		||||
                                             --  zlib.h:145
 | 
			
		||||
   Z_BEST_SPEED : constant := 1;       --  zlib.h:146
 | 
			
		||||
                                       --  zlib.h:146
 | 
			
		||||
   Z_BEST_COMPRESSION : constant := 9;       --  zlib.h:147
 | 
			
		||||
                                             --  zlib.h:147
 | 
			
		||||
   Z_DEFAULT_COMPRESSION : constant := -1;      --  zlib.h:148
 | 
			
		||||
                                                --  zlib.h:148
 | 
			
		||||
   Z_FILTERED : constant := 1;      --  zlib.h:151
 | 
			
		||||
                                    --  zlib.h:151
 | 
			
		||||
   Z_HUFFMAN_ONLY : constant := 2;        --  zlib.h:152
 | 
			
		||||
                                          --  zlib.h:152
 | 
			
		||||
   Z_DEFAULT_STRATEGY : constant := 8#0000#; --  zlib.h:153
 | 
			
		||||
                                             --  zlib.h:153
 | 
			
		||||
   Z_BINARY : constant := 8#0000#;  --  zlib.h:156
 | 
			
		||||
                                    --  zlib.h:156
 | 
			
		||||
   Z_ASCII : constant := 1;      --  zlib.h:157
 | 
			
		||||
                                 --  zlib.h:157
 | 
			
		||||
   Z_UNKNOWN : constant := 2;       --  zlib.h:158
 | 
			
		||||
                                    --  zlib.h:158
 | 
			
		||||
   Z_DEFLATED : constant := 8;      --  zlib.h:161
 | 
			
		||||
                                    --  zlib.h:161
 | 
			
		||||
   Z_NULL : constant := 8#0000#; --  zlib.h:164
 | 
			
		||||
                                 --  for initializing zalloc, zfree, opaque
 | 
			
		||||
                                 --  zlib.h:164
 | 
			
		||||
   type gzFile is new Voidp;                  --  zlib.h:646
 | 
			
		||||
 | 
			
		||||
   type Z_Stream is private;
 | 
			
		||||
 | 
			
		||||
   type Z_Streamp is access all Z_Stream;     --  zlib.h:89
 | 
			
		||||
 | 
			
		||||
   type alloc_func is access function
 | 
			
		||||
     (Opaque : Voidp;
 | 
			
		||||
      Items  : UInt;
 | 
			
		||||
      Size   : UInt)
 | 
			
		||||
      return Voidp; --  zlib.h:63
 | 
			
		||||
 | 
			
		||||
   type free_func is access procedure (opaque : Voidp; address : Voidp);
 | 
			
		||||
 | 
			
		||||
   function zlibVersion return Chars_Ptr;
 | 
			
		||||
 | 
			
		||||
   function Deflate (strm : Z_Streamp; flush : Int) return Int;
 | 
			
		||||
 | 
			
		||||
   function DeflateEnd (strm : Z_Streamp) return Int;
 | 
			
		||||
 | 
			
		||||
   function Inflate (strm : Z_Streamp; flush : Int) return Int;
 | 
			
		||||
 | 
			
		||||
   function InflateEnd (strm : Z_Streamp) return Int;
 | 
			
		||||
 | 
			
		||||
   function deflateSetDictionary
 | 
			
		||||
     (strm       : Z_Streamp;
 | 
			
		||||
      dictionary : Byte_Access;
 | 
			
		||||
      dictLength : UInt)
 | 
			
		||||
      return       Int;
 | 
			
		||||
 | 
			
		||||
   function deflateCopy (dest : Z_Streamp; source : Z_Streamp) return Int;
 | 
			
		||||
   --  zlib.h:478
 | 
			
		||||
 | 
			
		||||
   function deflateReset (strm : Z_Streamp) return Int; -- zlib.h:495
 | 
			
		||||
 | 
			
		||||
   function deflateParams
 | 
			
		||||
     (strm     : Z_Streamp;
 | 
			
		||||
      level    : Int;
 | 
			
		||||
      strategy : Int)
 | 
			
		||||
      return     Int;       -- zlib.h:506
 | 
			
		||||
 | 
			
		||||
   function inflateSetDictionary
 | 
			
		||||
     (strm       : Z_Streamp;
 | 
			
		||||
      dictionary : Byte_Access;
 | 
			
		||||
      dictLength : UInt)
 | 
			
		||||
      return       Int; --  zlib.h:548
 | 
			
		||||
 | 
			
		||||
   function inflateSync (strm : Z_Streamp) return Int;  --  zlib.h:565
 | 
			
		||||
 | 
			
		||||
   function inflateReset (strm : Z_Streamp) return Int; --  zlib.h:580
 | 
			
		||||
 | 
			
		||||
   function compress
 | 
			
		||||
     (dest      : Byte_Access;
 | 
			
		||||
      destLen   : ULong_Access;
 | 
			
		||||
      source    : Byte_Access;
 | 
			
		||||
      sourceLen : ULong)
 | 
			
		||||
      return      Int;           -- zlib.h:601
 | 
			
		||||
 | 
			
		||||
   function compress2
 | 
			
		||||
     (dest      : Byte_Access;
 | 
			
		||||
      destLen   : ULong_Access;
 | 
			
		||||
      source    : Byte_Access;
 | 
			
		||||
      sourceLen : ULong;
 | 
			
		||||
      level     : Int)
 | 
			
		||||
      return      Int;          -- zlib.h:615
 | 
			
		||||
 | 
			
		||||
   function uncompress
 | 
			
		||||
     (dest      : Byte_Access;
 | 
			
		||||
      destLen   : ULong_Access;
 | 
			
		||||
      source    : Byte_Access;
 | 
			
		||||
      sourceLen : ULong)
 | 
			
		||||
      return      Int;
 | 
			
		||||
 | 
			
		||||
   function gzopen (path : Chars_Ptr; mode : Chars_Ptr) return gzFile;
 | 
			
		||||
 | 
			
		||||
   function gzdopen (fd : Int; mode : Chars_Ptr) return gzFile;
 | 
			
		||||
 | 
			
		||||
   function gzsetparams
 | 
			
		||||
     (file     : gzFile;
 | 
			
		||||
      level    : Int;
 | 
			
		||||
      strategy : Int)
 | 
			
		||||
      return     Int;
 | 
			
		||||
 | 
			
		||||
   function gzread
 | 
			
		||||
     (file : gzFile;
 | 
			
		||||
      buf  : Voidp;
 | 
			
		||||
      len  : UInt)
 | 
			
		||||
      return Int;
 | 
			
		||||
 | 
			
		||||
   function gzwrite
 | 
			
		||||
     (file : in gzFile;
 | 
			
		||||
      buf  : in Voidp;
 | 
			
		||||
      len  : in UInt)
 | 
			
		||||
      return Int;
 | 
			
		||||
 | 
			
		||||
   function gzprintf (file : in gzFile; format : in Chars_Ptr) return Int;
 | 
			
		||||
 | 
			
		||||
   function gzputs (file : in gzFile; s : in Chars_Ptr) return Int;
 | 
			
		||||
 | 
			
		||||
   function gzgets
 | 
			
		||||
     (file : gzFile;
 | 
			
		||||
      buf  : Chars_Ptr;
 | 
			
		||||
      len  : Int)
 | 
			
		||||
      return Chars_Ptr;
 | 
			
		||||
 | 
			
		||||
   function gzputc (file : gzFile; char : Int) return Int;
 | 
			
		||||
 | 
			
		||||
   function gzgetc (file : gzFile) return Int;
 | 
			
		||||
 | 
			
		||||
   function gzflush (file : gzFile; flush : Int) return Int;
 | 
			
		||||
 | 
			
		||||
   function gzseek
 | 
			
		||||
     (file   : gzFile;
 | 
			
		||||
      offset : Int;
 | 
			
		||||
      whence : Int)
 | 
			
		||||
      return   Int;
 | 
			
		||||
 | 
			
		||||
   function gzrewind (file : gzFile) return Int;
 | 
			
		||||
 | 
			
		||||
   function gztell (file : gzFile) return Int;
 | 
			
		||||
 | 
			
		||||
   function gzeof (file : gzFile) return Int;
 | 
			
		||||
 | 
			
		||||
   function gzclose (file : gzFile) return Int;
 | 
			
		||||
 | 
			
		||||
   function gzerror (file : gzFile; errnum : Int_Access) return Chars_Ptr;
 | 
			
		||||
 | 
			
		||||
   function adler32
 | 
			
		||||
     (adler : ULong;
 | 
			
		||||
      buf   : Byte_Access;
 | 
			
		||||
      len   : UInt)
 | 
			
		||||
      return  ULong;
 | 
			
		||||
 | 
			
		||||
   function crc32
 | 
			
		||||
     (crc  : ULong;
 | 
			
		||||
      buf  : Byte_Access;
 | 
			
		||||
      len  : UInt)
 | 
			
		||||
      return ULong;
 | 
			
		||||
 | 
			
		||||
   function deflateInit
 | 
			
		||||
     (strm        : Z_Streamp;
 | 
			
		||||
      level       : Int;
 | 
			
		||||
      version     : Chars_Ptr;
 | 
			
		||||
      stream_size : Int)
 | 
			
		||||
      return        Int;
 | 
			
		||||
 | 
			
		||||
   function deflateInit2
 | 
			
		||||
     (strm        : Z_Streamp;
 | 
			
		||||
      level       : Int;
 | 
			
		||||
      method      : Int;
 | 
			
		||||
      windowBits  : Int;
 | 
			
		||||
      memLevel    : Int;
 | 
			
		||||
      strategy    : Int;
 | 
			
		||||
      version     : Chars_Ptr;
 | 
			
		||||
      stream_size : Int)
 | 
			
		||||
      return        Int;
 | 
			
		||||
 | 
			
		||||
   function Deflate_Init
 | 
			
		||||
     (strm       : Z_Streamp;
 | 
			
		||||
      level      : Int;
 | 
			
		||||
      method     : Int;
 | 
			
		||||
      windowBits : Int;
 | 
			
		||||
      memLevel   : Int;
 | 
			
		||||
      strategy   : Int)
 | 
			
		||||
      return       Int;
 | 
			
		||||
   pragma Inline (Deflate_Init);
 | 
			
		||||
 | 
			
		||||
   function inflateInit
 | 
			
		||||
     (strm        : Z_Streamp;
 | 
			
		||||
      version     : Chars_Ptr;
 | 
			
		||||
      stream_size : Int)
 | 
			
		||||
      return        Int;
 | 
			
		||||
 | 
			
		||||
   function inflateInit2
 | 
			
		||||
     (strm        : in Z_Streamp;
 | 
			
		||||
      windowBits  : in Int;
 | 
			
		||||
      version     : in Chars_Ptr;
 | 
			
		||||
      stream_size : in Int)
 | 
			
		||||
      return      Int;
 | 
			
		||||
 | 
			
		||||
   function inflateBackInit
 | 
			
		||||
     (strm        : in Z_Streamp;
 | 
			
		||||
      windowBits  : in Int;
 | 
			
		||||
      window      : in Byte_Access;
 | 
			
		||||
      version     : in Chars_Ptr;
 | 
			
		||||
      stream_size : in Int)
 | 
			
		||||
      return      Int;
 | 
			
		||||
   --  Size of window have to be 2**windowBits.
 | 
			
		||||
 | 
			
		||||
   function Inflate_Init (strm : Z_Streamp; windowBits : Int) return Int;
 | 
			
		||||
   pragma Inline (Inflate_Init);
 | 
			
		||||
 | 
			
		||||
   function zError (err : Int) return Chars_Ptr;
 | 
			
		||||
 | 
			
		||||
   function inflateSyncPoint (z : Z_Streamp) return Int;
 | 
			
		||||
 | 
			
		||||
   function get_crc_table return ULong_Access;
 | 
			
		||||
 | 
			
		||||
   --  Interface to the available fields of the z_stream structure.
 | 
			
		||||
   --  The application must update next_in and avail_in when avail_in has
 | 
			
		||||
   --  dropped to zero. It must update next_out and avail_out when avail_out
 | 
			
		||||
   --  has dropped to zero. The application must initialize zalloc, zfree and
 | 
			
		||||
   --  opaque before calling the init function.
 | 
			
		||||
 | 
			
		||||
   procedure Set_In
 | 
			
		||||
     (Strm   : in out Z_Stream;
 | 
			
		||||
      Buffer : in Voidp;
 | 
			
		||||
      Size   : in UInt);
 | 
			
		||||
   pragma Inline (Set_In);
 | 
			
		||||
 | 
			
		||||
   procedure Set_Out
 | 
			
		||||
     (Strm   : in out Z_Stream;
 | 
			
		||||
      Buffer : in Voidp;
 | 
			
		||||
      Size   : in UInt);
 | 
			
		||||
   pragma Inline (Set_Out);
 | 
			
		||||
 | 
			
		||||
   procedure Set_Mem_Func
 | 
			
		||||
     (Strm   : in out Z_Stream;
 | 
			
		||||
      Opaque : in Voidp;
 | 
			
		||||
      Alloc  : in alloc_func;
 | 
			
		||||
      Free   : in free_func);
 | 
			
		||||
   pragma Inline (Set_Mem_Func);
 | 
			
		||||
 | 
			
		||||
   function Last_Error_Message (Strm : in Z_Stream) return String;
 | 
			
		||||
   pragma Inline (Last_Error_Message);
 | 
			
		||||
 | 
			
		||||
   function Avail_Out (Strm : in Z_Stream) return UInt;
 | 
			
		||||
   pragma Inline (Avail_Out);
 | 
			
		||||
 | 
			
		||||
   function Avail_In (Strm : in Z_Stream) return UInt;
 | 
			
		||||
   pragma Inline (Avail_In);
 | 
			
		||||
 | 
			
		||||
   function Total_In (Strm : in Z_Stream) return ULong;
 | 
			
		||||
   pragma Inline (Total_In);
 | 
			
		||||
 | 
			
		||||
   function Total_Out (Strm : in Z_Stream) return ULong;
 | 
			
		||||
   pragma Inline (Total_Out);
 | 
			
		||||
 | 
			
		||||
   function inflateCopy
 | 
			
		||||
     (dest   : in Z_Streamp;
 | 
			
		||||
      Source : in Z_Streamp)
 | 
			
		||||
      return Int;
 | 
			
		||||
 | 
			
		||||
   function compressBound (Source_Len : in ULong) return ULong;
 | 
			
		||||
 | 
			
		||||
   function deflateBound
 | 
			
		||||
     (Strm       : in Z_Streamp;
 | 
			
		||||
      Source_Len : in ULong)
 | 
			
		||||
      return     ULong;
 | 
			
		||||
 | 
			
		||||
   function gzungetc (C : in Int; File : in  gzFile) return Int;
 | 
			
		||||
 | 
			
		||||
   function zlibCompileFlags return ULong;
 | 
			
		||||
 | 
			
		||||
private
 | 
			
		||||
 | 
			
		||||
   type Z_Stream is record            -- zlib.h:68
 | 
			
		||||
      Next_In   : Voidp      := Nul;  -- next input byte
 | 
			
		||||
      Avail_In  : UInt       := 0;    -- number of bytes available at next_in
 | 
			
		||||
      Total_In  : ULong      := 0;    -- total nb of input bytes read so far
 | 
			
		||||
      Next_Out  : Voidp      := Nul;  -- next output byte should be put there
 | 
			
		||||
      Avail_Out : UInt       := 0;    -- remaining free space at next_out
 | 
			
		||||
      Total_Out : ULong      := 0;    -- total nb of bytes output so far
 | 
			
		||||
      msg       : Chars_Ptr;          -- last error message, NULL if no error
 | 
			
		||||
      state     : Voidp;              -- not visible by applications
 | 
			
		||||
      zalloc    : alloc_func := null; -- used to allocate the internal state
 | 
			
		||||
      zfree     : free_func  := null; -- used to free the internal state
 | 
			
		||||
      opaque    : Voidp;              -- private data object passed to
 | 
			
		||||
                                      --  zalloc and zfree
 | 
			
		||||
      data_type : Int;                -- best guess about the data type:
 | 
			
		||||
                                      --  ascii or binary
 | 
			
		||||
      adler     : ULong;              -- adler32 value of the uncompressed
 | 
			
		||||
                                      --  data
 | 
			
		||||
      reserved  : ULong;              -- reserved for future use
 | 
			
		||||
   end record;
 | 
			
		||||
 | 
			
		||||
   pragma Convention (C, Z_Stream);
 | 
			
		||||
 | 
			
		||||
   pragma Import (C, zlibVersion, "zlibVersion");
 | 
			
		||||
   pragma Import (C, Deflate, "deflate");
 | 
			
		||||
   pragma Import (C, DeflateEnd, "deflateEnd");
 | 
			
		||||
   pragma Import (C, Inflate, "inflate");
 | 
			
		||||
   pragma Import (C, InflateEnd, "inflateEnd");
 | 
			
		||||
   pragma Import (C, deflateSetDictionary, "deflateSetDictionary");
 | 
			
		||||
   pragma Import (C, deflateCopy, "deflateCopy");
 | 
			
		||||
   pragma Import (C, deflateReset, "deflateReset");
 | 
			
		||||
   pragma Import (C, deflateParams, "deflateParams");
 | 
			
		||||
   pragma Import (C, inflateSetDictionary, "inflateSetDictionary");
 | 
			
		||||
   pragma Import (C, inflateSync, "inflateSync");
 | 
			
		||||
   pragma Import (C, inflateReset, "inflateReset");
 | 
			
		||||
   pragma Import (C, compress, "compress");
 | 
			
		||||
   pragma Import (C, compress2, "compress2");
 | 
			
		||||
   pragma Import (C, uncompress, "uncompress");
 | 
			
		||||
   pragma Import (C, gzopen, "gzopen");
 | 
			
		||||
   pragma Import (C, gzdopen, "gzdopen");
 | 
			
		||||
   pragma Import (C, gzsetparams, "gzsetparams");
 | 
			
		||||
   pragma Import (C, gzread, "gzread");
 | 
			
		||||
   pragma Import (C, gzwrite, "gzwrite");
 | 
			
		||||
   pragma Import (C, gzprintf, "gzprintf");
 | 
			
		||||
   pragma Import (C, gzputs, "gzputs");
 | 
			
		||||
   pragma Import (C, gzgets, "gzgets");
 | 
			
		||||
   pragma Import (C, gzputc, "gzputc");
 | 
			
		||||
   pragma Import (C, gzgetc, "gzgetc");
 | 
			
		||||
   pragma Import (C, gzflush, "gzflush");
 | 
			
		||||
   pragma Import (C, gzseek, "gzseek");
 | 
			
		||||
   pragma Import (C, gzrewind, "gzrewind");
 | 
			
		||||
   pragma Import (C, gztell, "gztell");
 | 
			
		||||
   pragma Import (C, gzeof, "gzeof");
 | 
			
		||||
   pragma Import (C, gzclose, "gzclose");
 | 
			
		||||
   pragma Import (C, gzerror, "gzerror");
 | 
			
		||||
   pragma Import (C, adler32, "adler32");
 | 
			
		||||
   pragma Import (C, crc32, "crc32");
 | 
			
		||||
   pragma Import (C, deflateInit, "deflateInit_");
 | 
			
		||||
   pragma Import (C, inflateInit, "inflateInit_");
 | 
			
		||||
   pragma Import (C, deflateInit2, "deflateInit2_");
 | 
			
		||||
   pragma Import (C, inflateInit2, "inflateInit2_");
 | 
			
		||||
   pragma Import (C, zError, "zError");
 | 
			
		||||
   pragma Import (C, inflateSyncPoint, "inflateSyncPoint");
 | 
			
		||||
   pragma Import (C, get_crc_table, "get_crc_table");
 | 
			
		||||
 | 
			
		||||
   --  since zlib 1.2.0:
 | 
			
		||||
 | 
			
		||||
   pragma Import (C, inflateCopy, "inflateCopy");
 | 
			
		||||
   pragma Import (C, compressBound, "compressBound");
 | 
			
		||||
   pragma Import (C, deflateBound, "deflateBound");
 | 
			
		||||
   pragma Import (C, gzungetc, "gzungetc");
 | 
			
		||||
   pragma Import (C, zlibCompileFlags, "zlibCompileFlags");
 | 
			
		||||
 | 
			
		||||
   pragma Import (C, inflateBackInit, "inflateBackInit_");
 | 
			
		||||
 | 
			
		||||
   --  I stopped binding the inflateBack routines, because realize that
 | 
			
		||||
   --  it does not support zlib and gzip headers for now, and have no
 | 
			
		||||
   --  symmetric deflateBack routines.
 | 
			
		||||
   --  ZLib-Ada is symmetric regarding deflate/inflate data transformation
 | 
			
		||||
   --  and has a similar generic callback interface for the
 | 
			
		||||
   --  deflate/inflate transformation based on the regular Deflate/Inflate
 | 
			
		||||
   --  routines.
 | 
			
		||||
 | 
			
		||||
   --  pragma Import (C, inflateBack, "inflateBack");
 | 
			
		||||
   --  pragma Import (C, inflateBackEnd, "inflateBackEnd");
 | 
			
		||||
 | 
			
		||||
end ZLib.Thin;
 | 
			
		||||
							
								
								
									
										701
									
								
								third_party/zlib/contrib/ada/zlib.adb
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										701
									
								
								third_party/zlib/contrib/ada/zlib.adb
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,701 @@
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
--  ZLib for Ada thick binding.                               --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Copyright (C) 2002-2004 Dmitriy Anisimkov                 --
 | 
			
		||||
--                                                            --
 | 
			
		||||
--  Open source license information is in the zlib.ads file.  --
 | 
			
		||||
----------------------------------------------------------------
 | 
			
		||||
 | 
			
		||||
--  $Id: zlib.adb,v 1.31 2004/09/06 06:53:19 vagul Exp $
 | 
			
		||||
 | 
			
		||||
with Ada.Exceptions;
 | 
			
		||||
with Ada.Unchecked_Conversion;
 | 
			
		||||
with Ada.Unchecked_Deallocation;
 | 
			
		||||
 | 
			
		||||
with Interfaces.C.Strings;
 | 
			
		||||
 | 
			
		||||
with ZLib.Thin;
 | 
			
		||||
 | 
			
		||||
package body ZLib is
 | 
			
		||||
 | 
			
		||||
   use type Thin.Int;
 | 
			
		||||
 | 
			
		||||
   type Z_Stream is new Thin.Z_Stream;
 | 
			
		||||
 | 
			
		||||
   type Return_Code_Enum is
 | 
			
		||||
      (OK,
 | 
			
		||||
       STREAM_END,
 | 
			
		||||
       NEED_DICT,
 | 
			
		||||
       ERRNO,
 | 
			
		||||
       STREAM_ERROR,
 | 
			
		||||
       DATA_ERROR,
 | 
			
		||||
       MEM_ERROR,
 | 
			
		||||
       BUF_ERROR,
 | 
			
		||||
       VERSION_ERROR);
 | 
			
		||||
 | 
			
		||||
   type Flate_Step_Function is access
 | 
			
		||||
     function (Strm : in Thin.Z_Streamp; Flush : in Thin.Int) return Thin.Int;
 | 
			
		||||
   pragma Convention (C, Flate_Step_Function);
 | 
			
		||||
 | 
			
		||||
   type Flate_End_Function is access
 | 
			
		||||
      function (Ctrm : in Thin.Z_Streamp) return Thin.Int;
 | 
			
		||||
   pragma Convention (C, Flate_End_Function);
 | 
			
		||||
 | 
			
		||||
   type Flate_Type is record
 | 
			
		||||
      Step : Flate_Step_Function;
 | 
			
		||||
      Done : Flate_End_Function;
 | 
			
		||||
   end record;
 | 
			
		||||
 | 
			
		||||
   subtype Footer_Array is Stream_Element_Array (1 .. 8);
 | 
			
		||||
 | 
			
		||||
   Simple_GZip_Header : constant Stream_Element_Array (1 .. 10)
 | 
			
		||||
     := (16#1f#, 16#8b#,                 --  Magic header
 | 
			
		||||
         16#08#,                         --  Z_DEFLATED
 | 
			
		||||
         16#00#,                         --  Flags
 | 
			
		||||
         16#00#, 16#00#, 16#00#, 16#00#, --  Time
 | 
			
		||||
         16#00#,                         --  XFlags
 | 
			
		||||
         16#03#                          --  OS code
 | 
			
		||||
        );
 | 
			
		||||
   --  The simplest gzip header is not for informational, but just for
 | 
			
		||||
   --  gzip format compatibility.
 | 
			
		||||
   --  Note that some code below is using assumption
 | 
			
		||||
   --  Simple_GZip_Header'Last > Footer_Array'Last, so do not make
 | 
			
		||||
   --  Simple_GZip_Header'Last <= Footer_Array'Last.
 | 
			
		||||
 | 
			
		||||
   Return_Code : constant array (Thin.Int range <>) of Return_Code_Enum
 | 
			
		||||
     := (0 => OK,
 | 
			
		||||
         1 => STREAM_END,
 | 
			
		||||
         2 => NEED_DICT,
 | 
			
		||||
        -1 => ERRNO,
 | 
			
		||||
        -2 => STREAM_ERROR,
 | 
			
		||||
        -3 => DATA_ERROR,
 | 
			
		||||
        -4 => MEM_ERROR,
 | 
			
		||||
        -5 => BUF_ERROR,
 | 
			
		||||
        -6 => VERSION_ERROR);
 | 
			
		||||
 | 
			
		||||
   Flate : constant array (Boolean) of Flate_Type
 | 
			
		||||
     := (True  => (Step => Thin.Deflate'Access,
 | 
			
		||||
                   Done => Thin.DeflateEnd'Access),
 | 
			
		||||
         False => (Step => Thin.Inflate'Access,
 | 
			
		||||
                   Done => Thin.InflateEnd'Access));
 | 
			
		||||
 | 
			
		||||
   Flush_Finish : constant array (Boolean) of Flush_Mode
 | 
			
		||||
     := (True => Finish, False => No_Flush);
 | 
			
		||||
 | 
			
		||||
   procedure Raise_Error (Stream : in Z_Stream);
 | 
			
		||||
   pragma Inline (Raise_Error);
 | 
			
		||||
 | 
			
		||||
   procedure Raise_Error (Message : in String);
 | 
			
		||||
   pragma Inline (Raise_Error);
 | 
			
		||||
 | 
			
		||||
   procedure Check_Error (Stream : in Z_Stream; Code : in Thin.Int);
 | 
			
		||||
 | 
			
		||||
   procedure Free is new Ada.Unchecked_Deallocation
 | 
			
		||||
      (Z_Stream, Z_Stream_Access);
 | 
			
		||||
 | 
			
		||||
   function To_Thin_Access is new Ada.Unchecked_Conversion
 | 
			
		||||
     (Z_Stream_Access, Thin.Z_Streamp);
 | 
			
		||||
 | 
			
		||||
   procedure Translate_GZip
 | 
			
		||||
     (Filter    : in out Filter_Type;
 | 
			
		||||
      In_Data   : in     Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      In_Last   :    out Ada.Streams.Stream_Element_Offset;
 | 
			
		||||
      Out_Data  :    out Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      Out_Last  :    out Ada.Streams.Stream_Element_Offset;
 | 
			
		||||
      Flush     : in     Flush_Mode);
 | 
			
		||||
   --  Separate translate routine for make gzip header.
 | 
			
		||||
 | 
			
		||||
   procedure Translate_Auto
 | 
			
		||||
     (Filter    : in out Filter_Type;
 | 
			
		||||
      In_Data   : in     Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      In_Last   :    out Ada.Streams.Stream_Element_Offset;
 | 
			
		||||
      Out_Data  :    out Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      Out_Last  :    out Ada.Streams.Stream_Element_Offset;
 | 
			
		||||
      Flush     : in     Flush_Mode);
 | 
			
		||||
   --  translate routine without additional headers.
 | 
			
		||||
 | 
			
		||||
   -----------------
 | 
			
		||||
   -- Check_Error --
 | 
			
		||||
   -----------------
 | 
			
		||||
 | 
			
		||||
   procedure Check_Error (Stream : in Z_Stream; Code : in Thin.Int) is
 | 
			
		||||
      use type Thin.Int;
 | 
			
		||||
   begin
 | 
			
		||||
      if Code /= Thin.Z_OK then
 | 
			
		||||
         Raise_Error
 | 
			
		||||
            (Return_Code_Enum'Image (Return_Code (Code))
 | 
			
		||||
              & ": " & Last_Error_Message (Stream));
 | 
			
		||||
      end if;
 | 
			
		||||
   end Check_Error;
 | 
			
		||||
 | 
			
		||||
   -----------
 | 
			
		||||
   -- Close --
 | 
			
		||||
   -----------
 | 
			
		||||
 | 
			
		||||
   procedure Close
 | 
			
		||||
     (Filter       : in out Filter_Type;
 | 
			
		||||
      Ignore_Error : in     Boolean := False)
 | 
			
		||||
   is
 | 
			
		||||
      Code : Thin.Int;
 | 
			
		||||
   begin
 | 
			
		||||
      if not Ignore_Error and then not Is_Open (Filter) then
 | 
			
		||||
         raise Status_Error;
 | 
			
		||||
      end if;
 | 
			
		||||
 | 
			
		||||
      Code := Flate (Filter.Compression).Done (To_Thin_Access (Filter.Strm));
 | 
			
		||||
 | 
			
		||||
      if Ignore_Error or else Code = Thin.Z_OK then
 | 
			
		||||
         Free (Filter.Strm);
 | 
			
		||||
      else
 | 
			
		||||
         declare
 | 
			
		||||
            Error_Message : constant String
 | 
			
		||||
              := Last_Error_Message (Filter.Strm.all);
 | 
			
		||||
         begin
 | 
			
		||||
            Free (Filter.Strm);
 | 
			
		||||
            Ada.Exceptions.Raise_Exception
 | 
			
		||||
               (ZLib_Error'Identity,
 | 
			
		||||
                Return_Code_Enum'Image (Return_Code (Code))
 | 
			
		||||
                  & ": " & Error_Message);
 | 
			
		||||
         end;
 | 
			
		||||
      end if;
 | 
			
		||||
   end Close;
 | 
			
		||||
 | 
			
		||||
   -----------
 | 
			
		||||
   -- CRC32 --
 | 
			
		||||
   -----------
 | 
			
		||||
 | 
			
		||||
   function CRC32
 | 
			
		||||
     (CRC  : in Unsigned_32;
 | 
			
		||||
      Data : in Ada.Streams.Stream_Element_Array)
 | 
			
		||||
      return Unsigned_32
 | 
			
		||||
   is
 | 
			
		||||
      use Thin;
 | 
			
		||||
   begin
 | 
			
		||||
      return Unsigned_32 (crc32 (ULong (CRC),
 | 
			
		||||
                                 Data'Address,
 | 
			
		||||
                                 Data'Length));
 | 
			
		||||
   end CRC32;
 | 
			
		||||
 | 
			
		||||
   procedure CRC32
 | 
			
		||||
     (CRC  : in out Unsigned_32;
 | 
			
		||||
      Data : in     Ada.Streams.Stream_Element_Array) is
 | 
			
		||||
   begin
 | 
			
		||||
      CRC := CRC32 (CRC, Data);
 | 
			
		||||
   end CRC32;
 | 
			
		||||
 | 
			
		||||
   ------------------
 | 
			
		||||
   -- Deflate_Init --
 | 
			
		||||
   ------------------
 | 
			
		||||
 | 
			
		||||
   procedure Deflate_Init
 | 
			
		||||
     (Filter       : in out Filter_Type;
 | 
			
		||||
      Level        : in     Compression_Level  := Default_Compression;
 | 
			
		||||
      Strategy     : in     Strategy_Type      := Default_Strategy;
 | 
			
		||||
      Method       : in     Compression_Method := Deflated;
 | 
			
		||||
      Window_Bits  : in     Window_Bits_Type   := Default_Window_Bits;
 | 
			
		||||
      Memory_Level : in     Memory_Level_Type  := Default_Memory_Level;
 | 
			
		||||
      Header       : in     Header_Type        := Default)
 | 
			
		||||
   is
 | 
			
		||||
      use type Thin.Int;
 | 
			
		||||
      Win_Bits : Thin.Int := Thin.Int (Window_Bits);
 | 
			
		||||
   begin
 | 
			
		||||
      if Is_Open (Filter) then
 | 
			
		||||
         raise Status_Error;
 | 
			
		||||
      end if;
 | 
			
		||||
 | 
			
		||||
      --  We allow ZLib to make header only in case of default header type.
 | 
			
		||||
      --  Otherwise we would either do header by ourselfs, or do not do
 | 
			
		||||
      --  header at all.
 | 
			
		||||
 | 
			
		||||
      if Header = None or else Header = GZip then
 | 
			
		||||
         Win_Bits := -Win_Bits;
 | 
			
		||||
      end if;
 | 
			
		||||
 | 
			
		||||
      --  For the GZip CRC calculation and make headers.
 | 
			
		||||
 | 
			
		||||
      if Header = GZip then
 | 
			
		||||
         Filter.CRC    := 0;
 | 
			
		||||
         Filter.Offset := Simple_GZip_Header'First;
 | 
			
		||||
      else
 | 
			
		||||
         Filter.Offset := Simple_GZip_Header'Last + 1;
 | 
			
		||||
      end if;
 | 
			
		||||
 | 
			
		||||
      Filter.Strm        := new Z_Stream;
 | 
			
		||||
      Filter.Compression := True;
 | 
			
		||||
      Filter.Stream_End  := False;
 | 
			
		||||
      Filter.Header      := Header;
 | 
			
		||||
 | 
			
		||||
      if Thin.Deflate_Init
 | 
			
		||||
           (To_Thin_Access (Filter.Strm),
 | 
			
		||||
            Level      => Thin.Int (Level),
 | 
			
		||||
            method     => Thin.Int (Method),
 | 
			
		||||
            windowBits => Win_Bits,
 | 
			
		||||
            memLevel   => Thin.Int (Memory_Level),
 | 
			
		||||
            strategy   => Thin.Int (Strategy)) /= Thin.Z_OK
 | 
			
		||||
      then
 | 
			
		||||
         Raise_Error (Filter.Strm.all);
 | 
			
		||||
      end if;
 | 
			
		||||
   end Deflate_Init;
 | 
			
		||||
 | 
			
		||||
   -----------
 | 
			
		||||
   -- Flush --
 | 
			
		||||
   -----------
 | 
			
		||||
 | 
			
		||||
   procedure Flush
 | 
			
		||||
     (Filter    : in out Filter_Type;
 | 
			
		||||
      Out_Data  :    out Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      Out_Last  :    out Ada.Streams.Stream_Element_Offset;
 | 
			
		||||
      Flush     : in     Flush_Mode)
 | 
			
		||||
   is
 | 
			
		||||
      No_Data : Stream_Element_Array := (1 .. 0 => 0);
 | 
			
		||||
      Last    : Stream_Element_Offset;
 | 
			
		||||
   begin
 | 
			
		||||
      Translate (Filter, No_Data, Last, Out_Data, Out_Last, Flush);
 | 
			
		||||
   end Flush;
 | 
			
		||||
 | 
			
		||||
   -----------------------
 | 
			
		||||
   -- Generic_Translate --
 | 
			
		||||
   -----------------------
 | 
			
		||||
 | 
			
		||||
   procedure Generic_Translate
 | 
			
		||||
     (Filter          : in out ZLib.Filter_Type;
 | 
			
		||||
      In_Buffer_Size  : in     Integer := Default_Buffer_Size;
 | 
			
		||||
      Out_Buffer_Size : in     Integer := Default_Buffer_Size)
 | 
			
		||||
   is
 | 
			
		||||
      In_Buffer  : Stream_Element_Array
 | 
			
		||||
                     (1 .. Stream_Element_Offset (In_Buffer_Size));
 | 
			
		||||
      Out_Buffer : Stream_Element_Array
 | 
			
		||||
                     (1 .. Stream_Element_Offset (Out_Buffer_Size));
 | 
			
		||||
      Last       : Stream_Element_Offset;
 | 
			
		||||
      In_Last    : Stream_Element_Offset;
 | 
			
		||||
      In_First   : Stream_Element_Offset;
 | 
			
		||||
      Out_Last   : Stream_Element_Offset;
 | 
			
		||||
   begin
 | 
			
		||||
      Main : loop
 | 
			
		||||
         Data_In (In_Buffer, Last);
 | 
			
		||||
 | 
			
		||||
         In_First := In_Buffer'First;
 | 
			
		||||
 | 
			
		||||
         loop
 | 
			
		||||
            Translate
 | 
			
		||||
              (Filter   => Filter,
 | 
			
		||||
               In_Data  => In_Buffer (In_First .. Last),
 | 
			
		||||
               In_Last  => In_Last,
 | 
			
		||||
               Out_Data => Out_Buffer,
 | 
			
		||||
               Out_Last => Out_Last,
 | 
			
		||||
               Flush    => Flush_Finish (Last < In_Buffer'First));
 | 
			
		||||
 | 
			
		||||
            if Out_Buffer'First <= Out_Last then
 | 
			
		||||
               Data_Out (Out_Buffer (Out_Buffer'First .. Out_Last));
 | 
			
		||||
            end if;
 | 
			
		||||
 | 
			
		||||
            exit Main when Stream_End (Filter);
 | 
			
		||||
 | 
			
		||||
            --  The end of in buffer.
 | 
			
		||||
 | 
			
		||||
            exit when In_Last = Last;
 | 
			
		||||
 | 
			
		||||
            In_First := In_Last + 1;
 | 
			
		||||
         end loop;
 | 
			
		||||
      end loop Main;
 | 
			
		||||
 | 
			
		||||
   end Generic_Translate;
 | 
			
		||||
 | 
			
		||||
   ------------------
 | 
			
		||||
   -- Inflate_Init --
 | 
			
		||||
   ------------------
 | 
			
		||||
 | 
			
		||||
   procedure Inflate_Init
 | 
			
		||||
     (Filter      : in out Filter_Type;
 | 
			
		||||
      Window_Bits : in     Window_Bits_Type := Default_Window_Bits;
 | 
			
		||||
      Header      : in     Header_Type      := Default)
 | 
			
		||||
   is
 | 
			
		||||
      use type Thin.Int;
 | 
			
		||||
      Win_Bits : Thin.Int := Thin.Int (Window_Bits);
 | 
			
		||||
 | 
			
		||||
      procedure Check_Version;
 | 
			
		||||
      --  Check the latest header types compatibility.
 | 
			
		||||
 | 
			
		||||
      procedure Check_Version is
 | 
			
		||||
      begin
 | 
			
		||||
         if Version <= "1.1.4" then
 | 
			
		||||
            Raise_Error
 | 
			
		||||
              ("Inflate header type " & Header_Type'Image (Header)
 | 
			
		||||
               & " incompatible with ZLib version " & Version);
 | 
			
		||||
         end if;
 | 
			
		||||
      end Check_Version;
 | 
			
		||||
 | 
			
		||||
   begin
 | 
			
		||||
      if Is_Open (Filter) then
 | 
			
		||||
         raise Status_Error;
 | 
			
		||||
      end if;
 | 
			
		||||
 | 
			
		||||
      case Header is
 | 
			
		||||
         when None =>
 | 
			
		||||
            Check_Version;
 | 
			
		||||
 | 
			
		||||
            --  Inflate data without headers determined
 | 
			
		||||
            --  by negative Win_Bits.
 | 
			
		||||
 | 
			
		||||
            Win_Bits := -Win_Bits;
 | 
			
		||||
         when GZip =>
 | 
			
		||||
            Check_Version;
 | 
			
		||||
 | 
			
		||||
            --  Inflate gzip data defined by flag 16.
 | 
			
		||||
 | 
			
		||||
            Win_Bits := Win_Bits + 16;
 | 
			
		||||
         when Auto =>
 | 
			
		||||
            Check_Version;
 | 
			
		||||
 | 
			
		||||
            --  Inflate with automatic detection
 | 
			
		||||
            --  of gzip or native header defined by flag 32.
 | 
			
		||||
 | 
			
		||||
            Win_Bits := Win_Bits + 32;
 | 
			
		||||
         when Default => null;
 | 
			
		||||
      end case;
 | 
			
		||||
 | 
			
		||||
      Filter.Strm        := new Z_Stream;
 | 
			
		||||
      Filter.Compression := False;
 | 
			
		||||
      Filter.Stream_End  := False;
 | 
			
		||||
      Filter.Header      := Header;
 | 
			
		||||
 | 
			
		||||
      if Thin.Inflate_Init
 | 
			
		||||
         (To_Thin_Access (Filter.Strm), Win_Bits) /= Thin.Z_OK
 | 
			
		||||
      then
 | 
			
		||||
         Raise_Error (Filter.Strm.all);
 | 
			
		||||
      end if;
 | 
			
		||||
   end Inflate_Init;
 | 
			
		||||
 | 
			
		||||
   -------------
 | 
			
		||||
   -- Is_Open --
 | 
			
		||||
   -------------
 | 
			
		||||
 | 
			
		||||
   function Is_Open (Filter : in Filter_Type) return Boolean is
 | 
			
		||||
   begin
 | 
			
		||||
      return Filter.Strm /= null;
 | 
			
		||||
   end Is_Open;
 | 
			
		||||
 | 
			
		||||
   -----------------
 | 
			
		||||
   -- Raise_Error --
 | 
			
		||||
   -----------------
 | 
			
		||||
 | 
			
		||||
   procedure Raise_Error (Message : in String) is
 | 
			
		||||
   begin
 | 
			
		||||
      Ada.Exceptions.Raise_Exception (ZLib_Error'Identity, Message);
 | 
			
		||||
   end Raise_Error;
 | 
			
		||||
 | 
			
		||||
   procedure Raise_Error (Stream : in Z_Stream) is
 | 
			
		||||
   begin
 | 
			
		||||
      Raise_Error (Last_Error_Message (Stream));
 | 
			
		||||
   end Raise_Error;
 | 
			
		||||
 | 
			
		||||
   ----------
 | 
			
		||||
   -- Read --
 | 
			
		||||
   ----------
 | 
			
		||||
 | 
			
		||||
   procedure Read
 | 
			
		||||
     (Filter : in out Filter_Type;
 | 
			
		||||
      Item   :    out Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      Last   :    out Ada.Streams.Stream_Element_Offset;
 | 
			
		||||
      Flush  : in     Flush_Mode := No_Flush)
 | 
			
		||||
   is
 | 
			
		||||
      In_Last    : Stream_Element_Offset;
 | 
			
		||||
      Item_First : Ada.Streams.Stream_Element_Offset := Item'First;
 | 
			
		||||
      V_Flush    : Flush_Mode := Flush;
 | 
			
		||||
 | 
			
		||||
   begin
 | 
			
		||||
      pragma Assert (Rest_First in Buffer'First .. Buffer'Last + 1);
 | 
			
		||||
      pragma Assert (Rest_Last in Buffer'First - 1 .. Buffer'Last);
 | 
			
		||||
 | 
			
		||||
      loop
 | 
			
		||||
         if Rest_Last = Buffer'First - 1 then
 | 
			
		||||
            V_Flush := Finish;
 | 
			
		||||
 | 
			
		||||
         elsif Rest_First > Rest_Last then
 | 
			
		||||
            Read (Buffer, Rest_Last);
 | 
			
		||||
            Rest_First := Buffer'First;
 | 
			
		||||
 | 
			
		||||
            if Rest_Last < Buffer'First then
 | 
			
		||||
               V_Flush := Finish;
 | 
			
		||||
            end if;
 | 
			
		||||
         end if;
 | 
			
		||||
 | 
			
		||||
         Translate
 | 
			
		||||
           (Filter   => Filter,
 | 
			
		||||
            In_Data  => Buffer (Rest_First .. Rest_Last),
 | 
			
		||||
            In_Last  => In_Last,
 | 
			
		||||
            Out_Data => Item (Item_First .. Item'Last),
 | 
			
		||||
            Out_Last => Last,
 | 
			
		||||
            Flush    => V_Flush);
 | 
			
		||||
 | 
			
		||||
         Rest_First := In_Last + 1;
 | 
			
		||||
 | 
			
		||||
         exit when Stream_End (Filter)
 | 
			
		||||
           or else Last = Item'Last
 | 
			
		||||
           or else (Last >= Item'First and then Allow_Read_Some);
 | 
			
		||||
 | 
			
		||||
         Item_First := Last + 1;
 | 
			
		||||
      end loop;
 | 
			
		||||
   end Read;
 | 
			
		||||
 | 
			
		||||
   ----------------
 | 
			
		||||
   -- Stream_End --
 | 
			
		||||
   ----------------
 | 
			
		||||
 | 
			
		||||
   function Stream_End (Filter : in Filter_Type) return Boolean is
 | 
			
		||||
   begin
 | 
			
		||||
      if Filter.Header = GZip and Filter.Compression then
 | 
			
		||||
         return Filter.Stream_End
 | 
			
		||||
            and then Filter.Offset = Footer_Array'Last + 1;
 | 
			
		||||
      else
 | 
			
		||||
         return Filter.Stream_End;
 | 
			
		||||
      end if;
 | 
			
		||||
   end Stream_End;
 | 
			
		||||
 | 
			
		||||
   --------------
 | 
			
		||||
   -- Total_In --
 | 
			
		||||
   --------------
 | 
			
		||||
 | 
			
		||||
   function Total_In (Filter : in Filter_Type) return Count is
 | 
			
		||||
   begin
 | 
			
		||||
      return Count (Thin.Total_In (To_Thin_Access (Filter.Strm).all));
 | 
			
		||||
   end Total_In;
 | 
			
		||||
 | 
			
		||||
   ---------------
 | 
			
		||||
   -- Total_Out --
 | 
			
		||||
   ---------------
 | 
			
		||||
 | 
			
		||||
   function Total_Out (Filter : in Filter_Type) return Count is
 | 
			
		||||
   begin
 | 
			
		||||
      return Count (Thin.Total_Out (To_Thin_Access (Filter.Strm).all));
 | 
			
		||||
   end Total_Out;
 | 
			
		||||
 | 
			
		||||
   ---------------
 | 
			
		||||
   -- Translate --
 | 
			
		||||
   ---------------
 | 
			
		||||
 | 
			
		||||
   procedure Translate
 | 
			
		||||
     (Filter    : in out Filter_Type;
 | 
			
		||||
      In_Data   : in     Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      In_Last   :    out Ada.Streams.Stream_Element_Offset;
 | 
			
		||||
      Out_Data  :    out Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      Out_Last  :    out Ada.Streams.Stream_Element_Offset;
 | 
			
		||||
      Flush     : in     Flush_Mode) is
 | 
			
		||||
   begin
 | 
			
		||||
      if Filter.Header = GZip and then Filter.Compression then
 | 
			
		||||
         Translate_GZip
 | 
			
		||||
           (Filter   => Filter,
 | 
			
		||||
            In_Data  => In_Data,
 | 
			
		||||
            In_Last  => In_Last,
 | 
			
		||||
            Out_Data => Out_Data,
 | 
			
		||||
            Out_Last => Out_Last,
 | 
			
		||||
            Flush    => Flush);
 | 
			
		||||
      else
 | 
			
		||||
         Translate_Auto
 | 
			
		||||
           (Filter   => Filter,
 | 
			
		||||
            In_Data  => In_Data,
 | 
			
		||||
            In_Last  => In_Last,
 | 
			
		||||
            Out_Data => Out_Data,
 | 
			
		||||
            Out_Last => Out_Last,
 | 
			
		||||
            Flush    => Flush);
 | 
			
		||||
      end if;
 | 
			
		||||
   end Translate;
 | 
			
		||||
 | 
			
		||||
   --------------------
 | 
			
		||||
   -- Translate_Auto --
 | 
			
		||||
   --------------------
 | 
			
		||||
 | 
			
		||||
   procedure Translate_Auto
 | 
			
		||||
     (Filter    : in out Filter_Type;
 | 
			
		||||
      In_Data   : in     Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      In_Last   :    out Ada.Streams.Stream_Element_Offset;
 | 
			
		||||
      Out_Data  :    out Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      Out_Last  :    out Ada.Streams.Stream_Element_Offset;
 | 
			
		||||
      Flush     : in     Flush_Mode)
 | 
			
		||||
   is
 | 
			
		||||
      use type Thin.Int;
 | 
			
		||||
      Code : Thin.Int;
 | 
			
		||||
 | 
			
		||||
   begin
 | 
			
		||||
      if not Is_Open (Filter) then
 | 
			
		||||
         raise Status_Error;
 | 
			
		||||
      end if;
 | 
			
		||||
 | 
			
		||||
      if Out_Data'Length = 0 and then In_Data'Length = 0 then
 | 
			
		||||
         raise Constraint_Error;
 | 
			
		||||
      end if;
 | 
			
		||||
 | 
			
		||||
      Set_Out (Filter.Strm.all, Out_Data'Address, Out_Data'Length);
 | 
			
		||||
      Set_In  (Filter.Strm.all, In_Data'Address, In_Data'Length);
 | 
			
		||||
 | 
			
		||||
      Code := Flate (Filter.Compression).Step
 | 
			
		||||
        (To_Thin_Access (Filter.Strm),
 | 
			
		||||
         Thin.Int (Flush));
 | 
			
		||||
 | 
			
		||||
      if Code = Thin.Z_STREAM_END then
 | 
			
		||||
         Filter.Stream_End := True;
 | 
			
		||||
      else
 | 
			
		||||
         Check_Error (Filter.Strm.all, Code);
 | 
			
		||||
      end if;
 | 
			
		||||
 | 
			
		||||
      In_Last  := In_Data'Last
 | 
			
		||||
         - Stream_Element_Offset (Avail_In (Filter.Strm.all));
 | 
			
		||||
      Out_Last := Out_Data'Last
 | 
			
		||||
         - Stream_Element_Offset (Avail_Out (Filter.Strm.all));
 | 
			
		||||
   end Translate_Auto;
 | 
			
		||||
 | 
			
		||||
   --------------------
 | 
			
		||||
   -- Translate_GZip --
 | 
			
		||||
   --------------------
 | 
			
		||||
 | 
			
		||||
   procedure Translate_GZip
 | 
			
		||||
     (Filter    : in out Filter_Type;
 | 
			
		||||
      In_Data   : in     Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      In_Last   :    out Ada.Streams.Stream_Element_Offset;
 | 
			
		||||
      Out_Data  :    out Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      Out_Last  :    out Ada.Streams.Stream_Element_Offset;
 | 
			
		||||
      Flush     : in     Flush_Mode)
 | 
			
		||||
   is
 | 
			
		||||
      Out_First : Stream_Element_Offset;
 | 
			
		||||
 | 
			
		||||
      procedure Add_Data (Data : in Stream_Element_Array);
 | 
			
		||||
      --  Add data to stream from the Filter.Offset till necessary,
 | 
			
		||||
      --  used for add gzip headr/footer.
 | 
			
		||||
 | 
			
		||||
      procedure Put_32
 | 
			
		||||
        (Item : in out Stream_Element_Array;
 | 
			
		||||
         Data : in     Unsigned_32);
 | 
			
		||||
      pragma Inline (Put_32);
 | 
			
		||||
 | 
			
		||||
      --------------
 | 
			
		||||
      -- Add_Data --
 | 
			
		||||
      --------------
 | 
			
		||||
 | 
			
		||||
      procedure Add_Data (Data : in Stream_Element_Array) is
 | 
			
		||||
         Data_First : Stream_Element_Offset renames Filter.Offset;
 | 
			
		||||
         Data_Last  : Stream_Element_Offset;
 | 
			
		||||
         Data_Len   : Stream_Element_Offset; --  -1
 | 
			
		||||
         Out_Len    : Stream_Element_Offset; --  -1
 | 
			
		||||
      begin
 | 
			
		||||
         Out_First := Out_Last + 1;
 | 
			
		||||
 | 
			
		||||
         if Data_First > Data'Last then
 | 
			
		||||
            return;
 | 
			
		||||
         end if;
 | 
			
		||||
 | 
			
		||||
         Data_Len  := Data'Last     - Data_First;
 | 
			
		||||
         Out_Len   := Out_Data'Last - Out_First;
 | 
			
		||||
 | 
			
		||||
         if Data_Len <= Out_Len then
 | 
			
		||||
            Out_Last  := Out_First  + Data_Len;
 | 
			
		||||
            Data_Last := Data'Last;
 | 
			
		||||
         else
 | 
			
		||||
            Out_Last  := Out_Data'Last;
 | 
			
		||||
            Data_Last := Data_First + Out_Len;
 | 
			
		||||
         end if;
 | 
			
		||||
 | 
			
		||||
         Out_Data (Out_First .. Out_Last) := Data (Data_First .. Data_Last);
 | 
			
		||||
 | 
			
		||||
         Data_First := Data_Last + 1;
 | 
			
		||||
         Out_First  := Out_Last + 1;
 | 
			
		||||
      end Add_Data;
 | 
			
		||||
 | 
			
		||||
      ------------
 | 
			
		||||
      -- Put_32 --
 | 
			
		||||
      ------------
 | 
			
		||||
 | 
			
		||||
      procedure Put_32
 | 
			
		||||
        (Item : in out Stream_Element_Array;
 | 
			
		||||
         Data : in     Unsigned_32)
 | 
			
		||||
      is
 | 
			
		||||
         D : Unsigned_32 := Data;
 | 
			
		||||
      begin
 | 
			
		||||
         for J in Item'First .. Item'First + 3 loop
 | 
			
		||||
            Item (J) := Stream_Element (D and 16#FF#);
 | 
			
		||||
            D := Shift_Right (D, 8);
 | 
			
		||||
         end loop;
 | 
			
		||||
      end Put_32;
 | 
			
		||||
 | 
			
		||||
   begin
 | 
			
		||||
      Out_Last := Out_Data'First - 1;
 | 
			
		||||
 | 
			
		||||
      if not Filter.Stream_End then
 | 
			
		||||
         Add_Data (Simple_GZip_Header);
 | 
			
		||||
 | 
			
		||||
         Translate_Auto
 | 
			
		||||
           (Filter   => Filter,
 | 
			
		||||
            In_Data  => In_Data,
 | 
			
		||||
            In_Last  => In_Last,
 | 
			
		||||
            Out_Data => Out_Data (Out_First .. Out_Data'Last),
 | 
			
		||||
            Out_Last => Out_Last,
 | 
			
		||||
            Flush    => Flush);
 | 
			
		||||
 | 
			
		||||
         CRC32 (Filter.CRC, In_Data (In_Data'First .. In_Last));
 | 
			
		||||
      end if;
 | 
			
		||||
 | 
			
		||||
      if Filter.Stream_End and then Out_Last <= Out_Data'Last then
 | 
			
		||||
         --  This detection method would work only when
 | 
			
		||||
         --  Simple_GZip_Header'Last > Footer_Array'Last
 | 
			
		||||
 | 
			
		||||
         if Filter.Offset = Simple_GZip_Header'Last + 1 then
 | 
			
		||||
            Filter.Offset := Footer_Array'First;
 | 
			
		||||
         end if;
 | 
			
		||||
 | 
			
		||||
         declare
 | 
			
		||||
            Footer : Footer_Array;
 | 
			
		||||
         begin
 | 
			
		||||
            Put_32 (Footer, Filter.CRC);
 | 
			
		||||
            Put_32 (Footer (Footer'First + 4 .. Footer'Last),
 | 
			
		||||
                    Unsigned_32 (Total_In (Filter)));
 | 
			
		||||
            Add_Data (Footer);
 | 
			
		||||
         end;
 | 
			
		||||
      end if;
 | 
			
		||||
   end Translate_GZip;
 | 
			
		||||
 | 
			
		||||
   -------------
 | 
			
		||||
   -- Version --
 | 
			
		||||
   -------------
 | 
			
		||||
 | 
			
		||||
   function Version return String is
 | 
			
		||||
   begin
 | 
			
		||||
      return Interfaces.C.Strings.Value (Thin.zlibVersion);
 | 
			
		||||
   end Version;
 | 
			
		||||
 | 
			
		||||
   -----------
 | 
			
		||||
   -- Write --
 | 
			
		||||
   -----------
 | 
			
		||||
 | 
			
		||||
   procedure Write
 | 
			
		||||
     (Filter : in out Filter_Type;
 | 
			
		||||
      Item   : in     Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      Flush  : in     Flush_Mode := No_Flush)
 | 
			
		||||
   is
 | 
			
		||||
      Buffer   : Stream_Element_Array (1 .. Buffer_Size);
 | 
			
		||||
      In_Last  : Stream_Element_Offset;
 | 
			
		||||
      Out_Last : Stream_Element_Offset;
 | 
			
		||||
      In_First : Stream_Element_Offset := Item'First;
 | 
			
		||||
   begin
 | 
			
		||||
      if Item'Length = 0 and Flush = No_Flush then
 | 
			
		||||
         return;
 | 
			
		||||
      end if;
 | 
			
		||||
 | 
			
		||||
      loop
 | 
			
		||||
         Translate
 | 
			
		||||
           (Filter   => Filter,
 | 
			
		||||
            In_Data  => Item (In_First .. Item'Last),
 | 
			
		||||
            In_Last  => In_Last,
 | 
			
		||||
            Out_Data => Buffer,
 | 
			
		||||
            Out_Last => Out_Last,
 | 
			
		||||
            Flush    => Flush);
 | 
			
		||||
 | 
			
		||||
         if Out_Last >= Buffer'First then
 | 
			
		||||
            Write (Buffer (1 .. Out_Last));
 | 
			
		||||
         end if;
 | 
			
		||||
 | 
			
		||||
         exit when In_Last = Item'Last or Stream_End (Filter);
 | 
			
		||||
 | 
			
		||||
         In_First := In_Last + 1;
 | 
			
		||||
      end loop;
 | 
			
		||||
   end Write;
 | 
			
		||||
 | 
			
		||||
end ZLib;
 | 
			
		||||
							
								
								
									
										328
									
								
								third_party/zlib/contrib/ada/zlib.ads
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										328
									
								
								third_party/zlib/contrib/ada/zlib.ads
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,328 @@
 | 
			
		||||
------------------------------------------------------------------------------
 | 
			
		||||
--                      ZLib for Ada thick binding.                         --
 | 
			
		||||
--                                                                          --
 | 
			
		||||
--              Copyright (C) 2002-2004 Dmitriy Anisimkov                   --
 | 
			
		||||
--                                                                          --
 | 
			
		||||
--  This library is free software; you can redistribute it and/or modify    --
 | 
			
		||||
--  it under the terms of the GNU General Public License as published by    --
 | 
			
		||||
--  the Free Software Foundation; either version 2 of the License, or (at   --
 | 
			
		||||
--  your option) any later version.                                         --
 | 
			
		||||
--                                                                          --
 | 
			
		||||
--  This library is distributed in the hope that it will be useful, but     --
 | 
			
		||||
--  WITHOUT ANY WARRANTY; without even the implied warranty of              --
 | 
			
		||||
--  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU       --
 | 
			
		||||
--  General Public License for more details.                                --
 | 
			
		||||
--                                                                          --
 | 
			
		||||
--  You should have received a copy of the GNU General Public License       --
 | 
			
		||||
--  along with this library; if not, write to the Free Software Foundation, --
 | 
			
		||||
--  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.          --
 | 
			
		||||
--                                                                          --
 | 
			
		||||
--  As a special exception, if other files instantiate generics from this   --
 | 
			
		||||
--  unit, or you link this unit with other files to produce an executable,  --
 | 
			
		||||
--  this  unit  does not  by itself cause  the resulting executable to be   --
 | 
			
		||||
--  covered by the GNU General Public License. This exception does not      --
 | 
			
		||||
--  however invalidate any other reasons why the executable file  might be  --
 | 
			
		||||
--  covered by the  GNU Public License.                                     --
 | 
			
		||||
------------------------------------------------------------------------------
 | 
			
		||||
 | 
			
		||||
--  $Id: zlib.ads,v 1.26 2004/09/06 06:53:19 vagul Exp $
 | 
			
		||||
 | 
			
		||||
with Ada.Streams;
 | 
			
		||||
 | 
			
		||||
with Interfaces;
 | 
			
		||||
 | 
			
		||||
package ZLib is
 | 
			
		||||
 | 
			
		||||
   ZLib_Error   : exception;
 | 
			
		||||
   Status_Error : exception;
 | 
			
		||||
 | 
			
		||||
   type Compression_Level is new Integer range -1 .. 9;
 | 
			
		||||
 | 
			
		||||
   type Flush_Mode is private;
 | 
			
		||||
 | 
			
		||||
   type Compression_Method is private;
 | 
			
		||||
 | 
			
		||||
   type Window_Bits_Type is new Integer range 8 .. 15;
 | 
			
		||||
 | 
			
		||||
   type Memory_Level_Type is new Integer range 1 .. 9;
 | 
			
		||||
 | 
			
		||||
   type Unsigned_32 is new Interfaces.Unsigned_32;
 | 
			
		||||
 | 
			
		||||
   type Strategy_Type is private;
 | 
			
		||||
 | 
			
		||||
   type Header_Type is (None, Auto, Default, GZip);
 | 
			
		||||
   --  Header type usage have a some limitation for inflate.
 | 
			
		||||
   --  See comment for Inflate_Init.
 | 
			
		||||
 | 
			
		||||
   subtype Count is Ada.Streams.Stream_Element_Count;
 | 
			
		||||
 | 
			
		||||
   Default_Memory_Level : constant Memory_Level_Type := 8;
 | 
			
		||||
   Default_Window_Bits  : constant Window_Bits_Type  := 15;
 | 
			
		||||
 | 
			
		||||
   ----------------------------------
 | 
			
		||||
   -- Compression method constants --
 | 
			
		||||
   ----------------------------------
 | 
			
		||||
 | 
			
		||||
   Deflated : constant Compression_Method;
 | 
			
		||||
   --  Only one method allowed in this ZLib version
 | 
			
		||||
 | 
			
		||||
   ---------------------------------
 | 
			
		||||
   -- Compression level constants --
 | 
			
		||||
   ---------------------------------
 | 
			
		||||
 | 
			
		||||
   No_Compression      : constant Compression_Level := 0;
 | 
			
		||||
   Best_Speed          : constant Compression_Level := 1;
 | 
			
		||||
   Best_Compression    : constant Compression_Level := 9;
 | 
			
		||||
   Default_Compression : constant Compression_Level := -1;
 | 
			
		||||
 | 
			
		||||
   --------------------------
 | 
			
		||||
   -- Flush mode constants --
 | 
			
		||||
   --------------------------
 | 
			
		||||
 | 
			
		||||
   No_Flush      : constant Flush_Mode;
 | 
			
		||||
   --  Regular way for compression, no flush
 | 
			
		||||
 | 
			
		||||
   Partial_Flush : constant Flush_Mode;
 | 
			
		||||
   --  Will be removed, use Z_SYNC_FLUSH instead
 | 
			
		||||
 | 
			
		||||
   Sync_Flush    : constant Flush_Mode;
 | 
			
		||||
   --  All pending output is flushed to the output buffer and the output
 | 
			
		||||
   --  is aligned on a byte boundary, so that the decompressor can get all
 | 
			
		||||
   --  input data available so far. (In particular avail_in is zero after the
 | 
			
		||||
   --  call if enough output space has been provided  before the call.)
 | 
			
		||||
   --  Flushing may degrade compression for some compression algorithms and so
 | 
			
		||||
   --  it should be used only when necessary.
 | 
			
		||||
 | 
			
		||||
   Block_Flush   : constant Flush_Mode;
 | 
			
		||||
   --  Z_BLOCK requests that inflate() stop
 | 
			
		||||
   --  if and when it get to the next deflate block boundary. When decoding the
 | 
			
		||||
   --  zlib or gzip format, this will cause inflate() to return immediately
 | 
			
		||||
   --  after the header and before the first block. When doing a raw inflate,
 | 
			
		||||
   --  inflate() will go ahead and process the first block, and will return
 | 
			
		||||
   --  when it gets to the end of that block, or when it runs out of data.
 | 
			
		||||
 | 
			
		||||
   Full_Flush    : constant Flush_Mode;
 | 
			
		||||
   --  All output is flushed as with SYNC_FLUSH, and the compression state
 | 
			
		||||
   --  is reset so that decompression can restart from this point if previous
 | 
			
		||||
   --  compressed data has been damaged or if random access is desired. Using
 | 
			
		||||
   --  Full_Flush too often can seriously degrade the compression.
 | 
			
		||||
 | 
			
		||||
   Finish        : constant Flush_Mode;
 | 
			
		||||
   --  Just for tell the compressor that input data is complete.
 | 
			
		||||
 | 
			
		||||
   ------------------------------------
 | 
			
		||||
   -- Compression strategy constants --
 | 
			
		||||
   ------------------------------------
 | 
			
		||||
 | 
			
		||||
   --  RLE stategy could be used only in version 1.2.0 and later.
 | 
			
		||||
 | 
			
		||||
   Filtered         : constant Strategy_Type;
 | 
			
		||||
   Huffman_Only     : constant Strategy_Type;
 | 
			
		||||
   RLE              : constant Strategy_Type;
 | 
			
		||||
   Default_Strategy : constant Strategy_Type;
 | 
			
		||||
 | 
			
		||||
   Default_Buffer_Size : constant := 4096;
 | 
			
		||||
 | 
			
		||||
   type Filter_Type is tagged limited private;
 | 
			
		||||
   --  The filter is for compression and for decompression.
 | 
			
		||||
   --  The usage of the type is depend of its initialization.
 | 
			
		||||
 | 
			
		||||
   function Version return String;
 | 
			
		||||
   pragma Inline (Version);
 | 
			
		||||
   --  Return string representation of the ZLib version.
 | 
			
		||||
 | 
			
		||||
   procedure Deflate_Init
 | 
			
		||||
     (Filter       : in out Filter_Type;
 | 
			
		||||
      Level        : in     Compression_Level  := Default_Compression;
 | 
			
		||||
      Strategy     : in     Strategy_Type      := Default_Strategy;
 | 
			
		||||
      Method       : in     Compression_Method := Deflated;
 | 
			
		||||
      Window_Bits  : in     Window_Bits_Type   := Default_Window_Bits;
 | 
			
		||||
      Memory_Level : in     Memory_Level_Type  := Default_Memory_Level;
 | 
			
		||||
      Header       : in     Header_Type        := Default);
 | 
			
		||||
   --  Compressor initialization.
 | 
			
		||||
   --  When Header parameter is Auto or Default, then default zlib header
 | 
			
		||||
   --  would be provided for compressed data.
 | 
			
		||||
   --  When Header is GZip, then gzip header would be set instead of
 | 
			
		||||
   --  default header.
 | 
			
		||||
   --  When Header is None, no header would be set for compressed data.
 | 
			
		||||
 | 
			
		||||
   procedure Inflate_Init
 | 
			
		||||
     (Filter      : in out Filter_Type;
 | 
			
		||||
      Window_Bits : in     Window_Bits_Type := Default_Window_Bits;
 | 
			
		||||
      Header      : in     Header_Type      := Default);
 | 
			
		||||
   --  Decompressor initialization.
 | 
			
		||||
   --  Default header type mean that ZLib default header is expecting in the
 | 
			
		||||
   --  input compressed stream.
 | 
			
		||||
   --  Header type None mean that no header is expecting in the input stream.
 | 
			
		||||
   --  GZip header type mean that GZip header is expecting in the
 | 
			
		||||
   --  input compressed stream.
 | 
			
		||||
   --  Auto header type mean that header type (GZip or Native) would be
 | 
			
		||||
   --  detected automatically in the input stream.
 | 
			
		||||
   --  Note that header types parameter values None, GZip and Auto are
 | 
			
		||||
   --  supported for inflate routine only in ZLib versions 1.2.0.2 and later.
 | 
			
		||||
   --  Deflate_Init is supporting all header types.
 | 
			
		||||
 | 
			
		||||
   function Is_Open (Filter : in Filter_Type) return Boolean;
 | 
			
		||||
   pragma Inline (Is_Open);
 | 
			
		||||
   --  Is the filter opened for compression or decompression.
 | 
			
		||||
 | 
			
		||||
   procedure Close
 | 
			
		||||
     (Filter       : in out Filter_Type;
 | 
			
		||||
      Ignore_Error : in     Boolean := False);
 | 
			
		||||
   --  Closing the compression or decompressor.
 | 
			
		||||
   --  If stream is closing before the complete and Ignore_Error is False,
 | 
			
		||||
   --  The exception would be raised.
 | 
			
		||||
 | 
			
		||||
   generic
 | 
			
		||||
      with procedure Data_In
 | 
			
		||||
        (Item : out Ada.Streams.Stream_Element_Array;
 | 
			
		||||
         Last : out Ada.Streams.Stream_Element_Offset);
 | 
			
		||||
      with procedure Data_Out
 | 
			
		||||
        (Item : in Ada.Streams.Stream_Element_Array);
 | 
			
		||||
   procedure Generic_Translate
 | 
			
		||||
     (Filter          : in out Filter_Type;
 | 
			
		||||
      In_Buffer_Size  : in     Integer := Default_Buffer_Size;
 | 
			
		||||
      Out_Buffer_Size : in     Integer := Default_Buffer_Size);
 | 
			
		||||
   --  Compress/decompress data fetch from Data_In routine and pass the result
 | 
			
		||||
   --  to the Data_Out routine. User should provide Data_In and Data_Out
 | 
			
		||||
   --  for compression/decompression data flow.
 | 
			
		||||
   --  Compression or decompression depend on Filter initialization.
 | 
			
		||||
 | 
			
		||||
   function Total_In (Filter : in Filter_Type) return Count;
 | 
			
		||||
   pragma Inline (Total_In);
 | 
			
		||||
   --  Returns total number of input bytes read so far
 | 
			
		||||
 | 
			
		||||
   function Total_Out (Filter : in Filter_Type) return Count;
 | 
			
		||||
   pragma Inline (Total_Out);
 | 
			
		||||
   --  Returns total number of bytes output so far
 | 
			
		||||
 | 
			
		||||
   function CRC32
 | 
			
		||||
     (CRC    : in Unsigned_32;
 | 
			
		||||
      Data   : in Ada.Streams.Stream_Element_Array)
 | 
			
		||||
      return Unsigned_32;
 | 
			
		||||
   pragma Inline (CRC32);
 | 
			
		||||
   --  Compute CRC32, it could be necessary for make gzip format
 | 
			
		||||
 | 
			
		||||
   procedure CRC32
 | 
			
		||||
     (CRC  : in out Unsigned_32;
 | 
			
		||||
      Data : in     Ada.Streams.Stream_Element_Array);
 | 
			
		||||
   pragma Inline (CRC32);
 | 
			
		||||
   --  Compute CRC32, it could be necessary for make gzip format
 | 
			
		||||
 | 
			
		||||
   -------------------------------------------------
 | 
			
		||||
   --  Below is more complex low level routines.  --
 | 
			
		||||
   -------------------------------------------------
 | 
			
		||||
 | 
			
		||||
   procedure Translate
 | 
			
		||||
     (Filter    : in out Filter_Type;
 | 
			
		||||
      In_Data   : in     Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      In_Last   :    out Ada.Streams.Stream_Element_Offset;
 | 
			
		||||
      Out_Data  :    out Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      Out_Last  :    out Ada.Streams.Stream_Element_Offset;
 | 
			
		||||
      Flush     : in     Flush_Mode);
 | 
			
		||||
   --  Compress/decompress the In_Data buffer and place the result into
 | 
			
		||||
   --  Out_Data. In_Last is the index of last element from In_Data accepted by
 | 
			
		||||
   --  the Filter. Out_Last is the last element of the received data from
 | 
			
		||||
   --  Filter. To tell the filter that incoming data are complete put the
 | 
			
		||||
   --  Flush parameter to Finish.
 | 
			
		||||
 | 
			
		||||
   function Stream_End (Filter : in Filter_Type) return Boolean;
 | 
			
		||||
   pragma Inline (Stream_End);
 | 
			
		||||
   --  Return the true when the stream is complete.
 | 
			
		||||
 | 
			
		||||
   procedure Flush
 | 
			
		||||
     (Filter    : in out Filter_Type;
 | 
			
		||||
      Out_Data  :    out Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      Out_Last  :    out Ada.Streams.Stream_Element_Offset;
 | 
			
		||||
      Flush     : in     Flush_Mode);
 | 
			
		||||
   pragma Inline (Flush);
 | 
			
		||||
   --  Flushing the data from the compressor.
 | 
			
		||||
 | 
			
		||||
   generic
 | 
			
		||||
      with procedure Write
 | 
			
		||||
        (Item : in Ada.Streams.Stream_Element_Array);
 | 
			
		||||
      --  User should provide this routine for accept
 | 
			
		||||
      --  compressed/decompressed data.
 | 
			
		||||
 | 
			
		||||
      Buffer_Size : in Ada.Streams.Stream_Element_Offset
 | 
			
		||||
         := Default_Buffer_Size;
 | 
			
		||||
      --  Buffer size for Write user routine.
 | 
			
		||||
 | 
			
		||||
   procedure Write
 | 
			
		||||
     (Filter  : in out Filter_Type;
 | 
			
		||||
      Item    : in     Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      Flush   : in     Flush_Mode := No_Flush);
 | 
			
		||||
   --  Compress/Decompress data from Item to the generic parameter procedure
 | 
			
		||||
   --  Write. Output buffer size could be set in Buffer_Size generic parameter.
 | 
			
		||||
 | 
			
		||||
   generic
 | 
			
		||||
      with procedure Read
 | 
			
		||||
        (Item : out Ada.Streams.Stream_Element_Array;
 | 
			
		||||
         Last : out Ada.Streams.Stream_Element_Offset);
 | 
			
		||||
      --  User should provide data for compression/decompression
 | 
			
		||||
      --  thru this routine.
 | 
			
		||||
 | 
			
		||||
      Buffer : in out Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      --  Buffer for keep remaining data from the previous
 | 
			
		||||
      --  back read.
 | 
			
		||||
 | 
			
		||||
      Rest_First, Rest_Last : in out Ada.Streams.Stream_Element_Offset;
 | 
			
		||||
      --  Rest_First have to be initialized to Buffer'Last + 1
 | 
			
		||||
      --  Rest_Last have to be initialized to Buffer'Last
 | 
			
		||||
      --  before usage.
 | 
			
		||||
 | 
			
		||||
      Allow_Read_Some : in Boolean := False;
 | 
			
		||||
      --  Is it allowed to return Last < Item'Last before end of data.
 | 
			
		||||
 | 
			
		||||
   procedure Read
 | 
			
		||||
     (Filter : in out Filter_Type;
 | 
			
		||||
      Item   :    out Ada.Streams.Stream_Element_Array;
 | 
			
		||||
      Last   :    out Ada.Streams.Stream_Element_Offset;
 | 
			
		||||
      Flush  : in     Flush_Mode := No_Flush);
 | 
			
		||||
   --  Compress/Decompress data from generic parameter procedure Read to the
 | 
			
		||||
   --  Item. User should provide Buffer and initialized Rest_First, Rest_Last
 | 
			
		||||
   --  indicators. If Allow_Read_Some is True, Read routines could return
 | 
			
		||||
   --  Last < Item'Last only at end of stream.
 | 
			
		||||
 | 
			
		||||
private
 | 
			
		||||
 | 
			
		||||
   use Ada.Streams;
 | 
			
		||||
 | 
			
		||||
   pragma Assert (Ada.Streams.Stream_Element'Size    =    8);
 | 
			
		||||
   pragma Assert (Ada.Streams.Stream_Element'Modulus = 2**8);
 | 
			
		||||
 | 
			
		||||
   type Flush_Mode is new Integer range 0 .. 5;
 | 
			
		||||
 | 
			
		||||
   type Compression_Method is new Integer range 8 .. 8;
 | 
			
		||||
 | 
			
		||||
   type Strategy_Type is new Integer range 0 .. 3;
 | 
			
		||||
 | 
			
		||||
   No_Flush      : constant Flush_Mode := 0;
 | 
			
		||||
   Partial_Flush : constant Flush_Mode := 1;
 | 
			
		||||
   Sync_Flush    : constant Flush_Mode := 2;
 | 
			
		||||
   Full_Flush    : constant Flush_Mode := 3;
 | 
			
		||||
   Finish        : constant Flush_Mode := 4;
 | 
			
		||||
   Block_Flush   : constant Flush_Mode := 5;
 | 
			
		||||
 | 
			
		||||
   Filtered         : constant Strategy_Type := 1;
 | 
			
		||||
   Huffman_Only     : constant Strategy_Type := 2;
 | 
			
		||||
   RLE              : constant Strategy_Type := 3;
 | 
			
		||||
   Default_Strategy : constant Strategy_Type := 0;
 | 
			
		||||
 | 
			
		||||
   Deflated : constant Compression_Method := 8;
 | 
			
		||||
 | 
			
		||||
   type Z_Stream;
 | 
			
		||||
 | 
			
		||||
   type Z_Stream_Access is access all Z_Stream;
 | 
			
		||||
 | 
			
		||||
   type Filter_Type is tagged limited record
 | 
			
		||||
      Strm        : Z_Stream_Access;
 | 
			
		||||
      Compression : Boolean;
 | 
			
		||||
      Stream_End  : Boolean;
 | 
			
		||||
      Header      : Header_Type;
 | 
			
		||||
      CRC         : Unsigned_32;
 | 
			
		||||
      Offset      : Stream_Element_Offset;
 | 
			
		||||
      --  Offset for gzip header/footer output.
 | 
			
		||||
   end record;
 | 
			
		||||
 | 
			
		||||
end ZLib;
 | 
			
		||||
							
								
								
									
										20
									
								
								third_party/zlib/contrib/ada/zlib.gpr
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										20
									
								
								third_party/zlib/contrib/ada/zlib.gpr
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,20 @@
 | 
			
		||||
project Zlib is
 | 
			
		||||
 | 
			
		||||
   for Languages use ("Ada");
 | 
			
		||||
   for Source_Dirs use (".");
 | 
			
		||||
   for Object_Dir use ".";
 | 
			
		||||
   for Main use ("test.adb", "mtest.adb", "read.adb", "buffer_demo");
 | 
			
		||||
 | 
			
		||||
   package Compiler is
 | 
			
		||||
      for Default_Switches ("ada") use ("-gnatwcfilopru", "-gnatVcdfimorst", "-gnatyabcefhiklmnoprst");
 | 
			
		||||
   end Compiler;
 | 
			
		||||
 | 
			
		||||
   package Linker is
 | 
			
		||||
      for Default_Switches ("ada") use ("-lz");
 | 
			
		||||
   end Linker;
 | 
			
		||||
 | 
			
		||||
   package Builder is
 | 
			
		||||
      for Default_Switches ("ada") use ("-s", "-gnatQ");
 | 
			
		||||
   end Builder;
 | 
			
		||||
 | 
			
		||||
end Zlib;
 | 
			
		||||
							
								
								
									
										452
									
								
								third_party/zlib/contrib/amd64/amd64-match.S
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										452
									
								
								third_party/zlib/contrib/amd64/amd64-match.S
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,452 @@
 | 
			
		||||
/*
 | 
			
		||||
 * match.S -- optimized version of longest_match()
 | 
			
		||||
 * based on the similar work by Gilles Vollant, and Brian Raiter, written 1998
 | 
			
		||||
 *
 | 
			
		||||
 * This is free software; you can redistribute it and/or modify it
 | 
			
		||||
 * under the terms of the BSD License. Use by owners of Che Guevarra
 | 
			
		||||
 * parafernalia is prohibited, where possible, and highly discouraged
 | 
			
		||||
 * elsewhere.
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
#ifndef NO_UNDERLINE
 | 
			
		||||
#	define	match_init	_match_init
 | 
			
		||||
#	define	longest_match	_longest_match
 | 
			
		||||
#endif
 | 
			
		||||
 | 
			
		||||
#define	scanend		ebx
 | 
			
		||||
#define	scanendw	bx
 | 
			
		||||
#define	chainlenwmask	edx /* high word: current chain len low word: s->wmask */
 | 
			
		||||
#define	curmatch	rsi
 | 
			
		||||
#define	curmatchd	esi
 | 
			
		||||
#define	windowbestlen	r8
 | 
			
		||||
#define	scanalign	r9
 | 
			
		||||
#define	scanalignd	r9d
 | 
			
		||||
#define	window		r10
 | 
			
		||||
#define	bestlen		r11
 | 
			
		||||
#define	bestlend	r11d
 | 
			
		||||
#define	scanstart	r12d
 | 
			
		||||
#define	scanstartw	r12w
 | 
			
		||||
#define scan		r13
 | 
			
		||||
#define nicematch	r14d
 | 
			
		||||
#define	limit		r15
 | 
			
		||||
#define	limitd		r15d
 | 
			
		||||
#define prev		rcx
 | 
			
		||||
 | 
			
		||||
/*
 | 
			
		||||
 * The 258 is a "magic number, not a parameter -- changing it
 | 
			
		||||
 * breaks the hell loose
 | 
			
		||||
 */
 | 
			
		||||
#define	MAX_MATCH	(258)
 | 
			
		||||
#define	MIN_MATCH	(3)
 | 
			
		||||
#define	MIN_LOOKAHEAD	(MAX_MATCH + MIN_MATCH + 1)
 | 
			
		||||
#define	MAX_MATCH_8	((MAX_MATCH + 7) & ~7)
 | 
			
		||||
 | 
			
		||||
/* stack frame offsets */
 | 
			
		||||
#define	LocalVarsSize	(112)
 | 
			
		||||
#define _chainlenwmask	( 8-LocalVarsSize)(%rsp)
 | 
			
		||||
#define _windowbestlen	(16-LocalVarsSize)(%rsp)
 | 
			
		||||
#define save_r14        (24-LocalVarsSize)(%rsp)
 | 
			
		||||
#define save_rsi        (32-LocalVarsSize)(%rsp)
 | 
			
		||||
#define save_rbx        (40-LocalVarsSize)(%rsp)
 | 
			
		||||
#define save_r12        (56-LocalVarsSize)(%rsp)
 | 
			
		||||
#define save_r13        (64-LocalVarsSize)(%rsp)
 | 
			
		||||
#define save_r15        (80-LocalVarsSize)(%rsp)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
.globl	match_init, longest_match
 | 
			
		||||
 | 
			
		||||
/*
 | 
			
		||||
 * On AMD64 the first argument of a function (in our case -- the pointer to
 | 
			
		||||
 * deflate_state structure) is passed in %rdi, hence our offsets below are
 | 
			
		||||
 * all off of that.
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
/* you can check the structure offset by running
 | 
			
		||||
 | 
			
		||||
#include <stdlib.h>
 | 
			
		||||
#include <stdio.h>
 | 
			
		||||
#include "deflate.h"
 | 
			
		||||
 | 
			
		||||
void print_depl()
 | 
			
		||||
{
 | 
			
		||||
deflate_state ds;
 | 
			
		||||
deflate_state *s=&ds;
 | 
			
		||||
printf("size pointer=%u\n",(int)sizeof(void*));
 | 
			
		||||
 | 
			
		||||
printf("#define dsWSize         (%3u)(%%rdi)\n",(int)(((char*)&(s->w_size))-((char*)s)));
 | 
			
		||||
printf("#define dsWMask         (%3u)(%%rdi)\n",(int)(((char*)&(s->w_mask))-((char*)s)));
 | 
			
		||||
printf("#define dsWindow        (%3u)(%%rdi)\n",(int)(((char*)&(s->window))-((char*)s)));
 | 
			
		||||
printf("#define dsPrev          (%3u)(%%rdi)\n",(int)(((char*)&(s->prev))-((char*)s)));
 | 
			
		||||
printf("#define dsMatchLen      (%3u)(%%rdi)\n",(int)(((char*)&(s->match_length))-((char*)s)));
 | 
			
		||||
printf("#define dsPrevMatch     (%3u)(%%rdi)\n",(int)(((char*)&(s->prev_match))-((char*)s)));
 | 
			
		||||
printf("#define dsStrStart      (%3u)(%%rdi)\n",(int)(((char*)&(s->strstart))-((char*)s)));
 | 
			
		||||
printf("#define dsMatchStart    (%3u)(%%rdi)\n",(int)(((char*)&(s->match_start))-((char*)s)));
 | 
			
		||||
printf("#define dsLookahead     (%3u)(%%rdi)\n",(int)(((char*)&(s->lookahead))-((char*)s)));
 | 
			
		||||
printf("#define dsPrevLen       (%3u)(%%rdi)\n",(int)(((char*)&(s->prev_length))-((char*)s)));
 | 
			
		||||
printf("#define dsMaxChainLen   (%3u)(%%rdi)\n",(int)(((char*)&(s->max_chain_length))-((char*)s)));
 | 
			
		||||
printf("#define dsGoodMatch     (%3u)(%%rdi)\n",(int)(((char*)&(s->good_match))-((char*)s)));
 | 
			
		||||
printf("#define dsNiceMatch     (%3u)(%%rdi)\n",(int)(((char*)&(s->nice_match))-((char*)s)));
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
*/
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
/*
 | 
			
		||||
  to compile for XCode 3.2 on MacOSX x86_64
 | 
			
		||||
  - run "gcc -g -c -DXCODE_MAC_X64_STRUCTURE amd64-match.S"
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
#ifndef CURRENT_LINX_XCODE_MAC_X64_STRUCTURE
 | 
			
		||||
#define dsWSize		( 68)(%rdi)
 | 
			
		||||
#define dsWMask		( 76)(%rdi)
 | 
			
		||||
#define dsWindow	( 80)(%rdi)
 | 
			
		||||
#define dsPrev		( 96)(%rdi)
 | 
			
		||||
#define dsMatchLen	(144)(%rdi)
 | 
			
		||||
#define dsPrevMatch	(148)(%rdi)
 | 
			
		||||
#define dsStrStart	(156)(%rdi)
 | 
			
		||||
#define dsMatchStart	(160)(%rdi)
 | 
			
		||||
#define dsLookahead	(164)(%rdi)
 | 
			
		||||
#define dsPrevLen	(168)(%rdi)
 | 
			
		||||
#define dsMaxChainLen	(172)(%rdi)
 | 
			
		||||
#define dsGoodMatch	(188)(%rdi)
 | 
			
		||||
#define dsNiceMatch	(192)(%rdi)
 | 
			
		||||
 | 
			
		||||
#else 
 | 
			
		||||
 | 
			
		||||
#ifndef STRUCT_OFFSET
 | 
			
		||||
#	define STRUCT_OFFSET	(0)
 | 
			
		||||
#endif
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
#define dsWSize		( 56 + STRUCT_OFFSET)(%rdi)
 | 
			
		||||
#define dsWMask		( 64 + STRUCT_OFFSET)(%rdi)
 | 
			
		||||
#define dsWindow	( 72 + STRUCT_OFFSET)(%rdi)
 | 
			
		||||
#define dsPrev		( 88 + STRUCT_OFFSET)(%rdi)
 | 
			
		||||
#define dsMatchLen	(136 + STRUCT_OFFSET)(%rdi)
 | 
			
		||||
#define dsPrevMatch	(140 + STRUCT_OFFSET)(%rdi)
 | 
			
		||||
#define dsStrStart	(148 + STRUCT_OFFSET)(%rdi)
 | 
			
		||||
#define dsMatchStart	(152 + STRUCT_OFFSET)(%rdi)
 | 
			
		||||
#define dsLookahead	(156 + STRUCT_OFFSET)(%rdi)
 | 
			
		||||
#define dsPrevLen	(160 + STRUCT_OFFSET)(%rdi)
 | 
			
		||||
#define dsMaxChainLen	(164 + STRUCT_OFFSET)(%rdi)
 | 
			
		||||
#define dsGoodMatch	(180 + STRUCT_OFFSET)(%rdi)
 | 
			
		||||
#define dsNiceMatch	(184 + STRUCT_OFFSET)(%rdi)
 | 
			
		||||
 | 
			
		||||
#endif
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
.text
 | 
			
		||||
 | 
			
		||||
/* uInt longest_match(deflate_state *deflatestate, IPos curmatch) */
 | 
			
		||||
 | 
			
		||||
longest_match:
 | 
			
		||||
/*
 | 
			
		||||
 * Retrieve the function arguments. %curmatch will hold cur_match
 | 
			
		||||
 * throughout the entire function (passed via rsi on amd64).
 | 
			
		||||
 * rdi will hold the pointer to the deflate_state (first arg on amd64)
 | 
			
		||||
 */
 | 
			
		||||
		mov     %rsi, save_rsi
 | 
			
		||||
		mov     %rbx, save_rbx
 | 
			
		||||
		mov	%r12, save_r12
 | 
			
		||||
		mov     %r13, save_r13
 | 
			
		||||
		mov     %r14, save_r14
 | 
			
		||||
		mov     %r15, save_r15
 | 
			
		||||
 | 
			
		||||
/* uInt wmask = s->w_mask;						*/
 | 
			
		||||
/* unsigned chain_length = s->max_chain_length;				*/
 | 
			
		||||
/* if (s->prev_length >= s->good_match) {				*/
 | 
			
		||||
/*     chain_length >>= 2;						*/
 | 
			
		||||
/* }									*/
 | 
			
		||||
 | 
			
		||||
		movl	dsPrevLen, %eax
 | 
			
		||||
		movl	dsGoodMatch, %ebx
 | 
			
		||||
		cmpl	%ebx, %eax
 | 
			
		||||
		movl	dsWMask, %eax
 | 
			
		||||
		movl	dsMaxChainLen, %chainlenwmask
 | 
			
		||||
		jl	LastMatchGood
 | 
			
		||||
		shrl	$2, %chainlenwmask
 | 
			
		||||
LastMatchGood:
 | 
			
		||||
 | 
			
		||||
/* chainlen is decremented once beforehand so that the function can	*/
 | 
			
		||||
/* use the sign flag instead of the zero flag for the exit test.	*/
 | 
			
		||||
/* It is then shifted into the high word, to make room for the wmask	*/
 | 
			
		||||
/* value, which it will always accompany.				*/
 | 
			
		||||
 | 
			
		||||
		decl	%chainlenwmask
 | 
			
		||||
		shll	$16, %chainlenwmask
 | 
			
		||||
		orl	%eax, %chainlenwmask
 | 
			
		||||
 | 
			
		||||
/* if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;	*/
 | 
			
		||||
 | 
			
		||||
		movl	dsNiceMatch, %eax
 | 
			
		||||
		movl	dsLookahead, %ebx
 | 
			
		||||
		cmpl	%eax, %ebx
 | 
			
		||||
		jl	LookaheadLess
 | 
			
		||||
		movl	%eax, %ebx
 | 
			
		||||
LookaheadLess:	movl	%ebx, %nicematch
 | 
			
		||||
 | 
			
		||||
/* register Bytef *scan = s->window + s->strstart;			*/
 | 
			
		||||
 | 
			
		||||
		mov	dsWindow, %window
 | 
			
		||||
		movl	dsStrStart, %limitd
 | 
			
		||||
		lea	(%limit, %window), %scan
 | 
			
		||||
 | 
			
		||||
/* Determine how many bytes the scan ptr is off from being		*/
 | 
			
		||||
/* dword-aligned.							*/
 | 
			
		||||
 | 
			
		||||
		mov	%scan, %scanalign
 | 
			
		||||
		negl	%scanalignd
 | 
			
		||||
		andl	$3, %scanalignd
 | 
			
		||||
 | 
			
		||||
/* IPos limit = s->strstart > (IPos)MAX_DIST(s) ?			*/
 | 
			
		||||
/*     s->strstart - (IPos)MAX_DIST(s) : NIL;				*/
 | 
			
		||||
 | 
			
		||||
		movl	dsWSize, %eax
 | 
			
		||||
		subl	$MIN_LOOKAHEAD, %eax
 | 
			
		||||
		xorl	%ecx, %ecx
 | 
			
		||||
		subl	%eax, %limitd
 | 
			
		||||
		cmovng	%ecx, %limitd
 | 
			
		||||
 | 
			
		||||
/* int best_len = s->prev_length;					*/
 | 
			
		||||
 | 
			
		||||
		movl	dsPrevLen, %bestlend
 | 
			
		||||
 | 
			
		||||
/* Store the sum of s->window + best_len in %windowbestlen locally, and in memory.	*/
 | 
			
		||||
 | 
			
		||||
		lea	(%window, %bestlen), %windowbestlen
 | 
			
		||||
		mov	%windowbestlen, _windowbestlen
 | 
			
		||||
 | 
			
		||||
/* register ush scan_start = *(ushf*)scan;				*/
 | 
			
		||||
/* register ush scan_end   = *(ushf*)(scan+best_len-1);			*/
 | 
			
		||||
/* Posf *prev = s->prev;						*/
 | 
			
		||||
 | 
			
		||||
		movzwl	(%scan), %scanstart
 | 
			
		||||
		movzwl	-1(%scan, %bestlen), %scanend
 | 
			
		||||
		mov	dsPrev, %prev
 | 
			
		||||
 | 
			
		||||
/* Jump into the main loop.						*/
 | 
			
		||||
 | 
			
		||||
		movl	%chainlenwmask, _chainlenwmask
 | 
			
		||||
		jmp	LoopEntry
 | 
			
		||||
 | 
			
		||||
.balign 16
 | 
			
		||||
 | 
			
		||||
/* do {
 | 
			
		||||
 *     match = s->window + cur_match;
 | 
			
		||||
 *     if (*(ushf*)(match+best_len-1) != scan_end ||
 | 
			
		||||
 *         *(ushf*)match != scan_start) continue;
 | 
			
		||||
 *     [...]
 | 
			
		||||
 * } while ((cur_match = prev[cur_match & wmask]) > limit
 | 
			
		||||
 *          && --chain_length != 0);
 | 
			
		||||
 *
 | 
			
		||||
 * Here is the inner loop of the function. The function will spend the
 | 
			
		||||
 * majority of its time in this loop, and majority of that time will
 | 
			
		||||
 * be spent in the first ten instructions.
 | 
			
		||||
 */
 | 
			
		||||
LookupLoop:
 | 
			
		||||
		andl	%chainlenwmask, %curmatchd
 | 
			
		||||
		movzwl	(%prev, %curmatch, 2), %curmatchd
 | 
			
		||||
		cmpl	%limitd, %curmatchd
 | 
			
		||||
		jbe	LeaveNow
 | 
			
		||||
		subl	$0x00010000, %chainlenwmask
 | 
			
		||||
		js	LeaveNow
 | 
			
		||||
LoopEntry:	cmpw	-1(%windowbestlen, %curmatch), %scanendw
 | 
			
		||||
		jne	LookupLoop
 | 
			
		||||
		cmpw	%scanstartw, (%window, %curmatch)
 | 
			
		||||
		jne	LookupLoop
 | 
			
		||||
 | 
			
		||||
/* Store the current value of chainlen.					*/
 | 
			
		||||
		movl	%chainlenwmask, _chainlenwmask
 | 
			
		||||
 | 
			
		||||
/* %scan is the string under scrutiny, and %prev to the string we	*/
 | 
			
		||||
/* are hoping to match it up with. In actuality, %esi and %edi are	*/
 | 
			
		||||
/* both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and %edx is	*/
 | 
			
		||||
/* initialized to -(MAX_MATCH_8 - scanalign).				*/
 | 
			
		||||
 | 
			
		||||
		mov	$(-MAX_MATCH_8), %rdx
 | 
			
		||||
		lea	(%curmatch, %window), %windowbestlen
 | 
			
		||||
		lea	MAX_MATCH_8(%windowbestlen, %scanalign), %windowbestlen
 | 
			
		||||
		lea	MAX_MATCH_8(%scan, %scanalign), %prev
 | 
			
		||||
 | 
			
		||||
/* the prefetching below makes very little difference... */
 | 
			
		||||
		prefetcht1	(%windowbestlen, %rdx)
 | 
			
		||||
		prefetcht1	(%prev, %rdx)
 | 
			
		||||
 | 
			
		||||
/*
 | 
			
		||||
 * Test the strings for equality, 8 bytes at a time. At the end,
 | 
			
		||||
 * adjust %rdx so that it is offset to the exact byte that mismatched.
 | 
			
		||||
 *
 | 
			
		||||
 * It should be confessed that this loop usually does not represent
 | 
			
		||||
 * much of the total running time. Replacing it with a more
 | 
			
		||||
 * straightforward "rep cmpsb" would not drastically degrade
 | 
			
		||||
 * performance -- unrolling it, for example, makes no difference.
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
#undef USE_SSE	/* works, but is 6-7% slower, than non-SSE... */
 | 
			
		||||
 | 
			
		||||
LoopCmps:
 | 
			
		||||
#ifdef USE_SSE
 | 
			
		||||
		/* Preload the SSE registers */
 | 
			
		||||
		movdqu	  (%windowbestlen, %rdx), %xmm1
 | 
			
		||||
		movdqu	  (%prev, %rdx), %xmm2
 | 
			
		||||
		pcmpeqb	%xmm2, %xmm1
 | 
			
		||||
		movdqu	16(%windowbestlen, %rdx), %xmm3
 | 
			
		||||
		movdqu	16(%prev, %rdx), %xmm4
 | 
			
		||||
		pcmpeqb	%xmm4, %xmm3
 | 
			
		||||
		movdqu	32(%windowbestlen, %rdx), %xmm5
 | 
			
		||||
		movdqu	32(%prev, %rdx), %xmm6
 | 
			
		||||
		pcmpeqb	%xmm6, %xmm5
 | 
			
		||||
		movdqu	48(%windowbestlen, %rdx), %xmm7
 | 
			
		||||
		movdqu	48(%prev, %rdx), %xmm8
 | 
			
		||||
		pcmpeqb	%xmm8, %xmm7
 | 
			
		||||
 | 
			
		||||
		/* Check the comparisions' results */
 | 
			
		||||
		pmovmskb %xmm1, %rax
 | 
			
		||||
		notw	%ax
 | 
			
		||||
		bsfw	%ax, %ax
 | 
			
		||||
		jnz	LeaveLoopCmps
 | 
			
		||||
		
 | 
			
		||||
		/* this is the only iteration of the loop with a possibility of having
 | 
			
		||||
		   incremented rdx by 0x108 (each loop iteration add 16*4 = 0x40 
 | 
			
		||||
		   and (0x40*4)+8=0x108 */
 | 
			
		||||
		add	$8, %rdx
 | 
			
		||||
		jz LenMaximum
 | 
			
		||||
		add	$8, %rdx
 | 
			
		||||
 | 
			
		||||
		
 | 
			
		||||
		pmovmskb %xmm3, %rax
 | 
			
		||||
		notw	%ax
 | 
			
		||||
		bsfw	%ax, %ax
 | 
			
		||||
		jnz	LeaveLoopCmps
 | 
			
		||||
		
 | 
			
		||||
		
 | 
			
		||||
		add	$16, %rdx
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
		pmovmskb %xmm5, %rax
 | 
			
		||||
		notw	%ax
 | 
			
		||||
		bsfw	%ax, %ax
 | 
			
		||||
		jnz	LeaveLoopCmps
 | 
			
		||||
		
 | 
			
		||||
		add	$16, %rdx
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
		pmovmskb %xmm7, %rax
 | 
			
		||||
		notw	%ax
 | 
			
		||||
		bsfw	%ax, %ax
 | 
			
		||||
		jnz	LeaveLoopCmps
 | 
			
		||||
		
 | 
			
		||||
		add	$16, %rdx
 | 
			
		||||
		
 | 
			
		||||
		jmp	LoopCmps
 | 
			
		||||
LeaveLoopCmps:	add	%rax, %rdx
 | 
			
		||||
#else
 | 
			
		||||
		mov	(%windowbestlen, %rdx), %rax
 | 
			
		||||
		xor	(%prev, %rdx), %rax
 | 
			
		||||
		jnz	LeaveLoopCmps
 | 
			
		||||
		
 | 
			
		||||
		mov	8(%windowbestlen, %rdx), %rax
 | 
			
		||||
		xor	8(%prev, %rdx), %rax
 | 
			
		||||
		jnz	LeaveLoopCmps8
 | 
			
		||||
 | 
			
		||||
		mov	16(%windowbestlen, %rdx), %rax
 | 
			
		||||
		xor	16(%prev, %rdx), %rax
 | 
			
		||||
		jnz	LeaveLoopCmps16
 | 
			
		||||
				
 | 
			
		||||
		add	$24, %rdx
 | 
			
		||||
		jnz	LoopCmps
 | 
			
		||||
		jmp	LenMaximum
 | 
			
		||||
#	if 0
 | 
			
		||||
/*
 | 
			
		||||
 * This three-liner is tantalizingly simple, but bsf is a slow instruction,
 | 
			
		||||
 * and the complicated alternative down below is quite a bit faster. Sad...
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
LeaveLoopCmps:	bsf	%rax, %rax /* find the first non-zero bit */
 | 
			
		||||
		shrl	$3, %eax /* divide by 8 to get the byte */
 | 
			
		||||
		add	%rax, %rdx
 | 
			
		||||
#	else
 | 
			
		||||
LeaveLoopCmps16:
 | 
			
		||||
		add	$8, %rdx
 | 
			
		||||
LeaveLoopCmps8:
 | 
			
		||||
		add	$8, %rdx
 | 
			
		||||
LeaveLoopCmps:	testl   $0xFFFFFFFF, %eax /* Check the first 4 bytes */
 | 
			
		||||
		jnz     Check16
 | 
			
		||||
		add     $4, %rdx
 | 
			
		||||
		shr     $32, %rax
 | 
			
		||||
Check16:        testw   $0xFFFF, %ax
 | 
			
		||||
		jnz     LenLower
 | 
			
		||||
		add	$2, %rdx
 | 
			
		||||
		shrl	$16, %eax
 | 
			
		||||
LenLower:	subb	$1, %al
 | 
			
		||||
		adc	$0, %rdx
 | 
			
		||||
#	endif
 | 
			
		||||
#endif
 | 
			
		||||
 | 
			
		||||
/* Calculate the length of the match. If it is longer than MAX_MATCH,	*/
 | 
			
		||||
/* then automatically accept it as the best possible match and leave.	*/
 | 
			
		||||
 | 
			
		||||
		lea	(%prev, %rdx), %rax
 | 
			
		||||
		sub	%scan, %rax
 | 
			
		||||
		cmpl	$MAX_MATCH, %eax
 | 
			
		||||
		jge	LenMaximum
 | 
			
		||||
 | 
			
		||||
/* If the length of the match is not longer than the best match we	*/
 | 
			
		||||
/* have so far, then forget it and return to the lookup loop.		*/
 | 
			
		||||
 | 
			
		||||
		cmpl	%bestlend, %eax
 | 
			
		||||
		jg	LongerMatch
 | 
			
		||||
		mov	_windowbestlen, %windowbestlen
 | 
			
		||||
		mov	dsPrev, %prev
 | 
			
		||||
		movl	_chainlenwmask, %edx
 | 
			
		||||
		jmp	LookupLoop
 | 
			
		||||
 | 
			
		||||
/*         s->match_start = cur_match;					*/
 | 
			
		||||
/*         best_len = len;						*/
 | 
			
		||||
/*         if (len >= nice_match) break;				*/
 | 
			
		||||
/*         scan_end = *(ushf*)(scan+best_len-1);			*/
 | 
			
		||||
 | 
			
		||||
LongerMatch:
 | 
			
		||||
		movl	%eax, %bestlend
 | 
			
		||||
		movl	%curmatchd, dsMatchStart
 | 
			
		||||
		cmpl	%nicematch, %eax
 | 
			
		||||
		jge	LeaveNow
 | 
			
		||||
 | 
			
		||||
		lea	(%window, %bestlen), %windowbestlen
 | 
			
		||||
		mov	%windowbestlen, _windowbestlen
 | 
			
		||||
 | 
			
		||||
		movzwl	-1(%scan, %rax), %scanend
 | 
			
		||||
		mov	dsPrev, %prev
 | 
			
		||||
		movl	_chainlenwmask, %chainlenwmask
 | 
			
		||||
		jmp	LookupLoop
 | 
			
		||||
 | 
			
		||||
/* Accept the current string, with the maximum possible length.		*/
 | 
			
		||||
 | 
			
		||||
LenMaximum:
 | 
			
		||||
		movl	$MAX_MATCH, %bestlend
 | 
			
		||||
		movl	%curmatchd, dsMatchStart
 | 
			
		||||
 | 
			
		||||
/* if ((uInt)best_len <= s->lookahead) return (uInt)best_len;		*/
 | 
			
		||||
/* return s->lookahead;							*/
 | 
			
		||||
 | 
			
		||||
LeaveNow:
 | 
			
		||||
		movl	dsLookahead, %eax
 | 
			
		||||
		cmpl	%eax, %bestlend
 | 
			
		||||
		cmovngl	%bestlend, %eax
 | 
			
		||||
LookaheadRet:
 | 
			
		||||
 | 
			
		||||
/* Restore the registers and return from whence we came.			*/
 | 
			
		||||
 | 
			
		||||
	mov	save_rsi, %rsi
 | 
			
		||||
	mov	save_rbx, %rbx
 | 
			
		||||
	mov	save_r12, %r12
 | 
			
		||||
	mov	save_r13, %r13
 | 
			
		||||
	mov	save_r14, %r14
 | 
			
		||||
	mov	save_r15, %r15
 | 
			
		||||
 | 
			
		||||
	ret
 | 
			
		||||
 | 
			
		||||
match_init:	ret
 | 
			
		||||
							
								
								
									
										51
									
								
								third_party/zlib/contrib/asm686/README.686
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										51
									
								
								third_party/zlib/contrib/asm686/README.686
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,51 @@
 | 
			
		||||
This is a patched version of zlib, modified to use
 | 
			
		||||
Pentium-Pro-optimized assembly code in the deflation algorithm. The
 | 
			
		||||
files changed/added by this patch are:
 | 
			
		||||
 | 
			
		||||
README.686
 | 
			
		||||
match.S
 | 
			
		||||
 | 
			
		||||
The speedup that this patch provides varies, depending on whether the
 | 
			
		||||
compiler used to build the original version of zlib falls afoul of the
 | 
			
		||||
PPro's speed traps. My own tests show a speedup of around 10-20% at
 | 
			
		||||
the default compression level, and 20-30% using -9, against a version
 | 
			
		||||
compiled using gcc 2.7.2.3. Your mileage may vary.
 | 
			
		||||
 | 
			
		||||
Note that this code has been tailored for the PPro/PII in particular,
 | 
			
		||||
and will not perform particuarly well on a Pentium.
 | 
			
		||||
 | 
			
		||||
If you are using an assembler other than GNU as, you will have to
 | 
			
		||||
translate match.S to use your assembler's syntax. (Have fun.)
 | 
			
		||||
 | 
			
		||||
Brian Raiter
 | 
			
		||||
breadbox@muppetlabs.com
 | 
			
		||||
April, 1998
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
Added for zlib 1.1.3:
 | 
			
		||||
 | 
			
		||||
The patches come from
 | 
			
		||||
http://www.muppetlabs.com/~breadbox/software/assembly.html
 | 
			
		||||
 | 
			
		||||
To compile zlib with this asm file, copy match.S to the zlib directory
 | 
			
		||||
then do:
 | 
			
		||||
 | 
			
		||||
CFLAGS="-O3 -DASMV" ./configure
 | 
			
		||||
make OBJA=match.o
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
Update:
 | 
			
		||||
 | 
			
		||||
I've been ignoring these assembly routines for years, believing that
 | 
			
		||||
gcc's generated code had caught up with it sometime around gcc 2.95
 | 
			
		||||
and the major rearchitecting of the Pentium 4. However, I recently
 | 
			
		||||
learned that, despite what I believed, this code still has some life
 | 
			
		||||
in it. On the Pentium 4 and AMD64 chips, it continues to run about 8%
 | 
			
		||||
faster than the code produced by gcc 4.1.
 | 
			
		||||
 | 
			
		||||
In acknowledgement of its continuing usefulness, I've altered the
 | 
			
		||||
license to match that of the rest of zlib. Share and Enjoy!
 | 
			
		||||
 | 
			
		||||
Brian Raiter
 | 
			
		||||
breadbox@muppetlabs.com
 | 
			
		||||
April, 2007
 | 
			
		||||
							
								
								
									
										357
									
								
								third_party/zlib/contrib/asm686/match.S
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										357
									
								
								third_party/zlib/contrib/asm686/match.S
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,357 @@
 | 
			
		||||
/* match.S -- x86 assembly version of the zlib longest_match() function.
 | 
			
		||||
 * Optimized for the Intel 686 chips (PPro and later).
 | 
			
		||||
 *
 | 
			
		||||
 * Copyright (C) 1998, 2007 Brian Raiter <breadbox@muppetlabs.com>
 | 
			
		||||
 *
 | 
			
		||||
 * This software is provided 'as-is', without any express or implied
 | 
			
		||||
 * warranty.  In no event will the author be held liable for any damages
 | 
			
		||||
 * arising from the use of this software.
 | 
			
		||||
 *
 | 
			
		||||
 * Permission is granted to anyone to use this software for any purpose,
 | 
			
		||||
 * including commercial applications, and to alter it and redistribute it
 | 
			
		||||
 * freely, subject to the following restrictions:
 | 
			
		||||
 *
 | 
			
		||||
 * 1. The origin of this software must not be misrepresented; you must not
 | 
			
		||||
 *    claim that you wrote the original software. If you use this software
 | 
			
		||||
 *    in a product, an acknowledgment in the product documentation would be
 | 
			
		||||
 *    appreciated but is not required.
 | 
			
		||||
 * 2. Altered source versions must be plainly marked as such, and must not be
 | 
			
		||||
 *    misrepresented as being the original software.
 | 
			
		||||
 * 3. This notice may not be removed or altered from any source distribution.
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
#ifndef NO_UNDERLINE
 | 
			
		||||
#define	match_init	_match_init
 | 
			
		||||
#define	longest_match	_longest_match
 | 
			
		||||
#endif
 | 
			
		||||
 | 
			
		||||
#define	MAX_MATCH	(258)
 | 
			
		||||
#define	MIN_MATCH	(3)
 | 
			
		||||
#define	MIN_LOOKAHEAD	(MAX_MATCH + MIN_MATCH + 1)
 | 
			
		||||
#define	MAX_MATCH_8	((MAX_MATCH + 7) & ~7)
 | 
			
		||||
 | 
			
		||||
/* stack frame offsets */
 | 
			
		||||
 | 
			
		||||
#define	chainlenwmask		0	/* high word: current chain len	*/
 | 
			
		||||
					/* low word: s->wmask		*/
 | 
			
		||||
#define	window			4	/* local copy of s->window	*/
 | 
			
		||||
#define	windowbestlen		8	/* s->window + bestlen		*/
 | 
			
		||||
#define	scanstart		16	/* first two bytes of string	*/
 | 
			
		||||
#define	scanend			12	/* last two bytes of string	*/
 | 
			
		||||
#define	scanalign		20	/* dword-misalignment of string	*/
 | 
			
		||||
#define	nicematch		24	/* a good enough match size	*/
 | 
			
		||||
#define	bestlen			28	/* size of best match so far	*/
 | 
			
		||||
#define	scan			32	/* ptr to string wanting match	*/
 | 
			
		||||
 | 
			
		||||
#define	LocalVarsSize		(36)
 | 
			
		||||
/*	saved ebx		36 */
 | 
			
		||||
/*	saved edi		40 */
 | 
			
		||||
/*	saved esi		44 */
 | 
			
		||||
/*	saved ebp		48 */
 | 
			
		||||
/*	return address		52 */
 | 
			
		||||
#define	deflatestate		56	/* the function arguments	*/
 | 
			
		||||
#define	curmatch		60
 | 
			
		||||
 | 
			
		||||
/* All the +zlib1222add offsets are due to the addition of fields
 | 
			
		||||
 *  in zlib in the deflate_state structure since the asm code was first written
 | 
			
		||||
 * (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
 | 
			
		||||
 * (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
 | 
			
		||||
 * if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
#define zlib1222add		(8)
 | 
			
		||||
 | 
			
		||||
#define	dsWSize			(36+zlib1222add)
 | 
			
		||||
#define	dsWMask			(44+zlib1222add)
 | 
			
		||||
#define	dsWindow		(48+zlib1222add)
 | 
			
		||||
#define	dsPrev			(56+zlib1222add)
 | 
			
		||||
#define	dsMatchLen		(88+zlib1222add)
 | 
			
		||||
#define	dsPrevMatch		(92+zlib1222add)
 | 
			
		||||
#define	dsStrStart		(100+zlib1222add)
 | 
			
		||||
#define	dsMatchStart		(104+zlib1222add)
 | 
			
		||||
#define	dsLookahead		(108+zlib1222add)
 | 
			
		||||
#define	dsPrevLen		(112+zlib1222add)
 | 
			
		||||
#define	dsMaxChainLen		(116+zlib1222add)
 | 
			
		||||
#define	dsGoodMatch		(132+zlib1222add)
 | 
			
		||||
#define	dsNiceMatch		(136+zlib1222add)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
.file "match.S"
 | 
			
		||||
 | 
			
		||||
.globl	match_init, longest_match
 | 
			
		||||
 | 
			
		||||
.text
 | 
			
		||||
 | 
			
		||||
/* uInt longest_match(deflate_state *deflatestate, IPos curmatch) */
 | 
			
		||||
.cfi_sections	.debug_frame
 | 
			
		||||
 | 
			
		||||
longest_match:
 | 
			
		||||
 | 
			
		||||
.cfi_startproc
 | 
			
		||||
/* Save registers that the compiler may be using, and adjust %esp to	*/
 | 
			
		||||
/* make room for our stack frame.					*/
 | 
			
		||||
 | 
			
		||||
		pushl	%ebp
 | 
			
		||||
		.cfi_def_cfa_offset 8
 | 
			
		||||
		.cfi_offset ebp, -8
 | 
			
		||||
		pushl	%edi
 | 
			
		||||
		.cfi_def_cfa_offset 12
 | 
			
		||||
		pushl	%esi
 | 
			
		||||
		.cfi_def_cfa_offset 16
 | 
			
		||||
		pushl	%ebx
 | 
			
		||||
		.cfi_def_cfa_offset 20
 | 
			
		||||
		subl	$LocalVarsSize, %esp
 | 
			
		||||
		.cfi_def_cfa_offset LocalVarsSize+20
 | 
			
		||||
 | 
			
		||||
/* Retrieve the function arguments. %ecx will hold cur_match		*/
 | 
			
		||||
/* throughout the entire function. %edx will hold the pointer to the	*/
 | 
			
		||||
/* deflate_state structure during the function's setup (before		*/
 | 
			
		||||
/* entering the main loop).						*/
 | 
			
		||||
 | 
			
		||||
		movl	deflatestate(%esp), %edx
 | 
			
		||||
		movl	curmatch(%esp), %ecx
 | 
			
		||||
 | 
			
		||||
/* uInt wmask = s->w_mask;						*/
 | 
			
		||||
/* unsigned chain_length = s->max_chain_length;				*/
 | 
			
		||||
/* if (s->prev_length >= s->good_match) {				*/
 | 
			
		||||
/*     chain_length >>= 2;						*/
 | 
			
		||||
/* }									*/
 | 
			
		||||
 
 | 
			
		||||
		movl	dsPrevLen(%edx), %eax
 | 
			
		||||
		movl	dsGoodMatch(%edx), %ebx
 | 
			
		||||
		cmpl	%ebx, %eax
 | 
			
		||||
		movl	dsWMask(%edx), %eax
 | 
			
		||||
		movl	dsMaxChainLen(%edx), %ebx
 | 
			
		||||
		jl	LastMatchGood
 | 
			
		||||
		shrl	$2, %ebx
 | 
			
		||||
LastMatchGood:
 | 
			
		||||
 | 
			
		||||
/* chainlen is decremented once beforehand so that the function can	*/
 | 
			
		||||
/* use the sign flag instead of the zero flag for the exit test.	*/
 | 
			
		||||
/* It is then shifted into the high word, to make room for the wmask	*/
 | 
			
		||||
/* value, which it will always accompany.				*/
 | 
			
		||||
 | 
			
		||||
		decl	%ebx
 | 
			
		||||
		shll	$16, %ebx
 | 
			
		||||
		orl	%eax, %ebx
 | 
			
		||||
		movl	%ebx, chainlenwmask(%esp)
 | 
			
		||||
 | 
			
		||||
/* if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;	*/
 | 
			
		||||
 | 
			
		||||
		movl	dsNiceMatch(%edx), %eax
 | 
			
		||||
		movl	dsLookahead(%edx), %ebx
 | 
			
		||||
		cmpl	%eax, %ebx
 | 
			
		||||
		jl	LookaheadLess
 | 
			
		||||
		movl	%eax, %ebx
 | 
			
		||||
LookaheadLess:	movl	%ebx, nicematch(%esp)
 | 
			
		||||
 | 
			
		||||
/* register Bytef *scan = s->window + s->strstart;			*/
 | 
			
		||||
 | 
			
		||||
		movl	dsWindow(%edx), %esi
 | 
			
		||||
		movl	%esi, window(%esp)
 | 
			
		||||
		movl	dsStrStart(%edx), %ebp
 | 
			
		||||
		lea	(%esi,%ebp), %edi
 | 
			
		||||
		movl	%edi, scan(%esp)
 | 
			
		||||
 | 
			
		||||
/* Determine how many bytes the scan ptr is off from being		*/
 | 
			
		||||
/* dword-aligned.							*/
 | 
			
		||||
 | 
			
		||||
		movl	%edi, %eax
 | 
			
		||||
		negl	%eax
 | 
			
		||||
		andl	$3, %eax
 | 
			
		||||
		movl	%eax, scanalign(%esp)
 | 
			
		||||
 | 
			
		||||
/* IPos limit = s->strstart > (IPos)MAX_DIST(s) ?			*/
 | 
			
		||||
/*     s->strstart - (IPos)MAX_DIST(s) : NIL;				*/
 | 
			
		||||
 | 
			
		||||
		movl	dsWSize(%edx), %eax
 | 
			
		||||
		subl	$MIN_LOOKAHEAD, %eax
 | 
			
		||||
		subl	%eax, %ebp
 | 
			
		||||
		jg	LimitPositive
 | 
			
		||||
		xorl	%ebp, %ebp
 | 
			
		||||
LimitPositive:
 | 
			
		||||
 | 
			
		||||
/* int best_len = s->prev_length;					*/
 | 
			
		||||
 | 
			
		||||
		movl	dsPrevLen(%edx), %eax
 | 
			
		||||
		movl	%eax, bestlen(%esp)
 | 
			
		||||
 | 
			
		||||
/* Store the sum of s->window + best_len in %esi locally, and in %esi.	*/
 | 
			
		||||
 | 
			
		||||
		addl	%eax, %esi
 | 
			
		||||
		movl	%esi, windowbestlen(%esp)
 | 
			
		||||
 | 
			
		||||
/* register ush scan_start = *(ushf*)scan;				*/
 | 
			
		||||
/* register ush scan_end   = *(ushf*)(scan+best_len-1);			*/
 | 
			
		||||
/* Posf *prev = s->prev;						*/
 | 
			
		||||
 | 
			
		||||
		movzwl	(%edi), %ebx
 | 
			
		||||
		movl	%ebx, scanstart(%esp)
 | 
			
		||||
		movzwl	-1(%edi,%eax), %ebx
 | 
			
		||||
		movl	%ebx, scanend(%esp)
 | 
			
		||||
		movl	dsPrev(%edx), %edi
 | 
			
		||||
 | 
			
		||||
/* Jump into the main loop.						*/
 | 
			
		||||
 | 
			
		||||
		movl	chainlenwmask(%esp), %edx
 | 
			
		||||
		jmp	LoopEntry
 | 
			
		||||
 | 
			
		||||
.balign 16
 | 
			
		||||
 | 
			
		||||
/* do {
 | 
			
		||||
 *     match = s->window + cur_match;
 | 
			
		||||
 *     if (*(ushf*)(match+best_len-1) != scan_end ||
 | 
			
		||||
 *         *(ushf*)match != scan_start) continue;
 | 
			
		||||
 *     [...]
 | 
			
		||||
 * } while ((cur_match = prev[cur_match & wmask]) > limit
 | 
			
		||||
 *          && --chain_length != 0);
 | 
			
		||||
 *
 | 
			
		||||
 * Here is the inner loop of the function. The function will spend the
 | 
			
		||||
 * majority of its time in this loop, and majority of that time will
 | 
			
		||||
 * be spent in the first ten instructions.
 | 
			
		||||
 *
 | 
			
		||||
 * Within this loop:
 | 
			
		||||
 * %ebx = scanend
 | 
			
		||||
 * %ecx = curmatch
 | 
			
		||||
 * %edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
 | 
			
		||||
 * %esi = windowbestlen - i.e., (window + bestlen)
 | 
			
		||||
 * %edi = prev
 | 
			
		||||
 * %ebp = limit
 | 
			
		||||
 */
 | 
			
		||||
LookupLoop:
 | 
			
		||||
		andl	%edx, %ecx
 | 
			
		||||
		movzwl	(%edi,%ecx,2), %ecx
 | 
			
		||||
		cmpl	%ebp, %ecx
 | 
			
		||||
		jbe	LeaveNow
 | 
			
		||||
		subl	$0x00010000, %edx
 | 
			
		||||
		js	LeaveNow
 | 
			
		||||
LoopEntry:	movzwl	-1(%esi,%ecx), %eax
 | 
			
		||||
		cmpl	%ebx, %eax
 | 
			
		||||
		jnz	LookupLoop
 | 
			
		||||
		movl	window(%esp), %eax
 | 
			
		||||
		movzwl	(%eax,%ecx), %eax
 | 
			
		||||
		cmpl	scanstart(%esp), %eax
 | 
			
		||||
		jnz	LookupLoop
 | 
			
		||||
 | 
			
		||||
/* Store the current value of chainlen.					*/
 | 
			
		||||
 | 
			
		||||
		movl	%edx, chainlenwmask(%esp)
 | 
			
		||||
 | 
			
		||||
/* Point %edi to the string under scrutiny, and %esi to the string we	*/
 | 
			
		||||
/* are hoping to match it up with. In actuality, %esi and %edi are	*/
 | 
			
		||||
/* both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and %edx is	*/
 | 
			
		||||
/* initialized to -(MAX_MATCH_8 - scanalign).				*/
 | 
			
		||||
 | 
			
		||||
		movl	window(%esp), %esi
 | 
			
		||||
		movl	scan(%esp), %edi
 | 
			
		||||
		addl	%ecx, %esi
 | 
			
		||||
		movl	scanalign(%esp), %eax
 | 
			
		||||
		movl	$(-MAX_MATCH_8), %edx
 | 
			
		||||
		lea	MAX_MATCH_8(%edi,%eax), %edi
 | 
			
		||||
		lea	MAX_MATCH_8(%esi,%eax), %esi
 | 
			
		||||
 | 
			
		||||
/* Test the strings for equality, 8 bytes at a time. At the end,
 | 
			
		||||
 * adjust %edx so that it is offset to the exact byte that mismatched.
 | 
			
		||||
 *
 | 
			
		||||
 * We already know at this point that the first three bytes of the
 | 
			
		||||
 * strings match each other, and they can be safely passed over before
 | 
			
		||||
 * starting the compare loop. So what this code does is skip over 0-3
 | 
			
		||||
 * bytes, as much as necessary in order to dword-align the %edi
 | 
			
		||||
 * pointer. (%esi will still be misaligned three times out of four.)
 | 
			
		||||
 *
 | 
			
		||||
 * It should be confessed that this loop usually does not represent
 | 
			
		||||
 * much of the total running time. Replacing it with a more
 | 
			
		||||
 * straightforward "rep cmpsb" would not drastically degrade
 | 
			
		||||
 * performance.
 | 
			
		||||
 */
 | 
			
		||||
LoopCmps:
 | 
			
		||||
		movl	(%esi,%edx), %eax
 | 
			
		||||
		xorl	(%edi,%edx), %eax
 | 
			
		||||
		jnz	LeaveLoopCmps
 | 
			
		||||
		movl	4(%esi,%edx), %eax
 | 
			
		||||
		xorl	4(%edi,%edx), %eax
 | 
			
		||||
		jnz	LeaveLoopCmps4
 | 
			
		||||
		addl	$8, %edx
 | 
			
		||||
		jnz	LoopCmps
 | 
			
		||||
		jmp	LenMaximum
 | 
			
		||||
LeaveLoopCmps4:	addl	$4, %edx
 | 
			
		||||
LeaveLoopCmps:	testl	$0x0000FFFF, %eax
 | 
			
		||||
		jnz	LenLower
 | 
			
		||||
		addl	$2, %edx
 | 
			
		||||
		shrl	$16, %eax
 | 
			
		||||
LenLower:	subb	$1, %al
 | 
			
		||||
		adcl	$0, %edx
 | 
			
		||||
 | 
			
		||||
/* Calculate the length of the match. If it is longer than MAX_MATCH,	*/
 | 
			
		||||
/* then automatically accept it as the best possible match and leave.	*/
 | 
			
		||||
 | 
			
		||||
		lea	(%edi,%edx), %eax
 | 
			
		||||
		movl	scan(%esp), %edi
 | 
			
		||||
		subl	%edi, %eax
 | 
			
		||||
		cmpl	$MAX_MATCH, %eax
 | 
			
		||||
		jge	LenMaximum
 | 
			
		||||
 | 
			
		||||
/* If the length of the match is not longer than the best match we	*/
 | 
			
		||||
/* have so far, then forget it and return to the lookup loop.		*/
 | 
			
		||||
 | 
			
		||||
		movl	deflatestate(%esp), %edx
 | 
			
		||||
		movl	bestlen(%esp), %ebx
 | 
			
		||||
		cmpl	%ebx, %eax
 | 
			
		||||
		jg	LongerMatch
 | 
			
		||||
		movl	windowbestlen(%esp), %esi
 | 
			
		||||
		movl	dsPrev(%edx), %edi
 | 
			
		||||
		movl	scanend(%esp), %ebx
 | 
			
		||||
		movl	chainlenwmask(%esp), %edx
 | 
			
		||||
		jmp	LookupLoop
 | 
			
		||||
 | 
			
		||||
/*         s->match_start = cur_match;					*/
 | 
			
		||||
/*         best_len = len;						*/
 | 
			
		||||
/*         if (len >= nice_match) break;				*/
 | 
			
		||||
/*         scan_end = *(ushf*)(scan+best_len-1);			*/
 | 
			
		||||
 | 
			
		||||
LongerMatch:	movl	nicematch(%esp), %ebx
 | 
			
		||||
		movl	%eax, bestlen(%esp)
 | 
			
		||||
		movl	%ecx, dsMatchStart(%edx)
 | 
			
		||||
		cmpl	%ebx, %eax
 | 
			
		||||
		jge	LeaveNow
 | 
			
		||||
		movl	window(%esp), %esi
 | 
			
		||||
		addl	%eax, %esi
 | 
			
		||||
		movl	%esi, windowbestlen(%esp)
 | 
			
		||||
		movzwl	-1(%edi,%eax), %ebx
 | 
			
		||||
		movl	dsPrev(%edx), %edi
 | 
			
		||||
		movl	%ebx, scanend(%esp)
 | 
			
		||||
		movl	chainlenwmask(%esp), %edx
 | 
			
		||||
		jmp	LookupLoop
 | 
			
		||||
 | 
			
		||||
/* Accept the current string, with the maximum possible length.		*/
 | 
			
		||||
 | 
			
		||||
LenMaximum:	movl	deflatestate(%esp), %edx
 | 
			
		||||
		movl	$MAX_MATCH, bestlen(%esp)
 | 
			
		||||
		movl	%ecx, dsMatchStart(%edx)
 | 
			
		||||
 | 
			
		||||
/* if ((uInt)best_len <= s->lookahead) return (uInt)best_len;		*/
 | 
			
		||||
/* return s->lookahead;							*/
 | 
			
		||||
 | 
			
		||||
LeaveNow:
 | 
			
		||||
		movl	deflatestate(%esp), %edx
 | 
			
		||||
		movl	bestlen(%esp), %ebx
 | 
			
		||||
		movl	dsLookahead(%edx), %eax
 | 
			
		||||
		cmpl	%eax, %ebx
 | 
			
		||||
		jg	LookaheadRet
 | 
			
		||||
		movl	%ebx, %eax
 | 
			
		||||
LookaheadRet:
 | 
			
		||||
 | 
			
		||||
/* Restore the stack and return from whence we came.			*/
 | 
			
		||||
 | 
			
		||||
		addl	$LocalVarsSize, %esp
 | 
			
		||||
		.cfi_def_cfa_offset 20
 | 
			
		||||
		popl	%ebx
 | 
			
		||||
		.cfi_def_cfa_offset 16
 | 
			
		||||
		popl	%esi
 | 
			
		||||
		.cfi_def_cfa_offset 12
 | 
			
		||||
		popl	%edi
 | 
			
		||||
		.cfi_def_cfa_offset 8
 | 
			
		||||
		popl	%ebp
 | 
			
		||||
		.cfi_def_cfa_offset 4
 | 
			
		||||
.cfi_endproc
 | 
			
		||||
match_init:	ret
 | 
			
		||||
							
								
								
									
										8
									
								
								third_party/zlib/contrib/blast/Makefile
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										8
									
								
								third_party/zlib/contrib/blast/Makefile
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,8 @@
 | 
			
		||||
blast: blast.c blast.h
 | 
			
		||||
	cc -DTEST -o blast blast.c
 | 
			
		||||
 | 
			
		||||
test: blast
 | 
			
		||||
	blast < test.pk | cmp - test.txt
 | 
			
		||||
 | 
			
		||||
clean:
 | 
			
		||||
	rm -f blast blast.o
 | 
			
		||||
							
								
								
									
										4
									
								
								third_party/zlib/contrib/blast/README
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										4
									
								
								third_party/zlib/contrib/blast/README
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,4 @@
 | 
			
		||||
Read blast.h for purpose and usage.
 | 
			
		||||
 | 
			
		||||
Mark Adler
 | 
			
		||||
madler@alumni.caltech.edu
 | 
			
		||||
							
								
								
									
										466
									
								
								third_party/zlib/contrib/blast/blast.c
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										466
									
								
								third_party/zlib/contrib/blast/blast.c
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,466 @@
 | 
			
		||||
/* blast.c
 | 
			
		||||
 * Copyright (C) 2003, 2012, 2013 Mark Adler
 | 
			
		||||
 * For conditions of distribution and use, see copyright notice in blast.h
 | 
			
		||||
 * version 1.3, 24 Aug 2013
 | 
			
		||||
 *
 | 
			
		||||
 * blast.c decompresses data compressed by the PKWare Compression Library.
 | 
			
		||||
 * This function provides functionality similar to the explode() function of
 | 
			
		||||
 * the PKWare library, hence the name "blast".
 | 
			
		||||
 *
 | 
			
		||||
 * This decompressor is based on the excellent format description provided by
 | 
			
		||||
 * Ben Rudiak-Gould in comp.compression on August 13, 2001.  Interestingly, the
 | 
			
		||||
 * example Ben provided in the post is incorrect.  The distance 110001 should
 | 
			
		||||
 * instead be 111000.  When corrected, the example byte stream becomes:
 | 
			
		||||
 *
 | 
			
		||||
 *    00 04 82 24 25 8f 80 7f
 | 
			
		||||
 *
 | 
			
		||||
 * which decompresses to "AIAIAIAIAIAIA" (without the quotes).
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
/*
 | 
			
		||||
 * Change history:
 | 
			
		||||
 *
 | 
			
		||||
 * 1.0  12 Feb 2003     - First version
 | 
			
		||||
 * 1.1  16 Feb 2003     - Fixed distance check for > 4 GB uncompressed data
 | 
			
		||||
 * 1.2  24 Oct 2012     - Add note about using binary mode in stdio
 | 
			
		||||
 *                      - Fix comparisons of differently signed integers
 | 
			
		||||
 * 1.3  24 Aug 2013     - Return unused input from blast()
 | 
			
		||||
 *                      - Fix test code to correctly report unused input
 | 
			
		||||
 *                      - Enable the provision of initial input to blast()
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
#include <stddef.h>             /* for NULL */
 | 
			
		||||
#include <setjmp.h>             /* for setjmp(), longjmp(), and jmp_buf */
 | 
			
		||||
#include "blast.h"              /* prototype for blast() */
 | 
			
		||||
 | 
			
		||||
#define local static            /* for local function definitions */
 | 
			
		||||
#define MAXBITS 13              /* maximum code length */
 | 
			
		||||
#define MAXWIN 4096             /* maximum window size */
 | 
			
		||||
 | 
			
		||||
/* input and output state */
 | 
			
		||||
struct state {
 | 
			
		||||
    /* input state */
 | 
			
		||||
    blast_in infun;             /* input function provided by user */
 | 
			
		||||
    void *inhow;                /* opaque information passed to infun() */
 | 
			
		||||
    unsigned char *in;          /* next input location */
 | 
			
		||||
    unsigned left;              /* available input at in */
 | 
			
		||||
    int bitbuf;                 /* bit buffer */
 | 
			
		||||
    int bitcnt;                 /* number of bits in bit buffer */
 | 
			
		||||
 | 
			
		||||
    /* input limit error return state for bits() and decode() */
 | 
			
		||||
    jmp_buf env;
 | 
			
		||||
 | 
			
		||||
    /* output state */
 | 
			
		||||
    blast_out outfun;           /* output function provided by user */
 | 
			
		||||
    void *outhow;               /* opaque information passed to outfun() */
 | 
			
		||||
    unsigned next;              /* index of next write location in out[] */
 | 
			
		||||
    int first;                  /* true to check distances (for first 4K) */
 | 
			
		||||
    unsigned char out[MAXWIN];  /* output buffer and sliding window */
 | 
			
		||||
};
 | 
			
		||||
 | 
			
		||||
/*
 | 
			
		||||
 * Return need bits from the input stream.  This always leaves less than
 | 
			
		||||
 * eight bits in the buffer.  bits() works properly for need == 0.
 | 
			
		||||
 *
 | 
			
		||||
 * Format notes:
 | 
			
		||||
 *
 | 
			
		||||
 * - Bits are stored in bytes from the least significant bit to the most
 | 
			
		||||
 *   significant bit.  Therefore bits are dropped from the bottom of the bit
 | 
			
		||||
 *   buffer, using shift right, and new bytes are appended to the top of the
 | 
			
		||||
 *   bit buffer, using shift left.
 | 
			
		||||
 */
 | 
			
		||||
local int bits(struct state *s, int need)
 | 
			
		||||
{
 | 
			
		||||
    int val;            /* bit accumulator */
 | 
			
		||||
 | 
			
		||||
    /* load at least need bits into val */
 | 
			
		||||
    val = s->bitbuf;
 | 
			
		||||
    while (s->bitcnt < need) {
 | 
			
		||||
        if (s->left == 0) {
 | 
			
		||||
            s->left = s->infun(s->inhow, &(s->in));
 | 
			
		||||
            if (s->left == 0) longjmp(s->env, 1);       /* out of input */
 | 
			
		||||
        }
 | 
			
		||||
        val |= (int)(*(s->in)++) << s->bitcnt;          /* load eight bits */
 | 
			
		||||
        s->left--;
 | 
			
		||||
        s->bitcnt += 8;
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    /* drop need bits and update buffer, always zero to seven bits left */
 | 
			
		||||
    s->bitbuf = val >> need;
 | 
			
		||||
    s->bitcnt -= need;
 | 
			
		||||
 | 
			
		||||
    /* return need bits, zeroing the bits above that */
 | 
			
		||||
    return val & ((1 << need) - 1);
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/*
 | 
			
		||||
 * Huffman code decoding tables.  count[1..MAXBITS] is the number of symbols of
 | 
			
		||||
 * each length, which for a canonical code are stepped through in order.
 | 
			
		||||
 * symbol[] are the symbol values in canonical order, where the number of
 | 
			
		||||
 * entries is the sum of the counts in count[].  The decoding process can be
 | 
			
		||||
 * seen in the function decode() below.
 | 
			
		||||
 */
 | 
			
		||||
struct huffman {
 | 
			
		||||
    short *count;       /* number of symbols of each length */
 | 
			
		||||
    short *symbol;      /* canonically ordered symbols */
 | 
			
		||||
};
 | 
			
		||||
 | 
			
		||||
/*
 | 
			
		||||
 * Decode a code from the stream s using huffman table h.  Return the symbol or
 | 
			
		||||
 * a negative value if there is an error.  If all of the lengths are zero, i.e.
 | 
			
		||||
 * an empty code, or if the code is incomplete and an invalid code is received,
 | 
			
		||||
 * then -9 is returned after reading MAXBITS bits.
 | 
			
		||||
 *
 | 
			
		||||
 * Format notes:
 | 
			
		||||
 *
 | 
			
		||||
 * - The codes as stored in the compressed data are bit-reversed relative to
 | 
			
		||||
 *   a simple integer ordering of codes of the same lengths.  Hence below the
 | 
			
		||||
 *   bits are pulled from the compressed data one at a time and used to
 | 
			
		||||
 *   build the code value reversed from what is in the stream in order to
 | 
			
		||||
 *   permit simple integer comparisons for decoding.
 | 
			
		||||
 *
 | 
			
		||||
 * - The first code for the shortest length is all ones.  Subsequent codes of
 | 
			
		||||
 *   the same length are simply integer decrements of the previous code.  When
 | 
			
		||||
 *   moving up a length, a one bit is appended to the code.  For a complete
 | 
			
		||||
 *   code, the last code of the longest length will be all zeros.  To support
 | 
			
		||||
 *   this ordering, the bits pulled during decoding are inverted to apply the
 | 
			
		||||
 *   more "natural" ordering starting with all zeros and incrementing.
 | 
			
		||||
 */
 | 
			
		||||
local int decode(struct state *s, struct huffman *h)
 | 
			
		||||
{
 | 
			
		||||
    int len;            /* current number of bits in code */
 | 
			
		||||
    int code;           /* len bits being decoded */
 | 
			
		||||
    int first;          /* first code of length len */
 | 
			
		||||
    int count;          /* number of codes of length len */
 | 
			
		||||
    int index;          /* index of first code of length len in symbol table */
 | 
			
		||||
    int bitbuf;         /* bits from stream */
 | 
			
		||||
    int left;           /* bits left in next or left to process */
 | 
			
		||||
    short *next;        /* next number of codes */
 | 
			
		||||
 | 
			
		||||
    bitbuf = s->bitbuf;
 | 
			
		||||
    left = s->bitcnt;
 | 
			
		||||
    code = first = index = 0;
 | 
			
		||||
    len = 1;
 | 
			
		||||
    next = h->count + 1;
 | 
			
		||||
    while (1) {
 | 
			
		||||
        while (left--) {
 | 
			
		||||
            code |= (bitbuf & 1) ^ 1;   /* invert code */
 | 
			
		||||
            bitbuf >>= 1;
 | 
			
		||||
            count = *next++;
 | 
			
		||||
            if (code < first + count) { /* if length len, return symbol */
 | 
			
		||||
                s->bitbuf = bitbuf;
 | 
			
		||||
                s->bitcnt = (s->bitcnt - len) & 7;
 | 
			
		||||
                return h->symbol[index + (code - first)];
 | 
			
		||||
            }
 | 
			
		||||
            index += count;             /* else update for next length */
 | 
			
		||||
            first += count;
 | 
			
		||||
            first <<= 1;
 | 
			
		||||
            code <<= 1;
 | 
			
		||||
            len++;
 | 
			
		||||
        }
 | 
			
		||||
        left = (MAXBITS+1) - len;
 | 
			
		||||
        if (left == 0) break;
 | 
			
		||||
        if (s->left == 0) {
 | 
			
		||||
            s->left = s->infun(s->inhow, &(s->in));
 | 
			
		||||
            if (s->left == 0) longjmp(s->env, 1);       /* out of input */
 | 
			
		||||
        }
 | 
			
		||||
        bitbuf = *(s->in)++;
 | 
			
		||||
        s->left--;
 | 
			
		||||
        if (left > 8) left = 8;
 | 
			
		||||
    }
 | 
			
		||||
    return -9;                          /* ran out of codes */
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/*
 | 
			
		||||
 * Given a list of repeated code lengths rep[0..n-1], where each byte is a
 | 
			
		||||
 * count (high four bits + 1) and a code length (low four bits), generate the
 | 
			
		||||
 * list of code lengths.  This compaction reduces the size of the object code.
 | 
			
		||||
 * Then given the list of code lengths length[0..n-1] representing a canonical
 | 
			
		||||
 * Huffman code for n symbols, construct the tables required to decode those
 | 
			
		||||
 * codes.  Those tables are the number of codes of each length, and the symbols
 | 
			
		||||
 * sorted by length, retaining their original order within each length.  The
 | 
			
		||||
 * return value is zero for a complete code set, negative for an over-
 | 
			
		||||
 * subscribed code set, and positive for an incomplete code set.  The tables
 | 
			
		||||
 * can be used if the return value is zero or positive, but they cannot be used
 | 
			
		||||
 * if the return value is negative.  If the return value is zero, it is not
 | 
			
		||||
 * possible for decode() using that table to return an error--any stream of
 | 
			
		||||
 * enough bits will resolve to a symbol.  If the return value is positive, then
 | 
			
		||||
 * it is possible for decode() using that table to return an error for received
 | 
			
		||||
 * codes past the end of the incomplete lengths.
 | 
			
		||||
 */
 | 
			
		||||
local int construct(struct huffman *h, const unsigned char *rep, int n)
 | 
			
		||||
{
 | 
			
		||||
    int symbol;         /* current symbol when stepping through length[] */
 | 
			
		||||
    int len;            /* current length when stepping through h->count[] */
 | 
			
		||||
    int left;           /* number of possible codes left of current length */
 | 
			
		||||
    short offs[MAXBITS+1];      /* offsets in symbol table for each length */
 | 
			
		||||
    short length[256];  /* code lengths */
 | 
			
		||||
 | 
			
		||||
    /* convert compact repeat counts into symbol bit length list */
 | 
			
		||||
    symbol = 0;
 | 
			
		||||
    do {
 | 
			
		||||
        len = *rep++;
 | 
			
		||||
        left = (len >> 4) + 1;
 | 
			
		||||
        len &= 15;
 | 
			
		||||
        do {
 | 
			
		||||
            length[symbol++] = len;
 | 
			
		||||
        } while (--left);
 | 
			
		||||
    } while (--n);
 | 
			
		||||
    n = symbol;
 | 
			
		||||
 | 
			
		||||
    /* count number of codes of each length */
 | 
			
		||||
    for (len = 0; len <= MAXBITS; len++)
 | 
			
		||||
        h->count[len] = 0;
 | 
			
		||||
    for (symbol = 0; symbol < n; symbol++)
 | 
			
		||||
        (h->count[length[symbol]])++;   /* assumes lengths are within bounds */
 | 
			
		||||
    if (h->count[0] == n)               /* no codes! */
 | 
			
		||||
        return 0;                       /* complete, but decode() will fail */
 | 
			
		||||
 | 
			
		||||
    /* check for an over-subscribed or incomplete set of lengths */
 | 
			
		||||
    left = 1;                           /* one possible code of zero length */
 | 
			
		||||
    for (len = 1; len <= MAXBITS; len++) {
 | 
			
		||||
        left <<= 1;                     /* one more bit, double codes left */
 | 
			
		||||
        left -= h->count[len];          /* deduct count from possible codes */
 | 
			
		||||
        if (left < 0) return left;      /* over-subscribed--return negative */
 | 
			
		||||
    }                                   /* left > 0 means incomplete */
 | 
			
		||||
 | 
			
		||||
    /* generate offsets into symbol table for each length for sorting */
 | 
			
		||||
    offs[1] = 0;
 | 
			
		||||
    for (len = 1; len < MAXBITS; len++)
 | 
			
		||||
        offs[len + 1] = offs[len] + h->count[len];
 | 
			
		||||
 | 
			
		||||
    /*
 | 
			
		||||
     * put symbols in table sorted by length, by symbol order within each
 | 
			
		||||
     * length
 | 
			
		||||
     */
 | 
			
		||||
    for (symbol = 0; symbol < n; symbol++)
 | 
			
		||||
        if (length[symbol] != 0)
 | 
			
		||||
            h->symbol[offs[length[symbol]]++] = symbol;
 | 
			
		||||
 | 
			
		||||
    /* return zero for complete set, positive for incomplete set */
 | 
			
		||||
    return left;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/*
 | 
			
		||||
 * Decode PKWare Compression Library stream.
 | 
			
		||||
 *
 | 
			
		||||
 * Format notes:
 | 
			
		||||
 *
 | 
			
		||||
 * - First byte is 0 if literals are uncoded or 1 if they are coded.  Second
 | 
			
		||||
 *   byte is 4, 5, or 6 for the number of extra bits in the distance code.
 | 
			
		||||
 *   This is the base-2 logarithm of the dictionary size minus six.
 | 
			
		||||
 *
 | 
			
		||||
 * - Compressed data is a combination of literals and length/distance pairs
 | 
			
		||||
 *   terminated by an end code.  Literals are either Huffman coded or
 | 
			
		||||
 *   uncoded bytes.  A length/distance pair is a coded length followed by a
 | 
			
		||||
 *   coded distance to represent a string that occurs earlier in the
 | 
			
		||||
 *   uncompressed data that occurs again at the current location.
 | 
			
		||||
 *
 | 
			
		||||
 * - A bit preceding a literal or length/distance pair indicates which comes
 | 
			
		||||
 *   next, 0 for literals, 1 for length/distance.
 | 
			
		||||
 *
 | 
			
		||||
 * - If literals are uncoded, then the next eight bits are the literal, in the
 | 
			
		||||
 *   normal bit order in the stream, i.e. no bit-reversal is needed. Similarly,
 | 
			
		||||
 *   no bit reversal is needed for either the length extra bits or the distance
 | 
			
		||||
 *   extra bits.
 | 
			
		||||
 *
 | 
			
		||||
 * - Literal bytes are simply written to the output.  A length/distance pair is
 | 
			
		||||
 *   an instruction to copy previously uncompressed bytes to the output.  The
 | 
			
		||||
 *   copy is from distance bytes back in the output stream, copying for length
 | 
			
		||||
 *   bytes.
 | 
			
		||||
 *
 | 
			
		||||
 * - Distances pointing before the beginning of the output data are not
 | 
			
		||||
 *   permitted.
 | 
			
		||||
 *
 | 
			
		||||
 * - Overlapped copies, where the length is greater than the distance, are
 | 
			
		||||
 *   allowed and common.  For example, a distance of one and a length of 518
 | 
			
		||||
 *   simply copies the last byte 518 times.  A distance of four and a length of
 | 
			
		||||
 *   twelve copies the last four bytes three times.  A simple forward copy
 | 
			
		||||
 *   ignoring whether the length is greater than the distance or not implements
 | 
			
		||||
 *   this correctly.
 | 
			
		||||
 */
 | 
			
		||||
local int decomp(struct state *s)
 | 
			
		||||
{
 | 
			
		||||
    int lit;            /* true if literals are coded */
 | 
			
		||||
    int dict;           /* log2(dictionary size) - 6 */
 | 
			
		||||
    int symbol;         /* decoded symbol, extra bits for distance */
 | 
			
		||||
    int len;            /* length for copy */
 | 
			
		||||
    unsigned dist;      /* distance for copy */
 | 
			
		||||
    int copy;           /* copy counter */
 | 
			
		||||
    unsigned char *from, *to;   /* copy pointers */
 | 
			
		||||
    static int virgin = 1;                              /* build tables once */
 | 
			
		||||
    static short litcnt[MAXBITS+1], litsym[256];        /* litcode memory */
 | 
			
		||||
    static short lencnt[MAXBITS+1], lensym[16];         /* lencode memory */
 | 
			
		||||
    static short distcnt[MAXBITS+1], distsym[64];       /* distcode memory */
 | 
			
		||||
    static struct huffman litcode = {litcnt, litsym};   /* length code */
 | 
			
		||||
    static struct huffman lencode = {lencnt, lensym};   /* length code */
 | 
			
		||||
    static struct huffman distcode = {distcnt, distsym};/* distance code */
 | 
			
		||||
        /* bit lengths of literal codes */
 | 
			
		||||
    static const unsigned char litlen[] = {
 | 
			
		||||
        11, 124, 8, 7, 28, 7, 188, 13, 76, 4, 10, 8, 12, 10, 12, 10, 8, 23, 8,
 | 
			
		||||
        9, 7, 6, 7, 8, 7, 6, 55, 8, 23, 24, 12, 11, 7, 9, 11, 12, 6, 7, 22, 5,
 | 
			
		||||
        7, 24, 6, 11, 9, 6, 7, 22, 7, 11, 38, 7, 9, 8, 25, 11, 8, 11, 9, 12,
 | 
			
		||||
        8, 12, 5, 38, 5, 38, 5, 11, 7, 5, 6, 21, 6, 10, 53, 8, 7, 24, 10, 27,
 | 
			
		||||
        44, 253, 253, 253, 252, 252, 252, 13, 12, 45, 12, 45, 12, 61, 12, 45,
 | 
			
		||||
        44, 173};
 | 
			
		||||
        /* bit lengths of length codes 0..15 */
 | 
			
		||||
    static const unsigned char lenlen[] = {2, 35, 36, 53, 38, 23};
 | 
			
		||||
        /* bit lengths of distance codes 0..63 */
 | 
			
		||||
    static const unsigned char distlen[] = {2, 20, 53, 230, 247, 151, 248};
 | 
			
		||||
    static const short base[16] = {     /* base for length codes */
 | 
			
		||||
        3, 2, 4, 5, 6, 7, 8, 9, 10, 12, 16, 24, 40, 72, 136, 264};
 | 
			
		||||
    static const char extra[16] = {     /* extra bits for length codes */
 | 
			
		||||
        0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8};
 | 
			
		||||
 | 
			
		||||
    /* set up decoding tables (once--might not be thread-safe) */
 | 
			
		||||
    if (virgin) {
 | 
			
		||||
        construct(&litcode, litlen, sizeof(litlen));
 | 
			
		||||
        construct(&lencode, lenlen, sizeof(lenlen));
 | 
			
		||||
        construct(&distcode, distlen, sizeof(distlen));
 | 
			
		||||
        virgin = 0;
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    /* read header */
 | 
			
		||||
    lit = bits(s, 8);
 | 
			
		||||
    if (lit > 1) return -1;
 | 
			
		||||
    dict = bits(s, 8);
 | 
			
		||||
    if (dict < 4 || dict > 6) return -2;
 | 
			
		||||
 | 
			
		||||
    /* decode literals and length/distance pairs */
 | 
			
		||||
    do {
 | 
			
		||||
        if (bits(s, 1)) {
 | 
			
		||||
            /* get length */
 | 
			
		||||
            symbol = decode(s, &lencode);
 | 
			
		||||
            len = base[symbol] + bits(s, extra[symbol]);
 | 
			
		||||
            if (len == 519) break;              /* end code */
 | 
			
		||||
 | 
			
		||||
            /* get distance */
 | 
			
		||||
            symbol = len == 2 ? 2 : dict;
 | 
			
		||||
            dist = decode(s, &distcode) << symbol;
 | 
			
		||||
            dist += bits(s, symbol);
 | 
			
		||||
            dist++;
 | 
			
		||||
            if (s->first && dist > s->next)
 | 
			
		||||
                return -3;              /* distance too far back */
 | 
			
		||||
 | 
			
		||||
            /* copy length bytes from distance bytes back */
 | 
			
		||||
            do {
 | 
			
		||||
                to = s->out + s->next;
 | 
			
		||||
                from = to - dist;
 | 
			
		||||
                copy = MAXWIN;
 | 
			
		||||
                if (s->next < dist) {
 | 
			
		||||
                    from += copy;
 | 
			
		||||
                    copy = dist;
 | 
			
		||||
                }
 | 
			
		||||
                copy -= s->next;
 | 
			
		||||
                if (copy > len) copy = len;
 | 
			
		||||
                len -= copy;
 | 
			
		||||
                s->next += copy;
 | 
			
		||||
                do {
 | 
			
		||||
                    *to++ = *from++;
 | 
			
		||||
                } while (--copy);
 | 
			
		||||
                if (s->next == MAXWIN) {
 | 
			
		||||
                    if (s->outfun(s->outhow, s->out, s->next)) return 1;
 | 
			
		||||
                    s->next = 0;
 | 
			
		||||
                    s->first = 0;
 | 
			
		||||
                }
 | 
			
		||||
            } while (len != 0);
 | 
			
		||||
        }
 | 
			
		||||
        else {
 | 
			
		||||
            /* get literal and write it */
 | 
			
		||||
            symbol = lit ? decode(s, &litcode) : bits(s, 8);
 | 
			
		||||
            s->out[s->next++] = symbol;
 | 
			
		||||
            if (s->next == MAXWIN) {
 | 
			
		||||
                if (s->outfun(s->outhow, s->out, s->next)) return 1;
 | 
			
		||||
                s->next = 0;
 | 
			
		||||
                s->first = 0;
 | 
			
		||||
            }
 | 
			
		||||
        }
 | 
			
		||||
    } while (1);
 | 
			
		||||
    return 0;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/* See comments in blast.h */
 | 
			
		||||
int blast(blast_in infun, void *inhow, blast_out outfun, void *outhow,
 | 
			
		||||
          unsigned *left, unsigned char **in)
 | 
			
		||||
{
 | 
			
		||||
    struct state s;             /* input/output state */
 | 
			
		||||
    int err;                    /* return value */
 | 
			
		||||
 | 
			
		||||
    /* initialize input state */
 | 
			
		||||
    s.infun = infun;
 | 
			
		||||
    s.inhow = inhow;
 | 
			
		||||
    if (left != NULL && *left) {
 | 
			
		||||
        s.left = *left;
 | 
			
		||||
        s.in = *in;
 | 
			
		||||
    }
 | 
			
		||||
    else
 | 
			
		||||
        s.left = 0;
 | 
			
		||||
    s.bitbuf = 0;
 | 
			
		||||
    s.bitcnt = 0;
 | 
			
		||||
 | 
			
		||||
    /* initialize output state */
 | 
			
		||||
    s.outfun = outfun;
 | 
			
		||||
    s.outhow = outhow;
 | 
			
		||||
    s.next = 0;
 | 
			
		||||
    s.first = 1;
 | 
			
		||||
 | 
			
		||||
    /* return if bits() or decode() tries to read past available input */
 | 
			
		||||
    if (setjmp(s.env) != 0)             /* if came back here via longjmp(), */
 | 
			
		||||
        err = 2;                        /*  then skip decomp(), return error */
 | 
			
		||||
    else
 | 
			
		||||
        err = decomp(&s);               /* decompress */
 | 
			
		||||
 | 
			
		||||
    /* return unused input */
 | 
			
		||||
    if (left != NULL)
 | 
			
		||||
        *left = s.left;
 | 
			
		||||
    if (in != NULL)
 | 
			
		||||
        *in = s.left ? s.in : NULL;
 | 
			
		||||
 | 
			
		||||
    /* write any leftover output and update the error code if needed */
 | 
			
		||||
    if (err != 1 && s.next && s.outfun(s.outhow, s.out, s.next) && err == 0)
 | 
			
		||||
        err = 1;
 | 
			
		||||
    return err;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
#ifdef TEST
 | 
			
		||||
/* Example of how to use blast() */
 | 
			
		||||
#include <stdio.h>
 | 
			
		||||
#include <stdlib.h>
 | 
			
		||||
 | 
			
		||||
#define CHUNK 16384
 | 
			
		||||
 | 
			
		||||
local unsigned inf(void *how, unsigned char **buf)
 | 
			
		||||
{
 | 
			
		||||
    static unsigned char hold[CHUNK];
 | 
			
		||||
 | 
			
		||||
    *buf = hold;
 | 
			
		||||
    return fread(hold, 1, CHUNK, (FILE *)how);
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
local int outf(void *how, unsigned char *buf, unsigned len)
 | 
			
		||||
{
 | 
			
		||||
    return fwrite(buf, 1, len, (FILE *)how) != len;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/* Decompress a PKWare Compression Library stream from stdin to stdout */
 | 
			
		||||
int main(void)
 | 
			
		||||
{
 | 
			
		||||
    int ret;
 | 
			
		||||
    unsigned left;
 | 
			
		||||
 | 
			
		||||
    /* decompress to stdout */
 | 
			
		||||
    left = 0;
 | 
			
		||||
    ret = blast(inf, stdin, outf, stdout, &left, NULL);
 | 
			
		||||
    if (ret != 0)
 | 
			
		||||
        fprintf(stderr, "blast error: %d\n", ret);
 | 
			
		||||
 | 
			
		||||
    /* count any leftover bytes */
 | 
			
		||||
    while (getchar() != EOF)
 | 
			
		||||
        left++;
 | 
			
		||||
    if (left)
 | 
			
		||||
        fprintf(stderr, "blast warning: %u unused bytes of input\n", left);
 | 
			
		||||
 | 
			
		||||
    /* return blast() error code */
 | 
			
		||||
    return ret;
 | 
			
		||||
}
 | 
			
		||||
#endif
 | 
			
		||||
							
								
								
									
										83
									
								
								third_party/zlib/contrib/blast/blast.h
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										83
									
								
								third_party/zlib/contrib/blast/blast.h
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,83 @@
 | 
			
		||||
/* blast.h -- interface for blast.c
 | 
			
		||||
  Copyright (C) 2003, 2012, 2013 Mark Adler
 | 
			
		||||
  version 1.3, 24 Aug 2013
 | 
			
		||||
 | 
			
		||||
  This software is provided 'as-is', without any express or implied
 | 
			
		||||
  warranty.  In no event will the author be held liable for any damages
 | 
			
		||||
  arising from the use of this software.
 | 
			
		||||
 | 
			
		||||
  Permission is granted to anyone to use this software for any purpose,
 | 
			
		||||
  including commercial applications, and to alter it and redistribute it
 | 
			
		||||
  freely, subject to the following restrictions:
 | 
			
		||||
 | 
			
		||||
  1. The origin of this software must not be misrepresented; you must not
 | 
			
		||||
     claim that you wrote the original software. If you use this software
 | 
			
		||||
     in a product, an acknowledgment in the product documentation would be
 | 
			
		||||
     appreciated but is not required.
 | 
			
		||||
  2. Altered source versions must be plainly marked as such, and must not be
 | 
			
		||||
     misrepresented as being the original software.
 | 
			
		||||
  3. This notice may not be removed or altered from any source distribution.
 | 
			
		||||
 | 
			
		||||
  Mark Adler    madler@alumni.caltech.edu
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
/*
 | 
			
		||||
 * blast() decompresses the PKWare Data Compression Library (DCL) compressed
 | 
			
		||||
 * format.  It provides the same functionality as the explode() function in
 | 
			
		||||
 * that library.  (Note: PKWare overused the "implode" verb, and the format
 | 
			
		||||
 * used by their library implode() function is completely different and
 | 
			
		||||
 * incompatible with the implode compression method supported by PKZIP.)
 | 
			
		||||
 *
 | 
			
		||||
 * The binary mode for stdio functions should be used to assure that the
 | 
			
		||||
 * compressed data is not corrupted when read or written.  For example:
 | 
			
		||||
 * fopen(..., "rb") and fopen(..., "wb").
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
typedef unsigned (*blast_in)(void *how, unsigned char **buf);
 | 
			
		||||
typedef int (*blast_out)(void *how, unsigned char *buf, unsigned len);
 | 
			
		||||
/* Definitions for input/output functions passed to blast().  See below for
 | 
			
		||||
 * what the provided functions need to do.
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
int blast(blast_in infun, void *inhow, blast_out outfun, void *outhow,
 | 
			
		||||
          unsigned *left, unsigned char **in);
 | 
			
		||||
/* Decompress input to output using the provided infun() and outfun() calls.
 | 
			
		||||
 * On success, the return value of blast() is zero.  If there is an error in
 | 
			
		||||
 * the source data, i.e. it is not in the proper format, then a negative value
 | 
			
		||||
 * is returned.  If there is not enough input available or there is not enough
 | 
			
		||||
 * output space, then a positive error is returned.
 | 
			
		||||
 *
 | 
			
		||||
 * The input function is invoked: len = infun(how, &buf), where buf is set by
 | 
			
		||||
 * infun() to point to the input buffer, and infun() returns the number of
 | 
			
		||||
 * available bytes there.  If infun() returns zero, then blast() returns with
 | 
			
		||||
 * an input error.  (blast() only asks for input if it needs it.)  inhow is for
 | 
			
		||||
 * use by the application to pass an input descriptor to infun(), if desired.
 | 
			
		||||
 *
 | 
			
		||||
 * If left and in are not NULL and *left is not zero when blast() is called,
 | 
			
		||||
 * then the *left bytes are *in are consumed for input before infun() is used.
 | 
			
		||||
 *
 | 
			
		||||
 * The output function is invoked: err = outfun(how, buf, len), where the bytes
 | 
			
		||||
 * to be written are buf[0..len-1].  If err is not zero, then blast() returns
 | 
			
		||||
 * with an output error.  outfun() is always called with len <= 4096.  outhow
 | 
			
		||||
 * is for use by the application to pass an output descriptor to outfun(), if
 | 
			
		||||
 * desired.
 | 
			
		||||
 *
 | 
			
		||||
 * If there is any unused input, *left is set to the number of bytes that were
 | 
			
		||||
 * read and *in points to them.  Otherwise *left is set to zero and *in is set
 | 
			
		||||
 * to NULL.  If left or in are NULL, then they are not set.
 | 
			
		||||
 *
 | 
			
		||||
 * The return codes are:
 | 
			
		||||
 *
 | 
			
		||||
 *   2:  ran out of input before completing decompression
 | 
			
		||||
 *   1:  output error before completing decompression
 | 
			
		||||
 *   0:  successful decompression
 | 
			
		||||
 *  -1:  literal flag not zero or one
 | 
			
		||||
 *  -2:  dictionary size not in 4..6
 | 
			
		||||
 *  -3:  distance is too far back
 | 
			
		||||
 *
 | 
			
		||||
 * At the bottom of blast.c is an example program that uses blast() that can be
 | 
			
		||||
 * compiled to produce a command-line decompression filter by defining TEST.
 | 
			
		||||
 */
 | 
			
		||||
							
								
								
									
										
											BIN
										
									
								
								third_party/zlib/contrib/blast/test.pk
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										
											BIN
										
									
								
								third_party/zlib/contrib/blast/test.pk
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
										
											Binary file not shown.
										
									
								
							
							
								
								
									
										1
									
								
								third_party/zlib/contrib/blast/test.txt
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										1
									
								
								third_party/zlib/contrib/blast/test.txt
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1 @@
 | 
			
		||||
AIAIAIAIAIAIA
 | 
			
		||||
							
								
								
									
										557
									
								
								third_party/zlib/contrib/delphi/ZLib.pas
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										557
									
								
								third_party/zlib/contrib/delphi/ZLib.pas
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,557 @@
 | 
			
		||||
{*******************************************************}
 | 
			
		||||
{                                                       }
 | 
			
		||||
{       Borland Delphi Supplemental Components          }
 | 
			
		||||
{       ZLIB Data Compression Interface Unit            }
 | 
			
		||||
{                                                       }
 | 
			
		||||
{       Copyright (c) 1997,99 Borland Corporation       }
 | 
			
		||||
{                                                       }
 | 
			
		||||
{*******************************************************}
 | 
			
		||||
 | 
			
		||||
{ Updated for zlib 1.2.x by Cosmin Truta <cosmint@cs.ubbcluj.ro> }
 | 
			
		||||
 | 
			
		||||
unit ZLib;
 | 
			
		||||
 | 
			
		||||
interface
 | 
			
		||||
 | 
			
		||||
uses SysUtils, Classes;
 | 
			
		||||
 | 
			
		||||
type
 | 
			
		||||
  TAlloc = function (AppData: Pointer; Items, Size: Integer): Pointer; cdecl;
 | 
			
		||||
  TFree = procedure (AppData, Block: Pointer); cdecl;
 | 
			
		||||
 | 
			
		||||
  // Internal structure.  Ignore.
 | 
			
		||||
  TZStreamRec = packed record
 | 
			
		||||
    next_in: PChar;       // next input byte
 | 
			
		||||
    avail_in: Integer;    // number of bytes available at next_in
 | 
			
		||||
    total_in: Longint;    // total nb of input bytes read so far
 | 
			
		||||
 | 
			
		||||
    next_out: PChar;      // next output byte should be put here
 | 
			
		||||
    avail_out: Integer;   // remaining free space at next_out
 | 
			
		||||
    total_out: Longint;   // total nb of bytes output so far
 | 
			
		||||
 | 
			
		||||
    msg: PChar;           // last error message, NULL if no error
 | 
			
		||||
    internal: Pointer;    // not visible by applications
 | 
			
		||||
 | 
			
		||||
    zalloc: TAlloc;       // used to allocate the internal state
 | 
			
		||||
    zfree: TFree;         // used to free the internal state
 | 
			
		||||
    AppData: Pointer;     // private data object passed to zalloc and zfree
 | 
			
		||||
 | 
			
		||||
    data_type: Integer;   // best guess about the data type: ascii or binary
 | 
			
		||||
    adler: Longint;       // adler32 value of the uncompressed data
 | 
			
		||||
    reserved: Longint;    // reserved for future use
 | 
			
		||||
  end;
 | 
			
		||||
 | 
			
		||||
  // Abstract ancestor class
 | 
			
		||||
  TCustomZlibStream = class(TStream)
 | 
			
		||||
  private
 | 
			
		||||
    FStrm: TStream;
 | 
			
		||||
    FStrmPos: Integer;
 | 
			
		||||
    FOnProgress: TNotifyEvent;
 | 
			
		||||
    FZRec: TZStreamRec;
 | 
			
		||||
    FBuffer: array [Word] of Char;
 | 
			
		||||
  protected
 | 
			
		||||
    procedure Progress(Sender: TObject); dynamic;
 | 
			
		||||
    property OnProgress: TNotifyEvent read FOnProgress write FOnProgress;
 | 
			
		||||
    constructor Create(Strm: TStream);
 | 
			
		||||
  end;
 | 
			
		||||
 | 
			
		||||
{ TCompressionStream compresses data on the fly as data is written to it, and
 | 
			
		||||
  stores the compressed data to another stream.
 | 
			
		||||
 | 
			
		||||
  TCompressionStream is write-only and strictly sequential. Reading from the
 | 
			
		||||
  stream will raise an exception. Using Seek to move the stream pointer
 | 
			
		||||
  will raise an exception.
 | 
			
		||||
 | 
			
		||||
  Output data is cached internally, written to the output stream only when
 | 
			
		||||
  the internal output buffer is full.  All pending output data is flushed
 | 
			
		||||
  when the stream is destroyed.
 | 
			
		||||
 | 
			
		||||
  The Position property returns the number of uncompressed bytes of
 | 
			
		||||
  data that have been written to the stream so far.
 | 
			
		||||
 | 
			
		||||
  CompressionRate returns the on-the-fly percentage by which the original
 | 
			
		||||
  data has been compressed:  (1 - (CompressedBytes / UncompressedBytes)) * 100
 | 
			
		||||
  If raw data size = 100 and compressed data size = 25, the CompressionRate
 | 
			
		||||
  is 75%
 | 
			
		||||
 | 
			
		||||
  The OnProgress event is called each time the output buffer is filled and
 | 
			
		||||
  written to the output stream.  This is useful for updating a progress
 | 
			
		||||
  indicator when you are writing a large chunk of data to the compression
 | 
			
		||||
  stream in a single call.}
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
  TCompressionLevel = (clNone, clFastest, clDefault, clMax);
 | 
			
		||||
 | 
			
		||||
  TCompressionStream = class(TCustomZlibStream)
 | 
			
		||||
  private
 | 
			
		||||
    function GetCompressionRate: Single;
 | 
			
		||||
  public
 | 
			
		||||
    constructor Create(CompressionLevel: TCompressionLevel; Dest: TStream);
 | 
			
		||||
    destructor Destroy; override;
 | 
			
		||||
    function Read(var Buffer; Count: Longint): Longint; override;
 | 
			
		||||
    function Write(const Buffer; Count: Longint): Longint; override;
 | 
			
		||||
    function Seek(Offset: Longint; Origin: Word): Longint; override;
 | 
			
		||||
    property CompressionRate: Single read GetCompressionRate;
 | 
			
		||||
    property OnProgress;
 | 
			
		||||
  end;
 | 
			
		||||
 | 
			
		||||
{ TDecompressionStream decompresses data on the fly as data is read from it.
 | 
			
		||||
 | 
			
		||||
  Compressed data comes from a separate source stream.  TDecompressionStream
 | 
			
		||||
  is read-only and unidirectional; you can seek forward in the stream, but not
 | 
			
		||||
  backwards.  The special case of setting the stream position to zero is
 | 
			
		||||
  allowed.  Seeking forward decompresses data until the requested position in
 | 
			
		||||
  the uncompressed data has been reached.  Seeking backwards, seeking relative
 | 
			
		||||
  to the end of the stream, requesting the size of the stream, and writing to
 | 
			
		||||
  the stream will raise an exception.
 | 
			
		||||
 | 
			
		||||
  The Position property returns the number of bytes of uncompressed data that
 | 
			
		||||
  have been read from the stream so far.
 | 
			
		||||
 | 
			
		||||
  The OnProgress event is called each time the internal input buffer of
 | 
			
		||||
  compressed data is exhausted and the next block is read from the input stream.
 | 
			
		||||
  This is useful for updating a progress indicator when you are reading a
 | 
			
		||||
  large chunk of data from the decompression stream in a single call.}
 | 
			
		||||
 | 
			
		||||
  TDecompressionStream = class(TCustomZlibStream)
 | 
			
		||||
  public
 | 
			
		||||
    constructor Create(Source: TStream);
 | 
			
		||||
    destructor Destroy; override;
 | 
			
		||||
    function Read(var Buffer; Count: Longint): Longint; override;
 | 
			
		||||
    function Write(const Buffer; Count: Longint): Longint; override;
 | 
			
		||||
    function Seek(Offset: Longint; Origin: Word): Longint; override;
 | 
			
		||||
    property OnProgress;
 | 
			
		||||
  end;
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
{ CompressBuf compresses data, buffer to buffer, in one call.
 | 
			
		||||
   In: InBuf = ptr to compressed data
 | 
			
		||||
       InBytes = number of bytes in InBuf
 | 
			
		||||
  Out: OutBuf = ptr to newly allocated buffer containing decompressed data
 | 
			
		||||
       OutBytes = number of bytes in OutBuf   }
 | 
			
		||||
procedure CompressBuf(const InBuf: Pointer; InBytes: Integer;
 | 
			
		||||
                      out OutBuf: Pointer; out OutBytes: Integer);
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
{ DecompressBuf decompresses data, buffer to buffer, in one call.
 | 
			
		||||
   In: InBuf = ptr to compressed data
 | 
			
		||||
       InBytes = number of bytes in InBuf
 | 
			
		||||
       OutEstimate = zero, or est. size of the decompressed data
 | 
			
		||||
  Out: OutBuf = ptr to newly allocated buffer containing decompressed data
 | 
			
		||||
       OutBytes = number of bytes in OutBuf   }
 | 
			
		||||
procedure DecompressBuf(const InBuf: Pointer; InBytes: Integer;
 | 
			
		||||
 OutEstimate: Integer; out OutBuf: Pointer; out OutBytes: Integer);
 | 
			
		||||
 | 
			
		||||
{ DecompressToUserBuf decompresses data, buffer to buffer, in one call.
 | 
			
		||||
   In: InBuf = ptr to compressed data
 | 
			
		||||
       InBytes = number of bytes in InBuf
 | 
			
		||||
  Out: OutBuf = ptr to user-allocated buffer to contain decompressed data
 | 
			
		||||
       BufSize = number of bytes in OutBuf   }
 | 
			
		||||
procedure DecompressToUserBuf(const InBuf: Pointer; InBytes: Integer;
 | 
			
		||||
  const OutBuf: Pointer; BufSize: Integer);
 | 
			
		||||
 | 
			
		||||
const
 | 
			
		||||
  zlib_version = '1.2.11';
 | 
			
		||||
 | 
			
		||||
type
 | 
			
		||||
  EZlibError = class(Exception);
 | 
			
		||||
  ECompressionError = class(EZlibError);
 | 
			
		||||
  EDecompressionError = class(EZlibError);
 | 
			
		||||
 | 
			
		||||
implementation
 | 
			
		||||
 | 
			
		||||
uses ZLibConst;
 | 
			
		||||
 | 
			
		||||
const
 | 
			
		||||
  Z_NO_FLUSH      = 0;
 | 
			
		||||
  Z_PARTIAL_FLUSH = 1;
 | 
			
		||||
  Z_SYNC_FLUSH    = 2;
 | 
			
		||||
  Z_FULL_FLUSH    = 3;
 | 
			
		||||
  Z_FINISH        = 4;
 | 
			
		||||
 | 
			
		||||
  Z_OK            = 0;
 | 
			
		||||
  Z_STREAM_END    = 1;
 | 
			
		||||
  Z_NEED_DICT     = 2;
 | 
			
		||||
  Z_ERRNO         = (-1);
 | 
			
		||||
  Z_STREAM_ERROR  = (-2);
 | 
			
		||||
  Z_DATA_ERROR    = (-3);
 | 
			
		||||
  Z_MEM_ERROR     = (-4);
 | 
			
		||||
  Z_BUF_ERROR     = (-5);
 | 
			
		||||
  Z_VERSION_ERROR = (-6);
 | 
			
		||||
 | 
			
		||||
  Z_NO_COMPRESSION       =   0;
 | 
			
		||||
  Z_BEST_SPEED           =   1;
 | 
			
		||||
  Z_BEST_COMPRESSION     =   9;
 | 
			
		||||
  Z_DEFAULT_COMPRESSION  = (-1);
 | 
			
		||||
 | 
			
		||||
  Z_FILTERED            = 1;
 | 
			
		||||
  Z_HUFFMAN_ONLY        = 2;
 | 
			
		||||
  Z_RLE                 = 3;
 | 
			
		||||
  Z_DEFAULT_STRATEGY    = 0;
 | 
			
		||||
 | 
			
		||||
  Z_BINARY   = 0;
 | 
			
		||||
  Z_ASCII    = 1;
 | 
			
		||||
  Z_UNKNOWN  = 2;
 | 
			
		||||
 | 
			
		||||
  Z_DEFLATED = 8;
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
{$L adler32.obj}
 | 
			
		||||
{$L compress.obj}
 | 
			
		||||
{$L crc32.obj}
 | 
			
		||||
{$L deflate.obj}
 | 
			
		||||
{$L infback.obj}
 | 
			
		||||
{$L inffast.obj}
 | 
			
		||||
{$L inflate.obj}
 | 
			
		||||
{$L inftrees.obj}
 | 
			
		||||
{$L trees.obj}
 | 
			
		||||
{$L uncompr.obj}
 | 
			
		||||
{$L zutil.obj}
 | 
			
		||||
 | 
			
		||||
procedure adler32; external;
 | 
			
		||||
procedure compressBound; external;
 | 
			
		||||
procedure crc32; external;
 | 
			
		||||
procedure deflateInit2_; external;
 | 
			
		||||
procedure deflateParams; external;
 | 
			
		||||
 | 
			
		||||
function _malloc(Size: Integer): Pointer; cdecl;
 | 
			
		||||
begin
 | 
			
		||||
  Result := AllocMem(Size);
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
procedure _free(Block: Pointer); cdecl;
 | 
			
		||||
begin
 | 
			
		||||
  FreeMem(Block);
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
procedure _memset(P: Pointer; B: Byte; count: Integer); cdecl;
 | 
			
		||||
begin
 | 
			
		||||
  FillChar(P^, count, B);
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
procedure _memcpy(dest, source: Pointer; count: Integer); cdecl;
 | 
			
		||||
begin
 | 
			
		||||
  Move(source^, dest^, count);
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
// deflate compresses data
 | 
			
		||||
function deflateInit_(var strm: TZStreamRec; level: Integer; version: PChar;
 | 
			
		||||
  recsize: Integer): Integer; external;
 | 
			
		||||
function deflate(var strm: TZStreamRec; flush: Integer): Integer; external;
 | 
			
		||||
function deflateEnd(var strm: TZStreamRec): Integer; external;
 | 
			
		||||
 | 
			
		||||
// inflate decompresses data
 | 
			
		||||
function inflateInit_(var strm: TZStreamRec; version: PChar;
 | 
			
		||||
  recsize: Integer): Integer; external;
 | 
			
		||||
function inflate(var strm: TZStreamRec; flush: Integer): Integer; external;
 | 
			
		||||
function inflateEnd(var strm: TZStreamRec): Integer; external;
 | 
			
		||||
function inflateReset(var strm: TZStreamRec): Integer; external;
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
function zlibAllocMem(AppData: Pointer; Items, Size: Integer): Pointer; cdecl;
 | 
			
		||||
begin
 | 
			
		||||
//  GetMem(Result, Items*Size);
 | 
			
		||||
  Result := AllocMem(Items * Size);
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
procedure zlibFreeMem(AppData, Block: Pointer); cdecl;
 | 
			
		||||
begin
 | 
			
		||||
  FreeMem(Block);
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
{function zlibCheck(code: Integer): Integer;
 | 
			
		||||
begin
 | 
			
		||||
  Result := code;
 | 
			
		||||
  if code < 0 then
 | 
			
		||||
    raise EZlibError.Create('error');    //!!
 | 
			
		||||
end;}
 | 
			
		||||
 | 
			
		||||
function CCheck(code: Integer): Integer;
 | 
			
		||||
begin
 | 
			
		||||
  Result := code;
 | 
			
		||||
  if code < 0 then
 | 
			
		||||
    raise ECompressionError.Create('error'); //!!
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
function DCheck(code: Integer): Integer;
 | 
			
		||||
begin
 | 
			
		||||
  Result := code;
 | 
			
		||||
  if code < 0 then
 | 
			
		||||
    raise EDecompressionError.Create('error');  //!!
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
procedure CompressBuf(const InBuf: Pointer; InBytes: Integer;
 | 
			
		||||
                      out OutBuf: Pointer; out OutBytes: Integer);
 | 
			
		||||
var
 | 
			
		||||
  strm: TZStreamRec;
 | 
			
		||||
  P: Pointer;
 | 
			
		||||
begin
 | 
			
		||||
  FillChar(strm, sizeof(strm), 0);
 | 
			
		||||
  strm.zalloc := zlibAllocMem;
 | 
			
		||||
  strm.zfree := zlibFreeMem;
 | 
			
		||||
  OutBytes := ((InBytes + (InBytes div 10) + 12) + 255) and not 255;
 | 
			
		||||
  GetMem(OutBuf, OutBytes);
 | 
			
		||||
  try
 | 
			
		||||
    strm.next_in := InBuf;
 | 
			
		||||
    strm.avail_in := InBytes;
 | 
			
		||||
    strm.next_out := OutBuf;
 | 
			
		||||
    strm.avail_out := OutBytes;
 | 
			
		||||
    CCheck(deflateInit_(strm, Z_BEST_COMPRESSION, zlib_version, sizeof(strm)));
 | 
			
		||||
    try
 | 
			
		||||
      while CCheck(deflate(strm, Z_FINISH)) <> Z_STREAM_END do
 | 
			
		||||
      begin
 | 
			
		||||
        P := OutBuf;
 | 
			
		||||
        Inc(OutBytes, 256);
 | 
			
		||||
        ReallocMem(OutBuf, OutBytes);
 | 
			
		||||
        strm.next_out := PChar(Integer(OutBuf) + (Integer(strm.next_out) - Integer(P)));
 | 
			
		||||
        strm.avail_out := 256;
 | 
			
		||||
      end;
 | 
			
		||||
    finally
 | 
			
		||||
      CCheck(deflateEnd(strm));
 | 
			
		||||
    end;
 | 
			
		||||
    ReallocMem(OutBuf, strm.total_out);
 | 
			
		||||
    OutBytes := strm.total_out;
 | 
			
		||||
  except
 | 
			
		||||
    FreeMem(OutBuf);
 | 
			
		||||
    raise
 | 
			
		||||
  end;
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
procedure DecompressBuf(const InBuf: Pointer; InBytes: Integer;
 | 
			
		||||
  OutEstimate: Integer; out OutBuf: Pointer; out OutBytes: Integer);
 | 
			
		||||
var
 | 
			
		||||
  strm: TZStreamRec;
 | 
			
		||||
  P: Pointer;
 | 
			
		||||
  BufInc: Integer;
 | 
			
		||||
begin
 | 
			
		||||
  FillChar(strm, sizeof(strm), 0);
 | 
			
		||||
  strm.zalloc := zlibAllocMem;
 | 
			
		||||
  strm.zfree := zlibFreeMem;
 | 
			
		||||
  BufInc := (InBytes + 255) and not 255;
 | 
			
		||||
  if OutEstimate = 0 then
 | 
			
		||||
    OutBytes := BufInc
 | 
			
		||||
  else
 | 
			
		||||
    OutBytes := OutEstimate;
 | 
			
		||||
  GetMem(OutBuf, OutBytes);
 | 
			
		||||
  try
 | 
			
		||||
    strm.next_in := InBuf;
 | 
			
		||||
    strm.avail_in := InBytes;
 | 
			
		||||
    strm.next_out := OutBuf;
 | 
			
		||||
    strm.avail_out := OutBytes;
 | 
			
		||||
    DCheck(inflateInit_(strm, zlib_version, sizeof(strm)));
 | 
			
		||||
    try
 | 
			
		||||
      while DCheck(inflate(strm, Z_NO_FLUSH)) <> Z_STREAM_END do
 | 
			
		||||
      begin
 | 
			
		||||
        P := OutBuf;
 | 
			
		||||
        Inc(OutBytes, BufInc);
 | 
			
		||||
        ReallocMem(OutBuf, OutBytes);
 | 
			
		||||
        strm.next_out := PChar(Integer(OutBuf) + (Integer(strm.next_out) - Integer(P)));
 | 
			
		||||
        strm.avail_out := BufInc;
 | 
			
		||||
      end;
 | 
			
		||||
    finally
 | 
			
		||||
      DCheck(inflateEnd(strm));
 | 
			
		||||
    end;
 | 
			
		||||
    ReallocMem(OutBuf, strm.total_out);
 | 
			
		||||
    OutBytes := strm.total_out;
 | 
			
		||||
  except
 | 
			
		||||
    FreeMem(OutBuf);
 | 
			
		||||
    raise
 | 
			
		||||
  end;
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
procedure DecompressToUserBuf(const InBuf: Pointer; InBytes: Integer;
 | 
			
		||||
  const OutBuf: Pointer; BufSize: Integer);
 | 
			
		||||
var
 | 
			
		||||
  strm: TZStreamRec;
 | 
			
		||||
begin
 | 
			
		||||
  FillChar(strm, sizeof(strm), 0);
 | 
			
		||||
  strm.zalloc := zlibAllocMem;
 | 
			
		||||
  strm.zfree := zlibFreeMem;
 | 
			
		||||
  strm.next_in := InBuf;
 | 
			
		||||
  strm.avail_in := InBytes;
 | 
			
		||||
  strm.next_out := OutBuf;
 | 
			
		||||
  strm.avail_out := BufSize;
 | 
			
		||||
  DCheck(inflateInit_(strm, zlib_version, sizeof(strm)));
 | 
			
		||||
  try
 | 
			
		||||
    if DCheck(inflate(strm, Z_FINISH)) <> Z_STREAM_END then
 | 
			
		||||
      raise EZlibError.CreateRes(@sTargetBufferTooSmall);
 | 
			
		||||
  finally
 | 
			
		||||
    DCheck(inflateEnd(strm));
 | 
			
		||||
  end;
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
// TCustomZlibStream
 | 
			
		||||
 | 
			
		||||
constructor TCustomZLibStream.Create(Strm: TStream);
 | 
			
		||||
begin
 | 
			
		||||
  inherited Create;
 | 
			
		||||
  FStrm := Strm;
 | 
			
		||||
  FStrmPos := Strm.Position;
 | 
			
		||||
  FZRec.zalloc := zlibAllocMem;
 | 
			
		||||
  FZRec.zfree := zlibFreeMem;
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
procedure TCustomZLibStream.Progress(Sender: TObject);
 | 
			
		||||
begin
 | 
			
		||||
  if Assigned(FOnProgress) then FOnProgress(Sender);
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
// TCompressionStream
 | 
			
		||||
 | 
			
		||||
constructor TCompressionStream.Create(CompressionLevel: TCompressionLevel;
 | 
			
		||||
  Dest: TStream);
 | 
			
		||||
const
 | 
			
		||||
  Levels: array [TCompressionLevel] of ShortInt =
 | 
			
		||||
    (Z_NO_COMPRESSION, Z_BEST_SPEED, Z_DEFAULT_COMPRESSION, Z_BEST_COMPRESSION);
 | 
			
		||||
begin
 | 
			
		||||
  inherited Create(Dest);
 | 
			
		||||
  FZRec.next_out := FBuffer;
 | 
			
		||||
  FZRec.avail_out := sizeof(FBuffer);
 | 
			
		||||
  CCheck(deflateInit_(FZRec, Levels[CompressionLevel], zlib_version, sizeof(FZRec)));
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
destructor TCompressionStream.Destroy;
 | 
			
		||||
begin
 | 
			
		||||
  FZRec.next_in := nil;
 | 
			
		||||
  FZRec.avail_in := 0;
 | 
			
		||||
  try
 | 
			
		||||
    if FStrm.Position <> FStrmPos then FStrm.Position := FStrmPos;
 | 
			
		||||
    while (CCheck(deflate(FZRec, Z_FINISH)) <> Z_STREAM_END)
 | 
			
		||||
      and (FZRec.avail_out = 0) do
 | 
			
		||||
    begin
 | 
			
		||||
      FStrm.WriteBuffer(FBuffer, sizeof(FBuffer));
 | 
			
		||||
      FZRec.next_out := FBuffer;
 | 
			
		||||
      FZRec.avail_out := sizeof(FBuffer);
 | 
			
		||||
    end;
 | 
			
		||||
    if FZRec.avail_out < sizeof(FBuffer) then
 | 
			
		||||
      FStrm.WriteBuffer(FBuffer, sizeof(FBuffer) - FZRec.avail_out);
 | 
			
		||||
  finally
 | 
			
		||||
    deflateEnd(FZRec);
 | 
			
		||||
  end;
 | 
			
		||||
  inherited Destroy;
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
function TCompressionStream.Read(var Buffer; Count: Longint): Longint;
 | 
			
		||||
begin
 | 
			
		||||
  raise ECompressionError.CreateRes(@sInvalidStreamOp);
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
function TCompressionStream.Write(const Buffer; Count: Longint): Longint;
 | 
			
		||||
begin
 | 
			
		||||
  FZRec.next_in := @Buffer;
 | 
			
		||||
  FZRec.avail_in := Count;
 | 
			
		||||
  if FStrm.Position <> FStrmPos then FStrm.Position := FStrmPos;
 | 
			
		||||
  while (FZRec.avail_in > 0) do
 | 
			
		||||
  begin
 | 
			
		||||
    CCheck(deflate(FZRec, 0));
 | 
			
		||||
    if FZRec.avail_out = 0 then
 | 
			
		||||
    begin
 | 
			
		||||
      FStrm.WriteBuffer(FBuffer, sizeof(FBuffer));
 | 
			
		||||
      FZRec.next_out := FBuffer;
 | 
			
		||||
      FZRec.avail_out := sizeof(FBuffer);
 | 
			
		||||
      FStrmPos := FStrm.Position;
 | 
			
		||||
      Progress(Self);
 | 
			
		||||
    end;
 | 
			
		||||
  end;
 | 
			
		||||
  Result := Count;
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
function TCompressionStream.Seek(Offset: Longint; Origin: Word): Longint;
 | 
			
		||||
begin
 | 
			
		||||
  if (Offset = 0) and (Origin = soFromCurrent) then
 | 
			
		||||
    Result := FZRec.total_in
 | 
			
		||||
  else
 | 
			
		||||
    raise ECompressionError.CreateRes(@sInvalidStreamOp);
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
function TCompressionStream.GetCompressionRate: Single;
 | 
			
		||||
begin
 | 
			
		||||
  if FZRec.total_in = 0 then
 | 
			
		||||
    Result := 0
 | 
			
		||||
  else
 | 
			
		||||
    Result := (1.0 - (FZRec.total_out / FZRec.total_in)) * 100.0;
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
// TDecompressionStream
 | 
			
		||||
 | 
			
		||||
constructor TDecompressionStream.Create(Source: TStream);
 | 
			
		||||
begin
 | 
			
		||||
  inherited Create(Source);
 | 
			
		||||
  FZRec.next_in := FBuffer;
 | 
			
		||||
  FZRec.avail_in := 0;
 | 
			
		||||
  DCheck(inflateInit_(FZRec, zlib_version, sizeof(FZRec)));
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
destructor TDecompressionStream.Destroy;
 | 
			
		||||
begin
 | 
			
		||||
  FStrm.Seek(-FZRec.avail_in, 1);
 | 
			
		||||
  inflateEnd(FZRec);
 | 
			
		||||
  inherited Destroy;
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
function TDecompressionStream.Read(var Buffer; Count: Longint): Longint;
 | 
			
		||||
begin
 | 
			
		||||
  FZRec.next_out := @Buffer;
 | 
			
		||||
  FZRec.avail_out := Count;
 | 
			
		||||
  if FStrm.Position <> FStrmPos then FStrm.Position := FStrmPos;
 | 
			
		||||
  while (FZRec.avail_out > 0) do
 | 
			
		||||
  begin
 | 
			
		||||
    if FZRec.avail_in = 0 then
 | 
			
		||||
    begin
 | 
			
		||||
      FZRec.avail_in := FStrm.Read(FBuffer, sizeof(FBuffer));
 | 
			
		||||
      if FZRec.avail_in = 0 then
 | 
			
		||||
      begin
 | 
			
		||||
        Result := Count - FZRec.avail_out;
 | 
			
		||||
        Exit;
 | 
			
		||||
      end;
 | 
			
		||||
      FZRec.next_in := FBuffer;
 | 
			
		||||
      FStrmPos := FStrm.Position;
 | 
			
		||||
      Progress(Self);
 | 
			
		||||
    end;
 | 
			
		||||
    CCheck(inflate(FZRec, 0));
 | 
			
		||||
  end;
 | 
			
		||||
  Result := Count;
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
function TDecompressionStream.Write(const Buffer; Count: Longint): Longint;
 | 
			
		||||
begin
 | 
			
		||||
  raise EDecompressionError.CreateRes(@sInvalidStreamOp);
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
function TDecompressionStream.Seek(Offset: Longint; Origin: Word): Longint;
 | 
			
		||||
var
 | 
			
		||||
  I: Integer;
 | 
			
		||||
  Buf: array [0..4095] of Char;
 | 
			
		||||
begin
 | 
			
		||||
  if (Offset = 0) and (Origin = soFromBeginning) then
 | 
			
		||||
  begin
 | 
			
		||||
    DCheck(inflateReset(FZRec));
 | 
			
		||||
    FZRec.next_in := FBuffer;
 | 
			
		||||
    FZRec.avail_in := 0;
 | 
			
		||||
    FStrm.Position := 0;
 | 
			
		||||
    FStrmPos := 0;
 | 
			
		||||
  end
 | 
			
		||||
  else if ( (Offset >= 0) and (Origin = soFromCurrent)) or
 | 
			
		||||
          ( ((Offset - FZRec.total_out) > 0) and (Origin = soFromBeginning)) then
 | 
			
		||||
  begin
 | 
			
		||||
    if Origin = soFromBeginning then Dec(Offset, FZRec.total_out);
 | 
			
		||||
    if Offset > 0 then
 | 
			
		||||
    begin
 | 
			
		||||
      for I := 1 to Offset div sizeof(Buf) do
 | 
			
		||||
        ReadBuffer(Buf, sizeof(Buf));
 | 
			
		||||
      ReadBuffer(Buf, Offset mod sizeof(Buf));
 | 
			
		||||
    end;
 | 
			
		||||
  end
 | 
			
		||||
  else
 | 
			
		||||
    raise EDecompressionError.CreateRes(@sInvalidStreamOp);
 | 
			
		||||
  Result := FZRec.total_out;
 | 
			
		||||
end;
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
end.
 | 
			
		||||
							
								
								
									
										11
									
								
								third_party/zlib/contrib/delphi/ZLibConst.pas
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										11
									
								
								third_party/zlib/contrib/delphi/ZLibConst.pas
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,11 @@
 | 
			
		||||
unit ZLibConst;
 | 
			
		||||
 | 
			
		||||
interface
 | 
			
		||||
 | 
			
		||||
resourcestring
 | 
			
		||||
  sTargetBufferTooSmall = 'ZLib error: target buffer may be too small';
 | 
			
		||||
  sInvalidStreamOp = 'Invalid stream operation';
 | 
			
		||||
 | 
			
		||||
implementation
 | 
			
		||||
 | 
			
		||||
end.
 | 
			
		||||
							
								
								
									
										76
									
								
								third_party/zlib/contrib/delphi/readme.txt
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										76
									
								
								third_party/zlib/contrib/delphi/readme.txt
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,76 @@
 | 
			
		||||
 | 
			
		||||
Overview
 | 
			
		||||
========
 | 
			
		||||
 | 
			
		||||
This directory contains an update to the ZLib interface unit,
 | 
			
		||||
distributed by Borland as a Delphi supplemental component.
 | 
			
		||||
 | 
			
		||||
The original ZLib unit is Copyright (c) 1997,99 Borland Corp.,
 | 
			
		||||
and is based on zlib version 1.0.4.  There are a series of bugs
 | 
			
		||||
and security problems associated with that old zlib version, and
 | 
			
		||||
we recommend the users to update their ZLib unit.
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
Summary of modifications
 | 
			
		||||
========================
 | 
			
		||||
 | 
			
		||||
- Improved makefile, adapted to zlib version 1.2.1.
 | 
			
		||||
 | 
			
		||||
- Some field types from TZStreamRec are changed from Integer to
 | 
			
		||||
  Longint, for consistency with the zlib.h header, and for 64-bit
 | 
			
		||||
  readiness.
 | 
			
		||||
 | 
			
		||||
- The zlib_version constant is updated.
 | 
			
		||||
 | 
			
		||||
- The new Z_RLE strategy has its corresponding symbolic constant.
 | 
			
		||||
 | 
			
		||||
- The allocation and deallocation functions and function types
 | 
			
		||||
  (TAlloc, TFree, zlibAllocMem and zlibFreeMem) are now cdecl,
 | 
			
		||||
  and _malloc and _free are added as C RTL stubs.  As a result,
 | 
			
		||||
  the original C sources of zlib can be compiled out of the box,
 | 
			
		||||
  and linked to the ZLib unit.
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
Suggestions for improvements
 | 
			
		||||
============================
 | 
			
		||||
 | 
			
		||||
Currently, the ZLib unit provides only a limited wrapper around
 | 
			
		||||
the zlib library, and much of the original zlib functionality is
 | 
			
		||||
missing.  Handling compressed file formats like ZIP/GZIP or PNG
 | 
			
		||||
cannot be implemented without having this functionality.
 | 
			
		||||
Applications that handle these formats are either using their own,
 | 
			
		||||
duplicated code, or not using the ZLib unit at all.
 | 
			
		||||
 | 
			
		||||
Here are a few suggestions:
 | 
			
		||||
 | 
			
		||||
- Checksum class wrappers around adler32() and crc32(), similar
 | 
			
		||||
  to the Java classes that implement the java.util.zip.Checksum
 | 
			
		||||
  interface.
 | 
			
		||||
 | 
			
		||||
- The ability to read and write raw deflate streams, without the
 | 
			
		||||
  zlib stream header and trailer.  Raw deflate streams are used
 | 
			
		||||
  in the ZIP file format.
 | 
			
		||||
 | 
			
		||||
- The ability to read and write gzip streams, used in the GZIP
 | 
			
		||||
  file format, and normally produced by the gzip program.
 | 
			
		||||
 | 
			
		||||
- The ability to select a different compression strategy, useful
 | 
			
		||||
  to PNG and MNG image compression, and to multimedia compression
 | 
			
		||||
  in general.  Besides the compression level
 | 
			
		||||
 | 
			
		||||
    TCompressionLevel = (clNone, clFastest, clDefault, clMax);
 | 
			
		||||
 | 
			
		||||
  which, in fact, could have used the 'z' prefix and avoided
 | 
			
		||||
  TColor-like symbols
 | 
			
		||||
 | 
			
		||||
    TCompressionLevel = (zcNone, zcFastest, zcDefault, zcMax);
 | 
			
		||||
 | 
			
		||||
  there could be a compression strategy
 | 
			
		||||
 | 
			
		||||
    TCompressionStrategy = (zsDefault, zsFiltered, zsHuffmanOnly, zsRle);
 | 
			
		||||
 | 
			
		||||
- ZIP and GZIP stream handling via TStreams.
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
--
 | 
			
		||||
Cosmin Truta <cosmint@cs.ubbcluj.ro>
 | 
			
		||||
							
								
								
									
										99
									
								
								third_party/zlib/contrib/delphi/zlibd32.mak
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										99
									
								
								third_party/zlib/contrib/delphi/zlibd32.mak
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,99 @@
 | 
			
		||||
# Makefile for zlib
 | 
			
		||||
# For use with Delphi and C++ Builder under Win32
 | 
			
		||||
# Updated for zlib 1.2.x by Cosmin Truta
 | 
			
		||||
 | 
			
		||||
# ------------ Borland C++ ------------
 | 
			
		||||
 | 
			
		||||
# This project uses the Delphi (fastcall/register) calling convention:
 | 
			
		||||
LOC = -DZEXPORT=__fastcall -DZEXPORTVA=__cdecl
 | 
			
		||||
 | 
			
		||||
CC = bcc32
 | 
			
		||||
LD = bcc32
 | 
			
		||||
AR = tlib
 | 
			
		||||
# do not use "-pr" in CFLAGS
 | 
			
		||||
CFLAGS = -a -d -k- -O2 $(LOC)
 | 
			
		||||
LDFLAGS =
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
# variables
 | 
			
		||||
ZLIB_LIB = zlib.lib
 | 
			
		||||
 | 
			
		||||
OBJ1 = adler32.obj compress.obj crc32.obj deflate.obj gzclose.obj gzlib.obj gzread.obj
 | 
			
		||||
OBJ2 = gzwrite.obj infback.obj inffast.obj inflate.obj inftrees.obj trees.obj uncompr.obj zutil.obj
 | 
			
		||||
OBJP1 = +adler32.obj+compress.obj+crc32.obj+deflate.obj+gzclose.obj+gzlib.obj+gzread.obj
 | 
			
		||||
OBJP2 = +gzwrite.obj+infback.obj+inffast.obj+inflate.obj+inftrees.obj+trees.obj+uncompr.obj+zutil.obj
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
# targets
 | 
			
		||||
all: $(ZLIB_LIB) example.exe minigzip.exe
 | 
			
		||||
 | 
			
		||||
.c.obj:
 | 
			
		||||
	$(CC) -c $(CFLAGS) $*.c
 | 
			
		||||
 | 
			
		||||
adler32.obj: adler32.c zlib.h zconf.h
 | 
			
		||||
 | 
			
		||||
compress.obj: compress.c zlib.h zconf.h
 | 
			
		||||
 | 
			
		||||
crc32.obj: crc32.c zlib.h zconf.h crc32.h
 | 
			
		||||
 | 
			
		||||
deflate.obj: deflate.c deflate.h zutil.h zlib.h zconf.h
 | 
			
		||||
 | 
			
		||||
gzclose.obj: gzclose.c zlib.h zconf.h gzguts.h
 | 
			
		||||
 | 
			
		||||
gzlib.obj: gzlib.c zlib.h zconf.h gzguts.h
 | 
			
		||||
 | 
			
		||||
gzread.obj: gzread.c zlib.h zconf.h gzguts.h
 | 
			
		||||
 | 
			
		||||
gzwrite.obj: gzwrite.c zlib.h zconf.h gzguts.h
 | 
			
		||||
 | 
			
		||||
infback.obj: infback.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
 | 
			
		||||
 inffast.h inffixed.h
 | 
			
		||||
 | 
			
		||||
inffast.obj: inffast.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
 | 
			
		||||
 inffast.h
 | 
			
		||||
 | 
			
		||||
inflate.obj: inflate.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
 | 
			
		||||
 inffast.h inffixed.h
 | 
			
		||||
 | 
			
		||||
inftrees.obj: inftrees.c zutil.h zlib.h zconf.h inftrees.h
 | 
			
		||||
 | 
			
		||||
trees.obj: trees.c zutil.h zlib.h zconf.h deflate.h trees.h
 | 
			
		||||
 | 
			
		||||
uncompr.obj: uncompr.c zlib.h zconf.h
 | 
			
		||||
 | 
			
		||||
zutil.obj: zutil.c zutil.h zlib.h zconf.h
 | 
			
		||||
 | 
			
		||||
example.obj: test/example.c zlib.h zconf.h
 | 
			
		||||
 | 
			
		||||
minigzip.obj: test/minigzip.c zlib.h zconf.h
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
# For the sake of the old Borland make,
 | 
			
		||||
# the command line is cut to fit in the MS-DOS 128 byte limit:
 | 
			
		||||
$(ZLIB_LIB): $(OBJ1) $(OBJ2)
 | 
			
		||||
	-del $(ZLIB_LIB)
 | 
			
		||||
	$(AR) $(ZLIB_LIB) $(OBJP1)
 | 
			
		||||
	$(AR) $(ZLIB_LIB) $(OBJP2)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
# testing
 | 
			
		||||
test: example.exe minigzip.exe
 | 
			
		||||
	example
 | 
			
		||||
	echo hello world | minigzip | minigzip -d
 | 
			
		||||
 | 
			
		||||
example.exe: example.obj $(ZLIB_LIB)
 | 
			
		||||
	$(LD) $(LDFLAGS) example.obj $(ZLIB_LIB)
 | 
			
		||||
 | 
			
		||||
minigzip.exe: minigzip.obj $(ZLIB_LIB)
 | 
			
		||||
	$(LD) $(LDFLAGS) minigzip.obj $(ZLIB_LIB)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
# cleanup
 | 
			
		||||
clean:
 | 
			
		||||
	-del *.obj
 | 
			
		||||
	-del *.exe
 | 
			
		||||
	-del *.lib
 | 
			
		||||
	-del *.tds
 | 
			
		||||
	-del zlib.bak
 | 
			
		||||
	-del foo.gz
 | 
			
		||||
 | 
			
		||||
							
								
								
									
										33
									
								
								third_party/zlib/contrib/dotzlib/DotZLib.build
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										33
									
								
								third_party/zlib/contrib/dotzlib/DotZLib.build
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,33 @@
 | 
			
		||||
<?xml version="1.0" encoding="utf-8" ?>
 | 
			
		||||
<project name="DotZLib" default="build" basedir="./DotZLib">
 | 
			
		||||
	<description>A .Net wrapper library around ZLib1.dll</description>
 | 
			
		||||
 | 
			
		||||
	<property name="nunit.location" value="c:/program files/NUnit V2.1/bin" />
 | 
			
		||||
	<property name="build.root" value="bin" />
 | 
			
		||||
 | 
			
		||||
	<property name="debug" value="true" />
 | 
			
		||||
	<property name="nunit" value="true" />
 | 
			
		||||
 | 
			
		||||
	<property name="build.folder" value="${build.root}/debug/" if="${debug}" />
 | 
			
		||||
	<property name="build.folder" value="${build.root}/release/" unless="${debug}" />
 | 
			
		||||
 | 
			
		||||
	<target name="clean" description="Remove all generated files">
 | 
			
		||||
		<delete dir="${build.root}" failonerror="false" />
 | 
			
		||||
	</target>
 | 
			
		||||
 | 
			
		||||
	<target name="build" description="compiles the source code">
 | 
			
		||||
 | 
			
		||||
		<mkdir dir="${build.folder}" />
 | 
			
		||||
		<csc target="library" output="${build.folder}DotZLib.dll" debug="${debug}">
 | 
			
		||||
			<references basedir="${nunit.location}">
 | 
			
		||||
				<includes if="${nunit}" name="nunit.framework.dll" />
 | 
			
		||||
			</references>
 | 
			
		||||
			<sources>
 | 
			
		||||
				<includes name="*.cs" />
 | 
			
		||||
				<excludes name="UnitTests.cs" unless="${nunit}" />
 | 
			
		||||
			</sources>
 | 
			
		||||
			<arg value="/d:nunit" if="${nunit}" />
 | 
			
		||||
		</csc>
 | 
			
		||||
	</target>
 | 
			
		||||
 | 
			
		||||
</project>
 | 
			
		||||
							
								
								
									
										
											BIN
										
									
								
								third_party/zlib/contrib/dotzlib/DotZLib.chm
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										
											BIN
										
									
								
								third_party/zlib/contrib/dotzlib/DotZLib.chm
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
										
											Binary file not shown.
										
									
								
							
							
								
								
									
										21
									
								
								third_party/zlib/contrib/dotzlib/DotZLib.sln
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										21
									
								
								third_party/zlib/contrib/dotzlib/DotZLib.sln
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,21 @@
 | 
			
		||||
Microsoft Visual Studio Solution File, Format Version 8.00
 | 
			
		||||
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DotZLib", "DotZLib\DotZLib.csproj", "{BB1EE0B1-1808-46CB-B786-949D91117FC5}"
 | 
			
		||||
	ProjectSection(ProjectDependencies) = postProject
 | 
			
		||||
	EndProjectSection
 | 
			
		||||
EndProject
 | 
			
		||||
Global
 | 
			
		||||
	GlobalSection(SolutionConfiguration) = preSolution
 | 
			
		||||
		Debug = Debug
 | 
			
		||||
		Release = Release
 | 
			
		||||
	EndGlobalSection
 | 
			
		||||
	GlobalSection(ProjectConfiguration) = postSolution
 | 
			
		||||
		{BB1EE0B1-1808-46CB-B786-949D91117FC5}.Debug.ActiveCfg = Debug|.NET
 | 
			
		||||
		{BB1EE0B1-1808-46CB-B786-949D91117FC5}.Debug.Build.0 = Debug|.NET
 | 
			
		||||
		{BB1EE0B1-1808-46CB-B786-949D91117FC5}.Release.ActiveCfg = Release|.NET
 | 
			
		||||
		{BB1EE0B1-1808-46CB-B786-949D91117FC5}.Release.Build.0 = Release|.NET
 | 
			
		||||
	EndGlobalSection
 | 
			
		||||
	GlobalSection(ExtensibilityGlobals) = postSolution
 | 
			
		||||
	EndGlobalSection
 | 
			
		||||
	GlobalSection(ExtensibilityAddIns) = postSolution
 | 
			
		||||
	EndGlobalSection
 | 
			
		||||
EndGlobal
 | 
			
		||||
							
								
								
									
										58
									
								
								third_party/zlib/contrib/dotzlib/DotZLib/AssemblyInfo.cs
									
									
									
									
										vendored
									
									
										Normal file
									
								
							
							
						
						
									
										58
									
								
								third_party/zlib/contrib/dotzlib/DotZLib/AssemblyInfo.cs
									
									
									
									
										vendored
									
									
										Normal file
									
								
							@@ -0,0 +1,58 @@
 | 
			
		||||
using System.Reflection;
 | 
			
		||||
using System.Runtime.CompilerServices;
 | 
			
		||||
 | 
			
		||||
//
 | 
			
		||||
// General Information about an assembly is controlled through the following
 | 
			
		||||
// set of attributes. Change these attribute values to modify the information
 | 
			
		||||
// associated with an assembly.
 | 
			
		||||
//
 | 
			
		||||
[assembly: AssemblyTitle("DotZLib")]
 | 
			
		||||
[assembly: AssemblyDescription(".Net bindings for ZLib compression dll 1.2.x")]
 | 
			
		||||
[assembly: AssemblyConfiguration("")]
 | 
			
		||||
[assembly: AssemblyCompany("Henrik Ravn")]
 | 
			
		||||
[assembly: AssemblyProduct("")]
 | 
			
		||||
[assembly: AssemblyCopyright("(c) 2004 by Henrik Ravn")]
 | 
			
		||||
[assembly: AssemblyTrademark("")]
 | 
			
		||||
[assembly: AssemblyCulture("")]
 | 
			
		||||
 | 
			
		||||
//
 | 
			
		||||
// Version information for an assembly consists of the following four values:
 | 
			
		||||
//
 | 
			
		||||
//      Major Version
 | 
			
		||||
//      Minor Version
 | 
			
		||||
//      Build Number
 | 
			
		||||
//      Revision
 | 
			
		||||
//
 | 
			
		||||
// You can specify all the values or you can default the Revision and Build Numbers
 | 
			
		||||
// by using the '*' as shown below:
 | 
			
		||||
 | 
			
		||||
[assembly: AssemblyVersion("1.0.*")]
 | 
			
		||||
 | 
			
		||||
//
 | 
			
		||||
// In order to sign your assembly you must specify a key to use. Refer to the
 | 
			
		||||
// Microsoft .NET Framework documentation for more information on assembly signing.
 | 
			
		||||
//
 | 
			
		||||
// Use the attributes below to control which key is used for signing.
 | 
			
		||||
//
 | 
			
		||||
// Notes:
 | 
			
		||||
//   (*) If no key is specified, the assembly is not signed.
 | 
			
		||||
//   (*) KeyName refers to a key that has been installed in the Crypto Service
 | 
			
		||||
//       Provider (CSP) on your machine. KeyFile refers to a file which contains
 | 
			
		||||
//       a key.
 | 
			
		||||
//   (*) If the KeyFile and the KeyName values are both specified, the
 | 
			
		||||
//       following processing occurs:
 | 
			
		||||
//       (1) If the KeyName can be found in the CSP, that key is used.
 | 
			
		||||
//       (2) If the KeyName does not exist and the KeyFile does exist, the key
 | 
			
		||||
//           in the KeyFile is installed into the CSP and used.
 | 
			
		||||
//   (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
 | 
			
		||||
//       When specifying the KeyFile, the location of the KeyFile should be
 | 
			
		||||
//       relative to the project output directory which is
 | 
			
		||||
//       %Project Directory%\obj\<configuration>. For example, if your KeyFile is
 | 
			
		||||
//       located in the project directory, you would specify the AssemblyKeyFile
 | 
			
		||||
//       attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
 | 
			
		||||
//   (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
 | 
			
		||||
//       documentation for more information on this.
 | 
			
		||||
//
 | 
			
		||||
[assembly: AssemblyDelaySign(false)]
 | 
			
		||||
[assembly: AssemblyKeyFile("")]
 | 
			
		||||
[assembly: AssemblyKeyName("")]
 | 
			
		||||
Some files were not shown because too many files have changed in this diff Show More
		Reference in New Issue
	
	Block a user